rtp-load-gen: Add CTRL interface

Change-Id: I1122e5c125f03b615d587f734fc1b7eadf827a27

.clang-format

@@ -64,6 +64,451 @@ DisableFormat: false
 ExperimentalAutoDetectBinPacking: false
 #FixNamespaceComments: false # Unknown to clang-format-4.0
 
+# Taken from:
+#   git grep -h '^#define [^[:space:]]*for_each[^[:space:]]*(' include/ \
+#   | sed "s,^#define \([^[:space:]]*for_each[^[:space:]]*\)(.*$,  - '\1'," \
+#   | sort | uniq
+ForEachMacros:
+  - 'apei_estatus_for_each_section'
+  - 'ata_for_each_dev'
+  - 'ata_for_each_link'
+  - '__ata_qc_for_each'
+  - 'ata_qc_for_each'
+  - 'ata_qc_for_each_raw'
+  - 'ata_qc_for_each_with_internal'
+  - 'ax25_for_each'
+  - 'ax25_uid_for_each'
+  - '__bio_for_each_bvec'
+  - 'bio_for_each_bvec'
+  - 'bio_for_each_bvec_all'
+  - 'bio_for_each_integrity_vec'
+  - '__bio_for_each_segment'
+  - 'bio_for_each_segment'
+  - 'bio_for_each_segment_all'
+  - 'bio_list_for_each'
+  - 'bip_for_each_vec'
+  - 'bitmap_for_each_clear_region'
+  - 'bitmap_for_each_set_region'
+  - 'blkg_for_each_descendant_post'
+  - 'blkg_for_each_descendant_pre'
+  - 'blk_queue_for_each_rl'
+  - 'bond_for_each_slave'
+  - 'bond_for_each_slave_rcu'
+  - 'bpf_for_each_spilled_reg'
+  - 'btree_for_each_safe128'
+  - 'btree_for_each_safe32'
+  - 'btree_for_each_safe64'
+  - 'btree_for_each_safel'
+  - 'card_for_each_dev'
+  - 'cgroup_taskset_for_each'
+  - 'cgroup_taskset_for_each_leader'
+  - 'cpufreq_for_each_entry'
+  - 'cpufreq_for_each_entry_idx'
+  - 'cpufreq_for_each_valid_entry'
+  - 'cpufreq_for_each_valid_entry_idx'
+  - 'css_for_each_child'
+  - 'css_for_each_descendant_post'
+  - 'css_for_each_descendant_pre'
+  - 'device_for_each_child_node'
+  - 'displayid_iter_for_each'
+  - 'dma_fence_chain_for_each'
+  - 'do_for_each_ftrace_op'
+  - 'drm_atomic_crtc_for_each_plane'
+  - 'drm_atomic_crtc_state_for_each_plane'
+  - 'drm_atomic_crtc_state_for_each_plane_state'
+  - 'drm_atomic_for_each_plane_damage'
+  - 'drm_client_for_each_connector_iter'
+  - 'drm_client_for_each_modeset'
+  - 'drm_connector_for_each_possible_encoder'
+  - 'drm_for_each_bridge_in_chain'
+  - 'drm_for_each_connector_iter'
+  - 'drm_for_each_crtc'
+  - 'drm_for_each_crtc_reverse'
+  - 'drm_for_each_encoder'
+  - 'drm_for_each_encoder_mask'
+  - 'drm_for_each_fb'
+  - 'drm_for_each_legacy_plane'
+  - 'drm_for_each_plane'
+  - 'drm_for_each_plane_mask'
+  - 'drm_for_each_privobj'
+  - 'drm_mm_for_each_hole'
+  - 'drm_mm_for_each_node'
+  - 'drm_mm_for_each_node_in_range'
+  - 'drm_mm_for_each_node_safe'
+  - 'flow_action_for_each'
+  - 'for_each_acpi_dev_match'
+  - 'for_each_active_dev_scope'
+  - 'for_each_active_drhd_unit'
+  - 'for_each_active_iommu'
+  - 'for_each_aggr_pgid'
+  - 'for_each_available_child_of_node'
+  - 'for_each_bio'
+  - 'for_each_board_func_rsrc'
+  - 'for_each_bvec'
+  - 'for_each_card_auxs'
+  - 'for_each_card_auxs_safe'
+  - 'for_each_card_components'
+  - 'for_each_card_dapms'
+  - 'for_each_card_pre_auxs'
+  - 'for_each_card_prelinks'
+  - 'for_each_card_rtds'
+  - 'for_each_card_rtds_safe'
+  - 'for_each_card_widgets'
+  - 'for_each_card_widgets_safe'
+  - 'for_each_cgroup_storage_type'
+  - 'for_each_child_of_node'
+  - 'for_each_clear_bit'
+  - 'for_each_clear_bit_from'
+  - 'for_each_cmsghdr'
+  - 'for_each_compatible_node'
+  - 'for_each_component_dais'
+  - 'for_each_component_dais_safe'
+  - 'for_each_comp_order'
+  - 'for_each_console'
+  - 'for_each_cpu'
+  - 'for_each_cpu_and'
+  - 'for_each_cpu_not'
+  - 'for_each_cpu_wrap'
+  - 'for_each_dapm_widgets'
+  - 'for_each_dev_addr'
+  - 'for_each_dev_scope'
+  - 'for_each_dma_cap_mask'
+  - 'for_each_dpcm_be'
+  - 'for_each_dpcm_be_rollback'
+  - 'for_each_dpcm_be_safe'
+  - 'for_each_dpcm_fe'
+  - 'for_each_drhd_unit'
+  - 'for_each_dss_dev'
+  - 'for_each_dtpm_table'
+  - 'for_each_efi_memory_desc'
+  - 'for_each_efi_memory_desc_in_map'
+  - 'for_each_element'
+  - 'for_each_element_extid'
+  - 'for_each_element_id'
+  - 'for_each_endpoint_of_node'
+  - 'for_each_evictable_lru'
+  - 'for_each_fib6_node_rt_rcu'
+  - 'for_each_fib6_walker_rt'
+  - 'for_each_free_mem_pfn_range_in_zone'
+  - 'for_each_free_mem_pfn_range_in_zone_from'
+  - 'for_each_free_mem_range'
+  - 'for_each_free_mem_range_reverse'
+  - 'for_each_func_rsrc'
+  - 'for_each_hstate'
+  - 'for_each_if'
+  - 'for_each_iommu'
+  - 'for_each_ip_tunnel_rcu'
+  - 'for_each_irq_nr'
+  - 'for_each_link_codecs'
+  - 'for_each_link_cpus'
+  - 'for_each_link_platforms'
+  - 'for_each_lru'
+  - 'for_each_matching_node'
+  - 'for_each_matching_node_and_match'
+  - 'for_each_member'
+  - 'for_each_memcg_cache_index'
+  - 'for_each_mem_pfn_range'
+  - '__for_each_mem_range'
+  - 'for_each_mem_range'
+  - '__for_each_mem_range_rev'
+  - 'for_each_mem_range_rev'
+  - 'for_each_mem_region'
+  - 'for_each_migratetype_order'
+  - 'for_each_msi_entry'
+  - 'for_each_msi_entry_safe'
+  - 'for_each_msi_vector'
+  - 'for_each_net'
+  - 'for_each_net_continue_reverse'
+  - 'for_each_netdev'
+  - 'for_each_netdev_continue'
+  - 'for_each_netdev_continue_rcu'
+  - 'for_each_netdev_continue_reverse'
+  - 'for_each_netdev_feature'
+  - 'for_each_netdev_in_bond_rcu'
+  - 'for_each_netdev_rcu'
+  - 'for_each_netdev_reverse'
+  - 'for_each_netdev_safe'
+  - 'for_each_net_rcu'
+  - 'for_each_new_connector_in_state'
+  - 'for_each_new_crtc_in_state'
+  - 'for_each_new_mst_mgr_in_state'
+  - 'for_each_new_plane_in_state'
+  - 'for_each_new_private_obj_in_state'
+  - 'for_each_node'
+  - 'for_each_node_by_name'
+  - 'for_each_node_by_type'
+  - 'for_each_node_mask'
+  - 'for_each_node_state'
+  - 'for_each_node_with_cpus'
+  - 'for_each_node_with_property'
+  - 'for_each_nonreserved_multicast_dest_pgid'
+  - 'for_each_of_allnodes'
+  - 'for_each_of_allnodes_from'
+  - 'for_each_of_cpu_node'
+  - 'for_each_of_pci_range'
+  - 'for_each_old_connector_in_state'
+  - 'for_each_old_crtc_in_state'
+  - 'for_each_old_mst_mgr_in_state'
+  - 'for_each_oldnew_connector_in_state'
+  - 'for_each_oldnew_crtc_in_state'
+  - 'for_each_oldnew_mst_mgr_in_state'
+  - 'for_each_oldnew_plane_in_state'
+  - 'for_each_oldnew_plane_in_state_reverse'
+  - 'for_each_oldnew_private_obj_in_state'
+  - 'for_each_old_plane_in_state'
+  - 'for_each_old_private_obj_in_state'
+  - 'for_each_online_cpu'
+  - 'for_each_online_node'
+  - 'for_each_online_pgdat'
+  - 'for_each_pci_bridge'
+  - 'for_each_pci_dev'
+  - 'for_each_pci_msi_entry'
+  - 'for_each_pcm_streams'
+  - 'for_each_physmem_range'
+  - 'for_each_populated_zone'
+  - 'for_each_possible_cpu'
+  - 'for_each_present_cpu'
+  - 'for_each_prime_number'
+  - 'for_each_prime_number_from'
+  - 'for_each_process'
+  - 'for_each_process_thread'
+  - 'for_each_prop_codec_conf'
+  - 'for_each_prop_dai_codec'
+  - 'for_each_prop_dai_cpu'
+  - 'for_each_prop_dlc_codecs'
+  - 'for_each_prop_dlc_cpus'
+  - 'for_each_prop_dlc_platforms'
+  - 'for_each_property_of_node'
+  - 'for_each_registered_fb'
+  - 'for_each_requested_gpio'
+  - 'for_each_requested_gpio_in_range'
+  - 'for_each_reserved_mem_range'
+  - 'for_each_reserved_mem_region'
+  - 'for_each_rtd_codec_dais'
+  - 'for_each_rtd_components'
+  - 'for_each_rtd_cpu_dais'
+  - 'for_each_rtd_dais'
+  - 'for_each_set_bit'
+  - 'for_each_set_bit_from'
+  - 'for_each_set_clump8'
+  - 'for_each_sg'
+  - 'for_each_sg_dma_page'
+  - 'for_each_sg_page'
+  - 'for_each_sgtable_dma_page'
+  - 'for_each_sgtable_dma_sg'
+  - 'for_each_sgtable_page'
+  - 'for_each_sgtable_sg'
+  - 'for_each_sibling_event'
+  - 'for_each_subelement'
+  - 'for_each_subelement_extid'
+  - 'for_each_subelement_id'
+  - '__for_each_thread'
+  - 'for_each_thread'
+  - 'for_each_unicast_dest_pgid'
+  - 'for_each_vsi'
+  - 'for_each_wakeup_source'
+  - 'for_each_zone'
+  - 'for_each_zone_zonelist'
+  - 'for_each_zone_zonelist_nodemask'
+  - 'fwnode_for_each_available_child_node'
+  - 'fwnode_for_each_child_node'
+  - 'fwnode_graph_for_each_endpoint'
+  - 'gadget_for_each_ep'
+  - 'genradix_for_each'
+  - 'genradix_for_each_from'
+  - 'hash_for_each'
+  - 'hash_for_each_possible'
+  - 'hash_for_each_possible_rcu'
+  - 'hash_for_each_possible_rcu_notrace'
+  - 'hash_for_each_possible_safe'
+  - 'hash_for_each_rcu'
+  - 'hash_for_each_safe'
+  - 'hctx_for_each_ctx'
+  - 'hlist_bl_for_each_entry'
+  - 'hlist_bl_for_each_entry_rcu'
+  - 'hlist_bl_for_each_entry_safe'
+  - 'hlist_for_each'
+  - 'hlist_for_each_entry'
+  - 'hlist_for_each_entry_continue'
+  - 'hlist_for_each_entry_continue_rcu'
+  - 'hlist_for_each_entry_continue_rcu_bh'
+  - 'hlist_for_each_entry_from'
+  - 'hlist_for_each_entry_from_rcu'
+  - 'hlist_for_each_entry_rcu'
+  - 'hlist_for_each_entry_rcu_bh'
+  - 'hlist_for_each_entry_rcu_notrace'
+  - 'hlist_for_each_entry_safe'
+  - 'hlist_for_each_entry_srcu'
+  - '__hlist_for_each_rcu'
+  - 'hlist_for_each_safe'
+  - 'hlist_nulls_for_each_entry'
+  - 'hlist_nulls_for_each_entry_from'
+  - 'hlist_nulls_for_each_entry_rcu'
+  - 'hlist_nulls_for_each_entry_safe'
+  - 'i3c_bus_for_each_i2cdev'
+  - 'i3c_bus_for_each_i3cdev'
+  - 'ide_host_for_each_port'
+  - 'ide_port_for_each_dev'
+  - 'ide_port_for_each_present_dev'
+  - 'idr_for_each_entry'
+  - 'idr_for_each_entry_continue'
+  - 'idr_for_each_entry_continue_ul'
+  - 'idr_for_each_entry_ul'
+  - 'in_dev_for_each_ifa_rcu'
+  - 'in_dev_for_each_ifa_rtnl'
+  - 'inet_bind_bucket_for_each'
+  - 'inet_lhash2_for_each_icsk_rcu'
+  - 'key_for_each'
+  - 'key_for_each_safe'
+  - 'klp_for_each_func'
+  - 'klp_for_each_func_safe'
+  - 'klp_for_each_func_static'
+  - 'klp_for_each_object'
+  - 'klp_for_each_object_safe'
+  - 'klp_for_each_object_static'
+  - 'kunit_suite_for_each_test_case'
+  - 'kvm_for_each_memslot'
+  - 'kvm_for_each_vcpu'
+  - 'list_for_each'
+  - 'list_for_each_codec'
+  - 'list_for_each_codec_safe'
+  - 'list_for_each_continue'
+  - 'list_for_each_entry'
+  - 'list_for_each_entry_continue'
+  - 'list_for_each_entry_continue_rcu'
+  - 'list_for_each_entry_continue_reverse'
+  - 'list_for_each_entry_from'
+  - 'list_for_each_entry_from_rcu'
+  - 'list_for_each_entry_from_reverse'
+  - 'list_for_each_entry_lockless'
+  - 'list_for_each_entry_rcu'
+  - 'list_for_each_entry_reverse'
+  - 'list_for_each_entry_safe'
+  - 'list_for_each_entry_safe_continue'
+  - 'list_for_each_entry_safe_from'
+  - 'list_for_each_entry_safe_reverse'
+  - 'list_for_each_entry_srcu'
+  - 'list_for_each_prev'
+  - 'list_for_each_prev_safe'
+  - 'list_for_each_safe'
+  - 'llist_for_each'
+  - 'llist_for_each_entry'
+  - 'llist_for_each_entry_safe'
+  - 'llist_for_each_safe'
+  - 'mci_for_each_dimm'
+  - 'media_device_for_each_entity'
+  - 'media_device_for_each_intf'
+  - 'media_device_for_each_link'
+  - 'media_device_for_each_pad'
+  - 'nanddev_io_for_each_page'
+  - 'netdev_for_each_lower_dev'
+  - 'netdev_for_each_lower_private'
+  - 'netdev_for_each_lower_private_rcu'
+  - 'netdev_for_each_mc_addr'
+  - 'netdev_for_each_uc_addr'
+  - 'netdev_for_each_upper_dev_rcu'
+  - 'netdev_hw_addr_list_for_each'
+  - 'nft_rule_for_each_expr'
+  - 'nla_for_each_attr'
+  - 'nla_for_each_nested'
+  - 'nlmsg_for_each_attr'
+  - 'nlmsg_for_each_msg'
+  - 'nr_neigh_for_each'
+  - 'nr_neigh_for_each_safe'
+  - 'nr_node_for_each'
+  - 'nr_node_for_each_safe'
+  - 'of_for_each_phandle'
+  - 'of_property_for_each_string'
+  - 'of_property_for_each_u32'
+  - 'pci_bus_for_each_resource'
+  - 'pcl_for_each_chunk'
+  - 'pcl_for_each_segment'
+  - 'pcm_for_each_format'
+  - 'ping_portaddr_for_each_entry'
+  - 'plist_for_each'
+  - 'plist_for_each_continue'
+  - 'plist_for_each_entry'
+  - 'plist_for_each_entry_continue'
+  - 'plist_for_each_entry_safe'
+  - 'plist_for_each_safe'
+  - 'pnp_for_each_card'
+  - 'pnp_for_each_dev'
+  - 'protocol_for_each_card'
+  - 'protocol_for_each_dev'
+  - 'queue_for_each_hw_ctx'
+  - 'radix_tree_for_each_slot'
+  - 'radix_tree_for_each_tagged'
+  - 'rb_for_each'
+  - 'rbtree_postorder_for_each_entry_safe'
+  - 'rdma_for_each_block'
+  - 'rdma_for_each_port'
+  - 'rdma_umem_for_each_dma_block'
+  - 'resource_list_for_each_entry'
+  - 'resource_list_for_each_entry_safe'
+  - 'rhl_for_each_entry_rcu'
+  - 'rhl_for_each_rcu'
+  - 'rht_for_each'
+  - 'rht_for_each_entry'
+  - 'rht_for_each_entry_from'
+  - 'rht_for_each_entry_rcu'
+  - 'rht_for_each_entry_rcu_from'
+  - 'rht_for_each_entry_safe'
+  - 'rht_for_each_from'
+  - 'rht_for_each_rcu'
+  - 'rht_for_each_rcu_from'
+  - '__rq_for_each_bio'
+  - 'rq_for_each_bvec'
+  - 'rq_for_each_segment'
+  - 'scsi_for_each_prot_sg'
+  - 'scsi_for_each_sg'
+  - 'sctp_for_each_hentry'
+  - 'sctp_skb_for_each'
+  - 'shdma_for_each_chan'
+  - '__shost_for_each_device'
+  - 'shost_for_each_device'
+  - 'sk_for_each'
+  - 'sk_for_each_bound'
+  - 'sk_for_each_entry_offset_rcu'
+  - 'sk_for_each_from'
+  - 'sk_for_each_rcu'
+  - 'sk_for_each_safe'
+  - 'sk_nulls_for_each'
+  - 'sk_nulls_for_each_from'
+  - 'sk_nulls_for_each_rcu'
+  - 'snd_array_for_each'
+  - 'snd_pcm_group_for_each_entry'
+  - 'snd_soc_dapm_widget_for_each_path'
+  - 'snd_soc_dapm_widget_for_each_path_safe'
+  - 'snd_soc_dapm_widget_for_each_sink_path'
+  - 'snd_soc_dapm_widget_for_each_source_path'
+  - 'tb_property_for_each'
+  - 'tcf_exts_for_each_action'
+  - 'udp_portaddr_for_each_entry'
+  - 'udp_portaddr_for_each_entry_rcu'
+  - 'usb_hub_for_each_child'
+  - 'v4l2_device_for_each_subdev'
+  - 'v4l2_m2m_for_each_dst_buf'
+  - 'v4l2_m2m_for_each_dst_buf_safe'
+  - 'v4l2_m2m_for_each_src_buf'
+  - 'v4l2_m2m_for_each_src_buf_safe'
+  - 'virtio_device_for_each_vq'
+  - 'while_for_each_ftrace_op'
+  - 'xa_for_each'
+  - 'xa_for_each_marked'
+  - 'xa_for_each_range'
+  - 'xa_for_each_start'
+  - 'xas_for_each'
+  - 'xas_for_each_conflict'
+  - 'xas_for_each_marked'
+  - 'xbc_array_for_each_value'
+  - 'xbc_for_each_key_value'
+  - 'xbc_node_for_each_array_value'
+  - 'xbc_node_for_each_child'
+  - 'xbc_node_for_each_key_value'
+  - 'zorro_for_each_dev'
+  - 'for_each_line'
+  - 'for_each_non_empty_line'
+
 #IncludeBlocks: Preserve # Unknown to clang-format-5.0
 IncludeCategories:
   - Regex: '.*'

README.vty-tests

@@ -1,6 +1,6 @@
 To run the configuration parsing and output (VTY) test suite, first install
 
-  https://gitea.osmocom.org/cellular-infrastructure/osmo-python-tests
+  git://git.osmocom.org/python/osmo-python-tests
 
 and pass the following configure options here:
 

TODO-RELEASE

@@ -24,3 +24,5 @@
 # If any interfaces have been removed or changed since the last public release, a=0.
 #
 #library		what		description / commit summary line
+update dependency to libosmocore > 1.5.1 for our use of osmo_sock_set_dscp()
+libosmo-mgcp-client  struct mgcp_client_conf ABI breackage

configure.ac

@@ -44,16 +44,15 @@ AC_SEARCH_LIBS([dlsym], [dl dld], [LIBRARY_DLSYM="$LIBS";LIBS=""])
 AC_SUBST(LIBRARY_DLSYM)
 
 
-PKG_CHECK_MODULES(LIBOSMOCORE, libosmocore >= 1.9.0)
-PKG_CHECK_MODULES(LIBOSMOGSM, libosmogsm >= 1.9.0)
-PKG_CHECK_MODULES(LIBOSMOCTRL, libosmoctrl >= 1.9.0)
-PKG_CHECK_MODULES(LIBOSMOVTY, libosmovty >= 1.9.0)
-PKG_CHECK_MODULES(LIBOSMONETIF, libosmo-netif >= 1.4.0)
-PKG_CHECK_MODULES(LIBOSMOABIS, libosmoabis >= 1.5.0)
-PKG_CHECK_MODULES(LIBOSMOTRAU, libosmotrau >= 1.5.0)
+PKG_CHECK_MODULES(LIBOSMOCORE, libosmocore >= 1.5.0)
+PKG_CHECK_MODULES(LIBOSMOGSM, libosmogsm >= 1.5.0)
+PKG_CHECK_MODULES(LIBOSMOCTRL, libosmoctrl >= 1.5.0)
+PKG_CHECK_MODULES(LIBOSMOVTY, libosmovty >= 1.5.0)
+PKG_CHECK_MODULES(LIBOSMONETIF, libosmo-netif >= 1.1.0)
+PKG_CHECK_MODULES(LIBOSMOABIS, libosmoabis >= 1.1.0)
+PKG_CHECK_MODULES(LIBOSMOTRAU, libosmotrau >= 1.1.0)
 
-CFLAGS="$CFLAGS -DBUILDING_LIBOSMOMGCPCLIENT -pthread"
-CPPFLAGS="$CPPFLAGS -DBUILDING_LIBOSMOMGCPCLIENT -pthread"
+CFLAGS="$CFLAGS -pthread"
 LDFLAGS="$LDFLAGS -pthread"
 
 AC_ARG_ENABLE(sanitize,
@@ -80,7 +79,6 @@ AC_ARG_ENABLE(werror,
 if test x"$werror" = x"yes"
 then
 	WERROR_FLAGS="-Werror"
-	WERROR_FLAGS+=" -Werror=implicit-int -Werror=int-conversion -Werror=old-style-definition"
 	WERROR_FLAGS+=" -Wno-error=deprecated -Wno-error=deprecated-declarations"
 	WERROR_FLAGS+=" -Wno-error=cpp" # "#warning"
 	CFLAGS="$CFLAGS $WERROR_FLAGS"
@@ -114,7 +112,7 @@ if test "x$enable_ext_tests" = "xyes" ; then
 	AM_PATH_PYTHON
 	AC_CHECK_PROG(OSMOTESTEXT_CHECK,osmotestvty.py,yes)
 	 if test "x$OSMOTESTEXT_CHECK" != "xyes" ; then
-		AC_MSG_ERROR([Please install https://gitea.osmocom.org/cellular-infrastructure/osmo-python-tests to run the VTY/CTRL tests.])
+		AC_MSG_ERROR([Please install git://osmocom.org/python/osmo-python-tests to run the VTY/CTRL tests.])
 	fi
 fi
 AC_MSG_CHECKING([whether to enable VTY/CTRL tests])

contrib/ipa.py

@@ -15,6 +15,10 @@
  * 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.
  */
 """
 

contrib/osmo-mgw.spec.in

@@ -29,30 +29,30 @@ BuildRequires:  pkgconfig >= 0.20
 %if 0%{?suse_version}
 BuildRequires:  systemd-rpm-macros
 %endif
-BuildRequires:  pkgconfig(libosmo-netif) >= 1.4.0
-BuildRequires:  pkgconfig(libosmocore) >= 1.9.0
-BuildRequires:  pkgconfig(libosmoctrl) >= 1.9.0
-BuildRequires:  pkgconfig(libosmogsm) >= 1.9.0
-BuildRequires:  pkgconfig(libosmovty) >= 1.9.0
-BuildRequires:  pkgconfig(libosmocoding) >= 1.9.0
-BuildRequires:  pkgconfig(libosmoabis) >= 1.5.0
-BuildRequires:  pkgconfig(libosmotrau) >= 1.5.0
+BuildRequires:  pkgconfig(libosmo-netif) >= 1.1.0
+BuildRequires:  pkgconfig(libosmocore) >= 1.5.0
+BuildRequires:  pkgconfig(libosmoctrl) >= 1.5.0
+BuildRequires:  pkgconfig(libosmogsm) >= 1.5.0
+BuildRequires:  pkgconfig(libosmovty) >= 1.5.0
+BuildRequires:  pkgconfig(libosmocoding) >= 1.5.0
+BuildRequires:  pkgconfig(libosmoabis) >= 1.1.0
+BuildRequires:  pkgconfig(libosmotrau) >= 1.1.0
 %{?systemd_requires}
 
 %description
 OsmoMGW is Osmocom's Media Gateway for 2G and 3G circuit-switched mobile networks.
 
-%package -n libosmo-mgcp-client12
+%package -n libosmo-mgcp-client8
 Summary:        Osmocom's Media Gateway Control Protocol client library
 Group:          System/Libraries
 
-%description -n libosmo-mgcp-client12
+%description -n libosmo-mgcp-client8
 Osmocom's Media Gateway Control Protocol client library.
 
 %package -n libosmo-mgcp-client-devel
 Summary:        Development files for Osmocom's Media Gateway Control Protocol client library
 Group:          Development/Libraries/C and C++
-Requires:       libosmo-mgcp-client12 = %{version}
+Requires:       libosmo-mgcp-client8 = %{version}
 
 %description -n libosmo-mgcp-client-devel
 Osmocom's Media Gateway Control Protocol client librarary.
@@ -90,8 +90,8 @@ find %{buildroot} -type f -name "*.la" -delete -print
 %check
 make %{?_smp_mflags} check || (find . -name testsuite.log -exec cat {} +)
 
-%post   -n libosmo-mgcp-client12 -p /sbin/ldconfig
-%postun -n libosmo-mgcp-client12 -p /sbin/ldconfig
+%post   -n libosmo-mgcp-client8 -p /sbin/ldconfig
+%postun -n libosmo-mgcp-client8 -p /sbin/ldconfig
 
 %if 0%{?suse_version}
 %preun
@@ -119,8 +119,8 @@ make %{?_smp_mflags} check || (find . -name testsuite.log -exec cat {} +)
 %dir %{_sysconfdir}/osmocom
 %config(noreplace) %{_sysconfdir}/osmocom/osmo-mgw.cfg
 
-%files -n libosmo-mgcp-client12
-%{_libdir}/libosmo-mgcp-client.so.12*
+%files -n libosmo-mgcp-client8
+%{_libdir}/libosmo-mgcp-client.so.8*
 
 %files -n libosmo-mgcp-client-devel
 %{_libdir}/libosmo-mgcp-client.so

contrib/rtp-load-gen/Makefile

@@ -0,0 +1,11 @@
+CFLAGS=-g -Wall $(shell pkg-config --cflags libosmocore libosmoctrl libosmo-netif liburing)
+LIBS=-lpthread $(shell pkg-config --libs libosmocore libosmoctrl libosmo-netif liburing)
+
+rtp-load-gen: rtp-load-gen.o rtp_provider.o rtp_provider_static.o ctrl_if.o
+	$(CC) -o $@ $^ $(LIBS)
+
+%.o: %.c
+	$(CC) $(CFLAGS) -o $@ -c $^
+
+clean:
+	@rm rtp-load-gen *.o

contrib/rtp-load-gen/ctrl_if.c

@@ -0,0 +1,214 @@
+/* CTRL interface of rtpsource program
+ *
+ * (C) 2020 by Harald Welte <laforge@gnumonks.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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <osmocom/ctrl/control_cmd.h>
+
+#include "internal.h"
+#include "rtp_provider.h"
+
+static struct rtpsim_connection *find_connection_by_cname(const char *cname)
+{
+	struct rtpsim_connection *rtpc;
+	struct rtpsim_instance *ri;
+
+	pthread_rwlock_rdlock(&g_rtpsim->rwlock);
+	llist_for_each_entry(ri, &g_rtpsim->instances, list) {
+		rtpc = rtpsim_conn_find(ri, cname);
+		if (rtpc) {
+			pthread_rwlock_unlock(&g_rtpsim->rwlock);
+			return rtpc;
+		}
+	}
+	pthread_rwlock_unlock(&g_rtpsim->rwlock);
+	return NULL;
+}
+
+static struct rtpsim_connection *create_connection(const char *cname, enum codec_type codec)
+{
+	struct rtpsim_connection *rtpc;
+	struct rtpsim_instance *ri;
+
+	pthread_rwlock_rdlock(&g_rtpsim->rwlock);
+	llist_for_each_entry(ri, &g_rtpsim->instances, list) {
+		rtpc = rtpsim_conn_reserve(ri, cname, codec);
+		if (rtpc) {
+			pthread_rwlock_unlock(&g_rtpsim->rwlock);
+			return rtpc;
+		}
+	}
+	pthread_rwlock_unlock(&g_rtpsim->rwlock);
+	return NULL;
+}
+
+static int connect_connection(struct rtpsim_connection *rtpc, const char *remote_host,
+			      uint16_t remote_port, uint8_t pt)
+{
+	int rc;
+
+	osmo_sockaddr_str_from_str(&rtpc->cfg.remote, remote_host, remote_port);
+	rtpc->cfg.pt = pt;
+
+	rc = rtpsim_conn_connect(rtpc);
+	if (rc < 0)
+		return rc;
+
+	rc = rtpsim_conn_start(rtpc);
+
+	return rc;
+}
+
+static int delete_connection(struct rtpsim_connection *rtpc)
+{
+	rtpsim_conn_stop(rtpc);
+	rtpsim_conn_unreserve(rtpc);
+	return 0;
+}
+
+CTRL_CMD_DEFINE_WO_NOVRF(rtp_create, "rtp_create");
+static int set_rtp_create(struct ctrl_cmd *cmd, void *data)
+{
+	struct rtpsim_connection *conn;
+	const char *cname, *codec_str;
+	char *tmp, *saveptr;
+	enum codec_type codec;
+
+	tmp = talloc_strdup(cmd, cmd->value);
+	OSMO_ASSERT(tmp);
+
+	cname = strtok_r(tmp, ",", &saveptr);
+	codec_str = strtok_r(NULL, ",", &saveptr);
+
+	if (!cname || !codec_str) {
+		cmd->reply = "Format is cname,codec";
+		goto error;
+	}
+
+	if (find_connection_by_cname(cname)) {
+		cmd->reply = "Connection already exists for cname";
+		goto error;
+	}
+
+	codec = get_string_value(codec_type_names, codec_str);
+	if (codec < 0) {
+		cmd->reply = "Invalid codec name (try GSM_FR, GSM_EFR etc.)";
+		goto error;
+	}
+
+	conn = create_connection(cname, codec);
+	if (!conn) {
+		cmd->reply = "Error creating RTP connection";
+		goto error;
+	}
+
+	/* Respond */
+	cmd->reply = talloc_asprintf(cmd, "%s,%s,%d", conn->cname, conn->cfg.local.ip, conn->cfg.local.port);
+	talloc_free(tmp);
+	return CTRL_CMD_REPLY;
+
+error:
+	talloc_free(tmp);
+	return CTRL_CMD_ERROR;
+}
+
+CTRL_CMD_DEFINE_WO_NOVRF(rtp_connect, "rtp_connect");
+static int set_rtp_connect(struct ctrl_cmd *cmd, void *data)
+{
+	struct rtpsim_connection *conn;
+	const char *cname, *remote_host, *remote_port, *pt;
+	char *tmp, *saveptr;
+	int rc;
+
+	tmp = talloc_strdup(cmd, cmd->value);
+	OSMO_ASSERT(tmp);
+
+	/* FIXME: parse command */
+	cname = strtok_r(tmp, ",", &saveptr);
+	remote_host = strtok_r(NULL, ",", &saveptr);
+	remote_port = strtok_r(NULL, ",", &saveptr);
+	pt = strtok_r(NULL, ",", &saveptr);
+
+	if (!cname || !remote_host || !remote_port || !pt) {
+		cmd->reply = "Format is cname,remote_host,remote_port,pt";
+		talloc_free(tmp);
+		return CTRL_CMD_ERROR;
+	}
+
+	conn = find_connection_by_cname(cname);
+	if (!conn) {
+		cmd->reply = "Error finding RTP connection for connect";
+		talloc_free(tmp);
+		return CTRL_CMD_ERROR;
+	}
+
+	rc = connect_connection(conn, remote_host, atoi(remote_port), atoi(pt));
+	if (rc < 0) {
+		cmd->reply = "Error binding RTP connection";
+		talloc_free(tmp);
+		return CTRL_CMD_ERROR;
+	}
+
+	/* Respond */
+	talloc_free(tmp);
+	cmd->reply = talloc_asprintf(cmd, "%s,%s,%d,%d", conn->cname, conn->cfg.remote.ip,
+					conn->cfg.remote.port, conn->cfg.pt);
+	return CTRL_CMD_REPLY;
+}
+
+CTRL_CMD_DEFINE_WO_NOVRF(rtp_delete, "rtp_delete");
+static int set_rtp_delete(struct ctrl_cmd *cmd, void *data)
+{
+	struct rtpsim_connection *conn;
+	const char *cname = cmd->value;
+
+	conn = find_connection_by_cname(cname);
+	if (!conn) {
+		cmd->reply = "Error finding RTP connection for delete";
+		return CTRL_CMD_ERROR;
+	}
+	cmd->reply = talloc_asprintf(cmd, "%s", conn->cname);
+
+	delete_connection(conn);
+
+	/* Respond */
+	return CTRL_CMD_REPLY;
+}
+
+
+
+
+
+int rtpsource_ctrl_cmds_install(void)
+{
+	int rc;
+
+	rc = ctrl_cmd_install(CTRL_NODE_ROOT, &cmd_rtp_create);
+	if (rc)
+		goto end;
+
+	rc = ctrl_cmd_install(CTRL_NODE_ROOT, &cmd_rtp_connect);
+	if (rc)
+		goto end;
+
+	rc = ctrl_cmd_install(CTRL_NODE_ROOT, &cmd_rtp_delete);
+	if (rc)
+		goto end;
+end:
+	return rc;
+}

contrib/rtp-load-gen/internal.h

@@ -0,0 +1,112 @@
+#pragma once
+#include <stdint.h>
+#include <pthread.h>
+#include <liburing.h>
+
+#include <osmocom/core/linuxlist.h>
+#include <osmocom/core/sockaddr_str.h>
+#include <osmocom/core/rate_ctr.h>
+#include <osmocom/core/select.h>
+#include <osmocom/ctrl/control_if.h>
+
+struct rtp_provider_instance;
+
+/* configuration of one RTP connection/socket */
+struct rtpsim_connection_cfg {
+	struct osmo_sockaddr_str local;
+	struct osmo_sockaddr_str remote;
+	uint8_t pt;
+	uint32_t ssrc;
+	uint32_t duration;
+};
+
+/* TX side state of RTP connection/socket */
+struct rtpsim_connection_tx {
+	bool enabled;
+	uint32_t timestamp;
+	uint16_t seq;
+
+	struct rtp_provider_instance *rtp_prov_inst;
+
+	/* transmit buffer for outgoing messages */
+	uint8_t *buf;
+	/* used part of buffer */
+	size_t buf_len;
+};
+
+/* RX side state of RTP connection/socket */
+struct rtpsim_connection_rx {
+	bool enabled;
+	/* receive buffer for incoming messages */
+	uint8_t *buf;
+	/* used length of buffer */
+	size_t buf_len;
+};
+
+struct rtpsim_instance;
+
+/* One RTP connection/socket */
+struct rtpsim_connection {
+	/* index in rtp_instance.connections */
+	unsigned int idx;
+	/* back-pointer */
+	struct rtpsim_instance *inst;
+
+	struct rtpsim_connection_cfg cfg;
+	struct rtpsim_connection_tx tx;
+	struct rtpsim_connection_rx rx;
+	struct rate_ctr_group *ctrg;
+
+	/* socket file descriptor */
+	int fd;
+	char *cname;
+};
+
+struct rtpsim_instance_cfg {
+	int num;
+	uint16_t base_port;
+	unsigned int num_flows;
+};
+
+/* one instance of the RTP simulator; typically one per worker thread */
+struct rtpsim_instance {
+	/* element in application global list of instances */
+	struct llist_head list;
+	struct rtpsim_instance_cfg cfg;
+	/* per-instance io_uring */
+	struct io_uring ring;
+	/* per-instance timerfd */
+	int timerfd;
+	/* counter group of per-instance counters */
+	struct rate_ctr_group *ctrg;
+
+	struct rtpsim_connection **connections;
+	/* size of 'connections' in number of pointers */
+	unsigned int connections_size;
+};
+
+struct rtpsim_global {
+	/* global list of instances */
+	struct llist_head instances;
+	pthread_rwlock_t rwlock;
+
+	struct ctrl_handle *ctrl;
+};
+
+
+enum {
+	DMAIN,
+};
+
+enum codec_type;
+
+extern struct rtpsim_global *g_rtpsim;
+
+struct rtpsim_connection *rtpsim_conn_find(struct rtpsim_instance *ri, const char *cname);
+struct rtpsim_connection *rtpsim_conn_reserve(struct rtpsim_instance *ri, const char *cname, enum codec_type codec);
+int rtpsim_conn_start(struct rtpsim_connection *rtpc);
+void rtpsim_conn_stop(struct rtpsim_connection *rtpc);
+void rtpsim_conn_unreserve(struct rtpsim_connection *rtpc);
+int rtpsim_conn_connect(struct rtpsim_connection *rtpc);
+
+int rtpsource_ctrl_cmds_install(void);

contrib/rtp-load-gen/rtp-load-gen.c

@@ -0,0 +1,560 @@
+#include <liburing.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <sys/timerfd.h>
+
+#include <osmocom/core/talloc.h>
+#include <osmocom/core/utils.h>
+#include <osmocom/core/linuxlist.h>
+#include <osmocom/core/sockaddr_str.h>
+#include <osmocom/core/socket.h>
+#include <osmocom/core/rate_ctr.h>
+#include <osmocom/core/application.h>
+#include <osmocom/core/stats.h>
+#include <osmocom/netif/rtp.h>
+
+#include "internal.h"
+#include "rtp_provider.h"
+#include "internal.h"
+
+/* use a separate rx-completion thread: submit from main, reap from completion */
+//#define USE_CQ_THREAD
+
+/* use registered files: Doesn't seem to work with sockets? */
+//#define USE_REGISTERED_FILES
+
+/* use registered buffers (mapped once into kernel, rather than at every write */
+#define USE_REGISTERED_BUFFERS
+
+/* number of sockets/flows to create */
+#define NUM_FLOWS	4096
+
+/* number of workers to spawn.  Each worker will get an equal share of NR_FLOWS to work on */
+#define NR_WORKERS	4
+
+/* size of rx/tx buffer for one RTP frame */
+#define BUF_SIZE	256
+
+#define NUM_FLOWS_PER_WORKER	(NUM_FLOWS/NR_WORKERS)
+
+#define TX_BUF_IDX	0
+#define RX_BUF_IDX	1
+
+struct rtpsim_global *g_rtpsim;
+
+enum rtpsim_conn_ctr {
+	RTP_CONN_CTR_TX_PKTS,
+	RTP_CONN_CTR_TX_BYTES,
+	RTP_CONN_CTR_RX_PKTS,
+	RTP_CONN_CTR_RX_BYTES,
+	RTP_CONN_CTR_RX_INVALID,
+};
+
+static const struct rate_ctr_desc rtpsim_conn_ctrs[] = {
+	[RTP_CONN_CTR_TX_PKTS] = { "tx_pkts:total", "Transmitted packets" },
+	[RTP_CONN_CTR_TX_BYTES] = { "tx_bytes:total", "Transmitted bytes" },
+	[RTP_CONN_CTR_RX_PKTS] = { "rx_pkts:total", "Received packets (total)" },
+	[RTP_CONN_CTR_RX_BYTES] = { "rx_bytes:total", "Transmitted bytes" },
+	[RTP_CONN_CTR_RX_INVALID] = { "rx_pkts:invalid", "Received packets (invalidl)" },
+};
+static const struct rate_ctr_group_desc rtpsim_conn_ctrg_desc = {
+	.group_name_prefix = "rtpsim_conn",
+	.group_description = "RTP Simulator Connection",
+	.class_id = 0,
+	.num_ctr = ARRAY_SIZE(rtpsim_conn_ctrs),
+	.ctr_desc = rtpsim_conn_ctrs,
+};
+
+enum rtpsim_ctr {
+	RTP_INST_TIMERS_TOTAL,
+	RTP_INST_TIMERS_LATE,
+};
+static const struct rate_ctr_desc rtpsim_ctrs[] = {
+	[RTP_INST_TIMERS_TOTAL] = { "timers:total", "Timers expiring (total)" },
+	[RTP_INST_TIMERS_LATE] = { "timers:late", "Timers expiring (late)" },
+};
+static const struct rate_ctr_group_desc rtpsim_ctrg_desc = {
+	.group_name_prefix = "rtpsim",
+	.group_description = "RTP Simulator Instance",
+	.class_id = 0,
+	.num_ctr = ARRAY_SIZE(rtpsim_ctrs),
+	.ctr_desc = rtpsim_ctrs,
+};
+
+struct rtpsim_instance *rtpsim_instance_init(void *ctx, const struct rtpsim_instance_cfg *rmp)
+{
+	struct rtpsim_instance *ri = talloc_zero(ctx, struct rtpsim_instance);
+	int rc;
+
+	if (!ri)
+		return NULL;
+	ri->connections_size = NUM_FLOWS_PER_WORKER;
+	ri->connections = talloc_zero_size(ri, sizeof(struct rtpsim_connection *)*ri->connections_size);
+	if (!ri->connections) {
+		talloc_free(ri);
+		return NULL;
+	}
+
+	ri->cfg = *rmp;
+	rc = io_uring_queue_init(NUM_FLOWS_PER_WORKER*2, &ri->ring, 0);
+	if (rc < 0) {
+		talloc_free(ri);
+		return NULL;
+	}
+	ri->ctrg = rate_ctr_group_alloc(ri, &rtpsim_ctrg_desc, rmp->num);
+	OSMO_ASSERT(ri->ctrg);
+	return ri;
+}
+
+static int rtpsim_instance_conn_add(struct rtpsim_instance *ri, struct rtpsim_connection *rtpc)
+{
+	unsigned int i;
+
+	for (i = 0; i < ri->connections_size; i++) {
+		if (ri->connections[i] == NULL) {
+			ri->connections[i] = rtpc;
+			rtpc->idx = i;
+			return i;
+		}
+	}
+	return -ENOSPC;
+}
+
+static struct rtpsim_connection *
+rtpsim_conn_open_bind(struct rtpsim_instance *ri, const struct rtpsim_connection_cfg *rcfg)
+{
+	struct rtpsim_connection *rtpc = talloc_zero(ri, struct rtpsim_connection);
+	struct osmo_sockaddr sa_local;
+	int rc;
+
+	if (!rtpc)
+		return NULL;
+
+	rtpc->inst = ri;
+	rtpc->cfg = *rcfg;
+
+	osmo_sockaddr_str_to_sockaddr(&rtpc->cfg.local, &sa_local.u.sas);
+
+	rc = osmo_sock_init_osa(SOCK_DGRAM, IPPROTO_UDP, &sa_local, NULL, OSMO_SOCK_F_BIND);
+	if (rc < 0) {
+		talloc_free(rtpc);
+		return NULL;
+	}
+
+	rtpc->fd = rc;
+	rtpc->ctrg = rate_ctr_group_alloc(rtpc, &rtpsim_conn_ctrg_desc, rtpc->cfg.local.port);
+	OSMO_ASSERT(rtpc->ctrg);
+#ifndef USE_REGISTERED_BUFFERS
+	rtpc->tx.buf = talloc_zero_size(rtpc, BUF_SIZE);
+	rtpc->rx.buf = talloc_zero_size(rtpc, BUF_SIZE);
+#endif
+	OSMO_ASSERT(rtpsim_instance_conn_add(ri, rtpc) >= 0);
+
+	return rtpc;
+}
+
+/* find a connection for given cname (may be NULL to find unused connection) */
+struct rtpsim_connection *rtpsim_conn_find(struct rtpsim_instance *ri, const char *cname)
+{
+	int i;
+
+	for (i = 0; i < ri->connections_size; i++) {
+		struct rtpsim_connection *rtpc = ri->connections[i];
+		if (!rtpc)
+			continue;
+		if (!rtpc->cname) {
+			if (!cname)
+				return rtpc;
+		} else {
+			continue;
+		}
+		if (!strcmp(rtpc->cname, cname))
+			return rtpc;
+	}
+	return NULL;
+}
+
+/* reserve a connection; associates cname with it */
+struct rtpsim_connection *rtpsim_conn_reserve(struct rtpsim_instance *ri, const char *cname,
+					      enum codec_type codec)
+{
+	struct rtpsim_connection *rtpc;
+	const struct rtp_provider *rtp_prov;
+
+	rtp_prov = rtp_provider_find("static"); // TODO: configurable */
+	OSMO_ASSERT(rtp_prov);
+
+	rtpc = rtpsim_conn_find(ri, NULL);
+	if (!rtpc)
+		return NULL;
+
+	/* this is called from main thread, we cannot use per-thread talloc contexts
+	 * such as ri or rtpc */
+	rtpc->cname = talloc_strdup(g_rtpsim, cname);
+	rtpc->tx.rtp_prov_inst = rtp_provider_instance_alloc(g_rtpsim, rtp_prov, codec);
+	OSMO_ASSERT(rtpc->tx.rtp_prov_inst);
+
+	/* re-start from zero transmit sequence number */
+	rtpc->tx.seq = 0;
+
+	return rtpc;
+}
+
+int rtpsim_conn_start(struct rtpsim_connection *rtpc)
+{
+	rtpc->tx.enabled = true;
+	rtpc->rx.enabled = true;
+
+	return 0;
+}
+
+void rtpsim_conn_stop(struct rtpsim_connection *rtpc)
+{
+	/* disable Rx and Tx */
+	rtpc->tx.enabled = false;
+	rtpc->rx.enabled = false;
+}
+
+/* unreserve a connection; stops all rx/tx and removes cname */
+void rtpsim_conn_unreserve(struct rtpsim_connection *rtpc)
+{
+	rtp_provider_instance_free(rtpc->tx.rtp_prov_inst);
+	rtpc->tx.rtp_prov_inst = NULL;
+
+	talloc_free(rtpc->cname);
+	rtpc->cname = NULL;
+}
+
+/* connect a RTP connection to its remote peer (as in rtpc->cfg.remote) */
+int rtpsim_conn_connect(struct rtpsim_connection *rtpc)
+{
+	struct osmo_sockaddr sa_remote;
+	int rc;
+
+	osmo_sockaddr_str_to_sockaddr(&rtpc->cfg.remote, &sa_remote.u.sas);
+	rc = connect(rtpc->fd, &sa_remote.u.sa, sizeof(struct osmo_sockaddr));
+	return rc;
+}
+
+/* transmit one RTP frame for given connection */
+static int rtpsim_conn_tx_frame(struct rtpsim_connection *rtpc)
+{
+	struct rtp_hdr *rtph = (struct rtp_hdr *) rtpc->tx.buf;
+	struct io_uring_sqe *sqe;
+	uint8_t *payload;
+	int rc;
+
+	rtph->version = RTP_VERSION;
+	rtph->padding = 0;
+	rtph->extension = 0;
+	rtph->csrc_count = 0;
+	rtph->marker = 0;
+	rtph->payload_type = rtpc->cfg.pt;
+	rtph->sequence = htons(rtpc->tx.seq++);
+	rtph->timestamp = htonl(rtpc->tx.timestamp);
+	rtpc->tx.timestamp += rtpc->cfg.duration;
+	rtph->ssrc = htonl(rtpc->cfg.ssrc);
+	payload = rtpc->tx.buf + sizeof(*rtph);
+	/* add payload data */
+
+	rc = rtp_provider_instance_gen_frame(rtpc->tx.rtp_prov_inst, payload, BUF_SIZE-sizeof(*rtph));
+	OSMO_ASSERT(rc >= 0);
+	rtpc->tx.buf_len = sizeof(*rtph) + rc;
+
+	sqe = io_uring_get_sqe(&rtpc->inst->ring);
+	OSMO_ASSERT(sqe);
+	sqe->user_data = rtpc->idx;
+#ifdef USE_REGISTERED_FILES
+	io_uring_sqe_set_flags(sqe, IOSQE_FIXED_FILE);
+#ifdef USE_REGISTERED_BUFFERS
+	io_uring_prep_write_fixed(sqe, rtpc->idx, rtpc->tx.buf, rtpc->tx.buf_len, 0, TX_BUF_IDX);
+#else
+	io_uring_prep_write(sqe, rtpc->idx, rtpc->tx.buf, rtpc->tx.buf_len, 0);
+#endif
+#else /* REGISTERED FILES */
+#ifdef USE_REGISTERED_BUFFERS
+	io_uring_prep_write_fixed(sqe, rtpc->fd, rtpc->tx.buf, rtpc->tx.buf_len, 0, TX_BUF_IDX);
+#else
+	io_uring_prep_write(sqe, rtpc->fd, rtpc->tx.buf, rtpc->tx.buf_len, 0);
+#endif
+#endif /* REGISTERED_FILES */
+
+	return 0;
+}
+
+/* submit RX buffer for a RTP frame on given connection */
+static int rtpsim_conn_rx_prep(struct rtpsim_connection *rtpc)
+{
+	struct io_uring_sqe *sqe;
+
+	sqe = io_uring_get_sqe(&rtpc->inst->ring);
+	OSMO_ASSERT(sqe);
+	sqe->user_data = 0x8000000 | rtpc->idx;
+#ifdef USE_REGISTERED_FILES
+	io_uring_sqe_set_flags(sqe, IOSQE_FIXED_FILE);
+	/* FIXME */
+#else /* REGISTERED FILES */
+#ifdef USE_REGISTERED_BUFFERS
+	io_uring_prep_read_fixed(sqe, rtpc->fd, rtpc->rx.buf, BUF_SIZE, 0, RX_BUF_IDX);
+#else
+	io_uring_prep_read(sqe, rtpc->fd, rtpc->rx.buf, BUF_SIZE, 0);
+#endif
+#endif /* REGISTERED_FILES */
+	return 0;
+}
+
+/* process one completion entry */
+static void handle_completion(struct rtpsim_instance *ri, struct io_uring_cqe *cqe)
+{
+	struct rtpsim_connection *rtpc = ri->connections[cqe->user_data & 0x7fffffff];
+	OSMO_ASSERT(rtpc);
+
+	if (cqe->user_data & 0x80000000) {
+		/* read */
+		rate_ctr_inc(&rtpc->ctrg->ctr[RTP_CONN_CTR_RX_PKTS]);
+		rate_ctr_add(&rtpc->ctrg->ctr[RTP_CONN_CTR_RX_BYTES], cqe->res);
+		OSMO_ASSERT(cqe->res >= 0);
+	} else {
+		/* write */
+		rate_ctr_inc(&rtpc->ctrg->ctr[RTP_CONN_CTR_TX_PKTS]);
+		rate_ctr_add(&rtpc->ctrg->ctr[RTP_CONN_CTR_TX_BYTES], cqe->res);
+		OSMO_ASSERT(cqe->res == sizeof(struct rtp_hdr) + 33);
+	}
+	io_uring_cqe_seen(&ri->ring, cqe);
+}
+
+#ifdef USE_CQ_THREAD
+/* 'main' function for separate completion queue reaping thread */
+static void *reap_completion(void *_ri)
+{
+	struct rtpsim_instance *ri = _ri;
+	while (1) {
+		struct io_uring_cqe *cqe;
+		int rc;
+
+		rc = io_uring_wait_cqe(&ri->ring, &cqe);
+		OSMO_ASSERT(rc >= 0);
+		handle_completion(ri, cqe);
+	}
+}
+#endif
+
+extern int osmo_ctx_init(const char *id);
+
+static void rtpsim_main(const struct rtpsim_instance_cfg *rmp)
+{
+	struct rtpsim_instance *ri;
+	struct rtpsim_connection *rtpc;
+	int i, rc;
+
+	char namebuf[32];
+	snprintf(namebuf, sizeof(namebuf), "rtpsim_worker%d", rmp->num);
+	osmo_ctx_init(namebuf);
+
+	ri = rtpsim_instance_init(OTC_GLOBAL, rmp);
+	OSMO_ASSERT(ri);
+
+	pthread_rwlock_wrlock(&g_rtpsim->rwlock);
+	llist_add_tail(&ri->list, &g_rtpsim->instances);
+	pthread_rwlock_unlock(&g_rtpsim->rwlock);
+
+	/* create desired number of sockets */
+	printf("binding sockets\n");
+	for (i = 0; i < rmp->num_flows; i++) {
+		struct rtpsim_connection *rtpc;
+		struct rtpsim_connection_cfg rcfg = {};
+		rcfg.local = (struct osmo_sockaddr_str) {
+			.af = AF_INET,
+			.ip = "127.0.0.1",
+			.port = rmp->base_port + 2*i,
+		};
+		rcfg.remote = (struct osmo_sockaddr_str) {
+			.af = AF_INET,
+			.ip = "127.0.0.1",
+			.port = rmp->base_port + 2*i,
+		};
+		rcfg.pt = 3;
+		rcfg.ssrc = 0x80000000 + rmp->base_port + i;
+		rcfg.duration = 160;	/* 8000 Hz sampling rate / 50 Hz RTP rate */
+
+		rtpc = rtpsim_conn_open_bind(ri, &rcfg);
+		OSMO_ASSERT(rtpc);
+	}
+
+#if 1
+	/* HACK */
+	printf("connecting sockets\n");
+	for (i = 0; i < rmp->num_flows; i++) {
+		char namebuf[32];
+		snprintf(namebuf, sizeof(namebuf), "conn%d", i);
+		struct rtpsim_connection *rtpc = rtpsim_conn_reserve(ri, namebuf, CODEC_GSM_FR);
+		OSMO_ASSERT(rtpc);
+		OSMO_ASSERT(rtpsim_conn_connect(rtpc) == 0);
+		OSMO_ASSERT(rtpsim_conn_start(rtpc) == 0);
+	}
+#endif
+
+#ifdef USE_REGISTERED_FILES
+	/* register all our file descriptors; seems to fail on 5.8.x ? */
+	int fds[NUM_FLOWS_PER_WORKER];
+	for (i = 0; i < ri->connections_size; i++) {
+		if (!rtpc) {
+			fds[i] = -1;
+			continue;
+		}
+		rtpc = ri->connections[i];
+		fds[i] = rtpc->fd;
+	}
+	printf("Registering %d files\n", i);
+	rc = io_uring_register_files(&ri->ring, fds, i);
+	printf("rc = %d: %s\n", rc, strerror(-rc));
+	OSMO_ASSERT(rc == 0);
+#endif
+
+#ifdef USE_REGISTERED_BUFFERS
+	/* register two large buffers for Rx and Tx; assign per-connection
+	 * buffers within those two registered buffers */
+	void *largebuf_tx = talloc_zero_size(ri, rmp->num_flows * BUF_SIZE);
+	void *largebuf_rx = talloc_zero_size(ri, rmp->num_flows * BUF_SIZE);
+	struct iovec iov[2] = {
+		[TX_BUF_IDX] = {
+			.iov_base = largebuf_tx,
+			.iov_len = rmp->num_flows * BUF_SIZE,
+		},
+		[RX_BUF_IDX] = {
+			.iov_base = largebuf_rx,
+			.iov_len = rmp->num_flows * BUF_SIZE,
+		},
+	};
+	printf("Registering buffers for %d sockets\n", i);
+	rc = io_uring_register_buffers(&ri->ring, iov, ARRAY_SIZE(iov));
+	printf("rc = %d: %s\n", rc, strerror(-rc));
+	OSMO_ASSERT(rc == 0);
+	for (i = 0; i < ri->connections_size; i++) {
+		rtpc = ri->connections[i];
+		if (!rtpc)
+			continue;
+		rtpc->tx.buf = largebuf_tx + (i * BUF_SIZE);
+		rtpc->rx.buf = largebuf_rx + (i * BUF_SIZE);
+	}
+#endif
+
+#ifdef USE_CQ_THREAD
+	/* start a separate completion thread instead of handling completions in-line */
+	pthread_t complete;
+	rc = pthread_create(&complete, NULL, reap_completion, ri);
+	OSMO_ASSERT(rc >= 0);
+#endif
+
+	/* start timerfd every 20ms */
+	ri->timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
+	OSMO_ASSERT(ri->timerfd >= 0);
+	struct itimerspec its = (struct itimerspec) {
+		.it_interval = { 0, 20*1000*1000 },
+		.it_value = { 0, 20*1000*1000 },
+	};
+	rc = timerfd_settime(ri->timerfd, 0, &its, NULL);
+	OSMO_ASSERT(rc == 0);
+
+	/* start transmitting */
+
+	while (1) {
+		/* the assumption here is that every flow wants to write 50
+		 * packets per second, so we try try to submit one write for each
+		 * flow every 20ms */
+		unsigned int submit_granularity = rmp->num_flows/50;
+		/* number of 20ms timer expirations */
+		uint64_t num_exp;
+		unsigned int t;
+
+		if (submit_granularity <= 0)
+			submit_granularity = 1;
+
+		/* read from timerfd to pace the 20ms inter packet interval */
+		rc = read(ri->timerfd, &num_exp, sizeof(num_exp));
+		OSMO_ASSERT(rc == sizeof(num_exp));
+
+		rate_ctr_add(&ri->ctrg->ctr[RTP_INST_TIMERS_TOTAL], num_exp);
+		if (num_exp != 1) {
+			fputc('X', stdout);
+			rate_ctr_add(&ri->ctrg->ctr[RTP_INST_TIMERS_LATE], num_exp-1);
+		} else {
+			fputc('.', stdout);
+		}
+		fflush(stdout);
+
+		for (t = 0; t < num_exp; t++) {
+			for (i = 0; i < ri->connections_size; i++) {
+				rtpc = ri->connections[i];
+				if (!rtpc)
+					continue;
+				if (rtpc->tx.enabled)
+					rtpsim_conn_tx_frame(rtpc);
+				if (rtpc->rx.enabled)
+					rtpsim_conn_rx_prep(rtpc);
+				if ((i % submit_granularity) == 0) {
+					int pending = io_uring_submit(&ri->ring);
+
+#ifndef USE_CQ_THREAD
+					for (int j = 0; j < pending; j++) {
+						struct io_uring_cqe *cqe;
+						int rc;
+
+						rc = io_uring_wait_cqe(&ri->ring, &cqe);
+						OSMO_ASSERT(rc >= 0);
+						handle_completion(ri, cqe);
+					}
+#endif /* USE_CQ_THREAD */
+				}
+			}
+		}
+	}
+
+}
+
+static void *rtpsim_worker_thread(void *_rmp)
+{
+	rtpsim_main((struct rtpsim_instance_cfg *)_rmp);
+	return NULL;
+}
+
+int main(int argc, char **argv)
+{
+	pthread_t worker[NR_WORKERS];
+	struct rtpsim_instance_cfg rmp[NR_WORKERS];
+	int i, rc;
+
+	g_rtpsim = talloc_zero(NULL, struct rtpsim_global);
+	OSMO_ASSERT(g_rtpsim);
+	INIT_LLIST_HEAD(&g_rtpsim->instances);
+	pthread_rwlock_init(&g_rtpsim->rwlock, NULL);
+
+	osmo_init_logging2(g_rtpsim, NULL);
+//	osmo_stats_init(g_rtpsim);
+
+	/* Create worker threads */
+	for (i = 0; i < NR_WORKERS; i++) {
+		int rc;
+		rmp[i].num = i;
+		rmp[i].num_flows = NUM_FLOWS_PER_WORKER;
+		rmp[i].base_port = 10000 + i * (2 * rmp[i].num_flows);
+		rc = pthread_create(&worker[i], NULL, rtpsim_worker_thread, &rmp[i]);
+		OSMO_ASSERT(rc >= 0);
+	}
+
+	/* CTRL interface */
+	//g_rtpsim->ctrl = ctrl_interface_setup_dynip(g_rss, ctrl_vty_get_bind_addr(), 11111, NULL);
+	g_rtpsim->ctrl = ctrl_interface_setup_dynip(g_rtpsim, "127.0.0.1", 11111, NULL);
+	OSMO_ASSERT(g_rtpsim->ctrl);
+	rc = rtpsource_ctrl_cmds_install();
+	OSMO_ASSERT(rc == 0);
+
+	while (1) {
+		osmo_select_main(0);
+	}
+
+	for (i = 0; i < NR_WORKERS; i++) {
+		pthread_join(worker[i], NULL);
+	}
+}

contrib/rtp-load-gen/rtp_provider.c

@@ -0,0 +1,71 @@
+#include <osmocom/core/talloc.h>
+#include <osmocom/core/utils.h>
+#include <osmocom/core/linuxlist.h>
+#include <osmocom/core/logging.h>
+
+#include "rtp_provider.h"
+#include "internal.h"
+
+
+static LLIST_HEAD(g_providers);
+
+const struct value_string codec_type_names[] = {
+	{ CODEC_ULAW,		"ULAW" },
+	{ CODEC_ALAW,		"ALAW" },
+	{ CODEC_GSM_FR,		"GSM_FR" },
+	{ CODEC_GSM_EFR,	"GSM_EFR" },
+	{ CODEC_GSM_HR,		"GSM_HR" },
+	{ CODEC_AMR_4_75,	"AMR_4_75" },
+	{ CODEC_AMR_5_15,	"AMR_5_15" },
+	{ CODEC_AMR_5_90,	"AMR_5_90" },
+	{ CODEC_AMR_6_70,	"AMR_6_70" },
+	{ CODEC_AMR_7_40,	"AMR_7_40" },
+	{ CODEC_AMR_7_95,	"AMR_7_95" },
+	{ CODEC_AMR_10_2,	"AMR_10_2" },
+	{ CODEC_AMR_12_2,	"AMR_12_2" },
+	{ CODEC_AMR_SID,	"AMR_SID" },
+	{ 0, NULL }
+};
+
+void rtp_provider_register(struct rtp_provider *prov)
+{
+	llist_add_tail(&prov->list, &g_providers);
+}
+
+const struct rtp_provider *rtp_provider_find(const char *name)
+{
+	struct rtp_provider *p;
+	llist_for_each_entry(p, &g_providers, list) {
+		if (!strcmp(name, p->name))
+			return p;
+	}
+	LOGP(DMAIN, LOGL_ERROR, "Couldn't find RTP provider '%s'\n", name);
+	return NULL;
+}
+
+struct rtp_provider_instance *
+rtp_provider_instance_alloc(void *ctx, const struct rtp_provider *provider, enum codec_type codec)
+{
+	struct rtp_provider_instance *pi;
+
+	pi = talloc_zero(ctx, struct rtp_provider_instance);
+	if (!pi)
+		return NULL;
+
+	pi->provider = provider;
+	pi->codec = codec;
+
+	return pi;
+}
+
+void rtp_provider_instance_free(struct rtp_provider_instance *pi)
+{
+	llist_del(&pi->list);
+	talloc_free(pi);
+}
+
+int rtp_provider_instance_gen_frame(struct rtp_provider_instance *pi, uint8_t *out, size_t out_size)
+{
+	OSMO_ASSERT(pi->provider);
+	return pi->provider->rtp_gen(pi, out, out_size);
+}

contrib/rtp-load-gen/rtp_provider.h

@@ -0,0 +1,57 @@
+#pragma once
+#include <stdint.h>
+#include <osmocom/core/linuxlist.h>
+#include <osmocom/core/utils.h>
+
+enum codec_type {
+	CODEC_ULAW,
+	CODEC_ALAW,
+	CODEC_GSM_FR,
+	CODEC_GSM_EFR,
+	CODEC_GSM_HR,
+	CODEC_AMR_4_75,
+	CODEC_AMR_5_15,
+	CODEC_AMR_5_90,
+	CODEC_AMR_6_70,
+	CODEC_AMR_7_40,
+	CODEC_AMR_7_95,
+	CODEC_AMR_10_2,
+	CODEC_AMR_12_2,
+	CODEC_AMR_SID,
+	_NUM_CODECS
+};
+
+extern const struct value_string codec_type_names[];
+
+struct rtp_provider_instance;
+
+struct rtp_provider {
+	/* global list of RTP providers */
+	struct llist_head list;
+	const char *name;
+
+	/* create/initialie a RTP provider with specified argument string */
+	int (*setup)(struct rtp_provider_instance *inst, const char *arg);
+
+	/* generate the next RTP packet; return length in octests or negative on error */
+	int (*rtp_gen)(struct rtp_provider_instance *inst, uint8_t *out, size_t out_size);
+};
+
+struct rtp_provider_instance {
+	/* entry in global list of RTP provider instances */
+	struct llist_head list;
+	/* pointer to provider of which we are an instance */
+	const struct rtp_provider *provider;
+	/* codec payload we are to generate */
+	enum codec_type codec;
+
+	/* private user data */
+	void *priv;
+};
+
+void rtp_provider_register(struct rtp_provider *prov);
+const struct rtp_provider *rtp_provider_find(const char *name);
+
+struct rtp_provider_instance *rtp_provider_instance_alloc(void *ctx, const struct rtp_provider *provider, enum codec_type codec);
+void rtp_provider_instance_free(struct rtp_provider_instance *pi);
+int rtp_provider_instance_gen_frame(struct rtp_provider_instance *pi, uint8_t *out, size_t out_size);

contrib/rtp-load-gen/rtp_provider_static.c

@@ -0,0 +1,108 @@
+
+#include <errno.h>
+#include <osmocom/codec/codec.h>
+#include <osmocom/core/utils.h>
+#include <osmocom/core/logging.h>
+
+#include "rtp_provider.h"
+#include "internal.h"
+
+static struct rtp_provider static_provider;
+
+static const uint8_t len4codec[_NUM_CODECS] = {
+    [CODEC_ULAW] = 160,
+    [CODEC_ALAW] = 160,
+    [CODEC_GSM_FR] = GSM_FR_BYTES,
+    [CODEC_GSM_EFR] = GSM_EFR_BYTES,
+    [CODEC_GSM_HR] = GSM_HR_BYTES,
+    [CODEC_AMR_4_75] = 12,
+    [CODEC_AMR_5_15] = 13,
+    [CODEC_AMR_5_90] = 15,
+    [CODEC_AMR_6_70] = 17,
+    [CODEC_AMR_7_40] = 19,
+    [CODEC_AMR_7_95] = 20,
+    [CODEC_AMR_10_2] = 26,
+    [CODEC_AMR_12_2] = 31,
+    [CODEC_AMR_SID] = 5,
+};
+
+/* generate a static / fixed RTP payload of matching codec/mode */
+static int rtp_gen_static(struct rtp_provider_instance *pi, uint8_t *out, size_t out_size)
+{
+	uint8_t len;
+
+	OSMO_ASSERT(pi->provider == &static_provider);
+
+	len = len4codec[pi->codec];
+	if (out_size < len) {
+		LOGP(DMAIN, LOGL_ERROR, "out_size %zu < %u\n", out_size, len);
+		return -EINVAL;
+	}
+
+	memset(out, 0, len);
+
+	switch (pi->codec) {
+	case CODEC_ULAW:
+	case CODEC_ALAW:
+		break;
+	case CODEC_GSM_FR:
+		out[0] = (out[0] & 0x0f) | 0xD0; /* mask in first four bit for FR */
+		break;
+	case CODEC_GSM_EFR:
+		out[0] = (out[0] & 0x0f) | 0xC0; /* mask in first four bit for EFR */
+		break;
+	case CODEC_GSM_HR:
+		break;
+	case CODEC_AMR_4_75:
+		out[0] = 0 << 4;
+		out[1] = 0 << 3;
+		break;
+	case CODEC_AMR_5_15:
+		out[0] = 1 << 4;
+		out[1] = 1 << 3;
+		break;
+	case CODEC_AMR_5_90:
+		out[0] = 2 << 4;
+		out[1] = 2 << 3;
+		break;
+	case CODEC_AMR_6_70:
+		out[0] = 3 << 4;
+		out[1] = 3 << 3;
+		break;
+	case CODEC_AMR_7_40:
+		out[0] = 4 << 4;
+		out[1] = 4 << 3;
+		break;
+	case CODEC_AMR_7_95:
+		out[0] = 5 << 4;
+		out[1] = 5 << 3;
+		break;
+	case CODEC_AMR_10_2:
+		out[0] = 6 << 4;
+		out[1] = 6 << 3;
+		break;
+	case CODEC_AMR_12_2:
+		out[0] = 7 << 4;
+		out[1] = 7 << 3;
+		break;
+	case CODEC_AMR_SID:
+		out[0] = 2 << 4; /* CMR: 5.90 */
+		out[0] = 8 << 3;
+		break;
+	default:
+		OSMO_ASSERT(0);
+	}
+
+	return len;
+}
+
+
+static struct rtp_provider static_provider = {
+	.name = "static",
+	.rtp_gen = &rtp_gen_static,
+};
+
+static void __attribute__((constructor)) rtp_provider_static_constr(void)
+{
+	rtp_provider_register(&static_provider);
+}

contrib/simcom2rtp/Makefile

@@ -0,0 +1,11 @@
+CFLAGS:= -O2 -g -Wall $(shell pkg-config --cflags libosmocore libosmotrau)
+LIBS:= $(shell pkg-config --libs libosmocore libosmotrau)
+
+all: osmo-simcom2rtp
+
+osmo-simcom2rtp: g711.o g711_table.o simcom2rtp.o
+	$(CC) $(LDFLAGS) -o $@ $^ $(LIBS)
+
+%.o: %.c
+	$(CC) $(CFLAGS) -o $@ -c $^
+

contrib/simcom2rtp/g711.c

@@ -0,0 +1,313 @@
+/*
+ * This source code is a product of Sun Microsystems, Inc. and is provided
+ * for unrestricted use.  Users may copy or modify this source code without
+ * charge.
+ *
+ * SUN SOURCE CODE IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING
+ * THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ *
+ * Sun source code is provided with no support and without any obligation on
+ * the part of Sun Microsystems, Inc. to assist in its use, correction,
+ * modification or enhancement.
+ *
+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THIS SOFTWARE
+ * OR ANY PART THEREOF.
+ *
+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
+ * or profits or other special, indirect and consequential damages, even if
+ * Sun has been advised of the possibility of such damages.
+ *
+ * Sun Microsystems, Inc.
+ * 2550 Garcia Avenue
+ * Mountain View, California  94043
+ */
+/*
+ * December 30, 1994:
+ * Functions linear2alaw, linear2ulaw have been updated to correctly
+ * convert unquantized 16 bit values.
+ * Tables for direct u- to A-law and A- to u-law conversions have been
+ * corrected.
+ * Borge Lindberg, Center for PersonKommunikation, Aalborg University.
+ * bli@cpk.auc.dk
+ *
+ */
+/*
+ * Downloaded from comp.speech site in Cambridge.
+ *
+ */
+
+#include "g711.h"
+
+/*
+ * g711.c
+ *
+ * u-law, A-law and linear PCM conversions.
+ * Source: http://www.speech.kth.se/cost250/refsys/latest/src/g711.c
+ */
+#define	SIGN_BIT	(0x80)		/* Sign bit for a A-law byte. */
+#define	QUANT_MASK	(0xf)		/* Quantization field mask. */
+#define	NSEGS		(8)		/* Number of A-law segments. */
+#define	SEG_SHIFT	(4)		/* Left shift for segment number. */
+#define	SEG_MASK	(0x70)		/* Segment field mask. */
+
+static short seg_aend[8] = {0x1F, 0x3F, 0x7F, 0xFF,
+			    0x1FF, 0x3FF, 0x7FF, 0xFFF};
+static short seg_uend[8] = {0x3F, 0x7F, 0xFF, 0x1FF,
+			    0x3FF, 0x7FF, 0xFFF, 0x1FFF};
+
+/* copy from CCITT G.711 specifications */
+unsigned char _u2a[128] = {			/* u- to A-law conversions */
+	1,	1,	2,	2,	3,	3,	4,	4,
+	5,	5,	6,	6,	7,	7,	8,	8,
+	9,	10,	11,	12,	13,	14,	15,	16,
+	17,	18,	19,	20,	21,	22,	23,	24,
+	25,	27,	29,	31,	33,	34,	35,	36,
+	37,	38,	39,	40,	41,	42,	43,	44,
+	46,	48,	49,	50,	51,	52,	53,	54,
+	55,	56,	57,	58,	59,	60,	61,	62,
+	64,	65,	66,	67,	68,	69,	70,	71,
+	72,	73,	74,	75,	76,	77,	78,	79,
+/* corrected:
+	81,	82,	83,	84,	85,	86,	87,	88, 
+   should be: */
+	80,	82,	83,	84,	85,	86,	87,	88,
+	89,	90,	91,	92,	93,	94,	95,	96,
+	97,	98,	99,	100,	101,	102,	103,	104,
+	105,	106,	107,	108,	109,	110,	111,	112,
+	113,	114,	115,	116,	117,	118,	119,	120,
+	121,	122,	123,	124,	125,	126,	127,	128};
+
+unsigned char _a2u[128] = {			/* A- to u-law conversions */
+	1,	3,	5,	7,	9,	11,	13,	15,
+	16,	17,	18,	19,	20,	21,	22,	23,
+	24,	25,	26,	27,	28,	29,	30,	31,
+	32,	32,	33,	33,	34,	34,	35,	35,
+	36,	37,	38,	39,	40,	41,	42,	43,
+	44,	45,	46,	47,	48,	48,	49,	49,
+	50,	51,	52,	53,	54,	55,	56,	57,
+	58,	59,	60,	61,	62,	63,	64,	64,
+	65,	66,	67,	68,	69,	70,	71,	72,
+/* corrected:
+	73,	74,	75,	76,	77,	78,	79,	79,
+   should be: */
+	73,	74,	75,	76,	77,	78,	79,	80,
+	80,	81,	82,	83,	84,	85,	86,	87,
+	88,	89,	90,	91,	92,	93,	94,	95,
+	96,	97,	98,	99,	100,	101,	102,	103,
+	104,	105,	106,	107,	108,	109,	110,	111,
+	112,	113,	114,	115,	116,	117,	118,	119,
+	120,	121,	122,	123,	124,	125,	126,	127};
+
+static short search(
+   short val,
+   short *table,
+   short size)
+{
+   short i;
+   
+   for (i = 0; i < size; i++) {
+      if (val <= *table++)
+	 return (i);
+   }
+   return (size);
+}
+
+/*
+ * linear2alaw() - Convert a 16-bit linear PCM value to 8-bit A-law
+ *
+ * linear2alaw() accepts an 16-bit integer and encodes it as A-law data.
+ *
+ *		Linear Input Code	Compressed Code
+ *	------------------------	---------------
+ *	0000000wxyza			000wxyz
+ *	0000001wxyza			001wxyz
+ *	000001wxyzab			010wxyz
+ *	00001wxyzabc			011wxyz
+ *	0001wxyzabcd			100wxyz
+ *	001wxyzabcde			101wxyz
+ *	01wxyzabcdef			110wxyz
+ *	1wxyzabcdefg			111wxyz
+ *
+ * For further information see John C. Bellamy's Digital Telephony, 1982,
+ * John Wiley & Sons, pps 98-111 and 472-476.
+ */
+unsigned char
+linear2alaw(short pcm_val)	/* 2's complement (16-bit range) */
+{
+   short	 mask;
+   short	 seg;
+   unsigned char aval;
+   
+   pcm_val = pcm_val >> 3;
+
+   if (pcm_val >= 0) {
+      mask = 0xD5;		/* sign (7th) bit = 1 */
+   } else {
+      mask = 0x55;		/* sign bit = 0 */
+      pcm_val = -pcm_val - 1;
+   }
+   
+   /* Convert the scaled magnitude to segment number. */
+   seg = search(pcm_val, seg_aend, 8);
+   
+   /* Combine the sign, segment, and quantization bits. */
+   
+   if (seg >= 8)		/* out of range, return maximum value. */
+      return (unsigned char) (0x7F ^ mask);
+   else {
+      aval = (unsigned char) seg << SEG_SHIFT;
+      if (seg < 2)
+	 aval |= (pcm_val >> 1) & QUANT_MASK;
+      else
+	 aval |= (pcm_val >> seg) & QUANT_MASK;
+      return (aval ^ mask);
+   }
+}
+
+/*
+ * alaw2linear() - Convert an A-law value to 16-bit linear PCM
+ *
+ */
+short
+alaw2linear(
+   unsigned char	a_val)
+{
+   short t;
+   short seg;
+   
+   a_val ^= 0x55;
+   
+   t = (a_val & QUANT_MASK) << 4;
+   seg = ((unsigned)a_val & SEG_MASK) >> SEG_SHIFT;
+   switch (seg) {
+   case 0:
+      t += 8;
+      break;
+   case 1:
+      t += 0x108;
+      break;
+   default:
+      t += 0x108;
+      t <<= seg - 1;
+   }
+   return ((a_val & SIGN_BIT) ? t : -t);
+}
+
+#define	BIAS		(0x84)		/* Bias for linear code. */
+#define CLIP            8159
+
+/*
+* linear2ulaw() - Convert a linear PCM value to u-law
+*
+* In order to simplify the encoding process, the original linear magnitude
+* is biased by adding 33 which shifts the encoding range from (0 - 8158) to
+* (33 - 8191). The result can be seen in the following encoding table:
+*
+*	Biased Linear Input Code	Compressed Code
+*	------------------------	---------------
+*	00000001wxyza			000wxyz
+*	0000001wxyzab			001wxyz
+*	000001wxyzabc			010wxyz
+*	00001wxyzabcd			011wxyz
+*	0001wxyzabcde			100wxyz
+*	001wxyzabcdef			101wxyz
+*	01wxyzabcdefg			110wxyz
+*	1wxyzabcdefgh			111wxyz
+*
+* Each biased linear code has a leading 1 which identifies the segment
+* number. The value of the segment number is equal to 7 minus the number
+* of leading 0's. The quantization interval is directly available as the
+* four bits wxyz.  * The trailing bits (a - h) are ignored.
+*
+* Ordinarily the complement of the resulting code word is used for
+* transmission, and so the code word is complemented before it is returned.
+*
+* For further information see John C. Bellamy's Digital Telephony, 1982,
+* John Wiley & Sons, pps 98-111 and 472-476.
+*/
+unsigned char
+linear2ulaw(
+   short pcm_val)	/* 2's complement (16-bit range) */
+{
+   short         mask;
+   short	 seg;
+   unsigned char uval;
+   
+   /* Get the sign and the magnitude of the value. */
+   pcm_val = pcm_val >> 2;
+   if (pcm_val < 0) {
+      pcm_val = -pcm_val;
+      mask = 0x7F;
+   } else {
+      mask = 0xFF;
+   }
+   if ( pcm_val > CLIP ) pcm_val = CLIP;		/* clip the magnitude */
+   pcm_val += (BIAS >> 2);
+   
+   /* Convert the scaled magnitude to segment number. */
+   seg = search(pcm_val, seg_uend, 8);
+   
+   /*
+   * Combine the sign, segment, quantization bits;
+   * and complement the code word.
+   */
+   if (seg >= 8)		/* out of range, return maximum value. */
+      return (unsigned char) (0x7F ^ mask);
+   else {
+      uval = (unsigned char) (seg << 4) | ((pcm_val >> (seg + 1)) & 0xF);
+      return (uval ^ mask);
+   }
+   
+}
+
+/*
+ * ulaw2linear() - Convert a u-law value to 16-bit linear PCM
+ *
+ * First, a biased linear code is derived from the code word. An unbiased
+ * output can then be obtained by subtracting 33 from the biased code.
+ *
+ * Note that this function expects to be passed the complement of the
+ * original code word. This is in keeping with ISDN conventions.
+ */
+short
+ulaw2linear(
+   unsigned char	u_val)
+{
+   short t;
+   
+   /* Complement to obtain normal u-law value. */
+   u_val = ~u_val;
+   
+   /*
+    * Extract and bias the quantization bits. Then
+    * shift up by the segment number and subtract out the bias.
+    */
+   t = ((u_val & QUANT_MASK) << 3) + BIAS;
+   t <<= ((unsigned)u_val & SEG_MASK) >> SEG_SHIFT;
+   
+   return ((u_val & SIGN_BIT) ? (BIAS - t) : (t - BIAS));
+}
+
+/* A-law to u-law conversion */
+unsigned char
+alaw2ulaw(
+   unsigned char	aval)
+{
+   aval &= 0xff;
+   return (unsigned char) ((aval & 0x80) ? (0xFF ^ _a2u[aval ^ 0xD5]) :
+	   (0x7F ^ _a2u[aval ^ 0x55]));
+}
+
+/* u-law to A-law conversion */
+unsigned char
+ulaw2alaw(
+   unsigned char	uval)
+{
+   uval &= 0xff;
+   return (unsigned char) ((uval & 0x80) ? (0xD5 ^ (_u2a[0xFF ^ uval] - 1)) :
+			   (0x55 ^ (_u2a[0x7F ^ uval] - 1)));
+}
+
+/* ---------- end of g711.c ----------------------------------------------------- */

contrib/simcom2rtp/g711.h

@@ -0,0 +1,27 @@
+/*
+ * g711.h
+ *
+ * u-law, A-law and linear PCM conversions.
+ * Source: http://www.speech.kth.se/cost250/refsys/latest/src/g711.h
+ */
+
+#ifndef _G711_H_
+#define _G711_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+unsigned char	linear2alaw(short pcm_val);
+short		    alaw2linear(unsigned char a_val);
+unsigned char	linear2ulaw(short pcm_val);
+short		    ulaw2linear(unsigned char u_val);
+unsigned char	alaw2ulaw(unsigned char aval);
+unsigned char	ulaw2alaw(unsigned char uval);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _G711_H_ */

contrib/simcom2rtp/g711_table.c

@@ -0,0 +1,102 @@
+#ifndef G711_TABLE_H
+#define G711_TABLE_H
+
+#include "g711.h"
+
+/* 16384 entries per table (16 bit) */
+unsigned char linear_to_alaw[65536];
+unsigned char linear_to_ulaw[65536];
+
+/* 16384 entries per table (8 bit) */
+unsigned short alaw_to_linear[256];
+unsigned short ulaw_to_linear[256];
+
+static void build_linear_to_xlaw_table(unsigned char *linear_to_xlaw,
+                                       unsigned char (*linear2xlaw)(short))
+{
+    int i;
+
+    for (i=0; i<65536;i++){
+        linear_to_xlaw[i] = linear2xlaw((short) i);
+    }
+}
+
+static void build_xlaw_to_linear_table(unsigned short *xlaw_to_linear,
+                                       short (*xlaw2linear)(unsigned char))
+{
+    int i;
+
+    for (i=0; i<256;i++){
+        xlaw_to_linear[i] = (unsigned short) xlaw2linear(i);
+    }
+}
+
+static void pcm16_to_xlaw(unsigned char *linear_to_xlaw, int src_length, const char *src_samples, char *dst_samples)
+{
+    int i;
+    const unsigned short *s_samples;
+
+    s_samples = (const unsigned short *)src_samples;
+
+    for (i=0; i < src_length / 2; i++)
+    {
+        dst_samples[i] = linear_to_xlaw[s_samples[i]];
+    }
+}
+
+static void xlaw_to_pcm16(unsigned short *xlaw_to_linear, int src_length, const char *src_samples, char *dst_samples)
+{
+    int i;
+    unsigned char *s_samples;
+    unsigned short *d_samples;
+
+    s_samples = (unsigned char *) src_samples;
+    d_samples = (unsigned short *)dst_samples;
+
+    for (i=0; i < src_length; i++)
+    {
+        d_samples[i] = xlaw_to_linear[s_samples[i]];
+    }
+}
+
+void pcm16_to_alaw(int src_length, const char *src_samples, char *dst_samples)
+{
+    pcm16_to_xlaw(linear_to_alaw, src_length, src_samples, dst_samples);
+}
+
+void pcm16_to_ulaw(int src_length, const char *src_samples, char *dst_samples)
+{
+    pcm16_to_xlaw(linear_to_ulaw, src_length, src_samples, dst_samples);
+}
+
+void alaw_to_pcm16(int src_length, const char *src_samples, char *dst_samples)
+{
+    xlaw_to_pcm16(alaw_to_linear, src_length, src_samples, dst_samples);
+}
+
+void ulaw_to_pcm16(int src_length, const char *src_samples, char *dst_samples)
+{
+    xlaw_to_pcm16(ulaw_to_linear, src_length, src_samples, dst_samples);
+}
+
+void pcm16_alaw_tableinit()
+{
+    build_linear_to_xlaw_table(linear_to_alaw, linear2alaw);
+}
+
+void pcm16_ulaw_tableinit()
+{
+    build_linear_to_xlaw_table(linear_to_ulaw, linear2ulaw);
+}
+
+void alaw_pcm16_tableinit()
+{
+    build_xlaw_to_linear_table(alaw_to_linear, alaw2linear);
+}
+
+void ulaw_pcm16_tableinit()
+{
+    build_xlaw_to_linear_table(ulaw_to_linear, ulaw2linear);
+}
+
+#endif // G711_TABLE_H

contrib/simcom2rtp/g711_table.h

@@ -0,0 +1,14 @@
+#ifndef G711_TABLE_H
+#define G711_TABLE_H
+
+void pcm16_to_alaw(int length, const char *src_samples, char *dst_samples);
+void pcm16_to_ulaw(int length, const char *src_samples, char *dst_samples);
+void alaw_to_pcm16(int length, const char *src_samples, char *dst_samples);
+void ulaw_to_pcm16(int length, const char *src_samples, char *dst_samples);
+
+void pcm16_alaw_tableinit();
+void pcm16_ulaw_tableinit();
+void alaw_pcm16_tableinit();
+void ulaw_pcm16_tableinit();
+
+#endif // G711_TABLE_H

contrib/simcom2rtp/simcom2rtp.c

@@ -0,0 +1,218 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <limits.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+
+#include <osmocom/core/select.h>
+#include <osmocom/core/msgb.h>
+#include <osmocom/core/fsm.h>
+#include <osmocom/core/logging.h>
+#include <osmocom/core/application.h>
+#include <osmocom/core/serial.h>
+
+#include <osmocom/trau/osmo_ortp.h>
+
+#include "g711.h"
+
+#define RTP_PT_PCMU	0
+#define RTP_PT_PCMA	8
+
+struct modem_state {
+	struct osmo_fd data_fd;
+	struct osmo_rtp_socket *rtp;
+	/* queue of linear PCM audio in RTP -> modem direction */
+	struct llist_head rtp2modem;
+	/* message buffer used if samples insufficient for next RTP frame were received */
+	struct msgb *modem2rtp;
+};
+
+static void *g_tall_ctx;
+
+
+/* call-back on received RTP data */
+static void ortp_rx_cb(struct osmo_rtp_socket *rs, const uint8_t *payload,
+			unsigned int payload_len, uint16_t seq_nr, uint32_t timestamp, bool marker)
+{
+	/* we received a RTP frame */
+	struct modem_state *ms = rs->priv;
+	struct msgb *msg = msgb_alloc(payload_len*2, "RTP Rx");
+	unsigned int i;
+	int16_t *out;
+
+	OSMO_ASSERT(msg);
+
+	out = (int16_t *) msgb_put(msg, payload_len*2);
+
+	if (payload_len != 160) {
+		fprintf(stderr, "RTP payload length %d != 160, dropping\n", payload_len);
+		msgb_free(msg);
+		return;
+	}
+
+	/* convert from Alaw to linear PCM (160 -> 320 bytes) */
+	for (i = 0; i < payload_len; i++)
+		out[i] = alaw2linear(payload[i]);
+
+	/* append to the write queue */
+	msgb_enqueue(&ms->rtp2modem, msg);
+	ms->data_fd.when |= OSMO_FD_WRITE;
+}
+
+static void modem2rtp(struct modem_state *ms, const uint8_t *data, unsigned int len)
+{
+	const int16_t *data16 = (const int16_t *)data;
+	unsigned int samples = len / 2;
+	unsigned int offset = 0;
+	unsigned int i;
+
+	/* samples are always 16bit, we cannot read half a sample */
+	OSMO_ASSERT((len & 1) == 0);
+
+	/* first complete any pending incomplete RTP frame */
+	if (ms->modem2rtp) {
+		struct msgb *msg = ms->modem2rtp;
+		unsigned int missing_samples = 160 - msgb_length(msg);
+		for (i = 0; i < missing_samples; i++) {
+			if (i >= samples)
+				break;
+			msgb_put_u8(msg, linear2alaw(data16[i]));
+		}
+		offset = i;
+		if (msgb_length(msg) == 160) {
+			osmo_rtp_send_frame_ext(ms->rtp, msgb_data(msg), msgb_length(msg), 160, false);
+			msgb_free(msg);
+		}
+	}
+
+	/* then send as many RTP frames as we have samples */
+	for (offset = offset; offset + 160 <= samples; offset += 160) {
+		uint8_t buf[160];
+		for (i = 0; i < sizeof(buf); i++)
+			buf[i] = linear2alaw(data16[offset + i]);
+		osmo_rtp_send_frame_ext(ms->rtp, buf, sizeof(buf), 160, false);
+	}
+
+	/* store remainder in msgb */
+	if (offset < samples) {
+		struct msgb *msg = msgb_alloc_c(ms, 160, "modem2rtp");
+		OSMO_ASSERT(msg);
+		OSMO_ASSERT(len - offset < 160);
+		for (i = 0; i < len - offset; i++)
+			msgb_put_u8(msg, linear2alaw(data16[offset + i]));
+		ms->modem2rtp = msg;
+	}
+}
+
+
+/* call back on file descriptor events of the modem DATA ttyUSB device */
+static int modem_data_fd_cb(struct osmo_fd *ofd, unsigned int what)
+{
+	struct modem_state *ms = ofd->data;
+	int rc;
+
+	if (what & OSMO_FD_READ) {
+		/* SIM5360 USB AUDIO Application Note v1.01 states 1600 bytes every 100ms */
+		uint8_t rx_buf[1600];
+		rc = read(ofd->fd, rx_buf, sizeof(rx_buf));
+		OSMO_ASSERT(rc > 0);
+		modem2rtp(ms, rx_buf, rc);
+	}
+
+	if (what & OSMO_FD_WRITE) {
+		struct msgb *msg = msgb_dequeue(&ms->rtp2modem);
+		if (!msg)
+			ofd->when &= ~OSMO_FD_WRITE;
+		else {
+			/* SIM5300 USB AUDIO Application Note v1.01 states 640 bytes every 40ms;
+			 * we simply write every RTP frame individually (320 bytes every 20ms) */
+			rc = write(ofd->fd, msgb_data(msg), msgb_length(msg));
+			if (rc != msgb_length(msg))
+				fprintf(stderr, "Short write: %d < %u\n", rc, msgb_length(msg));
+			msgb_free(msg);
+		}
+	}
+
+	return 0;
+}
+
+
+static int modem_data_open(struct modem_state *ms, const char *basepath)
+{
+	char fname[PATH_MAX+1];
+	int fd;
+
+	/* the assumption is that the caller provides something like
+	 * "/dev/serial/by-path/pci-0000:00:14.0-usb-0:2:1" */
+	snprintf(fname, sizeof(fname), "%s.0-port0", basepath);
+
+	fd = osmo_serial_init(fname, 921600);
+	if (fd < 0) {
+		fprintf(stderr, "failed to open device '%s': %s\n", fname, strerror(errno));
+		return -1;
+	}
+	osmo_fd_setup(&ms->data_fd, fd, OSMO_FD_READ, modem_data_fd_cb, ms, 0);
+	osmo_fd_register(&ms->data_fd);
+
+	return 0;
+}
+
+static struct modem_state *modem_create(void *ctx)
+{
+	struct modem_state *ms = talloc_zero(ctx, struct modem_state);
+	int rc;
+
+	INIT_LLIST_HEAD(&ms->rtp2modem);
+
+	ms->rtp = osmo_rtp_socket_create(ms, 0);
+	OSMO_ASSERT(ms->rtp);
+	osmo_rtp_socket_set_pt(ms->rtp, RTP_PT_PCMA);
+	ms->rtp->priv = ms;
+	ms->rtp->rx_cb = ortp_rx_cb;
+
+	rc = osmo_rtp_socket_bind(ms->rtp, "0.0.0.0", 1111);
+	OSMO_ASSERT(rc == 0);
+
+	rc = osmo_rtp_socket_connect(ms->rtp, "127.0.0.1", 2222);
+	//rc = osmo_rtp_socket_autoconnect(ms->rtp);
+	OSMO_ASSERT(rc == 0);
+
+	osmo_rtp_set_source_desc(ms->rtp, "cname", "simcom2rtp", NULL, NULL, NULL,
+				 "osmo-simcom2rtp", NULL);
+
+	return ms;
+}
+
+
+
+
+int main(int argc, char **argv)
+{
+
+	talloc_enable_null_tracking();
+	g_tall_ctx = talloc_named_const(NULL, 1, "simcom2rtp");
+
+	msgb_talloc_ctx_init(g_tall_ctx, 0);
+	osmo_init_logging2(g_tall_ctx, NULL);
+	osmo_fsm_log_timeouts(true);
+	osmo_fsm_log_addr(true);
+	//osmo_stats_init(g_tall_ctx);
+	osmo_rtp_init(g_tall_ctx);
+
+	struct modem_state *ms = modem_create(g_tall_ctx);
+	int rc;
+
+	OSMO_ASSERT(ms);
+	rc = modem_data_open(ms, "/dev/serial/by-path/pci-0000:00:14.0-usb-0:2:1");
+	OSMO_ASSERT(rc == 0);
+
+	while (1) {
+		osmo_select_main(0);
+	}
+
+}

contrib/systemd/osmo-mgw.service

@@ -1,20 +1,11 @@
 [Unit]
 Description=Osmocom Media Gateway (MGW)
-After=network-online.target
-Wants=network-online.target
 
 [Service]
 Type=simple
-StateDirectory=osmocom
-WorkingDirectory=%S/osmocom
 Restart=always
 ExecStart=/usr/bin/osmo-mgw -s -c /etc/osmocom/osmo-mgw.cfg
 RestartSec=2
-# CPU scheduling policy:
-CPUSchedulingPolicy=rr
-# For real-time scheduling policies an integer between 1 (lowest priority) and 99 (highest priority):
-CPUSchedulingPriority=1
-# See sched(7) for further details on real-time policies and priorities
 
 [Install]
 WantedBy=multi-user.target

debian/changelog

@@ -1,376 +1,3 @@
-osmo-mgw (1.12.1) unstable; urgency=medium
-
-  [ Pau Espin Pedrol ]
-  * mgcp-client: Fix missing include in mgcp_client_pool.h
-  * mgcp-client: Introduce API osmo_mgcpc_ep_local_name()
-  * mgw: Configure IuUP if codec set during MDCX
-
- -- Oliver Smith <osmith@sysmocom.de>  Thu, 28 Sep 2023 15:58:17 +0200
-
-osmo-mgw (1.12.0) unstable; urgency=medium
-
-  [ Philipp Maier ]
-  * mgcp_sdp: add spec reference
-  * mgcp_sdp: cosmetic: remove newline
-  * mgcp_endp: cosmetic move mgcp_endp_release to the end
-  * mgcp_endp: cosmetic: remove unnecessary new line
-  * mgcp_e1: fix log output
-  * mgcp_e1: be more frugal withe E1 line resources
-  * mgcp_client: fix sourcecode formatting
-  * mgcp_e1: fix typo
-  * mgcp_e1: rewrite comment
-  * mgcp_e1: rename e1_send to e1_send_ts_frame
-  * mgcp_e1: cosmetic: rewrite comment
-  * Revert "mgcp_codec: do not differentiate between oa and bwe when comparing codec"
-  * mgcp_codec: fix oa/bwe comparison in mgcp_codec_pt_translate()
-  * mgcp_codec: refactor payload type converstion
-  * mgcp_codec: cosmetic: remove line break in api-doc
-  * mgcp_network: fix apidoc
-  * mgcp_vty: add warnings for deprecated config options
-  * mgcp_codec: move mgcp_codec_decide down
-  * mgcp_codec: fix codec decision
-  * mgcp_network: do not deliver RTP packets with unpatched PT
-  * mgcp_codec: be sensitive about IuFP when checking codecs
-  * mgcp_client.h: also add spec ref to the other 3gpp defined payload types
-
-  [ Harald Welte ]
-  * cosmetic: Fix grammar suggesting reading _the_ user manual
-
-  [ arehbein ]
-  * Transition to use of 'telnet_init_default'
-
-  [ Oliver Smith ]
-  * mgcp_client: mgcp_msg_gen: add more error logs
-  * mgcp_client_pool: add mgcp_client_pool_empty()
-  * Cosmetic: mgcp_client: fix typo
-  * debian: set compat level to 10
-  * systemd: depend on networking-online.target
-  * Cosmetic: fix a typo
-  * mgcp_client: check rc of map_str_to_codec
-
-  [ Pau Espin Pedrol ]
-  * mgcp_network: Unregister osmo_fd before closing fd
-  * mgcp-client: Call osmo_fd_unregister() before closing and changing bfd->fd
-  * mgcp-client: Drop unused struct mgcp_client field
-  * mgcp_client: Introduce mgcp_client_conf_alloc(), deprecate mgcp_client_conf_init()
-  * mgcp-client: Move some static functions further above
-  * mgw: Allow auditing speciall 'null' endpoint
-  * mgcp-client: Add keepalive feature
-  * mgcp_client: pool: Only pick clients with an MGCP link considered to be UP
-  * mgcp-client: Always mark client as UP if keepalive request-interval disabled
-  * mgcp-client: Mark client as UP when keepalive request-interval/timeout is disabled through VTY
-
-  [ Vadim Yanitskiy ]
-  * */Makefile.am: libraries shall not be in AM_LDFLAGS
-  * tests: use -no-install libtool flag to avoid ./lt-* scripts
-  * tests: $(BUILT_SOURCES) is not defined, depend on osmo-mgw
-  * copyright: fix typo: sysmocom s/s.m.f.c./s.f.m.c./ GmbH
-
-  [ Neels Hofmeyr ]
-  * mgcp_find_section_end(): skip spaces at start of SDP
-  * mgcp_client: simpler error handling
-  * mgcp: fix "L: a:" header parsing: heed ";" separator
-  * mgcp_client: tweak extract_codec_name() implementation
-
-  [ Andreas Eversberg ]
-  * ASCI: Add new mode for voice group/broadcast call
-  * ASCI: Support conference briding with 1..n connections
-
- -- Pau Espin Pedrol <pespin@sysmocom.de>  Tue, 12 Sep 2023 14:48:51 +0200
-
-osmo-mgw (1.11.0) unstable; urgency=medium
-
-  [ Pau Espin Pedrol ]
-  * mgcp-client: Remove impossible code path
-  * mgcp_osmux: Drop duplicated conn_osmux_release_cid() in code path
-  * Use Osmux default port define from libosmo-netif
-  * osmux: Use new osmux APIs to let libosmo-netif alloc struct osmux_out_handle
-  * mgw: Fix osmux conn local IP selection
-  * cosmetic: osmux: Fix wrong indentation
-  * mgw: Use X-Osmux string define
-  * Add Osmux log category
-  * cosmetic: main: Properly format log_info_cat
-  * osmux: Use better name for function which may allocate a new struct
-  * osmux: Use osmo_sockaddr wherever possible
-  * osmux: Log refcounting of osmux_handle_list
-  * osmux: Fix memleak on error code path
-  * osmux: don't store conn ptr inside shared osmux_handle
-  * osmux: set log level of expected code path to INFO
-  * cosmetic: vty: Fix indentation whitespace
-  * osmux: Log sendto() error
-  * cosmetic: mgcp_conn.h: fix indentation whitespace
-  * osmux: Attach osmux to virtual trunk
-  * osmux: Clean up helper macro osmux_chunk_length()
-  * osmux: Get rid of static NULL talloc context
-  * Fix typo in ratectr description
-  * mgcp_conn: rename field s/rate_ctr_group/ctrg/g
-  * Use 'static const' instead of 'const static' everywhere
-  * osmux: Add connection and global rate counters
-  * cosmetic: osmux: Fix formatting of if-else brackets
-  * osmux: Rename field osmux usage policy and define it with proper type
-  * Use bool type instead of int in config field
-  * osmux: Support local CID != remote CID
-  * osmux: Fix incorrect rate_ctr_group used in mgcp_osmux.c
-  * osmux: Improve per-conn tx rate counters
-  * vty: show per-connection Osmux VTY stats
-  * osmux: Rename field s/init/initialized
-  * osmux: Allocate rate counters during initialization of osmux conn
-  * cosmetic: osmux: Drop extra empty line
-  * osmux: Drop unneeded comment block
-  * osmux: Lower log level when osmux batch received for unknown CID
-  * osmux: Keep decoding osmux pkt if a batch contains an unknown CID
-  * Allocate struct osmux_in_handle through new libosmo-netif APIs
-  * osmux: Drop logging of osmux internal counters
-  * osmux: cleanup misleading code calling rtp_bridge_cb
-  * osmux: Unify rtp_conn osmux type into a single type
-  * osmux: Match remote address in osmux_conn_lookup()
-  * osmux: Fill in from_addr in struct osmo_rtp_msg_ctx
-  * osmux: Log remote address upon rx of osmux pkt
-  * send_dummy: Use proper condition to test if conn is osmux
-  * Fix regression in detection of legacy dummy packets
-  * Use new libosmocore API osmo_sockaddr_is_any()
-  * Get rid of separate rtp_port field
-  * osmux: Use available API to check if remote end is known
-  * Add Osmux IPv6 support
-  * Clean up local var pointers in mgcp_get_local_addr()
-  * osmux: Change couple log lines to OSMUX category
-  * osmux: Add square brackets around IPv6 address to distinguish port in log line
-  * osmux: Drop unused role parameter
-  * osmux: cosmetic: Fix indentation
-  * Check once if remote addr is available when sending dummy packet
-  * osmux: Simplify and constify param passing
-  * osmux: Set conn->type during osmux_init_conn()
-  * osmux: Make conn_osmux_{allocate,release}_local_cid() APIs static
-  * osmux: Define osmux_dummy cfg as boolean
-  * osmux: Move setting OSMUX_STATE_DISABLED to initializer function
-  * osmux: Erase references to bsc-nat
-  * mgcp_conn_dump(): Separate dump for osmux and iuup connections
-  * osmux: Introduce osmux peer-behind-nat (on|off) and rework conn activation
-  * osmux: Clean up mgcp_config osmux fields
-  * cosmetic: Fix typo in comment
-  * mgcp-client: pool: Improve documentation of some internal fields
-  * mgcp-client: Avoid double iteration picking client from pool
-  * mgcp-client: Fix typo in internal function name
-  * mgcp-client: Rename internal field in mgcp_client_pool
-  * mgcp-client: Move & rename helper function outside of vty code
-  * mgcp-client: Create alloc() and free() internal APIs for mgcp_client_pool_member
-  * mgcp-client: Move internal API acting on mgcp_client_pool to the correct file section
-  * mgcp-client: Refactor reinit of mgcp clients
-  * mgcp-client: Rearrange order of structs and APIs in header
-  * mgcp-client: Rearrange internal backpointers
-  * mgcp-client: Introduce APIs to manually select mgcp_client from pool
-  * mgcp-client: vty: Write deprecation warning using non-mgw nodes
-  * mgcp-client: Use random free local port by default
-  * mgcp-client: Convert users supporting new MGW Pool VTY node during write-config
-  * mgcp-client: Introduce API mgcp_client_pool_config_write
-  * mgcp-client: Add new VTY commands under mgw node without mgw prefix
-  * mgcp-client: Fix 'mgw endpoint-range' command dropped from old VTY node
-  * mgcp-client: Refactor system keeping old users not calling mgcp_client_pool_config_write() working
-  * mgcp-client: Fix no 'mgw ' prefix written in old VTY node
-  * Fix misleading error log
-  * mgcp_send: Use mgcp_conn_rtp_is_iuup() helper
-  * cosmetic: Clarify and fix typos in comment
-  * mgw: Log unexpected RTP AMR OA-vs-BE payload
-  * Rename and move func checking if amr mode is explicitly configured
-  * mgw: rx_rtp(): reorder checks and handlings
-  * mgw: Rename s/mgcp_send_rtp/mgcp_conn_rtp_dispatch_rtp/
-  * osmux: Rename function and pass msgb directly to it
-  * osmux: Make sure RTP AMR feed to osmux is in octet-aligned mode
-  * Improve logging on AMR OA<->BWE conversion failure
-  * osmux: Rotate over available Osmux CID when allocating a new one
-  * osmux: Use new osmux_xfrm_input API to set name on each link
-  * iuup: Use osmo_amr_ft_valid() API
-
-  [ Vadim Yanitskiy ]
-  * libosmo-mgcp-client: add -no-undefined to *_la_LDFLAGS
-
-  [ Philipp Maier ]
-  * mgcp_e1: fix apidoc
-  * mgcp_network: improve coment
-
-  [ Max ]
-  * Set working directory in systemd service file
-  * Add realtime scheduling and set priority in service file
-  * ctrl: take both address and port from vty config
-
-  [ Harald Welte ]
-  * Make osmo_mgcpc_ep_fsm_pre_term() static
-  * Support building with -Werror=strict-prototypes / -Werror=old-style-definition
-  * Add -Werror=implicit-int -Werror=int-conversion -Werror=old-style-definition
-  * update outdated vty copyright statement
-
-  [ Oliver Smith ]
-  * mgcp_client_pool.h: add missing stdbool include
-  * Fix various typos
-  * mgcp_client: add new clearmode codec
-
-  [ Neels Hofmeyr ]
-  * AMR->IuUP: do not crash on AMR data before IuUP Init
-  * AMR->IuUP: properly translate Q -> FQC
-  * IuUP->AMR: do not patch payload type a second time
-  * IuUP->AMR: log whether converting to AMR OA or BE
-  * AMR->IuUP: log conversion, like for the flipside
-
- -- Pau Espin Pedrol <pespin@sysmocom.de>  Tue, 07 Feb 2023 16:58:41 +0100
-
-osmo-mgw (1.10.0) unstable; urgency=medium
-
-  [ Eric ]
-  * adjust mgcp response context
-  * rework message handling
-  * add a lock-free bounded spsc interthread queue
-  * clang-format: remove foreach macros
-  * fix mgcp_conn_free_all ubsan complaints
-
-  [ Philipp Maier ]
-  * configuration: point out difference between trunk-nr and e1 line nr
-  * mgcp_client: add new codec IUFP as VND.3GPP.IUFP
-  * mgcp_codec: do not differentiate between oa and bwe when comparing codec
-  * mgcp_network: do not try to convert RTCP packets
-  * mgcp_network: fix typo RTPC -> RTCP
-
-  [ Oliver Smith ]
-  * treewide: remove FSF address
-
-  [ Pau Espin Pedrol ]
-  * mgcp_network.c: Set proper CRC Header for ACK Initialization
-  * cosmetic: Rename variable payload=>payload_type
-  * mgcp_network.c: Fix byte alignment of CRC Header for ACK Initialization
-  * Define mgcp_rtp_end.output_enabled as bool
-  * cosmetic: mgcp_codec.c: Fix typo in comment
-  * Drop unneeded ax_check_compile_flag.m4
-  * Make function amr_is_octet_aligned publicly available
-  * Initial IuUP support using proper FSMs
-  * IuUP: Support RFCI ID != RFCI Index
-  * iuup: Fix caps in logging message
-  * iuup: Check for IuUP Initialization retrans
-
-  [ Alexander Couzens ]
-  * doc/overview: fix wrong project page link
-
-  [ Vadim Yanitskiy ]
-  * tests: use 'check_PROGRAMS' instead of 'noinst_PROGRAMS'
-  * libosmo-mgcp: e1: fix memleaks in e1_recv_cb()
-
-  [ Harald Welte ]
-  * update git URLs (git -> https; gitea)
-
- -- Pau Espin Pedrol <pespin@sysmocom.de>  Tue, 28 Jun 2022 18:50:25 +0200
-
-osmo-mgw (1.9.0) unstable; urgency=medium
-
-  [ Harald Welte ]
-  * TOS bits != DSCP
-  * manual: don't define fig-bsc twice
-  * switch from osmo_sock_set_dscp() to OSMO_SOCK_F_DSCP()
-  * mgw: Add support for setting socket priority from VTY
-  * manual: Include QoS chapter and add osmo-mgw specific example
-
-  [ Keith ]
-  * Add vty command 'show mgcp active'
-  * Log some useful messages at ERROR/INFO instead of DEBUG
-
-  [ Neels Hofmeyr ]
-  * send DLCX only once
-  * tweak termination DLCX log msg
-  * add osmo_mgcpc_ep_ci_get_remote_rtp_info()
-  * check_rtp_destin(): clarify log msg
-  * mgcp_client_fsm delete: set mgcp_client as ctx, not NULL
-  * mgcp_client_endpoint_fsm: on term, still let conns wait for DLCX OK
-  * mgcp_client_fsm: add missing log_subsys
-  * mgcp_client: add logging on received MGCP messages
-
-  [ Philipp Maier ]
-  * mgcp_network: fix implicit address loopback
-  * mgcp_common, mgcp_udp_send: make parameter buf const
-  * mgcp_network: refactor MGCP_DUMMY_LOAD
-  * mgcp_client: drop nunnecessary else statement
-  * mgcp_client: fix error handling in mgcp message generation
-  * mgcp_protocol: fix loop that sends dummy RTP packets
-  * mgw_main: fix loop that resets all endpoints
-  * mgcp_trunk: drop ws line
-  * mgcp_ratectr: drop ws line
-  * mgcp_ratectr: fix sourcecode formatting
-  * mgcp_trunk: add value string for trunk type.
-  * mgcp_ratectr: refactor rate counter and set group name
-  * mgcp_protocol: forward declare mgcp_endpoint
-  * mgcp_endp: make wildcarded detection separate
-  * mgcp_protocol: refactor request handler array
-  * mgcp_trunk: use unsigned int instead of int as trunk_nr
-  * mgcp_protocol: refactor MGCP request handling
-  * mgcp_ratectr: add stats items to monitor trunk usage
-  * mgcp_msg: add trunk parameter to mgcp_check_param for logging
-  * mgcp_protocol: refactor function create_response_with_sdp
-  * mgcp_protocol: add support for wildcarded DLCX
-  * remove struct member wildcarded_req from struct mgcp_endpoint
-  * mgcp_lient: remove unsubstantial FIXME note
-  * mgcp_protocol: assert endp when it becomes mandatory
-  * mgcp_trunk: check MGW domain name earlier
-  * mgcp_ratectr: add stats items to monitor trunk usage
-  * mgcp_client: fix typo Initalize -> Initialize
-  * mgcp_protocol: get rid of policy_cb and change_cb
-  * mgcp_ratectr: do not set talloc destructor on library allocated item
-  * mgcp_client: allow to reset endpoints on startup
-  * mgcp_client_vty: remove unnecessary checks
-  * mgcp_client: do not print (null) when address is ANY
-  * mgcp_client: refactor function init_socket
-  * libosmo-mgcp-client: extend the mgcp_client for MGW pooling
-  * mgcp_client_vty: add missing docstrings
-  * mgcp_client_vty: add OSMO_ASSERT on pool parameter
-  * mgcp_client_vty: fix docstrings for mgw-pool
-  * mgcp_client_vty: cosmetic: doc string should terminated with \n
-  * mgcp_client_vty: fixing docstring
-  * mgcp_ratectr: remove unusued rate counters
-  * mgcp_client: fix typo in doxygen comment
-  * mgcp_client: add MGW name as logging context
-
-  [ Pau Espin Pedrol ]
-  * Use new stat item/ctr getter APIs
-  * constify arg in addr_is_any()
-  * Define patch_ssrc as bool type
-  * constify some function arg pointers
-  * mgcp_network.c: Reorder some functions in file
-  * mgcp_send_dummy: Check RTP destination is available before attempt tx
-  * mgw: rx CRCX: Avoid sending dummy rtp if remote address not provided
-  * Fail rx MDCX sendrecv with invalid remote addr
-  * Take into account Marker bit when patching RTP stream
-  * Use DLMGCP instead of DLGLOBAL in log lines
-  * Fix attribute parsing on gcc 11.1.0
-
-  [ neels ]
-  * Revert "mgcp_ratectr: add stats items to monitor trunk usage"
-
-  [ Daniel Willmann ]
-  * contrib/jenkins: Use ASAN for osmo-mgw
-
-  [ Oliver Smith ]
-  * mgcp_client_vty: add missing NO_STR
-  * Revert "Turn some compiler warnings into errors"
-
-  [ Eric ]
-  * add vscode stuff to gitignore
-  * configure.ac: fix maybe-uninitialized for clang
-  * fix missing includes and forward declarations
-  * rename do_retransmission
-  * mgcp_sdp: fix potential leak
-  * stats: make sanitizers happy
-  * libosmo-mgcp: cleanup audio codex alloc
-  * libosmo-mgcp: atomic rate counter group indexes
-  * libosmo-mgcp: do not use the default msgb talloc context
-  * globally lock the portrange when trying to grab a port to prep for multithreading
-  * embed strings into structs
-  * adjust talloc context
-  * endp: do not cache cfg pointer
-  * add modified .clang-format
-  * rename strip_epname and find_specific_endpoint and make them available
-  * fix mgcp_conn_free_all
-  * fix up some docstrings that lost their dot
-
-  [ Vadim Yanitskiy ]
-  * libosmo-mgcp: use OSMO_STRLCPY_ARRAY in mgcp_codec_add()
-
- -- Pau Espin Pedrol <pespin@sysmocom.de>  Tue, 16 Nov 2021 16:59:21 +0100
-
 osmo-mgw (1.8.1) unstable; urgency=medium
 
   * attempt to fix RPM spec file after recent soversion bump

debian/compat

@@ -1 +1 @@
-10
+9

debian/control

@@ -2,17 +2,17 @@ Source: osmo-mgw
 Section: net
 Priority: extra
 Maintainer: Osmocom team <openbsc@lists.osmocom.org>
-Build-Depends: debhelper (>= 10),
+Build-Depends: debhelper (>=9),
                dh-autoreconf,
                pkg-config,
                autotools-dev,
-               libosmocore-dev (>= 1.9.0),
-               libosmo-netif-dev (>= 1.4.0),
-               libosmo-abis-dev (>= 1.5.0),
-               osmo-gsm-manuals-dev (>= 1.5.0)
+               libosmocore-dev (>= 1.5.0),
+               libosmo-netif-dev (>= 1.1.0),
+               libosmo-abis-dev (>= 1.1.0),
+               osmo-gsm-manuals-dev (>= 1.1.0)
 Standards-Version: 3.9.8
-Vcs-Git: https://gitea.osmocom.org/cellular-infrastructure/osmo-mgw
-Vcs-Browser: https://gitea.osmocom.org/cellular-infrastructure/osmo-mgw
+Vcs-Git: git://git.osmocom.org/osmo-mgw.git
+Vcs-Browser: https://git.osmocom.org/osmo-mgw/
 Homepage: https://osmocom.org/projects/osmo-mgw
 
 Package: osmo-mgw
@@ -21,7 +21,7 @@ Multi-Arch: foreign
 Depends: ${misc:Depends}, ${shlibs:Depends}
 Description: OsmoMGW: Osmocom's Media Gateway for 2G and 3G circuit-switched mobile networks
 
-Package: libosmo-mgcp-client12
+Package: libosmo-mgcp-client8
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -33,7 +33,7 @@ Package: libosmo-mgcp-client-dev
 Section: libdevel
 Architecture: any
 Multi-Arch: same
-Depends: libosmo-mgcp-client12 (= ${binary:Version}), ${misc:Depends}
+Depends: libosmo-mgcp-client8 (= ${binary:Version}), ${misc:Depends}
 Description: libosmo-mgcp-client: Osmocom's Media Gateway Control Protocol client utilities
 
 Package: osmo-mgw-doc

debian/copyright

@@ -1,12 +1,12 @@
 Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
 Upstream-Name: osmo-mgw
-Source: https://gitea.osmocom.org/cellular-infrastructure/osmo-mgw
+Source: git://git.osmocom.org/osmo-mgw
 
 Files:     *
 Copyright: 2009-2014 On-Waves
            2009-2015 Holger Hans Peter Freyther <zecke@selfish.org>
            2013 Jacob Erlbeck <jerlbeck@sysmocom.de>
-           2016-2017 sysmocom s.f.m.c. GmbH <info@sysmocom.de>
+           2016-2017 sysmocom s.m.f.c. GmbH <info@sysmocom.de>
 License:   AGPL-3.0+
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU Affero General Public License as published by
@@ -22,7 +22,7 @@ License:   AGPL-3.0+
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 Files:     src/libosmo-mgcp-client/* include/osmocom/mgcp_client/*
-Copyright: 2016 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
+Copyright: 2016 by sysmocom s.m.f.c. GmbH <info@sysmocom.de>
            Based on OpenBSC interface to quagga VTY (libmsc/vty_interface_layer3.c)
            2009 by Harald Welte <laforge@gnumonks.org>
            2009-2011 by Holger Hans Peter Freyther

doc/manuals/chapters/configuration.adoc

@@ -91,11 +91,6 @@ the IP related aspects is nearly identical to the configuration of the virtual
 trunk. However, it is important that the user assigns one of the E1 line numbers
 that were configured under the e1_input node.
 
-NOTE: The endpoint name that is used on MGCP level will include the trunk number,
-not the E1 line number. For simplicity (and compatibility with OsmoBSC) it is
-recommended to use equal numbers for trunk and E1 line. However, if required any
-E1 line can be mapped flexible on any trunk as long as the mapping is bijective.
-
 .Example: A typical configuration with one E1 trunk
 ----
 e1_input

doc/manuals/chapters/mgcp_endpoints.adoc

@@ -91,10 +91,4 @@ encoding/decoding for 16K and 8K subslots. Endpoints with other bitrates are
 not yet useable.
 
 NOTE: the VTY command "show mgcp" can be used to get a list of all available
-endpoints (including identifiers)
-
-=== The `null` endpoint
-
-OsmoMGW offers a special `null@<domain>` endpoint which can be audited at all times.
-This is useful for MGCP clients who wish to submit requests to OsmoMGW
-periodically to find out whether it is still reachable and in a working state.
+endpoints (including identifiers)

doc/manuals/chapters/overview.adoc

@@ -107,8 +107,8 @@ We are planning to add further endpoint types for:
 
 You can find the OsmoMGW issue tracker and wiki online at
 
-- https://osmocom.org/projects/osmo-mgw
-- https://osmocom.org/projects/osmo-mgw/wiki
+- https://osmocom.org/projects/osmomgw
+- https://osmocom.org/projects/osmomgw/wiki
 
 RFC 3435 for MGCP is located at
 

include/Makefile.am

@@ -3,7 +3,6 @@ SUBDIRS = \
 	$(NULL)
 
 nobase_include_HEADERS = \
-	osmocom/mgcp_client/defs.h \
 	osmocom/mgcp_client/mgcp_client.h \
 	osmocom/mgcp_client/mgcp_client_endpoint_fsm.h \
 	osmocom/mgcp_client/mgcp_client_fsm.h \

include/osmocom/mgcp/Makefile.am

@@ -6,11 +6,11 @@ noinst_HEADERS = \
 	mgcp_endp.h \
 	mgcp_sdp.h \
 	mgcp_codec.h \
+	mgcp_ctrl.h \
 	mgcp_trunk.h \
 	debug.h \
 	mgcp_ratectr.h \
 	mgcp_e1.h \
 	mgcp_network.h \
 	mgcp_protocol.h \
-	mgcp_iuup.h \
 	$(NULL)

include/osmocom/mgcp/debug.h

@@ -30,7 +30,6 @@
 enum {
 	DRTP,
 	DE1,
-	DOSMUX,
 	Debug_LastEntry,
 };
 

include/osmocom/mgcp/mgcp.h

@@ -29,7 +29,6 @@
 #include <osmocom/core/logging.h>
 
 #include <osmocom/mgcp/mgcp_common.h>
-#include <osmocom/mgcp/osmux.h>
 
 #include <arpa/inet.h>
 #include <sys/types.h>
@@ -157,26 +156,24 @@ struct mgcp_config {
 
 	enum mgcp_role role;
 
-	struct {
-		/* Osmux usage policy: */
-		enum osmux_usage usage;
-		/* addr to bind the server to */
-		char *local_addr_v4;
-		char *local_addr_v6;
-		/* osmux port */
-		uint16_t local_port;
-		/* The osmux socket is allocated on demand (1st time used).
-		* This tells us if the osmux socket is already initialized.  */
-		bool initialized;
-		/* osmux batch factor: from 1 to 4 maximum */
-		int batch_factor;
-		/* osmux batch size (in bytes) */
-		int batch_size;
-		/* Pad circuit with dummy AMR frames if no payload to transmit is available */
-		bool dummy_padding;
-		/* Whether peer is behind NAT (Retrieve remote addr from 1st received Osmux packet) */
-		bool peer_behind_nat;
-	} osmux;
+	/* osmux translator: 0 means disabled, 1 means enabled */
+	int osmux;
+	/* addr to bind the server to */
+	char osmux_addr[INET6_ADDRSTRLEN];
+	/* The BSC-NAT may ask for enabling osmux on demand. This tells us if
+	 * the osmux socket is already initialized.
+	 */
+	int osmux_init;
+	/* osmux batch factor: from 1 to 4 maximum */
+	int osmux_batch;
+	/* osmux batch size (in bytes) */
+	int osmux_batch_size;
+	/* osmux port */
+	uint16_t osmux_port;
+	/* Pad circuit with dummy messages until we see the first voice
+	 * message.
+	 */
+	uint16_t osmux_dummy;
 	/* domain name of the media gateway */
 	char domain[255+1];
 
@@ -210,4 +207,4 @@ int mgcp_send_reset_all(struct mgcp_config *cfg);
 
 int mgcp_create_bind(const char *source_addr, struct osmo_fd *fd, int port, uint8_t dscp,
 		     uint8_t prio);
-int mgcp_udp_send(int fd, const struct osmo_sockaddr *addr, const char *buf, int len);
+int mgcp_udp_send(int fd, struct osmo_sockaddr *addr, int port, const char *buf, int len);

include/osmocom/mgcp/mgcp_codec.h

@@ -13,9 +13,7 @@ struct mgcp_conn_rtp;
 void mgcp_codec_summary(struct mgcp_conn_rtp *conn);
 void mgcp_codec_reset_all(struct mgcp_conn_rtp *conn);
 int mgcp_codec_add(struct mgcp_conn_rtp *conn, int payload_type, const char *audio_name, const struct mgcp_codec_param *param);
-int mgcp_codec_decide(struct mgcp_conn_rtp *conn_src, struct mgcp_conn_rtp *conn_dst);
+int mgcp_codec_decide(struct mgcp_conn_rtp *conn);
+int mgcp_codec_pt_translate(struct mgcp_conn_rtp *conn_src, struct mgcp_conn_rtp *conn_dst, int payload_type);
 const struct mgcp_rtp_codec *mgcp_codec_pt_find_by_subtype_name(struct mgcp_conn_rtp *conn,
 								const char *subtype_name, unsigned int match_nr);
-bool mgcp_codec_amr_align_mode_is_indicated(const struct mgcp_rtp_codec *codec);
-bool mgcp_codec_amr_is_octet_aligned(const struct mgcp_rtp_codec *codec);
-struct mgcp_rtp_codec *mgcp_codec_from_pt(struct mgcp_conn_rtp *conn, int payload_type);

include/osmocom/mgcp/mgcp_common.h

@@ -47,7 +47,6 @@ enum mgcp_connection_mode {
 	MGCP_CONN_SEND_ONLY = 2,
 	MGCP_CONN_RECV_SEND = MGCP_CONN_RECV_ONLY | MGCP_CONN_SEND_ONLY,
 	MGCP_CONN_LOOPBACK  = 4 | MGCP_CONN_RECV_SEND,
-	MGCP_CONN_CONFECHO  = 8 | MGCP_CONN_RECV_SEND,
 };
 
 #define MGCP_X_OSMO_IGN_HEADER "X-Osmo-IGN:"

include/osmocom/mgcp/mgcp_conn.h

@@ -28,7 +28,6 @@
 #include <osmocom/mgcp/osmux.h>
 #include <osmocom/core/linuxlist.h>
 #include <osmocom/core/rate_ctr.h>
-#include <osmocom/gsm/iuup.h>
 #include <inttypes.h>
 
 #define LOGPCONN(conn, cat, level, fmt, args...) \
@@ -46,8 +45,8 @@ LOGPENDP((conn)->endp, cat, level, "CI:%s " fmt, \
 /* Specific rtp connection type (see struct mgcp_conn_rtp) */
 enum mgcp_conn_rtp_type {
 	MGCP_RTP_DEFAULT	= 0,
-	MGCP_RTP_OSMUX,
-	MGCP_RTP_IUUP,
+	MGCP_OSMUX_BSC,
+	MGCP_OSMUX_BSC_NAT,
 };
 
 /*! Connection type, specifies which member of the union "u" in mgcp_conn
@@ -79,31 +78,22 @@ struct mgcp_conn_rtp {
 	struct {
 		/* Osmux state: disabled, activating, active */
 		enum osmux_state state;
-		/* Is local_cid holding valid data? is it allocated from pool? */
-		bool local_cid_allocated;
-		/* Allocated local Osmux circuit ID for this conn */
-		uint8_t local_cid;
-		/* Is remote_cid holding valid data? was it already received from client? */
-		bool remote_cid_present;
-		/* Received remote Osmux circuit ID for this conn */
-		uint8_t remote_cid;
-		/* handle to batch messages, shared (refcounted) among several conns */
+		/* Is cid holding valid data? is it allocated from pool? */
+		bool cid_allocated;
+		/* Allocated Osmux circuit ID for this conn */
+		uint8_t cid;
+		/* handle to batch messages */
 		struct osmux_in_handle *in;
-		/* handle to unbatch messages, one allocated and owned per conn */
-		struct osmux_out_handle *out;
-		/* statistics: */
-		struct rate_ctr_group *ctrg;
+		/* handle to unbatch messages */
+		struct osmux_out_handle out;
+		/* statistics */
+		struct {
+			uint32_t chunks;
+			uint32_t octets;
+		} stats;
 	} osmux;
 
-	struct {
-		struct osmo_iuup_instance *iui;
-		bool active_init; /* true: Send IuUP Init */
-		int rfci_id_no_data; /* RFCI Id for RFCI NO_DATA (-1 if not available) */
-		bool configured;
-		struct osmo_iuup_rnl_prim *init_ind;
-	} iuup;
-
-	struct rate_ctr_group *ctrg;
+	struct rate_ctr_group *rate_ctr_group;
 };
 
 /*! MGCP connection (untyped) */
@@ -145,12 +135,12 @@ struct mgcp_conn {
 enum {
 	IN_STREAM_ERR_TSTMP_CTR,
 	OUT_STREAM_ERR_TSTMP_CTR,
-	RTP_PACKETS_RX_CTR,
-	RTP_OCTETS_RX_CTR,
-	RTP_PACKETS_TX_CTR,
-	RTP_OCTETS_TX_CTR,
-	RTP_DROPPED_PACKETS_CTR,
-	RTP_NUM_CONNECTIONS,
+        RTP_PACKETS_RX_CTR,
+        RTP_OCTETS_RX_CTR,
+        RTP_PACKETS_TX_CTR,
+        RTP_OCTETS_TX_CTR,
+        RTP_DROPPED_PACKETS_CTR,
+        RTP_NUM_CONNECTIONS,
 };
 
 /* RTP per-connection statistics. Instances of the corresponding rate counter group
@@ -163,7 +153,7 @@ static const struct rate_ctr_desc mgcp_conn_rate_ctr_desc[] = {
 	[RTP_OCTETS_RX_CTR] = {"rtp:octets_rx", "Inbound rtp octets."},
 	[RTP_PACKETS_TX_CTR] = {"rtp:packets_tx", "Outbound rtp packets."},
 	[RTP_OCTETS_TX_CTR] = {"rtp:octets_tx", "Outbound rtp octets."},
-	[RTP_DROPPED_PACKETS_CTR] = {"rtp:dropped", "Dropped rtp packets."}
+	[RTP_DROPPED_PACKETS_CTR] = {"rtp:dropped", "dropped rtp packets."}
 };
 
 /* Aggregated RTP connection stats. These are updated when an RTP connection is freed.
@@ -181,55 +171,9 @@ static const struct rate_ctr_desc all_rtp_conn_rate_ctr_desc[] = {
 	[RTP_NUM_CONNECTIONS] = {"all_rtp:num_closed_conns", "Total number of rtp connections closed."}
 };
 
-/* Osmux connection related counters */
-enum {
-	OSMUX_CHUNKS_RX_CTR,
-	OSMUX_OCTETS_RX_CTR,
-	OSMUX_RTP_PACKETS_TX_CTR,
-	OSMUX_RTP_PACKETS_TX_DROPPED_CTR,
-	OSMUX_AMR_OCTETS_TX_CTR,
-	/* Only available in global stats: */
-	OSMUX_NUM_CONNECTIONS,
-	OSMUX_PACKETS_RX_CTR,
-	OSMUX_PACKETS_TX_CTR,
-	OSMUX_DROPPED_PACKETS_CTR,
-};
-
-/* RTP per-connection statistics. Instances of the corresponding rate counter group
- * exist for the lifetime of an RTP connection.
- * Must be kept in sync with all_rtp_conn_rate_ctr_desc below */
-static const struct rate_ctr_desc mgcp_conn_osmux_rate_ctr_desc[] = {
-	[OSMUX_CHUNKS_RX_CTR] = {"osmux:chunks_rx", "Inbound Osmux chunks."},
-	[OSMUX_OCTETS_RX_CTR] = {"osmux:octets_rx", "Inbound Osmux octets."},
-	[OSMUX_RTP_PACKETS_TX_CTR] = {"osmux:rtp_packets_tx", "Tx outbound RTP packets to encode as Osmux."},
-	[OSMUX_RTP_PACKETS_TX_DROPPED_CTR] = {"osmux:rtp_packets_tx_dropped", "Dropped Tx outbound RTP packets to encode as Osmux."},
-	[OSMUX_AMR_OCTETS_TX_CTR] = {"osmux:amr_octets_tx", "Tx outbound AMD payload octets."},
-};
-
-/* Aggregated Osmux connection stats. These are updated when an Osmux connection is freed.
- * Must be kept in sync with mgcp_conn_osmux_rate_ctr_desc above */
-static const struct rate_ctr_desc all_osmux_conn_rate_ctr_desc[] = {
-	[OSMUX_CHUNKS_RX_CTR] = {"all_osmux:chunks_rx", "Inbound Osmux chunks."},
-	[OSMUX_OCTETS_RX_CTR] = {"all_osmux:octets_rx", "Inbound Osmux octets."},
-	[OSMUX_RTP_PACKETS_TX_CTR] = {"all_osmux:rtp_packets_tx", "Tx outbound RTP packets to encode as Osmux."},
-	[OSMUX_RTP_PACKETS_TX_DROPPED_CTR] = {"all_osmux:rtp_packets_tx_dropped", "Dropped Tx outbound RTP packets to encode as Osmux."},
-	[OSMUX_AMR_OCTETS_TX_CTR] = {"all_osmux:amr_octets_tx", "Tx outbound AMD payload octets."},
-	/* These last counters below do not exist in per-connection stats, only here: */
-	[OSMUX_NUM_CONNECTIONS] = {"all_osmux:num_closed_conns", "Total number of osmux connections closed."},
-	[OSMUX_PACKETS_RX_CTR] = {"all_osmux:packets_rx", "Total inbound UDP/Osmux packets."},
-	[OSMUX_PACKETS_TX_CTR] = {"all_osmux:packets_tx", "Total outbound UDP/Osmux packets."},
-	[OSMUX_DROPPED_PACKETS_CTR] = {"all_osmux:dropped_packets", "Dropped outbound UDP/Osmux packets."}
-};
-
 /* Was conn configured to handle Osmux? */
 static inline bool mgcp_conn_rtp_is_osmux(const struct mgcp_conn_rtp *conn) {
-	return conn->type == MGCP_RTP_OSMUX;
-}
-
-/* Was conn configured to handle Osmux? */
-static inline bool mgcp_conn_rtp_is_iuup(const struct mgcp_conn_rtp *conn)
-{
-	return conn->type == MGCP_RTP_IUUP;
+	return conn->type == MGCP_OSMUX_BSC || conn->type == MGCP_OSMUX_BSC_NAT;
 }
 
 struct mgcp_conn *mgcp_conn_alloc(void *ctx, struct mgcp_endpoint *endp,

include/osmocom/mgcp/mgcp_ctrl.h

@@ -1,11 +1,7 @@
-/* IuUP connection functionalitites */
-
 /*
- * (C) 2021 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
+ * (C) 2020 by Harald Welte <laforge@gnumonks.org>
  * All Rights Reserved
  *
- * Author: Pau Espin Pedrol
- *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
  * the Free Software Foundation; either version 3 of the License, or
@@ -20,14 +16,9 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
+
 #pragma once
 
-#include <osmocom/core/msgb.h>
+struct ctrl_handle *mgw_ctrl_interface_setup(struct mgcp_config *cfg,
+                                             const char *bind_addr, uint16_t port);
 
-struct mgcp_conn_rtp;
-
-int mgcp_conn_iuup_init(struct mgcp_conn_rtp *conn_rtp);
-void mgcp_conn_iuup_cleanup(struct mgcp_conn_rtp *conn_rtp);
-int mgcp_conn_iuup_dispatch_rtp(struct msgb *msg);
-int mgcp_conn_iuup_send_rtp(struct mgcp_conn_rtp *conn_src_rtp, struct mgcp_conn_rtp *conn_dest_rtp, struct msgb *msg);
-int mgcp_conn_iuup_send_dummy(struct mgcp_conn_rtp *conn_rtp);

include/osmocom/mgcp/mgcp_e1.h

@@ -23,5 +23,5 @@ static const uint8_t e1_offsets[] = { 0, 0, 4, 0, 2, 4, 6, 0, 1, 2, 3, 4, 5, 6,
 
 int mgcp_e1_endp_equip(struct mgcp_endpoint *endp, uint8_t ts, uint8_t ss, uint8_t offs);
 void mgcp_e1_endp_update(struct mgcp_endpoint *endp);
-void mgcp_e1_endp_release(struct mgcp_endpoint *endp, uint8_t ts);
+void mgcp_e1_endp_release(struct mgcp_endpoint *endp);
 int mgcp_e1_send_rtp(struct mgcp_endpoint *endp, struct mgcp_rtp_codec *codec, struct msgb *msg);

include/osmocom/mgcp/mgcp_endp.h

@@ -40,13 +40,8 @@ LOGP(cat, level, "endpoint:%s " fmt, \
      endp ? endp->name : "none", \
      ## args)
 
-enum rtp_proto {
-	MGCP_PROTO_RTP,
-	MGCP_PROTO_RTCP,
-};
-
 struct osmo_rtp_msg_ctx {
-	enum rtp_proto proto;
+	int proto;
 	struct mgcp_conn_rtp *conn_src;
 	struct osmo_sockaddr *from_addr;
 };
@@ -130,10 +125,10 @@ struct mgcp_endpoint {
 };
 
 struct mgcp_endpoint *mgcp_endp_alloc(struct mgcp_trunk *trunk, unsigned int index);
+void mgcp_endp_release(struct mgcp_endpoint *endp);
 int mgcp_endp_claim(struct mgcp_endpoint *endp, const char *callid);
 void mgcp_endp_update(struct mgcp_endpoint *endp);
 bool mgcp_endp_is_wildcarded(const char *epname);
-bool mgcp_endp_is_null(const char *epname);
 struct mgcp_endpoint *mgcp_endp_by_name_trunk(int *cause, const char *epname,
 					      const struct mgcp_trunk *trunk);
 struct mgcp_endpoint *mgcp_endp_by_name(int *cause, const char *epname,
@@ -145,4 +140,3 @@ void mgcp_endp_strip_name(char *epname_stripped, const char *epname,
 			 const struct mgcp_trunk *trunk);
 struct mgcp_endpoint *mgcp_endp_find_specific(const char *epname,
 			const struct mgcp_trunk *trunk);
-void mgcp_endp_release(struct mgcp_endpoint *endp);

include/osmocom/mgcp/mgcp_network.h

@@ -9,8 +9,7 @@
 
 /* The following constant defines an RTP dummy payload that is used for
  * "UDP Hole Punching" (NAT) */
-#define MGCP_DUMMY_LOAD 0x23
-static const char rtp_dummy_payload[] = { MGCP_DUMMY_LOAD };
+static const char rtp_dummy_payload[] = { 0x23 };
 
 /* Check if the data in a given message buffer matches the rtp dummy payload
  * defined above */
@@ -71,6 +70,8 @@ struct mgcp_rtp_state {
 	 * data is just re-used) */
 	uint16_t alt_rtp_tx_sequence;
 	uint32_t alt_rtp_tx_ssrc;
+
+	bool patched_first_rtp_payload; /* FIXME: drop this, see OS#2459 */
 };
 
 struct mgcp_rtp_codec {
@@ -93,7 +94,7 @@ struct mgcp_rtp_end {
 	struct osmo_sockaddr addr;
 
 	/* in network byte order */
-	int rtcp_port;
+	int rtp_port, rtcp_port;
 
 	/* currently selected audio codec */
 	struct mgcp_rtp_codec *codec;
@@ -109,8 +110,8 @@ struct mgcp_rtp_end {
 	uint32_t packet_duration_ms;
 	int maximum_packet_time; /* -1: not set */
 	char *fmtp_extra;
-	/* are we transmitting packets (true) or dropping (false) outbound packets */
-	bool output_enabled;
+	/* are we transmitting packets (1) or dropping (0) outbound packets */
+	int output_enabled;
 	/* FIXME: This parameter can be set + printed, but is nowhere used! */
 	int force_output_ptime;
 
@@ -157,7 +158,7 @@ void mgcp_patch_and_count(const struct mgcp_endpoint *endp,
 			  struct mgcp_rtp_state *state,
 			  struct mgcp_rtp_end *rtp_end,
 			  struct osmo_sockaddr *addr, struct msgb *msg);
-int mgcp_get_local_addr(char *addr, struct mgcp_conn_rtp *conn);
+void mgcp_get_local_addr(char *addr, struct mgcp_conn_rtp *conn);
 
 /* payload processing default functions */
 int mgcp_rtp_processing_default(struct mgcp_endpoint *endp, struct mgcp_rtp_end *dst_end,
@@ -176,12 +177,3 @@ void mgcp_get_net_downlink_format_default(struct mgcp_endpoint *endp,
 void mgcp_rtp_annex_count(const struct mgcp_endpoint *endp, struct mgcp_rtp_state *state,
 			const uint16_t seq, const int32_t transit,
 			const uint32_t ssrc, const bool marker_bit);
-
-void rtpconn_rate_ctr_add(struct mgcp_conn_rtp *conn_rtp, struct mgcp_endpoint *endp,
-				 int id, int inc);
-void rtpconn_rate_ctr_inc(struct mgcp_conn_rtp *conn_rtp, struct mgcp_endpoint *endp,
-				 int id);
-void forward_data_tap(int fd, struct mgcp_rtp_tap *tap, struct msgb *msg);
-uint32_t mgcp_get_current_ts(unsigned codec_rate);
-
-int amr_oa_bwe_convert(struct mgcp_endpoint *endp, struct msgb *msg, bool target_is_oa);

include/osmocom/mgcp/mgcp_ratectr.h

@@ -80,8 +80,6 @@ struct mgcp_ratectr_trunk {
 	struct rate_ctr_group *mgcp_dlcx_ctr_group;
 	/* Rate counter group which aggregates stats of individual RTP connections. */
 	struct rate_ctr_group *all_rtp_conn_stats;
-	/* Rate counter group which aggregates stats of individual Osmux connections. */
-	struct rate_ctr_group *all_osmux_conn_stats;
 	/* Rate counter group which contains stats for E1 events (only valid for E1 trunks) */
 	struct rate_ctr_group *e1_stats;
 };

include/osmocom/mgcp/mgcp_threads_queue.h

@@ -1,52 +0,0 @@
-/*
- * (C) 2021 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
- * All Rights Reserved
- *
- * Author: Eric Wild
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Affero 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 Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include <stdatomic.h>
-#include <stdbool.h>
-#include <stdlib.h>
-
-struct spsc {
-	atomic_uint readptr;
-	atomic_uint writeptr;
-
-	int efd_r, efd_w; /* eventfds used to block/notify readers/writers */
-
-	int count;
-	int size_per_buf;
-
-	void *buf; /* buffer size count*size_per_buf */
-	uintptr_t data[0]; /* count sized array of pointers to size_per_buf chunks in buf array*/
-};
-
-struct qchan {
-	struct spsc *a;
-	struct spsc *b;
-};
-
-bool spsc_push(struct spsc *q, void *elem);
-bool spsc_pop(struct spsc *q, void *elem);
-ssize_t spsc_prep_pop(struct spsc *q);
-int spsc_get_a_rdfd(struct qchan *q);
-
-struct qchan spsc_chan_init(void *talloc_ctx, unsigned int count, unsigned int size_per_buf);
-struct qchan spsc_chan_init_ex(void *talloc_ctx, unsigned int count, unsigned int size_per_buf, bool blockr_a,
-			       bool blockw_a, bool blockr_b, bool blockw_b);
-void spsc_chan_close(struct qchan *q);

include/osmocom/mgcp/mgcp_trunk.h

@@ -31,6 +31,8 @@ struct mgcp_trunk {
 	int audio_send_ptime;
 	int audio_send_name;
 
+	int no_audio_transcoding;
+
 	int omit_rtcp;
 	int keepalive_interval;
 
@@ -64,7 +66,7 @@ struct mgcp_trunk {
 		/* E1 specific */
 		struct {
 			unsigned int vty_line_nr;
-			uint8_t ts_usecount[NUM_E1_TS-1];
+			bool ts_in_use[NUM_E1_TS-1];
 			struct osmo_i460_timeslot i460_ts[NUM_E1_TS-1];
 			/* Note: on an E1 line TS 0 is devoted to framing and
 			 * alignment and therefore only NUM_E1_TS-1 timeslots

include/osmocom/mgcp/osmux.h

@@ -1,22 +1,25 @@
 #pragma once
 
-#include <stdint.h>
-
 #include <osmocom/core/socket.h>
 
 #include <osmocom/netif/osmux.h>
 struct mgcp_conn_rtp;
-struct mgcp_trunk;
-struct mgcp_endpoint;
-struct mgcp_conn_rtp;
 
-int osmux_init(struct mgcp_trunk *trunk);
-int osmux_init_conn(struct mgcp_conn_rtp *conn);
-int conn_osmux_enable(struct mgcp_conn_rtp *conn);
+#define OSMUX_PORT	1984
+
+enum {
+	OSMUX_ROLE_BSC = 0,
+	OSMUX_ROLE_BSC_NAT,
+};
+
+int osmux_init(int role, struct mgcp_config *cfg);
+int osmux_enable_conn(struct mgcp_endpoint *endp, struct mgcp_conn_rtp *conn,
+		      struct osmo_sockaddr *addr, uint16_t port);
 void conn_osmux_disable(struct mgcp_conn_rtp *conn);
-int conn_osmux_event_rx_crcx_mdcx(struct mgcp_conn_rtp *conn);
-int conn_osmux_send_rtp(struct mgcp_conn_rtp *conn, struct msgb *msg);
-int osmux_send_dummy(struct mgcp_conn_rtp *conn);
+int conn_osmux_allocate_cid(struct mgcp_conn_rtp *conn, int osmux_cid);
+void conn_osmux_release_cid(struct mgcp_conn_rtp *conn);
+int osmux_xfrm_to_osmux(char *buf, int buf_len, struct mgcp_conn_rtp *conn);
+int osmux_send_dummy(struct mgcp_endpoint *endp, struct mgcp_conn_rtp *conn);
 
 void osmux_cid_pool_get(uint8_t osmux_cid);
 int osmux_cid_pool_get_next(void);
@@ -26,14 +29,10 @@ int osmux_cid_pool_count_used(void);
 
 enum osmux_state {
 	OSMUX_STATE_DISABLED = 0, /* Osmux not being currently used by endp */
-	OSMUX_STATE_ACTIVATING,   /* Osmux was accepted in MGCP CRCX ACK. It can now be enabled by \ref conn_osmux_enable. */
-	OSMUX_STATE_ENABLED,	  /* Osmux was initialized by \ref conn_osmux_enable and can process frames */
+	OSMUX_STATE_ACTIVATING,   /* Osmux was accepted in MGCP CRCX ACK. It can now be enabled by \ref osmux_enable_endpoint. */
+	OSMUX_STATE_ENABLED,	  /* Osmux was initialized by \ref osmux_enable_endpoint and can process frames */
 };
 
-extern const struct value_string osmux_state_strs[];
-static inline const char *osmux_state_str(enum osmux_state val)
-{ return get_value_string(osmux_state_strs, val); }
-
 enum osmux_usage {
 	OSMUX_USAGE_OFF = 0,
 	OSMUX_USAGE_ON = 1,

include/osmocom/mgcp_client/defs.h

@@ -1,7 +0,0 @@
-#include <osmocom/core/defs.h>
-
-#if BUILDING_LIBOSMOMGCPCLIENT
-# define OSMO_DEPRECATED_OUTSIDE_LIBOSMOMGCPCLIENT(text)
-#else
-# define OSMO_DEPRECATED_OUTSIDE_LIBOSMOMGCPCLIENT(text) OSMO_DEPRECATED(text)
-#endif

include/osmocom/mgcp_client/mgcp_client.h

@@ -3,15 +3,14 @@
 #include <stdint.h>
 #include <arpa/inet.h>
 
-#include <osmocom/mgcp_client/defs.h>
 #include <osmocom/mgcp_client/mgcp_common.h>
 
 /* See also: RFC 3435, chapter 3.5 Transmission over UDP */
 #define MGCP_CLIENT_LOCAL_ADDR_DEFAULT NULL /* INADDR(6)_ANY */
-#define MGCP_CLIENT_LOCAL_PORT_DEFAULT 0
+#define MGCP_CLIENT_LOCAL_PORT_DEFAULT 2727
 #define MGCP_CLIENT_REMOTE_ADDR_DEFAULT "127.0.0.1"
 #define MGCP_CLIENT_REMOTE_PORT_DEFAULT 2427
-#define MGCP_CLIENT_KEEPALIVE_DEFAULT_ENDP "null"
+
 #define MGCP_CLIENT_MGW_STR "Configure MGCP connection to Media Gateway\n"
 
 struct msgb;
@@ -36,12 +35,6 @@ struct mgcp_client_conf {
 
 	/* human readable name / description */
 	char *description;
-
-	struct {
-		uint32_t timeout_sec;
-		uint32_t req_interval_sec;
-		char req_endpoint_name[MGCP_ENDPOINT_MAXLEN];
-	} keepalive;
 };
 
 typedef unsigned int mgcp_trans_id_t;
@@ -52,12 +45,10 @@ enum mgcp_codecs {
 	CODEC_GSM_8000_1 = 3,
 	CODEC_PCMA_8000_1 = 8,
 	CODEC_G729_8000_1 = 18,
-	CODEC_GSMEFR_8000_1 = 110,	/* 3GPP TS 48.103 table 5.4.2.2.1 */
-	CODEC_GSMHR_8000_1 = 111,	/* 3GPP TS 48.103 table 5.4.2.2.1 */
-	CODEC_AMR_8000_1 = 112,		/* 3GPP TS 48.103 table 5.4.2.2.1 */
-	CODEC_AMRWB_16000_1 = 113,	/* 3GPP TS 48.103 table 5.4.2.2.1 */
-	CODEC_IUFP = 96,
-	CODEC_CLEARMODE = 120,		/* 3GPP TS 48.103 table 5.4.2.2.1 */
+	CODEC_GSMEFR_8000_1 = 110,
+	CODEC_GSMHR_8000_1 = 111,
+	CODEC_AMR_8000_1 = 112,
+	CODEC_AMRWB_16000_1 = 113,
 };
 /* Note: when new codec types are added, the corresponding value strings
  * in mgcp_client.c (codec_table) must be updated as well. Enumerations
@@ -140,8 +131,7 @@ struct mgcp_msg {
 	struct mgcp_codec_param param;
 };
 
-struct mgcp_client_conf *mgcp_client_conf_alloc(void *ctx);
-void mgcp_client_conf_init(struct mgcp_client_conf *conf) OSMO_DEPRECATED_OUTSIDE_LIBOSMOMGCPCLIENT("use mgcp_client_conf_alloc() (or even better, switch to the mgcp_client_pool API!)");
+void mgcp_client_conf_init(struct mgcp_client_conf *conf);
 void mgcp_client_vty_init(void *talloc_ctx, int node, struct mgcp_client_conf *conf);
 int mgcp_client_config_write(struct vty *vty, const char *indent);
 struct mgcp_client_conf *mgcp_client_conf_actual(struct mgcp_client *mgcp);
@@ -149,7 +139,7 @@ struct mgcp_client_conf *mgcp_client_conf_actual(struct mgcp_client *mgcp);
 struct mgcp_client *mgcp_client_init(void *ctx,
 				     struct mgcp_client_conf *conf);
 int mgcp_client_connect(struct mgcp_client *mgcp);
-int mgcp_client_connect2(struct mgcp_client *mgcp, unsigned int retry_n_ports) OSMO_DEPRECATED("Use mgcp_client_connect() instead");
+int mgcp_client_connect2(struct mgcp_client *mgcp, unsigned int retry_n_ports);
 void mgcp_client_disconnect(struct mgcp_client *mgcp);
 
 const char *mgcp_client_remote_addr_str(struct mgcp_client *mgcp);

include/osmocom/mgcp_client/mgcp_client_endpoint_fsm.h

@@ -45,7 +45,6 @@ static inline void osmo_mgcpc_ep_ci_dlcx(struct osmo_mgcpc_ep_ci *ci)
 void osmo_mgcpc_ep_clear(struct osmo_mgcpc_ep *ep);
 
 const char *osmo_mgcpc_ep_name(const struct osmo_mgcpc_ep *ep);
-const char *osmo_mgcpc_ep_local_name(const struct osmo_mgcpc_ep *ep);
 const char *osmo_mgcpc_ep_ci_name(const struct osmo_mgcpc_ep_ci *ci);
 const char *osmo_mgcpc_ep_ci_id(const struct osmo_mgcpc_ep_ci *ci);
 struct mgcp_client *osmo_mgcpc_ep_client(const struct osmo_mgcpc_ep *ep);

include/osmocom/mgcp_client/mgcp_client_internal.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <osmocom/core/write_queue.h>
-#include <osmocom/core/timer.h>
 
 #define MSGB_CB_MGCP_TRANS_ID 0
 
@@ -16,10 +15,13 @@ struct mgcp_client {
 	struct osmo_wqueue wq;
 	mgcp_trans_id_t next_trans_id;
 	struct llist_head responses_pending;
-	struct mgcp_client_pool_member *pool_member;
-	struct osmo_timer_list keepalive_tx_timer;
-	struct osmo_timer_list keepalive_rx_timer;
-	bool conn_up;
+	struct llist_head inuse_endpoints;
+	struct mgcp_client_pool *pool;
+};
+
+struct mgcp_inuse_endpoint {
+	struct llist_head entry;
+	uint16_t id;
 };
 
 struct mgcp_response_pending {

include/osmocom/mgcp_client/mgcp_client_pool.h

@@ -1,24 +1,11 @@
 #pragma once
 
-#include <stdbool.h>
-
-#include <osmocom/vty/vty.h>
-
 struct mgcp_client;
 struct mgcp_client_pool;
-struct mgcp_client_pool_member;
 
 struct mgcp_client_pool *mgcp_client_pool_alloc(void *talloc_ctx);
-
 void mgcp_client_pool_vty_init(int parent_node, int mgw_node, const char *indent, struct mgcp_client_pool *pool);
-int mgcp_client_pool_config_write(struct vty *vty, const char *indent);
 unsigned int mgcp_client_pool_connect(struct mgcp_client_pool *pool);
 void mgcp_client_pool_register_single(struct mgcp_client_pool *pool, struct mgcp_client *mgcp_client);
-bool mgcp_client_pool_empty(const struct mgcp_client_pool *pool);
-
 struct mgcp_client *mgcp_client_pool_get(struct mgcp_client_pool *pool);
 void mgcp_client_pool_put(struct mgcp_client *mgcp_client);
-
-struct mgcp_client_pool_member *mgcp_client_pool_find_member_by_nr(struct mgcp_client_pool *pool, unsigned int nr);
-struct mgcp_client *mgcp_client_pool_member_get(struct mgcp_client_pool_member *pool_member);
-bool mgcp_client_pool_member_is_blocked(const struct mgcp_client_pool_member *pool_member);

include/osmocom/mgcp_client/mgcp_client_pool_internal.h

@@ -1,31 +1,9 @@
 #pragma once
 
-/* Struct to handle a pool of MGWs. (Use _pool functions) */
-struct mgcp_client_pool {
-
-	/* A pointer to a 'single' mgcp client. This is a non-pooled MGCP client that is configured using
-	 * mgcp_client_vty_init() and actively registered by the API user using mgcp_client_pool_register_single() */
-	struct mgcp_client *mgcp_client_single;
-
-	/* A list that manages the pool members (see mgcp_client_pool_member->list above) */
-	struct llist_head member_list;
-
-	/* String to use for indentation when writing the configuration file to the VTY. This field is populated by
-	 * mgcp_client_pool_vty_init() */
-	char *vty_indent;
-
-	/* VTY node specification used with this pool. This field is populated by mgcp_client_pool_vty_init() */
-	struct cmd_node *vty_node;
-};
-
 /* Struct to handle a member of a pool of MGWs. */
 struct mgcp_client_pool_member {
-	/* Entry in llist mgcp_client_pool->pool. */
 	struct llist_head list;
 
-	/* The pool managing this object: */
-	struct mgcp_client_pool *pool;
-
 	/* Reference number assinged by VTY. This number is used to manage the pool from the VTY and to identify it in
 	 * the log. */
 	unsigned int nr;
@@ -46,7 +24,22 @@ struct mgcp_client_pool_member {
 	unsigned int refcount;
 };
 
-struct mgcp_client_pool_member *mgcp_client_pool_member_alloc(struct mgcp_client_pool *pool, unsigned int nr);
-void mgcp_client_pool_member_free(struct mgcp_client_pool_member *pool_member);
-int mgcp_client_pool_member_reinit_client(struct mgcp_client_pool_member *pool_member);
+/* Struct to handle a pool of MGWs. (Use _pool functions) */
+struct mgcp_client_pool {
+
+	/* A pointer to a 'single' mgcp client. This is a non-pooled MGCP client that is configured using
+	 * mgcp_client_vty_init() and actively registered by the API user using mgcp_client_pool_register_single() */
+	struct mgcp_client *mgcp_client_single;
+
+	/* A list that manages the pool members (see above) */
+	struct llist_head pool;
+
+	/* String to use for indentation when writing the configuration file to the VTY. This field is populated by
+	 * mgcp_client_pool_vty_init() */
+	char *vty_indent;
+
+	/* VTY node specification used with this pool. This field is populated by mgcp_client_pool_vty_init() */
+	struct cmd_node *vty_node;
+};
+
 const char *mgcp_client_pool_member_name(const struct mgcp_client_pool_member *pool_member);

m4/ax_check_compile_flag.m4

@@ -0,0 +1,74 @@
+# ===========================================================================
+#   http://www.gnu.org/software/autoconf-archive/ax_check_compile_flag.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_CHECK_COMPILE_FLAG(FLAG, [ACTION-SUCCESS], [ACTION-FAILURE], [EXTRA-FLAGS], [INPUT])
+#
+# DESCRIPTION
+#
+#   Check whether the given FLAG works with the current language's compiler
+#   or gives an error.  (Warnings, however, are ignored)
+#
+#   ACTION-SUCCESS/ACTION-FAILURE are shell commands to execute on
+#   success/failure.
+#
+#   If EXTRA-FLAGS is defined, it is added to the current language's default
+#   flags (e.g. CFLAGS) when the check is done.  The check is thus made with
+#   the flags: "CFLAGS EXTRA-FLAGS FLAG".  This can for example be used to
+#   force the compiler to issue an error when a bad flag is given.
+#
+#   INPUT gives an alternative input source to AC_COMPILE_IFELSE.
+#
+#   NOTE: Implementation based on AX_CFLAGS_GCC_OPTION. Please keep this
+#   macro in sync with AX_CHECK_{PREPROC,LINK}_FLAG.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Guido U. Draheim <guidod@gmx.de>
+#   Copyright (c) 2011 Maarten Bosmans <mkbosmans@gmail.com>
+#
+#   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/>.
+#
+#   As a special exception, the respective Autoconf Macro's copyright owner
+#   gives unlimited permission to copy, distribute and modify the configure
+#   scripts that are the output of Autoconf when processing the Macro. You
+#   need not follow the terms of the GNU General Public License when using
+#   or distributing such scripts, even though portions of the text of the
+#   Macro appear in them. The GNU General Public License (GPL) does govern
+#   all other use of the material that constitutes the Autoconf Macro.
+#
+#   This special exception to the GPL applies to versions of the Autoconf
+#   Macro released by the Autoconf Archive. When you make and distribute a
+#   modified version of the Autoconf Macro, you may extend this special
+#   exception to the GPL to apply to your modified version as well.
+
+#serial 4
+
+AC_DEFUN([AX_CHECK_COMPILE_FLAG],
+[AC_PREREQ(2.64)dnl for _AC_LANG_PREFIX and AS_VAR_IF
+AS_VAR_PUSHDEF([CACHEVAR],[ax_cv_check_[]_AC_LANG_ABBREV[]flags_$4_$1])dnl
+AC_CACHE_CHECK([whether _AC_LANG compiler accepts $1], CACHEVAR, [
+  ax_check_save_flags=$[]_AC_LANG_PREFIX[]FLAGS
+  _AC_LANG_PREFIX[]FLAGS="$[]_AC_LANG_PREFIX[]FLAGS $4 $1"
+  AC_COMPILE_IFELSE([m4_default([$5],[AC_LANG_PROGRAM()])],
+    [AS_VAR_SET(CACHEVAR,[yes])],
+    [AS_VAR_SET(CACHEVAR,[no])])
+  _AC_LANG_PREFIX[]FLAGS=$ax_check_save_flags])
+AS_VAR_IF(CACHEVAR,yes,
+  [m4_default([$2], :)],
+  [m4_default([$3], :)])
+AS_VAR_POPDEF([CACHEVAR])dnl
+])dnl AX_CHECK_COMPILE_FLAGS

src/Makefile.am

@@ -13,6 +13,12 @@ AM_CFLAGS = \
 	$(COVERAGE_CFLAGS) \
 	$(NULL)
 
+AM_LDFLAGS = \
+	$(LIBOSMOCORE_LIBS) \
+	$(LIBOSMOGSM_LIBS) \
+	$(COVERAGE_LDFLAGS) \
+	$(NULL)
+
 # Libraries
 SUBDIRS = \
 	libosmo-mgcp-client \

src/libosmo-mgcp-client/Makefile.am

@@ -14,12 +14,14 @@ AM_CFLAGS = \
 	$(NULL)
 
 AM_LDFLAGS = \
+	$(LIBOSMOCORE_LIBS) \
+	$(LIBOSMOVTY_LIBS) \
 	$(COVERAGE_LDFLAGS) \
 	$(NULL)
 
 # This is not at all related to the release version, but a range of supported
 # API versions. Read TODO_RELEASE in the source tree's root!
-MGCP_CLIENT_LIBVERSION=13:0:1
+MGCP_CLIENT_LIBVERSION=8:0:0
 
 lib_LTLIBRARIES = \
 	libosmo-mgcp-client.la \
@@ -33,13 +35,4 @@ libosmo_mgcp_client_la_SOURCES = \
 	mgcp_client_pool.c \
 	$(NULL)
 
-libosmo_mgcp_client_la_LDFLAGS = \
-	$(AM_LDFLAGS) \
-	-version-info $(MGCP_CLIENT_LIBVERSION) \
-	-no-undefined \
-	$(NULL)
-
-libosmo_mgcp_client_la_LIBADD = \
-	$(LIBOSMOCORE_LIBS) \
-	$(LIBOSMOVTY_LIBS) \
-	$(NULL)
+libosmo_mgcp_client_la_LDFLAGS = $(AM_LDFLAGS) -version-info $(MGCP_CLIENT_LIBVERSION)

src/libosmo-mgcp-client/mgcp_client.c

@@ -59,8 +59,6 @@ const struct value_string osmo_mgcpc_codec_names[] = {
 	{ CODEC_GSMHR_8000_1, "GSM-HR-08/8000/1" },
 	{ CODEC_AMR_8000_1, "AMR/8000/1" },
 	{ CODEC_AMRWB_16000_1, "AMR-WB/16000/1" },
-	{ CODEC_IUFP, "VND.3GPP.IUFP/16000" },
-	{ CODEC_CLEARMODE, "CLEARMODE/8000" },
 	{ 0, NULL },
 };
 
@@ -69,16 +67,17 @@ const struct value_string osmo_mgcpc_codec_names[] = {
 static char *extract_codec_name(const char *str)
 {
 	static char buf[64];
-	char *pos;
+	unsigned int i;
 
 	if (!str)
 		return NULL;
 
 	osmo_strlcpy(buf, str, sizeof(buf));
 
-	pos = strchr(buf, '/');
-	if (pos)
-		*pos = '\0';
+	for (i = 0; i < strlen(buf); i++) {
+		if (buf[i] == '/')
+			buf[i] = '\0';
+	}
 
 	return buf;
 }
@@ -147,7 +146,7 @@ unsigned int map_codec_to_pt(const struct ptmap *ptmap, unsigned int ptmap_len,
 	 *  is also ignored and a 1:1 mapping is performed instead. */
 
 	/* we may return the codec directly since enum mgcp_codecs directly
-	 * corresponds to the statically assigned payload types */
+	 * corresponds to the statićally assigned payload types */
 	if (codec < 96 || codec > 127)
 		return codec;
 
@@ -193,7 +192,9 @@ enum mgcp_codecs map_pt_to_codec(struct ptmap *ptmap, unsigned int ptmap_len,
 	return pt;
 }
 
-static void _mgcp_client_conf_init(struct mgcp_client_conf *conf)
+/*! Initialize MGCP client configuration struct with default values.
+ *  \param[out] conf Client configuration.*/
+void mgcp_client_conf_init(struct mgcp_client_conf *conf)
 {
 	/* NULL and -1 default to MGCP_CLIENT_*_DEFAULT values */
 	*conf = (struct mgcp_client_conf){
@@ -201,39 +202,11 @@ static void _mgcp_client_conf_init(struct mgcp_client_conf *conf)
 		.local_port = -1,
 		.remote_addr = NULL,
 		.remote_port = -1,
-		.keepalive = {
-			.timeout_sec = 0, /* disabled */
-			.req_interval_sec = 0, /* disabled */
-			.req_endpoint_name = MGCP_CLIENT_KEEPALIVE_DEFAULT_ENDP,
-		},
 	};
 
 	INIT_LLIST_HEAD(&conf->reset_epnames);
 }
 
-/*! Allocate and initialize MGCP client configuration struct with default values.
- *  \param[in] ctx talloc context to use as a parent during allocation.
- *
- * The returned struct can be freed using talloc_free().
- */
-struct mgcp_client_conf *mgcp_client_conf_alloc(void *ctx)
-{
-	struct mgcp_client_conf *conf = talloc(ctx, struct mgcp_client_conf);
-	_mgcp_client_conf_init(conf);
-	return conf;
-}
-
-/*! Initialize MGCP client configuration struct with default values.
- *  \param[out] conf Client configuration.
- *
- * This function is deprecated and should not be used, as it may break if size
- * of struct mgcp_client_conf changes in the future!
- */
-void mgcp_client_conf_init(struct mgcp_client_conf *conf)
-{
-	_mgcp_client_conf_init(conf);
-}
-
 static void mgcp_client_handle_response(struct mgcp_client *mgcp,
 					struct mgcp_response_pending *pending,
 					struct mgcp_response *response)
@@ -370,7 +343,7 @@ static int mgcp_parse_audio_ptime_rtpmap(struct mgcp_response *r, const char *li
 {
 	unsigned int pt;
 	char codec_resp[64];
-	int rc;
+	enum mgcp_codecs codec;
 
 #define A_PTIME "a=ptime:"
 #define A_RTPMAP "a=rtpmap:"
@@ -391,14 +364,9 @@ static int mgcp_parse_audio_ptime_rtpmap(struct mgcp_response *r, const char *li
 			LOGP(DLMGCP, LOGL_ERROR, "No more space in ptmap array (len=%u)\n", r->ptmap_len);
 			return -ENOSPC;
 		}
-		rc = map_str_to_codec(codec_resp);
-		if (rc < 0) {
-			LOGP(DLMGCP, LOGL_ERROR,
-			     "Failed to parse SDP parameter, can't parse codec in rtpmap: %s\n", osmo_quote_str(line, -1));
-			return -EINVAL;
-		}
+		codec = map_str_to_codec(codec_resp);
 		r->ptmap[r->ptmap_len].pt = pt;
-		r->ptmap[r->ptmap_len].codec = rc;
+		r->ptmap[r->ptmap_len].codec = codec;
 		r->ptmap_len++;
 	}
 
@@ -473,7 +441,7 @@ static int mgcp_parse_osmux_cid(const char *line)
 		     osmux_cid, OSMUX_CID_MAX);
 		return -2;
 	}
-	LOGP(DLMGCP, LOGL_DEBUG, "MGW offered Osmux CID %u\n", osmux_cid);
+	LOGP(DLMGCP, LOGL_DEBUG, "bsc-nat offered Osmux CID %u\n", osmux_cid);
 
 	return osmux_cid;
 }
@@ -486,15 +454,15 @@ static char *mgcp_find_section_end(char *string)
 
 	rc = strstr(string, "\n\n");
 	if (rc)
-		return rc + 2;
+		return rc;
 
 	rc = strstr(string, "\n\r\n\r");
 	if (rc)
-		return rc + 4;
+		return rc;
 
 	rc = strstr(string, "\r\n\r\n");
 	if (rc)
-		return rc + 4;
+		return rc;
 
 	return NULL;
 }
@@ -705,14 +673,6 @@ int mgcp_client_rx(struct mgcp_client *mgcp, struct msgb *msg)
 	r = talloc_zero(mgcp, struct mgcp_response);
 	OSMO_ASSERT(r);
 
-	/* Re-arm keepalive timer if enabled */
-	if (OSMO_UNLIKELY(mgcp->conn_up == false)) {
-		LOGPMGW(mgcp, LOGL_NOTICE, "MGCP link to MGW now considered UP\n");
-		mgcp->conn_up = true;
-	}
-	if (mgcp->actual.keepalive.timeout_sec > 0)
-		osmo_timer_schedule(&mgcp->keepalive_rx_timer, mgcp->actual.keepalive.timeout_sec, 0);
-
 	rc = mgcp_response_parse_head(r, msg);
 	if (rc) {
 		LOGPMGW(mgcp, LOGL_ERROR, "Cannot parse MGCP response (head)\n");
@@ -765,6 +725,10 @@ static int mgcp_do_read(struct osmo_fd *fd)
 
 		msgb_free(msg);
 		return -1;
+	} else if (ret > 4096 - 128) {
+		LOGPMGW(mgcp, LOGL_ERROR, "Too much data: %s: %d\n", osmo_sock_get_name2(fd->fd), ret);
+		msgb_free(msg);
+		return -1;
 	}
 
 	msg->l2h = msgb_put(msg, ret);
@@ -783,84 +747,13 @@ static int mgcp_do_write(struct osmo_fd *fd, struct msgb *msg)
 		osmo_escape_str((const char *)msg->data, OSMO_MIN(42, msg->len)));
 
 	ret = write(fd->fd, msg->data, msg->len);
-	if (OSMO_UNLIKELY(ret != msg->len))
+	if (ret != msg->len)
 		LOGPMGW(mgcp, LOGL_ERROR, "Failed to Tx MGCP: %s: %d='%s'; msg: len=%u '%s'...\n",
 			osmo_sock_get_name2(fd->fd), errno, strerror(errno),
 			msg->len, osmo_escape_str((const char *)msg->data, OSMO_MIN(42, msg->len)));
-
-	/* Re-arm the keepalive Tx timer: */
-	if (mgcp->actual.keepalive.req_interval_sec > 0)
-		osmo_timer_schedule(&mgcp->keepalive_tx_timer, mgcp->actual.keepalive.req_interval_sec, 0);
 	return ret;
 }
 
-static const char *_mgcp_client_name_append_domain(const struct mgcp_client *mgcp, const char *name)
-{
-	static char endpoint[MGCP_ENDPOINT_MAXLEN];
-	int rc;
-
-	rc = snprintf(endpoint, sizeof(endpoint), "%s@%s", name, mgcp_client_endpoint_domain(mgcp));
-	if (rc > sizeof(endpoint) - 1) {
-		LOGPMGW(mgcp, LOGL_ERROR, "MGCP endpoint exceeds maximum length of %zu: '%s@%s'\n",
-			sizeof(endpoint) - 1, name, mgcp_client_endpoint_domain(mgcp));
-		return NULL;
-	}
-	if (rc < 1) {
-		LOGPMGW(mgcp, LOGL_ERROR, "Cannot compose MGCP endpoint name\n");
-		return NULL;
-	}
-	return endpoint;
-}
-
-/* Safely ignore the MGCP response to the DLCX sent via _mgcp_client_send_dlcx() */
-static void _ignore_mgcp_response(struct mgcp_response *response, void *priv) { }
-
-/* Format DLCX message (fire and forget) and send it off to the MGW */
-static void _mgcp_client_send_dlcx(struct mgcp_client *mgcp, const char *epname)
-{
-	struct msgb *msgb_dlcx;
-	struct mgcp_msg mgcp_msg_dlcx = {
-		.verb = MGCP_VERB_DLCX,
-		.presence = MGCP_MSG_PRESENCE_ENDPOINT,
-	};
-	osmo_strlcpy(mgcp_msg_dlcx.endpoint, epname, sizeof(mgcp_msg_dlcx.endpoint));
-	msgb_dlcx = mgcp_msg_gen(mgcp, &mgcp_msg_dlcx);
-	mgcp_client_tx(mgcp, msgb_dlcx, &_ignore_mgcp_response, NULL);
-}
-
-/* Format AuditEndpoint message (fire and forget) and send it off to the MGW */
-static void _mgcp_client_send_auep(struct mgcp_client *mgcp, const char *epname)
-{
-	struct msgb *msgb_auep;
-	struct mgcp_msg mgcp_msg_auep = {
-		.verb = MGCP_VERB_AUEP,
-		.presence = MGCP_MSG_PRESENCE_ENDPOINT,
-	};
-	OSMO_STRLCPY_ARRAY(mgcp_msg_auep.endpoint, epname);
-	msgb_auep = mgcp_msg_gen(mgcp, &mgcp_msg_auep);
-	mgcp_client_tx(mgcp, msgb_auep, &_ignore_mgcp_response, NULL);
-}
-
-static void mgcp_client_keepalive_tx_timer_cb(void *data)
-{
-	struct mgcp_client *mgcp = (struct mgcp_client *)data;
-	LOGPMGW(mgcp, LOGL_INFO, "Triggering keepalive MGCP request\n");
-	const char *epname = _mgcp_client_name_append_domain(mgcp, mgcp->actual.keepalive.req_endpoint_name);
-	_mgcp_client_send_auep(mgcp, epname);
-
-	/* Re-arm the timer: */
-	osmo_timer_schedule(&mgcp->keepalive_tx_timer, mgcp->actual.keepalive.req_interval_sec, 0);
-}
-
-static void mgcp_client_keepalive_rx_timer_cb(void *data)
-{
-	struct mgcp_client *mgcp = (struct mgcp_client *)data;
-	LOGPMGW(mgcp, LOGL_ERROR, "MGCP link to MGW now considered DOWN (keepalive timeout, more than %u seconds with no answer from MGW)\n",
-		mgcp->actual.keepalive.timeout_sec);
-	mgcp->conn_up = false;
-	/* TODO: Potentially time out all ongoing transactions for that MGW. Maybe based on VTY cfg? */
-}
-
 struct mgcp_client *mgcp_client_init(void *ctx,
 				     struct mgcp_client_conf *conf)
 {
@@ -873,12 +766,13 @@ struct mgcp_client *mgcp_client_init(void *ctx,
 		return NULL;
 
 	INIT_LLIST_HEAD(&mgcp->responses_pending);
+	INIT_LLIST_HEAD(&mgcp->inuse_endpoints);
 
 	mgcp->next_trans_id = 1;
 
 	mgcp->actual.local_addr = conf->local_addr ? conf->local_addr :
 		MGCP_CLIENT_LOCAL_ADDR_DEFAULT;
-	mgcp->actual.local_port = conf->local_port > 0 ? (uint16_t)conf->local_port :
+	mgcp->actual.local_port = conf->local_port >= 0 ? (uint16_t)conf->local_port :
 		MGCP_CLIENT_LOCAL_PORT_DEFAULT;
 
 	mgcp->actual.remote_addr = conf->remote_addr ? conf->remote_addr :
@@ -905,36 +799,110 @@ struct mgcp_client *mgcp_client_init(void *ctx,
 	if (conf->description)
 		mgcp->actual.description = talloc_strdup(mgcp, conf->description);
 
-	osmo_wqueue_init(&mgcp->wq, 1024);
-	mgcp->wq.read_cb = mgcp_do_read;
-	mgcp->wq.write_cb = mgcp_do_write;
-	osmo_fd_setup(&mgcp->wq.bfd, -1, OSMO_FD_READ, osmo_wqueue_bfd_cb, mgcp, 0);
-
-	memcpy(&mgcp->actual.keepalive, &conf->keepalive, sizeof(conf->keepalive));
-	osmo_timer_setup(&mgcp->keepalive_tx_timer, mgcp_client_keepalive_tx_timer_cb, mgcp);
-	osmo_timer_setup(&mgcp->keepalive_rx_timer, mgcp_client_keepalive_rx_timer_cb, mgcp);
-
 	return mgcp;
 }
 
+static int init_socket(struct mgcp_client *mgcp, unsigned int retry_n_ports)
+{
+	int rc;
+	struct osmo_wqueue *wq;
+	unsigned int i;
+
+	wq = &mgcp->wq;
+
+	for (i = 0; i < retry_n_ports + 1; i++) {
+
+		/* Initialize socket with the currently configured port number */
+		rc = osmo_sock_init2_ofd(&wq->bfd, AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP, mgcp->actual.local_addr,
+					 mgcp->actual.local_port, mgcp->actual.remote_addr, mgcp->actual.remote_port,
+					 OSMO_SOCK_F_BIND | OSMO_SOCK_F_CONNECT);
+		if (rc > 0)
+			return rc;
+
+		/* If there is a different port than the default port configured then we assume that the user has
+		 * chosen that port conciously and we will not try to resolve this by silently choosing a different
+		 * port. */
+		if (mgcp->actual.local_port != MGCP_CLIENT_LOCAL_PORT_DEFAULT && i == 0)
+			return -EINVAL;
+
+		if (i == retry_n_ports) {
+			/* Last try failed */
+			LOGPMGW(mgcp, LOGL_NOTICE, "Failed to bind to %s:%d -- check configuration!\n",
+			     mgcp->actual.local_addr ? mgcp->actual.local_addr : "(any)", mgcp->actual.local_port);
+			if (retry_n_ports == 0)
+				return -EINVAL;
+		} else {
+			/* Choose a new port number to try next */
+			LOGPMGW(mgcp, LOGL_NOTICE,
+			     "Failed to bind to %s:%d, retrying with port %d -- check configuration!\n",
+			     mgcp->actual.local_addr ? mgcp->actual.local_addr : "(any)", mgcp->actual.local_port,
+			     mgcp->actual.local_port + 1);
+			mgcp->actual.local_port++;
+		}
+	}
+
+	LOGPMGW(mgcp, LOGL_FATAL, "Failed to find a port to bind on %u times -- check configuration!\n", i);
+	return -EINVAL;
+}
+
+/* Safely ignore the MGCP response to the DLCX sent via _mgcp_client_send_dlcx() */
+static void _ignore_mgcp_response(struct mgcp_response *response, void *priv) { }
+
+/* Format DLCX message (fire and forget) and send it off to the MGW */
+static void _mgcp_client_send_dlcx(struct mgcp_client *mgcp, const char *epname)
+{
+	struct msgb *msgb_dlcx;
+	struct mgcp_msg mgcp_msg_dlcx = {
+		.verb = MGCP_VERB_DLCX,
+		.presence = MGCP_MSG_PRESENCE_ENDPOINT,
+	};
+	osmo_strlcpy(mgcp_msg_dlcx.endpoint, epname, sizeof(mgcp_msg_dlcx.endpoint));
+	msgb_dlcx = mgcp_msg_gen(mgcp, &mgcp_msg_dlcx);
+	mgcp_client_tx(mgcp, msgb_dlcx, &_ignore_mgcp_response, NULL);
+}
+
+static const char *_mgcp_client_name_append_domain(const struct mgcp_client *mgcp, const char *name)
+{
+	static char endpoint[MGCP_ENDPOINT_MAXLEN];
+	int rc;
+
+	rc = snprintf(endpoint, sizeof(endpoint), "%s@%s", name, mgcp_client_endpoint_domain(mgcp));
+	if (rc > sizeof(endpoint) - 1) {
+		LOGPMGW(mgcp, LOGL_ERROR, "MGCP endpoint exceeds maximum length of %zu: '%s@%s'\n",
+			sizeof(endpoint) - 1, name, mgcp_client_endpoint_domain(mgcp));
+		return NULL;
+	}
+	if (rc < 1) {
+		LOGPMGW(mgcp, LOGL_ERROR, "Cannot compose MGCP endpoint name\n");
+		return NULL;
+	}
+	return endpoint;
+}
+
 /*! Initialize client connection (opens socket)
  *  \param[in,out] mgcp MGCP client descriptor.
+ *  \param[in] retry_n_ports number of consecutive local ports that should be used to retry on failure.
  *  \returns 0 on success, -EINVAL on error. */
-int mgcp_client_connect(struct mgcp_client *mgcp)
+int mgcp_client_connect2(struct mgcp_client *mgcp, unsigned int retry_n_ports)
 {
+	struct osmo_wqueue *wq;
 	int rc;
 	struct reset_ep *reset_ep;
 	const char *epname;
-	bool some_dlcx_sent = false;
 
 	if (!mgcp) {
 		LOGPMGW(mgcp, LOGL_FATAL, "Client not initialized properly\n");
 		return -EINVAL;
 	}
 
-	rc = osmo_sock_init2_ofd(&mgcp->wq.bfd, AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP, mgcp->actual.local_addr,
-				 mgcp->actual.local_port, mgcp->actual.remote_addr, mgcp->actual.remote_port,
-				 OSMO_SOCK_F_BIND | OSMO_SOCK_F_CONNECT);
+	wq = &mgcp->wq;
+	osmo_wqueue_init(wq, 1024);
+	wq->read_cb = mgcp_do_read;
+	wq->write_cb = mgcp_do_write;
+
+	osmo_fd_setup(&wq->bfd, -1, OSMO_FD_READ, osmo_wqueue_bfd_cb, mgcp, 0);
+
+	rc = init_socket(mgcp, retry_n_ports);
 	if (rc < 0) {
 		LOGPMGW(mgcp, LOGL_FATAL,
 		     "Failed to initialize socket %s:%u -> %s:%u for MGW: %s\n",
@@ -944,7 +912,7 @@ int mgcp_client_connect(struct mgcp_client *mgcp)
 		goto error_close_fd;
 	}
 
-	LOGPMGW(mgcp, LOGL_INFO, "MGW connection: %s\n", osmo_sock_get_name2(mgcp->wq.bfd.fd));
+	LOGPMGW(mgcp, LOGL_INFO, "MGW connection: %s\n", osmo_sock_get_name2(wq->bfd.fd));
 
 	/* If configured, send a DLCX message to the endpoints that are configured to
 	 * be reset on startup. Usually this is a wildcarded endpoint. */
@@ -952,36 +920,20 @@ int mgcp_client_connect(struct mgcp_client *mgcp)
 		epname = _mgcp_client_name_append_domain(mgcp, reset_ep->name);
 		LOGPMGW(mgcp, LOGL_INFO, "Sending DLCX to: %s\n", epname);
 		_mgcp_client_send_dlcx(mgcp, epname);
-		some_dlcx_sent = true;
 	}
-
-	if (mgcp->actual.keepalive.req_interval_sec > 0) {
-		if (!some_dlcx_sent) {
-			/* Attempt an immediate probe to find out if link is UP or DOWN: */
-			osmo_timer_schedule(&mgcp->keepalive_tx_timer, 0, 0);
-		}
-		/* else: keepalive_tx_timer was already scheduled (if needed) down in the stack during Tx DLCX above */
-	} else {
-		/* Assume link is UP by default, so that this MGW can be selected: */
-		mgcp->conn_up = true;
-	}
-
-	if (mgcp->actual.keepalive.timeout_sec > 0)
-		osmo_timer_schedule(&mgcp->keepalive_rx_timer, mgcp->actual.keepalive.timeout_sec, 0);
-
 	return 0;
 error_close_fd:
-	close(mgcp->wq.bfd.fd);
-	mgcp->wq.bfd.fd = -1;
+	close(wq->bfd.fd);
+	wq->bfd.fd = -1;
 	return rc;
 }
 
-/*! DEPRECATED: Initialize client connection (opens socket)
+/*! Initialize client connection (opens socket)
  *  \param[in,out] mgcp MGCP client descriptor.
  *  \returns 0 on success, -EINVAL on error. */
-int mgcp_client_connect2(struct mgcp_client *mgcp, unsigned int retry_n_ports)
+int mgcp_client_connect(struct mgcp_client *mgcp)
 {
-	return mgcp_client_connect(mgcp);
+	return mgcp_client_connect2(mgcp, 99);
 }
 
 /*! Terminate client connection
@@ -996,18 +948,13 @@ void mgcp_client_disconnect(struct mgcp_client *mgcp)
 		return;
 	}
 
-	/* Disarm keepalive Tx/Rx timer until next connect() */
-	osmo_timer_del(&mgcp->keepalive_rx_timer);
-	osmo_timer_del(&mgcp->keepalive_tx_timer);
-	mgcp->conn_up = false;
-
 	wq = &mgcp->wq;
 	osmo_wqueue_clear(wq);
 	LOGPMGW(mgcp, LOGL_INFO, "MGCP association: %s -- closed!\n", osmo_sock_get_name2(wq->bfd.fd));
-	if (osmo_fd_is_registered(&wq->bfd))
-		osmo_fd_unregister(&wq->bfd);
 	close(wq->bfd.fd);
 	wq->bfd.fd = -1;
+	if (osmo_fd_is_registered(&wq->bfd))
+		osmo_fd_unregister(&wq->bfd);
 }
 
 /*! Get the IP-Aaddress of the associated MGW as string.
@@ -1103,8 +1050,11 @@ const char *mgcp_client_e1_epname(void *ctx, const struct mgcp_client *mgcp, uin
 	return epname;
 }
 
-struct mgcp_response_pending *mgcp_client_pending_add(struct mgcp_client *mgcp, mgcp_trans_id_t trans_id,
-						      mgcp_response_cb_t response_cb, void *priv)
+struct mgcp_response_pending * mgcp_client_pending_add(
+					struct mgcp_client *mgcp,
+					mgcp_trans_id_t trans_id,
+					mgcp_response_cb_t response_cb,
+					void *priv)
 {
 	struct mgcp_response_pending *pending;
 
@@ -1232,87 +1182,87 @@ static mgcp_trans_id_t mgcp_client_next_trans_id(struct mgcp_client *mgcp)
 static int add_lco(struct msgb *msg, struct mgcp_msg *mgcp_msg)
 {
 	unsigned int i;
+	int rc = 0;
 	const char *codec;
 	unsigned int pt;
 
-#define MSGB_PRINTF_OR_RET(FMT, ARGS...) do { \
-		if (msgb_printf(msg, FMT, ##ARGS) != 0) { \
-			LOGP(DLMGCP, LOGL_ERROR, "Message buffer too small, can not generate MGCP/SDP message\n"); \
-			return -ENOBUFS; \
-		} \
-	} while (0)
-
-	MSGB_PRINTF_OR_RET("L:");
+	rc |= msgb_printf(msg, "L:");
 
 	if (mgcp_msg->ptime)
-		MSGB_PRINTF_OR_RET(" p:%u,", mgcp_msg->ptime);
+		rc |= msgb_printf(msg, " p:%u,", mgcp_msg->ptime);
 
 	if (mgcp_msg->codecs_len) {
-		MSGB_PRINTF_OR_RET(" a:");
+		rc |= msgb_printf(msg, " a:");
 		for (i = 0; i < mgcp_msg->codecs_len; i++) {
 			pt = mgcp_msg->codecs[i];
 			codec = get_value_string_or_null(osmo_mgcpc_codec_names, pt);
 
 			/* Note: Use codec descriptors from enum mgcp_codecs
 			 * in mgcp_client only! */
-			if (!codec)
+			if (!codec) {
+				msgb_free(msg);
 				return -EINVAL;
+			}
 
-			MSGB_PRINTF_OR_RET("%s", extract_codec_name(codec));
+			rc |= msgb_printf(msg, "%s", extract_codec_name(codec));
 			if (i < mgcp_msg->codecs_len - 1)
-				MSGB_PRINTF_OR_RET(";");
+				rc |= msgb_printf(msg, ";");
 		}
-		MSGB_PRINTF_OR_RET(",");
+		rc |= msgb_printf(msg, ",");
 	}
 
-	MSGB_PRINTF_OR_RET(" nt:IN\r\n");
-	return 0;
+	rc |= msgb_printf(msg, " nt:IN\r\n");
 
-#undef MSGB_PRINTF_OR_RET
+	if (rc != 0) {
+		LOGP(DLMGCP, LOGL_ERROR,
+		     "message buffer to small, can not generate MGCP message (LCO)\n");
+		msgb_free(msg);
+		return -ENOBUFS;
+	}
+	return 0;
 }
 
 /* Helper function for mgcp_msg_gen(): Add SDP information to MGCP message */
 static int add_sdp(struct msgb *msg, struct mgcp_msg *mgcp_msg, struct mgcp_client *mgcp)
 {
 	unsigned int i;
+	int rc = 0;
 	char local_ip[INET6_ADDRSTRLEN];
 	int local_ip_family, audio_ip_family;
 	const char *codec;
 	unsigned int pt;
 
-#define MSGB_PRINTF_OR_RET(FMT, ARGS...) do { \
-		if (msgb_printf(msg, FMT, ##ARGS) != 0) { \
-			LOGPMGW(mgcp, LOGL_ERROR, "Message buffer too small, can not generate MGCP message (SDP)\n"); \
-			return -ENOBUFS; \
-		} \
-	} while (0)
-
 	/* Add separator to mark the beginning of the SDP block */
-	MSGB_PRINTF_OR_RET("\r\n");
+	rc |= msgb_printf(msg, "\r\n");
 
 	/* Add SDP protocol version */
-	MSGB_PRINTF_OR_RET("v=0\r\n");
+	rc |= msgb_printf(msg, "v=0\r\n");
 
 	/* Determine local IP-Address */
 	if (osmo_sock_local_ip(local_ip, mgcp->actual.remote_addr) < 0) {
 		LOGPMGW(mgcp, LOGL_ERROR,
 			"Could not determine local IP-Address!\n");
+		msgb_free(msg);
 		return -EINVAL;
 	}
 	local_ip_family = osmo_ip_str_type(local_ip);
-	if (local_ip_family == AF_UNSPEC)
+	if (local_ip_family == AF_UNSPEC) {
+		msgb_free(msg);
 		return -EINVAL;
+	}
 	audio_ip_family = osmo_ip_str_type(mgcp_msg->audio_ip);
-	if (audio_ip_family == AF_UNSPEC)
+	if (audio_ip_family == AF_UNSPEC) {
+		msgb_free(msg);
 		return -EINVAL;
+	}
 
 	/* Add owner/creator (SDP) */
-	MSGB_PRINTF_OR_RET("o=- %x 23 IN IP%c %s\r\n", mgcp_msg->call_id,
+	rc |= msgb_printf(msg, "o=- %x 23 IN IP%c %s\r\n", mgcp_msg->call_id,
 			  local_ip_family == AF_INET6 ? '6' : '4',
 			  local_ip);
 
 	/* Add session name (none) */
-	MSGB_PRINTF_OR_RET("s=-\r\n");
+	rc |= msgb_printf(msg, "s=-\r\n");
 
 	/* Add RTP address and port */
 	if (mgcp_msg->audio_port == 0) {
@@ -1327,20 +1277,20 @@ static int add_sdp(struct msgb *msg, struct mgcp_msg *mgcp_msg, struct mgcp_clie
 		msgb_free(msg);
 		return -EINVAL;
 	}
-	MSGB_PRINTF_OR_RET("c=IN IP%c %s\r\n",
+	rc |= msgb_printf(msg, "c=IN IP%c %s\r\n",
 			  audio_ip_family == AF_INET6 ? '6' : '4',
 			  mgcp_msg->audio_ip);
 
 	/* Add time description, active time (SDP) */
-	MSGB_PRINTF_OR_RET("t=0 0\r\n");
+	rc |= msgb_printf(msg, "t=0 0\r\n");
 
-	MSGB_PRINTF_OR_RET("m=audio %u RTP/AVP", mgcp_msg->audio_port);
+	rc |= msgb_printf(msg, "m=audio %u RTP/AVP", mgcp_msg->audio_port);
 	for (i = 0; i < mgcp_msg->codecs_len; i++) {
 		pt = map_codec_to_pt(mgcp_msg->ptmap, mgcp_msg->ptmap_len, mgcp_msg->codecs[i]);
-		MSGB_PRINTF_OR_RET(" %u", pt);
+		rc |= msgb_printf(msg, " %u", pt);
 
 	}
-	MSGB_PRINTF_OR_RET("\r\n");
+	rc |= msgb_printf(msg, "\r\n");
 
 	/* Add optional codec parameters (fmtp) */
 	if (mgcp_msg->param_present) {
@@ -1350,9 +1300,9 @@ static int add_sdp(struct msgb *msg, struct mgcp_msg *mgcp_msg, struct mgcp_clie
 				   continue;
 			pt = map_codec_to_pt(mgcp_msg->ptmap, mgcp_msg->ptmap_len, mgcp_msg->codecs[i]);
 			if (mgcp_msg->param.amr_octet_aligned_present && mgcp_msg->param.amr_octet_aligned)
-				MSGB_PRINTF_OR_RET("a=fmtp:%u octet-align=1\r\n", pt);
+				rc |= msgb_printf(msg, "a=fmtp:%u octet-align=1\r\n", pt);
 			else if (mgcp_msg->param.amr_octet_aligned_present && !mgcp_msg->param.amr_octet_aligned)
-				MSGB_PRINTF_OR_RET("a=fmtp:%u octet-align=0\r\n", pt);
+				rc |= msgb_printf(msg, "a=fmtp:%u octet-align=0\r\n", pt);
 		}
 	}
 
@@ -1367,18 +1317,25 @@ static int add_sdp(struct msgb *msg, struct mgcp_msg *mgcp_msg, struct mgcp_clie
 
 			/* Note: Use codec descriptors from enum mgcp_codecs
 			 * in mgcp_client only! */
-			if (!codec)
+			if (!codec) {
+				msgb_free(msg);
 				return -EINVAL;
+			}
 
-			MSGB_PRINTF_OR_RET("a=rtpmap:%u %s\r\n", pt, codec);
+			rc |= msgb_printf(msg, "a=rtpmap:%u %s\r\n", pt, codec);
 		}
 	}
 
 	if (mgcp_msg->ptime)
-		MSGB_PRINTF_OR_RET("a=ptime:%u\r\n", mgcp_msg->ptime);
+		rc |= msgb_printf(msg, "a=ptime:%u\r\n", mgcp_msg->ptime);
+
+	if (rc != 0) {
+		LOGPMGW(mgcp, LOGL_ERROR, "Message buffer to small, can not generate MGCP message (SDP)\n");
+		msgb_free(msg);
+		return -ENOBUFS;
+	}
 
 	return 0;
-#undef MSGB_PRINTF_OR_RET
 }
 
 /*! Generate an MGCP message
@@ -1390,16 +1347,10 @@ struct msgb *mgcp_msg_gen(struct mgcp_client *mgcp, struct mgcp_msg *mgcp_msg)
 	mgcp_trans_id_t trans_id = mgcp_client_next_trans_id(mgcp);
 	uint32_t mandatory_mask;
 	struct msgb *msg = msgb_alloc_headroom(4096, 128, "MGCP tx");
+	int rc = 0;
 	bool use_sdp = false;
 	char buf[32];
 
-#define MSGB_PRINTF_OR_RET(FMT, ARGS...) do { \
-		if (msgb_printf(msg, FMT, ##ARGS) != 0) { \
-			LOGPMGW(mgcp, LOGL_ERROR, "Message buffer too small, can not generate MGCP/SDP message\n"); \
-			goto exit_error; \
-		} \
-	} while (0)
-
 	msg->l2h = msg->data;
 	msg->cb[MSGB_CB_MGCP_TRANS_ID] = trans_id;
 
@@ -1407,70 +1358,75 @@ struct msgb *mgcp_msg_gen(struct mgcp_client *mgcp, struct mgcp_msg *mgcp_msg)
 	switch (mgcp_msg->verb) {
 	case MGCP_VERB_CRCX:
 		mandatory_mask = MGCP_CRCX_MANDATORY;
-		MSGB_PRINTF_OR_RET("CRCX %u", trans_id);
+		rc |= msgb_printf(msg, "CRCX %u", trans_id);
 		break;
 	case MGCP_VERB_MDCX:
 		mandatory_mask = MGCP_MDCX_MANDATORY;
-		MSGB_PRINTF_OR_RET("MDCX %u", trans_id);
+		rc |= msgb_printf(msg, "MDCX %u", trans_id);
 		break;
 	case MGCP_VERB_DLCX:
 		mandatory_mask = MGCP_DLCX_MANDATORY;
-		MSGB_PRINTF_OR_RET("DLCX %u", trans_id);
+		rc |= msgb_printf(msg, "DLCX %u", trans_id);
 		break;
 	case MGCP_VERB_AUEP:
 		mandatory_mask = MGCP_AUEP_MANDATORY;
-		MSGB_PRINTF_OR_RET("AUEP %u", trans_id);
+		rc |= msgb_printf(msg, "AUEP %u", trans_id);
 		break;
 	case MGCP_VERB_RSIP:
 		mandatory_mask = MGCP_RSIP_MANDATORY;
-		MSGB_PRINTF_OR_RET("RSIP %u", trans_id);
+		rc |= msgb_printf(msg, "RSIP %u", trans_id);
 		break;
 	default:
 		LOGPMGW(mgcp, LOGL_ERROR, "Invalid command verb, can not generate MGCP message\n");
-		goto exit_error;
+		msgb_free(msg);
+		return NULL;
 	}
 
 	/* Check if mandatory fields are missing */
 	if (!((mgcp_msg->presence & mandatory_mask) == mandatory_mask)) {
 		LOGPMGW(mgcp, LOGL_ERROR,
 			"One or more missing mandatory fields, can not generate MGCP message\n");
-		goto exit_error;
+		msgb_free(msg);
+		return NULL;
 	}
 
 	/* Add endpoint name */
 	if (mgcp_msg->presence & MGCP_MSG_PRESENCE_ENDPOINT) {
 		if (strlen(mgcp_msg->endpoint) <= 0) {
 			LOGPMGW(mgcp, LOGL_ERROR, "Empty endpoint name, can not generate MGCP message\n");
-			goto exit_error;
+			msgb_free(msg);
+			return NULL;
 		}
 
 		if (strstr(mgcp_msg->endpoint, "@") == NULL) {
 			LOGPMGW(mgcp, LOGL_ERROR,
 				"Endpoint name (%s) lacks separator (@), can not generate MGCP message\n",
 				mgcp_msg->endpoint);
-			goto exit_error;
+			msgb_free(msg);
+			return NULL;
 		}
 
-		MSGB_PRINTF_OR_RET(" %s", mgcp_msg->endpoint);
+		rc |= msgb_printf(msg, " %s", mgcp_msg->endpoint);
 	}
 
 	/* Add protocol version */
-	MSGB_PRINTF_OR_RET(" MGCP 1.0\r\n");
+	rc |= msgb_printf(msg, " MGCP 1.0\r\n");
 
 	/* Add call id */
 	if (mgcp_msg->presence & MGCP_MSG_PRESENCE_CALL_ID)
-		MSGB_PRINTF_OR_RET("C: %x\r\n", mgcp_msg->call_id);
+		rc |= msgb_printf(msg, "C: %x\r\n", mgcp_msg->call_id);
 
 	/* Add connection id */
 	if (mgcp_msg->presence & MGCP_MSG_PRESENCE_CONN_ID) {
 		if (strlen(mgcp_msg->conn_id) <= 0) {
 			LOGPMGW(mgcp, LOGL_ERROR, "Empty connection id, can not generate MGCP message\n");
-			goto exit_error;
+			msgb_free(msg);
+			return NULL;
 		}
-		MSGB_PRINTF_OR_RET("I: %s\r\n", mgcp_msg->conn_id);
+		rc |= msgb_printf(msg, "I: %s\r\n", mgcp_msg->conn_id);
 	}
 
-	/* Using SDP makes sense when a valid IP/Port combination is specified,
+	/* Using SDP makes sense when a valid IP/Port combination is specifiec,
 	 * if we do not know this information yet, we fall back to LCO */
 	if (mgcp_msg->presence & MGCP_MSG_PRESENCE_AUDIO_IP
 	    && mgcp_msg->presence & MGCP_MSG_PRESENCE_AUDIO_PORT)
@@ -1480,32 +1436,35 @@ struct msgb *mgcp_msg_gen(struct mgcp_client *mgcp, struct mgcp_msg *mgcp_msg)
 	if (!use_sdp
 	    && (mgcp_msg->verb == MGCP_VERB_CRCX
 		|| mgcp_msg->verb == MGCP_VERB_MDCX)) {
-		if (add_lco(msg, mgcp_msg) < 0) {
-			LOGPMGW(mgcp, LOGL_ERROR, "Failed to add LCO, can not generate MGCP message\n");
-			goto exit_error;
-		}
+	        if (add_lco(msg, mgcp_msg) < 0)
+			return NULL;
 	}
 
 	/* Add mode */
 	if (mgcp_msg->presence & MGCP_MSG_PRESENCE_CONN_MODE)
-		MSGB_PRINTF_OR_RET("M: %s\r\n", mgcp_client_cmode_name(mgcp_msg->conn_mode));
+		rc |=
+		    msgb_printf(msg, "M: %s\r\n",
+				mgcp_client_cmode_name(mgcp_msg->conn_mode));
 
 	/* Add X-Osmo-IGN */
 	if ((mgcp_msg->presence & MGCP_MSG_PRESENCE_X_OSMO_IGN)
 	    && (mgcp_msg->x_osmo_ign != 0))
-		MSGB_PRINTF_OR_RET(MGCP_X_OSMO_IGN_HEADER "%s\r\n",
-				   mgcp_msg->x_osmo_ign & MGCP_X_OSMO_IGN_CALLID ? " C" : "");
+		rc |=
+		    msgb_printf(msg, MGCP_X_OSMO_IGN_HEADER "%s\r\n",
+				mgcp_msg->x_osmo_ign & MGCP_X_OSMO_IGN_CALLID ? " C": "");
 
 	/* Add X-Osmo-Osmux */
 	if ((mgcp_msg->presence & MGCP_MSG_PRESENCE_X_OSMO_OSMUX_CID)) {
 		if (mgcp_msg->x_osmo_osmux_cid < -1 || mgcp_msg->x_osmo_osmux_cid > OSMUX_CID_MAX) {
 			LOGPMGW(mgcp, LOGL_ERROR, "Wrong Osmux CID %d, can not generate MGCP message\n",
 				mgcp_msg->x_osmo_osmux_cid);
-			goto exit_error;
+			msgb_free(msg);
+			return NULL;
 		}
 		snprintf(buf, sizeof(buf), " %d", mgcp_msg->x_osmo_osmux_cid);
-		MSGB_PRINTF_OR_RET(MGCP_X_OSMO_OSMUX_HEADER "%s\r\n",
-				   mgcp_msg->x_osmo_osmux_cid == -1 ? " *" : buf);
+		rc |=
+		    msgb_printf(msg, MGCP_X_OSMO_OSMUX_HEADER "%s\r\n",
+				mgcp_msg->x_osmo_osmux_cid == -1 ? " *": buf);
 	}
 
 
@@ -1513,18 +1472,17 @@ struct msgb *mgcp_msg_gen(struct mgcp_client *mgcp, struct mgcp_msg *mgcp_msg)
 	if (use_sdp
 	    && (mgcp_msg->verb == MGCP_VERB_CRCX
 		|| mgcp_msg->verb == MGCP_VERB_MDCX)) {
-		if (add_sdp(msg, mgcp_msg, mgcp) < 0) {
-			LOGPMGW(mgcp, LOGL_ERROR, "Failed to add SDP, can not generate MGCP message\n");
-			goto exit_error;
-		}
+	        if (add_sdp(msg, mgcp_msg, mgcp) < 0)
+			return NULL;
+	}
+
+	if (rc != 0) {
+		LOGPMGW(mgcp, LOGL_ERROR, "Message buffer to small, can not generate MGCP message\n");
+		msgb_free(msg);
+		msg = NULL;
 	}
 
 	return msg;
-
-exit_error:
-	msgb_free(msg);
-	return NULL;
-#undef MSGB_PRINTF_OR_RET
 }
 
 /*! Retrieve the MGCP transaction ID from a msgb generated by mgcp_msg_gen()
@@ -1548,7 +1506,6 @@ const struct value_string mgcp_client_connection_mode_strs[] = {
 	{ MGCP_CONN_RECV_SEND, "sendrecv" },
 	{ MGCP_CONN_SEND_ONLY, "sendonly" },
 	{ MGCP_CONN_RECV_ONLY, "recvonly" },
-	{ MGCP_CONN_CONFECHO, "confecho" },
 	{ MGCP_CONN_LOOPBACK, "loopback" },
 	{ 0, NULL }
 };

src/libosmo-mgcp-client/mgcp_client_endpoint_fsm.c

@@ -173,30 +173,6 @@ const char *osmo_mgcpc_ep_name(const struct osmo_mgcpc_ep *ep)
 	return osmo_fsm_inst_name(ep->fi);
 }
 
-/*! Get "local endpoint name" part of the endpoint name: (local-endpoint-name@domain-name)
- *
- * \param ep  The MGCP Endpoint
- * \returns the local endpoint name if found, NULL on error.
- */
-const char *osmo_mgcpc_ep_local_name(const struct osmo_mgcpc_ep *ep)
-{
-	static char buf[1024];
-	const char *sep;
-
-	OSMO_ASSERT(ep);
-	sep = strchr(ep->endpoint, '@');
-	if (!sep) {
-		OSMO_STRLCPY_ARRAY(buf, ep->endpoint);
-		return buf;
-	}
-	if (sep - ep->endpoint >= sizeof(buf))
-		return NULL;
-
-	memcpy(buf, ep->endpoint, sep - ep->endpoint);
-	buf[sep - ep->endpoint] = '\0';
-	return buf;
-}
-
 const char *mgcp_conn_peer_name(const struct mgcp_conn_peer *info)
 {
 	/* I'd be fine with a smaller buffer and accept truncation, but gcc possibly refuses to build if
@@ -251,7 +227,7 @@ static struct value_string osmo_mgcpc_ep_fsm_event_names[33] = {};
 
 static char osmo_mgcpc_ep_fsm_event_name_bufs[32][32] = {};
 
-static void fill_event_names(void)
+static void fill_event_names()
 {
 	int i;
 	for (i = 0; i < (ARRAY_SIZE(osmo_mgcpc_ep_fsm_event_names) - 1); i++) {
@@ -267,7 +243,7 @@ static void fill_event_names(void)
 	}
 }
 
-static __attribute__((constructor)) void osmo_mgcpc_ep_fsm_init(void)
+static __attribute__((constructor)) void osmo_mgcpc_ep_fsm_init()
 {
 	OSMO_ASSERT(osmo_fsm_register(&osmo_mgcpc_ep_fsm) == 0);
 	fill_event_names();
@@ -1021,7 +997,7 @@ static int osmo_mgcpc_ep_fsm_timer_cb(struct osmo_fsm_inst *fi)
 	return 0;
 }
 
-static void osmo_mgcpc_ep_fsm_pre_term(struct osmo_fsm_inst *fi, enum osmo_fsm_term_cause cause)
+void osmo_mgcpc_ep_fsm_pre_term(struct osmo_fsm_inst *fi, enum osmo_fsm_term_cause cause)
 {
 	int i;
 	struct osmo_mgcpc_ep *ep = osmo_mgcpc_ep_fi_mgwep(fi);

src/libosmo-mgcp-client/mgcp_client_fsm.c

@@ -760,7 +760,7 @@ const char *osmo_mgcpc_conn_peer_name(const struct mgcp_conn_peer *info)
 	return buf;
 }
 
-static __attribute__((constructor)) void osmo_mgcp_client_fsm_init(void)
+static __attribute__((constructor)) void osmo_mgcp_client_fsm_init()
 {
 	OSMO_ASSERT(osmo_fsm_register(&fsm_mgcp_client) == 0);
 }

src/libosmo-mgcp-client/mgcp_client_pool.c

@@ -18,7 +18,6 @@
  *
  */
 
-#include <asm-generic/errno.h>
 #include <osmocom/mgcp_client/mgcp_client.h>
 #include <osmocom/mgcp_client/mgcp_client_internal.h>
 #include <osmocom/mgcp_client/mgcp_client_pool_internal.h>
@@ -28,6 +27,32 @@
 #define LOGPPMGW(pool_member, level, fmt, args...) \
 LOGP(DLMGCP, level, "MGW-pool(%s) " fmt, mgcp_client_pool_member_name(pool_member), ## args)
 
+/* Get a human readable name for a given pool member. */
+const char *mgcp_client_pool_member_name(const struct mgcp_client_pool_member *pool_member)
+{
+	const struct mgcp_client *mpcp_client;
+	struct mgcp_client mpcp_client_dummy;
+	static char name[512];
+	const char *description;
+
+	if (!pool_member)
+		return "(null)";
+
+	/* It is not guranteed that a pool_member has an MGCP client. The client may not yet be initialized or the
+	 * initalization may have been failed. In this case we will generate a dummy MGCP client to work with. */
+	if (!pool_member->client) {
+		memcpy(&mpcp_client_dummy.actual, &pool_member->conf, sizeof(mpcp_client_dummy.actual));
+		mpcp_client = &mpcp_client_dummy;
+	} else {
+		mpcp_client = pool_member->client;
+	}
+
+	description = mgcp_client_name(mpcp_client);
+	snprintf(name, sizeof(name), "%d:%s", pool_member->nr, description);
+
+	return name;
+}
+
 /*! Allocate MGCP client pool. This is called once on startup and before the pool is used with
  *  mgcp_client_pool_vty_init(). Since the pool is linked with the VTY it must exist througout the entire runtime.
  *  \param[in] talloc_ctx talloc context. */
@@ -39,7 +64,7 @@ struct mgcp_client_pool *mgcp_client_pool_alloc(void *talloc_ctx)
 	if (!pool)
 		return NULL;
 
-	INIT_LLIST_HEAD(&pool->member_list);
+	INIT_LLIST_HEAD(&pool->pool);
 
 	return pool;
 }
@@ -52,11 +77,29 @@ unsigned int mgcp_client_pool_connect(struct mgcp_client_pool *pool)
 	struct mgcp_client_pool_member *pool_member;
 	unsigned int pool_members_initialized = 0;
 
-	llist_for_each_entry(pool_member, &pool->member_list, list) {
+	llist_for_each_entry(pool_member, &pool->pool, list) {
 
 		/* Initialize client */
-		if (mgcp_client_pool_member_reinit_client(pool_member) == 0)
-			pool_members_initialized++;
+		pool_member->client = mgcp_client_init(pool_member, &pool_member->conf);
+		if (!pool_member->client) {
+			LOGPPMGW(pool_member, LOGL_ERROR, "MGCP client initialization failed\n");
+			continue;
+		}
+
+		/* Set backpointer so that we can detect later that this MGCP client is managed
+		 * by this pool. */
+		pool_member->client->pool = pool;
+
+		/* Connect client */
+		if (mgcp_client_connect2(pool_member->client, 0)) {
+			LOGPPMGW(pool_member, LOGL_ERROR, "MGCP client connect failed at (%s:%u)\n",
+				 pool_member->conf.remote_addr, pool_member->conf.remote_port);
+			talloc_free(pool_member->client);
+			pool_member->client = NULL;
+			continue;
+		}
+
+		pool_members_initialized++;
 	}
 
 	return pool_members_initialized;
@@ -75,43 +118,23 @@ void mgcp_client_pool_register_single(struct mgcp_client_pool *pool, struct mgcp
 	pool->mgcp_client_single = mgcp_client;
 }
 
-bool mgcp_client_pool_empty(const struct mgcp_client_pool *pool)
-{
-	return llist_empty(&pool->member_list);
-}
-
-/*! Lookup the selected MGCP client config by its reference number */
-struct mgcp_client_pool_member *mgcp_client_pool_find_member_by_nr(struct mgcp_client_pool *pool, unsigned int nr)
-{
-	struct mgcp_client_pool_member *pool_member;
-
-	llist_for_each_entry(pool_member, &pool->member_list, list) {
-		if (pool_member->nr == nr)
-			return pool_member;
-	}
-
-	return NULL;
-}
-
 /* Not every pool member may have a functional MGCP client, we will run through the pool once until we meet a
- * pool member that is suitable (is not blocked, has a client with a working link, has a low load). */
+ * pool member that is suitable (has a client, is not blocked, has a low load). */
 static struct mgcp_client_pool_member *mgcp_client_pool_pick(struct mgcp_client_pool *pool)
 {
 	struct mgcp_client_pool_member *pool_member;
 	struct mgcp_client_pool_member *pool_member_picked = NULL;
-	unsigned int n_pool_members = 0;
+	unsigned int n_pool_members = llist_count(&pool->pool);
 
-	llist_for_each_entry(pool_member, &pool->member_list, list) {
-		n_pool_members++;
-		bool conn_up = pool_member->client && pool_member->client->conn_up;
-		if (pool_member->blocked == false && conn_up) {
+	llist_for_each_entry(pool_member, &pool->pool, list) {
+		if (pool_member->blocked == false && pool_member->client) {
 			if (!pool_member_picked)
 				pool_member_picked = pool_member;
 			else if (pool_member_picked->refcount > pool_member->refcount)
 				pool_member_picked = pool_member;
 		} else {
-			LOGPPMGW(pool_member, LOGL_DEBUG, "%s -- MGW %u is unusable (blocked=%u, cli=%u, link=%u)\n",
-				 __func__, pool_member->nr, pool_member->blocked, !!pool_member->client, conn_up);
+			LOGPPMGW(pool_member, LOGL_DEBUG, "MGW pool has %u members -- MGW %u is unusable\n", n_pool_members,
+				 pool_member->nr);
 		}
 	}
 
@@ -140,24 +163,26 @@ struct mgcp_client *mgcp_client_pool_get(struct mgcp_client_pool *pool)
 	 *  by the application code. */
 
 	/* When the pool is empty, return a single MGCP client if it is registered. */
-	if (llist_empty(&pool->member_list) && pool->mgcp_client_single) {
+	if (llist_empty(&pool->pool) && pool->mgcp_client_single) {
 		LOGP(DLMGCP, LOGL_DEBUG, "MGW pool is empty -- using (single) MGW %s\n",
 		     mgcp_client_name(pool->mgcp_client_single));
 		return pool->mgcp_client_single;
 	}
 
 	/* Abort when the pool is empty */
-	if (llist_empty(&pool->member_list)) {
+	if (llist_empty(&pool->pool)) {
 		LOGP(DLMGCP, LOGL_ERROR, "MGW pool is empty -- no MGW available!\n");
 		return NULL;
 	}
 
 	/* Pick a suitable pool member */
 	pool_member = mgcp_client_pool_pick(pool);
-	if (!pool_member)
-		return NULL;
+	if (pool_member) {
+		pool_member->refcount++;
+		return pool_member->client;
+	}
 
-	return mgcp_client_pool_member_get(pool_member);
+	return NULL;
 }
 
 /*! put an MGCP client back into the pool (decrement reference counter).
@@ -169,130 +194,23 @@ struct mgcp_client *mgcp_client_pool_get(struct mgcp_client_pool *pool)
 void mgcp_client_pool_put(struct mgcp_client *mgcp_client)
 {
 	struct mgcp_client_pool_member *pool_member;
+	struct mgcp_client_pool *pool;
 
 	if (!mgcp_client)
 		return;
 
-	if (!mgcp_client->pool_member)
+	if (mgcp_client->pool)
+		pool = mgcp_client->pool;
+	else
 		return;
-	pool_member = mgcp_client->pool_member;
 
-	if (pool_member->refcount == 0) {
-		LOGPPMGW(pool_member, LOGL_ERROR, "MGW pool member has invalid refcount\n");
-		return;
+	llist_for_each_entry(pool_member, &pool->pool, list) {
+		if (pool_member->client == mgcp_client) {
+			if (pool_member->refcount == 0) {
+				LOGPPMGW(pool_member, LOGL_ERROR, "MGW pool member has invalid refcount\n");
+				return;
+			}
+			pool_member->refcount--;
+		}
 	}
-	pool_member->refcount--;
-}
-
-/***************************
- * mgcp_client_pool_member:
- ***************************/
-
-/*! Allocate an mgcp_client_pool_member.
- *  \param[in] pool MGCP client pool descriptor.
- *  \param[in] nr Reference number of the pool member.
- */
-struct mgcp_client_pool_member *mgcp_client_pool_member_alloc(struct mgcp_client_pool *pool, unsigned int nr)
-{
-	struct mgcp_client_pool_member *pool_member;
-
-	pool_member = talloc_zero(pool, struct mgcp_client_pool_member);
-	OSMO_ASSERT(pool_member);
-	mgcp_client_conf_init(&pool_member->conf);
-	pool_member->pool = pool;
-	pool_member->nr = nr;
-	llist_add_tail(&pool_member->list, &pool->member_list);
-	return pool_member;
-}
-
-/*! Free an mgcp_client_pool_member allocated through mgcp_client_pool_member_alloc().
- *  \param[in] pool_member MGCP client pool descriptor.
- *
- * It also frees the associated MGCP client if present.
- */
-void mgcp_client_pool_member_free(struct mgcp_client_pool_member *pool_member)
-{
-	llist_del(&pool_member->list);
-	if (pool_member->client) {
-		mgcp_client_disconnect(pool_member->client);
-		talloc_free(pool_member->client);
-	}
-	talloc_free(pool_member);
-}
-
-/*! Recreate and reconnect the MGCP client associated to the pool descriptor.
- *  \param[in] pool_member MGCP client pool descriptor.
- */
-int mgcp_client_pool_member_reinit_client(struct mgcp_client_pool_member *pool_member)
-{
-	/* Get rid of a possibly existing old MGCP client instance first */
-	if (pool_member->client) {
-		mgcp_client_disconnect(pool_member->client);
-		talloc_free(pool_member->client);
-	}
-
-	/* Initialize client */
-	pool_member->client = mgcp_client_init(pool_member, &pool_member->conf);
-	if (!pool_member->client) {
-		LOGPPMGW(pool_member, LOGL_ERROR, "MGCP client initialization failed\n");
-		return -EINVAL;
-	}
-
-	/* Set backpointer so that we can detect later that this MGCP client is managed by this pool. */
-	pool_member->client->pool_member = pool_member;
-
-	/* Connect client */
-	if (mgcp_client_connect(pool_member->client)) {
-		LOGPPMGW(pool_member, LOGL_ERROR, "MGCP client connect failed at (%s:%u)\n",
-				pool_member->conf.remote_addr, pool_member->conf.remote_port);
-		talloc_free(pool_member->client);
-		pool_member->client = NULL;
-		return -ECONNABORTED;
-	}
-	return 0;
-}
-
-/* Get a human readable name for a given pool member. */
-const char *mgcp_client_pool_member_name(const struct mgcp_client_pool_member *pool_member)
-{
-	const struct mgcp_client *mpcp_client;
-	struct mgcp_client mpcp_client_dummy;
-	static char name[512];
-	const char *description;
-
-	if (!pool_member)
-		return "(null)";
-
-	/* It is not guranteed that a pool_member has an MGCP client. The client may not yet be initialized or the
-	 * initalization may have been failed. In this case we will generate a dummy MGCP client to work with. */
-	if (!pool_member->client) {
-		memcpy(&mpcp_client_dummy.actual, &pool_member->conf, sizeof(mpcp_client_dummy.actual));
-		mpcp_client = &mpcp_client_dummy;
-	} else {
-		mpcp_client = pool_member->client;
-	}
-
-	description = mgcp_client_name(mpcp_client);
-	snprintf(name, sizeof(name), "%d:%s", pool_member->nr, description);
-
-	return name;
-}
-
-/*! Get the MGCP client associated with the pool reference from the pool (increment reference counter).
- *  \param[in] pool_member MGCP client pool descriptor.
- *  \returns MGCP client descriptor, NULL if no member was not ready.
- */
-struct mgcp_client *mgcp_client_pool_member_get(struct mgcp_client_pool_member *pool_member)
-{
-	pool_member->refcount++;
-	return pool_member->client;
-}
-
-/*! Get whether the MGCP client associated with the pool reference is blocked by policy.
- *  \param[in] pool_member MGCP client pool descriptor.
- *  \returns true if blocked, false otherwise
- */
-bool mgcp_client_pool_member_is_blocked(const struct mgcp_client_pool_member *pool_member)
-{
-	return pool_member->blocked;
 }

src/libosmo-mgcp-client/mgcp_client_vty.c

@@ -1,5 +1,5 @@
 /* MGCP client interface to quagga VTY */
-/* (C) 2016 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
+/* (C) 2016 by sysmocom s.m.f.c. GmbH <info@sysmocom.de>
  * Based on OpenBSC interface to quagga VTY (libmsc/vty_interface_layer3.c)
  * (C) 2009 by Harald Welte <laforge@gnumonks.org>
  * (C) 2009-2011 by Holger Hans Peter Freyther
@@ -28,16 +28,14 @@
 #include <osmocom/vty/command.h>
 #include <osmocom/vty/misc.h>
 #include <osmocom/core/utils.h>
-#include <osmocom/core/timer.h>
 
 #include <osmocom/mgcp_client/mgcp_client.h>
 #include <osmocom/mgcp_client/mgcp_client_internal.h>
 #include <osmocom/mgcp_client/mgcp_client_pool_internal.h>
-#include <osmocom/mgcp_client/mgcp_client_pool.h>
 
 #define MGW_STR MGCP_CLIENT_MGW_STR
 
-/* Only common (non-pooled) VTY commands will use this talloc context. All
+/* Only common (non-pooled) VTY connands will use this talloc context. All
  * pooled VTY commands will use the pool (global_mgcp_client_pool) as
  * talloc context. */
 static void *global_mgcp_client_ctx = NULL;
@@ -49,46 +47,17 @@ static struct mgcp_client_conf *global_mgcp_client_conf = NULL;
 /* Pointer to the MGCP pool that is managed by mgcp_client_pool_vty_init() */
 static struct mgcp_client_pool *global_mgcp_client_pool = NULL;
 
-static struct mgcp_client_conf *get_mgcp_client_config(struct vty *vty)
+struct mgcp_client_conf *get_mgcp_client_config(struct vty *vty)
 {
 	if (global_mgcp_client_pool && vty->node == global_mgcp_client_pool->vty_node->node)
 		return vty->index;
-
-	/* Global single MGCP config, deprecated: */
-	vty_out(vty, "%% MGCP commands outside of 'mgw' nodes are deprecated. "
-		"You should consider reading the User Manual and migrating to 'mgw' node.%s",
-		VTY_NEWLINE);
-
-	return global_mgcp_client_conf;
+	else
+		return global_mgcp_client_conf;
 }
 
-static struct mgcp_client *get_mgcp_client(struct vty *vty)
-{
-	struct mgcp_client_conf *conf = get_mgcp_client_config(vty);
-	struct mgcp_client_pool_member *pool_member;
-
-	if (global_mgcp_client_pool && vty->node == global_mgcp_client_pool->vty_node->node) {
-		llist_for_each_entry(pool_member, &global_mgcp_client_pool->member_list, list) {
-			/* Find matching the conf pointer: */
-			if (&pool_member->conf != conf)
-				continue;
-			return pool_member->client;
-		}
-	}
-
-	/* Global single MGCP config, deprecated: */
-	vty_out(vty, "%% MGCP commands outside of 'mgw' nodes are deprecated. "
-		"You should consider reading the User Manual and migrating to 'mgw' node.%s",
-		VTY_NEWLINE);
-
-	/* There's no way to obtain the struct mgcp_client in old interface, but anyway it's deprecated. */
-	return NULL;
-}
-
-
 DEFUN(cfg_mgw_local_ip, cfg_mgw_local_ip_cmd,
-      "local-ip " VTY_IPV46_CMD,
-      "local bind to connect to MGW from\n"
+      "mgw local-ip " VTY_IPV46_CMD,
+      MGW_STR "local bind to connect to MGW from\n"
       "local bind IPv4 address\n"
       "local bind IPv6 address\n")
 {
@@ -103,16 +72,10 @@ ALIAS_DEPRECATED(cfg_mgw_local_ip, cfg_mgcpgw_local_ip_cmd,
 		 "mgcpgw local-ip A.B.C.D",
 		 MGW_STR "local bind to connect to MGCP gateway with\n"
 		 "local bind IP address\n")
-ALIAS_DEPRECATED(cfg_mgw_local_ip,
-		 cfg_mgw_mgw_local_ip_cmd,
-		 "mgw local-ip " VTY_IPV46_CMD,
-		 MGW_STR "local bind to connect to MGW from\n"
-		 "local bind IPv4 address\n"
-		 "local bind IPv6 address\n")
 
 DEFUN(cfg_mgw_local_port, cfg_mgw_local_port_cmd,
-      "local-port <0-65535>",
-      "local port to connect to MGW from\n"
+      "mgw local-port <0-65535>",
+      MGW_STR "local port to connect to MGW from\n"
       "local bind port\n")
 {
 	struct mgcp_client_conf *conf = get_mgcp_client_config(vty);
@@ -124,15 +87,10 @@ ALIAS_DEPRECATED(cfg_mgw_local_port, cfg_mgcpgw_local_port_cmd,
 		 "mgcpgw local-port <0-65535>",
 		 MGW_STR "local bind to connect to MGCP gateway with\n"
 		 "local bind port\n")
-ALIAS_DEPRECATED(cfg_mgw_local_port,
-		 cfg_mgw_mgw_local_port_cmd,
-		 "mgw local-port <0-65535>",
-		 MGW_STR "local port to connect to MGW from\n"
-		 "local bind port\n")
 
 DEFUN(cfg_mgw_remote_ip, cfg_mgw_remote_ip_cmd,
-      "remote-ip " VTY_IPV46_CMD,
-      "remote IP address to reach the MGW at\n"
+      "mgw remote-ip " VTY_IPV46_CMD,
+      MGW_STR "remote IP address to reach the MGW at\n"
       "remote IPv4 address\n"
       "remote IPv6 address\n")
 {
@@ -146,16 +104,10 @@ ALIAS_DEPRECATED(cfg_mgw_remote_ip, cfg_mgcpgw_remote_ip_cmd,
 		 "mgcpgw remote-ip A.B.C.D",
 		 MGW_STR "remote bind to connect to MGCP gateway with\n"
 		 "remote bind IP address\n")
-ALIAS_DEPRECATED(cfg_mgw_remote_ip,
-		 cfg_mgw_mgw_remote_ip_cmd,
-		 "mgw remote-ip " VTY_IPV46_CMD,
-		 MGW_STR "remote IP address to reach the MGW at\n"
-		 "remote IPv4 address\n"
-		 "remote IPv6 address\n")
 
 DEFUN(cfg_mgw_remote_port, cfg_mgw_remote_port_cmd,
-      "remote-port <0-65535>",
-      "remote port to reach the MGW at\n"
+      "mgw remote-port <0-65535>",
+      MGW_STR "remote port to reach the MGW at\n"
       "remote port\n")
 {
 	struct mgcp_client_conf *conf = get_mgcp_client_config(vty);
@@ -167,13 +119,8 @@ ALIAS_DEPRECATED(cfg_mgw_remote_port, cfg_mgcpgw_remote_port_cmd,
 		 "mgcpgw remote-port <0-65535>",
 		 MGW_STR "remote bind to connect to MGCP gateway with\n"
 		 "remote bind port\n")
-ALIAS_DEPRECATED(cfg_mgw_remote_port,
-		 cfg_mgw_mgw_remote_port_cmd,
-		 "mgw remote-port <0-65535>",
-		 MGW_STR "remote port to reach the MGW at\n"
-		 "remote port\n")
 
-DEFUN_DEPRECATED(cfg_mgw_mgw_endpoint_range, cfg_mgw_mgw_endpoint_range_cmd,
+DEFUN_DEPRECATED(cfg_mgw_endpoint_range, cfg_mgw_endpoint_range_cmd,
       "mgw endpoint-range <1-65534> <1-65534>",
       MGW_STR "DEPRECATED: the endpoint range cannot be defined by the client\n"
       "-\n" "-\n")
@@ -183,7 +130,7 @@ DEFUN_DEPRECATED(cfg_mgw_mgw_endpoint_range, cfg_mgw_mgw_endpoint_range_cmd,
 		VTY_NEWLINE);
 	return CMD_SUCCESS;
 }
-ALIAS_DEPRECATED(cfg_mgw_mgw_endpoint_range, cfg_mgcpgw_endpoint_range_cmd,
+ALIAS_DEPRECATED(cfg_mgw_endpoint_range, cfg_mgcpgw_endpoint_range_cmd,
       "mgcpgw endpoint-range <1-65534> <1-65534>",
       MGW_STR "usable range of endpoint identifiers\n"
       "set first useable endpoint identifier\n"
@@ -211,8 +158,8 @@ ALIAS_DEPRECATED(cfg_mgw_rtp_bts_base_port,
 
 DEFUN(cfg_mgw_endpoint_domain_name,
       cfg_mgw_endpoint_domain_name_cmd,
-      "endpoint-domain NAME",
-      "Set the domain name to send in MGCP messages, e.g. the part 'foo' in 'rtpbridge/*@foo'.\n"
+      "mgw endpoint-domain NAME",
+      MGW_STR "Set the domain name to send in MGCP messages, e.g. the part 'foo' in 'rtpbridge/*@foo'.\n"
       "Domain name, should be alphanumeric.\n")
 {
 	struct mgcp_client_conf *conf = get_mgcp_client_config(vty);
@@ -225,16 +172,11 @@ DEFUN(cfg_mgw_endpoint_domain_name,
 	}
 	return CMD_SUCCESS;
 }
-ALIAS_DEPRECATED(cfg_mgw_endpoint_domain_name,
-      cfg_mgw_mgw_endpoint_domain_name_cmd,
-      "mgw endpoint-domain NAME",
-      MGW_STR "Set the domain name to send in MGCP messages, e.g. the part 'foo' in 'rtpbridge/*@foo'.\n"
-      "Domain name, should be alphanumeric.\n")
 
 DEFUN(cfg_mgw_reset_ep_name,
       cfg_mgw_reset_ep_name_cmd,
-      "reset-endpoint NAME",
-      "Add an endpoint name that should be reset (DLCX) on connect to the reset-endpoint list,"
+      "mgw reset-endpoint NAME",
+      MGW_STR "Add an endpoint name that should be reset (DLCX) on connect to the reset-endpoint list,"
       "e.g. 'rtpbridge/*'\n"
       "Endpoint name, e.g. 'rtpbridge/*' or 'ds/e1-0/s-3/su16-4'.\n")
 {
@@ -272,17 +214,11 @@ DEFUN(cfg_mgw_reset_ep_name,
 
 	return CMD_SUCCESS;
 }
-ALIAS_DEPRECATED(cfg_mgw_reset_ep_name,
-      cfg_mgw_mgw_reset_ep_name_cmd,
-      "mgw reset-endpoint NAME",
-      MGW_STR "Add an endpoint name that should be reset (DLCX) on connect to the reset-endpoint list,"
-      "e.g. 'rtpbridge/*'\n"
-      "Endpoint name, e.g. 'rtpbridge/*' or 'ds/e1-0/s-3/su16-4'.\n")
 
 DEFUN(cfg_mgw_no_reset_ep_name,
       cfg_mgw_no_reset_ep_name_cmd,
-      "no reset-endpoint NAME",
-      NO_STR "remove an endpoint name from the reset-endpoint list, e.g. 'rtpbridge/*'\n"
+      "no mgw reset-endpoint NAME",
+      NO_STR MGW_STR "remove an endpoint name from the reset-endpoint list, e.g. 'rtpbridge/*'\n"
       "Endpoint name, e.g. 'rtpbridge/*' or 'ds/e1-0/s-3/su16-4'.\n")
 {
 	struct reset_ep *reset_ep;
@@ -299,96 +235,6 @@ DEFUN(cfg_mgw_no_reset_ep_name,
 	vty_out(vty, "%% no such endpoint name configured ('%s')%s", argv[0], VTY_NEWLINE);
 	return CMD_WARNING;
 }
-ALIAS_DEPRECATED(cfg_mgw_no_reset_ep_name,
-      cfg_mgw_mgw_no_reset_ep_name_cmd,
-      "no mgw reset-endpoint NAME",
-      NO_STR MGW_STR "remove an endpoint name from the reset-endpoint list, e.g. 'rtpbridge/*'\n"
-      "Endpoint name, e.g. 'rtpbridge/*' or 'ds/e1-0/s-3/su16-4'.\n")
-
-DEFUN(cfg_mgw_mgw_keepalive_req_interval,
-      cfg_mgw_mgw_keepalive_req_interval_cmd,
-      "keepalive request-interval <0-4294967295>",
-      "Monitor if the MGCP link against MGW is still usable\n"
-      "Send an MGCP command to the MGW at given interval if no other commands are sent\n"
-      "The interval at which send MGCP commands (s), 0 to disable\n")
-{
-	struct mgcp_client_conf *conf = get_mgcp_client_config(vty);
-	struct mgcp_client *mgcp = get_mgcp_client(vty);
-
-	conf->keepalive.req_interval_sec = atoi(argv[0]);
-
-	if (!mgcp)
-		return CMD_SUCCESS;
-
-	/* If client already exists, apply the change immediately if possible: */
-	mgcp->actual.keepalive.req_interval_sec = atoi(argv[0]);
-	if (mgcp->wq.bfd.fd != -1) { /* UDP MGCP socket connected */
-		if (mgcp->actual.keepalive.req_interval_sec > 0) {
-			/* Re-schedule: */
-			osmo_timer_schedule(&mgcp->keepalive_tx_timer, mgcp->actual.keepalive.req_interval_sec, 0);
-		} else {
-			if (osmo_timer_pending(&mgcp->keepalive_tx_timer))
-				osmo_timer_del(&mgcp->keepalive_tx_timer);
-			/* Assume link is UP by default, so that this MGW can be selected: */
-			mgcp->conn_up = true;
-		}
-	} /* else: wait until connect() to do first scheduling */
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_mgw_mgw_keepalive_req_endpoint,
-      cfg_mgw_mgw_keepalive_req_endpoint_cmd,
-      "keepalive request-endpoint NAME",
-      "Monitor if the MGCP link against MGW is still usable\n"
-      "Use a given endpoint name when sending an MGCP command to the MGW for keepalive purposes\n"
-      "The name of the endpoint to use\n")
-{
-	struct mgcp_client_conf *conf = get_mgcp_client_config(vty);
-	struct mgcp_client *mgcp = get_mgcp_client(vty);
-
-	OSMO_STRLCPY_ARRAY(conf->keepalive.req_endpoint_name, argv[0]);
-
-	if (!mgcp)
-		return CMD_SUCCESS;
-
-	/* If client already exists, apply the change immediately if possible: */
-	OSMO_STRLCPY_ARRAY(mgcp->actual.keepalive.req_endpoint_name, argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_mgw_mgw_keepalive_timeout,
-      cfg_mgw_mgw_keepalive_timeout_cmd,
-      "keepalive timeout <0-4294967295>",
-      "Monitor if the MGCP link against MGW is still usable\n"
-      "Consider the link to the MGW to be down after time without receiving any message from it\n"
-      "The timeout (s), 0 to disable\n")
-{
-	struct mgcp_client_conf *conf = get_mgcp_client_config(vty);
-	struct mgcp_client *mgcp = get_mgcp_client(vty);
-
-	conf->keepalive.timeout_sec = atoi(argv[0]);
-
-	if (!mgcp)
-		return CMD_SUCCESS;
-
-	/* If client already exists, apply the change immediately if possible: */
-	mgcp->actual.keepalive.timeout_sec = atoi(argv[0]);
-	if (mgcp->wq.bfd.fd != -1) { /* UDP MGCP socket connected */
-		if (mgcp->actual.keepalive.timeout_sec > 0) {
-			/* Re-schedule: */
-			osmo_timer_schedule(&mgcp->keepalive_rx_timer, mgcp->actual.keepalive.timeout_sec, 0);
-		} else {
-			if (osmo_timer_pending(&mgcp->keepalive_rx_timer))
-				osmo_timer_del(&mgcp->keepalive_rx_timer);
-			/* Assume link is UP by default, so that this MGW can be selected: */
-			mgcp->conn_up = true;
-		}
-	} /* else: wait until connect() to do first scheduling */
-
-	return CMD_SUCCESS;
-}
 
 static int config_write(struct vty *vty, const char *indent, struct mgcp_client_conf *conf)
 {
@@ -396,47 +242,33 @@ static int config_write(struct vty *vty, const char *indent, struct mgcp_client_
 	int port;
 	struct reset_ep *reset_ep;
 
-	/* If caller doesn't the MGW pool API (mgcp_client_pool_vty_init was never called),
-	 * then the "mgw" cmd prefix must be added since the old node always contained it.
-	 */
-	const char *mgw_prefix = global_mgcp_client_pool ? "" : "mgw ";
-
-	if (conf->description) /* description never had "mgw" prefix even on old node: */
+	if (conf->description)
 		vty_out(vty, "%sdescription %s%s", indent, conf->description, VTY_NEWLINE);
 
 	addr = conf->local_addr;
 	if (addr)
-		vty_out(vty, "%s%slocal-ip %s%s", indent, mgw_prefix, addr, VTY_NEWLINE);
+		vty_out(vty, "%smgw local-ip %s%s", indent, addr,
+			VTY_NEWLINE);
 	port = conf->local_port;
 	if (port >= 0)
-		vty_out(vty, "%s%slocal-port %u%s", indent, mgw_prefix,
+		vty_out(vty, "%smgw local-port %u%s", indent,
 			(uint16_t)port, VTY_NEWLINE);
 
 	addr = conf->remote_addr;
 	if (addr)
-		vty_out(vty, "%s%sremote-ip %s%s", indent, mgw_prefix, addr, VTY_NEWLINE);
+		vty_out(vty, "%smgw remote-ip %s%s", indent, addr,
+			VTY_NEWLINE);
 	port = conf->remote_port;
 	if (port >= 0)
-		vty_out(vty, "%s%sremote-port %u%s", indent, mgw_prefix,
+		vty_out(vty, "%smgw remote-port %u%s", indent,
 			(uint16_t)port, VTY_NEWLINE);
 
 	if (conf->endpoint_domain_name[0])
-		vty_out(vty, "%s%sendpoint-domain %s%s", indent, mgw_prefix,
+		vty_out(vty, "%smgw endpoint-domain %s%s", indent,
 			conf->endpoint_domain_name, VTY_NEWLINE);
 
 	llist_for_each_entry(reset_ep, &conf->reset_epnames, list)
-		vty_out(vty, "%s%sreset-endpoint %s%s", indent, mgw_prefix, reset_ep->name, VTY_NEWLINE);
-
-	if (conf->keepalive.req_interval_sec != 0)
-		vty_out(vty, "%s%skeepalive request-interval %u%s", indent, mgw_prefix,
-			conf->keepalive.req_interval_sec, VTY_NEWLINE);
-	if (strncmp(conf->keepalive.req_endpoint_name, MGCP_CLIENT_KEEPALIVE_DEFAULT_ENDP,
-		    sizeof(conf->keepalive.req_endpoint_name)) != 0)
-		vty_out(vty, "%s%skeepalive request-endpoint %s%s", indent,  mgw_prefix,
-			conf->keepalive.req_endpoint_name, VTY_NEWLINE);
-	if (conf->keepalive.timeout_sec != 0)
-		vty_out(vty, "%s%skeepalive timeout %u%s", indent,  mgw_prefix,
-			conf->keepalive.timeout_sec, VTY_NEWLINE);
+		vty_out(vty, "%smgw reset-endpoint %s%s", indent, reset_ep->name, VTY_NEWLINE);
 
 	return CMD_SUCCESS;
 }
@@ -447,11 +279,6 @@ static int config_write(struct vty *vty, const char *indent, struct mgcp_client_
  *  \returns CMD_SUCCESS on success, CMD_WARNING on error */
 int mgcp_client_config_write(struct vty *vty, const char *indent)
 {
-	/* If caller supports MGW pool API (mgcp_client_pool_vty_init was
-	 * called), then skip printing any config in this node and print it when
-	 * the whole 'mgw' node is printed. */
-	if (global_mgcp_client_pool)
-		return CMD_SUCCESS;
 	return config_write(vty, indent, global_mgcp_client_conf);
 }
 
@@ -459,18 +286,15 @@ static void vty_init_common(void *talloc_ctx, int node)
 {
 	global_mgcp_client_ctx = talloc_ctx;
 
-	/* deprecated 'mgw' commands ('mgw' prepended as first arg) */
-	install_lib_element(node, &cfg_mgw_mgw_local_ip_cmd);
-	install_lib_element(node, &cfg_mgw_mgw_local_port_cmd);
-	install_lib_element(node, &cfg_mgw_mgw_remote_ip_cmd);
-	install_lib_element(node, &cfg_mgw_mgw_remote_port_cmd);
-	install_lib_element(node, &cfg_mgw_mgw_endpoint_range_cmd);
-	install_lib_element(node, &cfg_mgw_mgw_endpoint_domain_name_cmd);
-	install_lib_element(node, &cfg_mgw_mgw_reset_ep_name_cmd);
-	install_lib_element(node, &cfg_mgw_mgw_no_reset_ep_name_cmd);
-	install_lib_element(node, &cfg_mgw_mgw_keepalive_req_interval_cmd);
-	install_lib_element(node, &cfg_mgw_mgw_keepalive_req_endpoint_cmd);
-	install_lib_element(node, &cfg_mgw_mgw_keepalive_timeout_cmd);
+	install_lib_element(node, &cfg_mgw_local_ip_cmd);
+	install_lib_element(node, &cfg_mgw_local_port_cmd);
+	install_lib_element(node, &cfg_mgw_remote_ip_cmd);
+	install_lib_element(node, &cfg_mgw_remote_port_cmd);
+	install_lib_element(node, &cfg_mgw_endpoint_range_cmd);
+	install_lib_element(node, &cfg_mgw_rtp_bts_base_port_cmd);
+	install_lib_element(node, &cfg_mgw_endpoint_domain_name_cmd);
+	install_lib_element(node, &cfg_mgw_reset_ep_name_cmd);
+	install_lib_element(node, &cfg_mgw_no_reset_ep_name_cmd);
 
 	osmo_fsm_vty_add_cmds();
 }
@@ -495,62 +319,38 @@ void mgcp_client_vty_init(void *talloc_ctx, int node, struct mgcp_client_conf *c
 	vty_init_common(talloc_ctx, node);
 }
 
-/* Mark whether user called mgcp_client_pool_config_write() and hence support new API */
-static bool mgcp_client_pool_config_write_called = false;
-
-static int _mgcp_client_pool_config_write(struct vty *vty, const char *indent)
+static int config_write_pool(struct vty *vty)
 {
 	struct mgcp_client_pool *pool = global_mgcp_client_pool;
 	struct mgcp_client_pool_member *pool_member;
-	unsigned int subindent_buf_len;
-	char *subindent;
+	unsigned int indent_buf_len = strlen(pool->vty_indent) + 1 + 1;
+	char *indent = talloc_zero_size(vty, indent_buf_len);
 
-	if (!indent)
-		indent = pool->vty_indent ? : "";
-	subindent_buf_len = strlen(indent) + 1 + 1;
-	subindent = talloc_zero_size(vty, subindent_buf_len);
+	snprintf(indent, indent_buf_len, "%s ", pool->vty_indent);
 
-	snprintf(subindent, subindent_buf_len, "%s ", indent);
-
-	llist_for_each_entry(pool_member, &pool->member_list, list) {
-		vty_out(vty, "%smgw %u%s", indent, pool_member->nr, VTY_NEWLINE);
-		config_write(vty, subindent, &pool_member->conf);
+	llist_for_each_entry(pool_member, &pool->pool, list) {
+		vty_out(vty, "%smgw %u%s", pool->vty_indent, pool_member->nr, VTY_NEWLINE);
+		config_write(vty, indent, &pool_member->conf);
 	}
 
-	/* MGW pool API is supported by user (global_mgcp_client_pool is set
-	 * because mgcp_client_pool_vty_init was called). If single MGW was
-	 * configured through old VTY and no mgw in the new MGW pool VTY is
-	 * replacing it, then output the single MGW converted to the new MGW
-	 * pool VTY. */
-	if (llist_empty(&pool->member_list) && pool->mgcp_client_single) {
-		vty_out(vty, "%smgw 0%s", indent, VTY_NEWLINE);
-		config_write(vty, subindent, global_mgcp_client_conf);
-	}
-
-	talloc_free(subindent);
+	talloc_free(indent);
 	return CMD_SUCCESS;
 }
 
-/* Deprecated, used for backward compatibility with older users which didn't call
- * mgcp_client_pool_config_write(): */
-static int config_write_pool(struct vty *vty)
+/* Lookup the selected MGCP client config by its reference number */
+static struct mgcp_client_pool_member *pool_member_by_nr(unsigned int nr)
 {
-	if (mgcp_client_pool_config_write_called)
-		return CMD_SUCCESS;
+	struct mgcp_client_pool_member *pool_member = NULL;
+	struct mgcp_client_pool_member *pool_member_tmp;
 
-	return _mgcp_client_pool_config_write(vty, NULL);
-}
+	llist_for_each_entry(pool_member_tmp, &global_mgcp_client_pool->pool, list) {
+		if (pool_member_tmp->nr == nr) {
+			pool_member = pool_member_tmp;
+			break;
+		}
+	}
 
-/*! Write out MGCP client config to VTY.
- *  \param[in] vty VTY to which we should print.
- *  \param[in] indent string used for indentation (e.g. " ").
-	       If NULL, indentation passed during mgcp_client_pool_vty_init() will be used.
- *  \returns CMD_SUCCESS on success, CMD_WARNING on error */
-int mgcp_client_pool_config_write(struct vty *vty, const char *indent)
-{
-	/* Tell internal node write function that the user supports calling proper API: */
-	mgcp_client_pool_config_write_called = true;
-	return _mgcp_client_pool_config_write(vty, indent);
+	return pool_member;
 }
 
 DEFUN_ATTR(cfg_mgw,
@@ -559,10 +359,13 @@ DEFUN_ATTR(cfg_mgw,
 	int nr = atoi(argv[0]);
 	struct mgcp_client_pool_member *pool_member;
 
-	pool_member = mgcp_client_pool_find_member_by_nr(global_mgcp_client_pool, nr);
+	pool_member = pool_member_by_nr(nr);
 	if (!pool_member) {
-		pool_member = mgcp_client_pool_member_alloc(global_mgcp_client_pool, nr);
+		pool_member = talloc_zero(global_mgcp_client_pool, struct mgcp_client_pool_member);
 		OSMO_ASSERT(pool_member);
+		mgcp_client_conf_init(&pool_member->conf);
+		pool_member->nr = nr;
+		llist_add_tail(&pool_member->list, &global_mgcp_client_pool->pool);
 	}
 
 	vty->index = &pool_member->conf;
@@ -579,7 +382,7 @@ DEFUN_ATTR(cfg_no_mgw,
 	int nr = atoi(argv[0]);
 	struct mgcp_client_pool_member *pool_member;
 
-	pool_member = mgcp_client_pool_find_member_by_nr(global_mgcp_client_pool, nr);
+	pool_member = pool_member_by_nr(nr);
 	if (!pool_member) {
 		vty_out(vty, "%% no such MGCP client configured ('%s')%s", argv[0], VTY_NEWLINE);
 		return CMD_WARNING;
@@ -592,7 +395,12 @@ DEFUN_ATTR(cfg_no_mgw,
 		return CMD_WARNING;
 	}
 
-	mgcp_client_pool_member_free(pool_member);
+	llist_del(&pool_member->list);
+	if (pool_member->client) {
+		mgcp_client_disconnect(pool_member->client);
+		talloc_free(pool_member->client);
+	}
+	talloc_free(pool_member);
 
 	return CMD_SUCCESS;
 }
@@ -604,7 +412,7 @@ DEFUN_ATTR(mgw_reconnect, mgw_reconnect_cmd,
 	int nr = atoi(argv[0]);
 	struct mgcp_client_pool_member *pool_member = NULL;
 
-	pool_member = mgcp_client_pool_find_member_by_nr(global_mgcp_client_pool, nr);
+	pool_member = pool_member_by_nr(nr);
 	if (!pool_member) {
 		vty_out(vty, "%% no such MGCP client configured ('%s')%s", argv[0], VTY_NEWLINE);
 		return CMD_WARNING;
@@ -617,10 +425,32 @@ DEFUN_ATTR(mgw_reconnect, mgw_reconnect_cmd,
 		return CMD_WARNING;
 	}
 
-	if (mgcp_client_pool_member_reinit_client(pool_member) < 0) {
+	/* Get rid of a possibly existing old MGCP client instance first */
+	if (pool_member->client) {
+		mgcp_client_disconnect(pool_member->client);
+		talloc_free(pool_member->client);
+	}
+
+	/* Create a new MGCP client instance with the current config */
+	pool_member->client = mgcp_client_init(pool_member, &pool_member->conf);
+	if (!pool_member->client) {
+		LOGP(DLMGCP, LOGL_ERROR, "(manual) MGW %s initalization failed\n",
+		     mgcp_client_pool_member_name(pool_member));
+		vty_out(vty, "%% MGCP client (MGW %s) initalization failed ('%s')%s",
+			mgcp_client_pool_member_name(pool_member), argv[0], VTY_NEWLINE);
+		return CMD_WARNING;
+	}
+
+	/* Set backpointer so that we can detect later that this MGCP client is managed by this pool. */
+	pool_member->client->pool = global_mgcp_client_pool;
+
+	/* Connect client */
+	if (mgcp_client_connect(pool_member->client)) {
 		LOGP(DLMGCP, LOGL_ERROR, "(manual) MGW %s connect failed at (%s:%u)\n",
 		     mgcp_client_pool_member_name(pool_member), pool_member->conf.remote_addr,
 		     pool_member->conf.remote_port);
+		talloc_free(pool_member->client);
+		pool_member->client = NULL;
 		vty_out(vty, "%% MGCP client (MGW %s) initalization failed ('%s')%s",
 			mgcp_client_pool_member_name(pool_member), argv[0], VTY_NEWLINE);
 		return CMD_WARNING;
@@ -636,7 +466,7 @@ DEFUN_ATTR(mgw_block, mgw_block_cmd,
 	int nr = atoi(argv[0]);
 	struct mgcp_client_pool_member *pool_member = NULL;
 
-	pool_member = mgcp_client_pool_find_member_by_nr(global_mgcp_client_pool, nr);
+	pool_member = pool_member_by_nr(nr);
 	if (!pool_member) {
 		vty_out(vty, "%% no such MGCP client configured ('%s')%s", argv[0], VTY_NEWLINE);
 		return CMD_WARNING;
@@ -653,7 +483,7 @@ DEFUN_ATTR(mgw_unblock, mgw_unblock_cmd,
 	int nr = atoi(argv[0]);
 	struct mgcp_client_pool_member *pool_member = NULL;
 
-	pool_member = mgcp_client_pool_find_member_by_nr(global_mgcp_client_pool, nr);
+	pool_member = pool_member_by_nr(nr);
 	if (!pool_member) {
 		vty_out(vty, "%% no such MGCP client configured ('%s')%s", argv[0], VTY_NEWLINE);
 		return CMD_WARNING;
@@ -663,27 +493,22 @@ DEFUN_ATTR(mgw_unblock, mgw_unblock_cmd,
 	return CMD_SUCCESS;
 }
 
-DEFUN(mgw_show, mgw_show_cmd, "show mgw-pool", SHOW_STR "Display information about the MGW-Pool\n")
+DEFUN(mgw_show, mgw_snow_cmd, "show mgw-pool", SHOW_STR "Display information about the MGW-Pool\n")
 {
 	vty_out(vty, "%% MGW-Pool:%s", VTY_NEWLINE);
 	struct mgcp_client_pool_member *pool_member;
 
-	if (llist_empty(&global_mgcp_client_pool->member_list) && global_mgcp_client_pool->mgcp_client_single) {
+	if (llist_empty(&global_mgcp_client_pool->pool) && global_mgcp_client_pool->mgcp_client_single) {
 		vty_out(vty, "%%  (pool is empty, single MGCP client will be used)%s", VTY_NEWLINE);
 		return CMD_SUCCESS;
-	} else if (llist_empty(&global_mgcp_client_pool->member_list)) {
+	} else if (llist_empty(&global_mgcp_client_pool->pool)) {
 		vty_out(vty, "%%  (pool is empty)%s", VTY_NEWLINE);
 		return CMD_SUCCESS;
 	}
 
-	llist_for_each_entry(pool_member, &global_mgcp_client_pool->member_list, list) {
-		const struct mgcp_client *cli = pool_member->client;
+	llist_for_each_entry(pool_member, &global_mgcp_client_pool->pool, list) {
 		vty_out(vty, "%%  MGW %s%s", mgcp_client_pool_member_name(pool_member), VTY_NEWLINE);
-		vty_out(vty, "%%   MGCP link:     %s,%s%s",
-			cli && cli->wq.bfd.fd != -1 ? "connected" : "disconnected",
-			cli && cli->conn_up ?
-				((cli->actual.keepalive.timeout_sec > 0) ? "UP" : "MAYBE") :
-				"DOWN",
+		vty_out(vty, "%%   mgcp-client:   %s%s", pool_member->client ? "connected" : "disconnected",
 			VTY_NEWLINE);
 		vty_out(vty, "%%   service:       %s%s", pool_member->blocked ? "blocked" : "unblocked", VTY_NEWLINE);
 		vty_out(vty, "%%   ongoing calls: %u%s", pool_member->refcount, VTY_NEWLINE);
@@ -695,8 +520,7 @@ DEFUN(mgw_show, mgw_show_cmd, "show mgw-pool", SHOW_STR "Display information abo
  *  (called once at startup by the application process).
  *  \param[in] parent_node identifier of the parent node on which the mgw node appears.
  *  \param[in] mgw_node identifier that should be used with the newly installed MGW node.
- *  \param[in] indent indentation string to match the indentation in the VTY config.
-	       If NULL, it must be passed explicitly each time mgcp_client_pool_config_write() is called.
+ *  \param[in] indent indentation string to match the indentation in the VTY config
  *  \param[in] pool user provided memory to store the configured MGCP client (MGW) pool. */
 void mgcp_client_pool_vty_init(int parent_node, int mgw_node, const char *indent, struct mgcp_client_pool *pool)
 {
@@ -704,12 +528,11 @@ void mgcp_client_pool_vty_init(int parent_node, int mgw_node, const char *indent
 	OSMO_ASSERT(pool);
 
 	/* Never allow this function to be called twice on the same pool */
+	OSMO_ASSERT(!pool->vty_indent);
 	OSMO_ASSERT(!pool->vty_node);
 
-	if (indent) {
-		pool->vty_indent = talloc_strdup(pool, indent);
-		OSMO_ASSERT(pool->vty_indent);
-	}
+	pool->vty_indent = talloc_strdup(pool, indent);
+	OSMO_ASSERT(pool->vty_indent);
 	pool->vty_node = talloc_zero(pool, struct cmd_node);
 	OSMO_ASSERT(pool->vty_node);
 	pool->vty_node->node = mgw_node;
@@ -719,19 +542,8 @@ void mgcp_client_pool_vty_init(int parent_node, int mgw_node, const char *indent
 	install_lib_element(parent_node, &cfg_mgw_cmd);
 	install_lib_element(parent_node, &cfg_no_mgw_cmd);
 
-	/* Note: config_write_pool is deprecated and user is expected to
-	 * manually call mgcp_client_pool_config_write() when printing the VTY
-	 * config */
 	install_node(pool->vty_node, config_write_pool);
 	vty_init_common(pool, mgw_node);
-	install_lib_element(mgw_node, &cfg_mgw_local_ip_cmd);
-	install_lib_element(mgw_node, &cfg_mgw_local_port_cmd);
-	install_lib_element(mgw_node, &cfg_mgw_remote_ip_cmd);
-	install_lib_element(mgw_node, &cfg_mgw_remote_port_cmd);
-	install_lib_element(mgw_node, &cfg_mgw_rtp_bts_base_port_cmd);
-	install_lib_element(mgw_node, &cfg_mgw_endpoint_domain_name_cmd);
-	install_lib_element(mgw_node, &cfg_mgw_reset_ep_name_cmd);
-	install_lib_element(mgw_node, &cfg_mgw_no_reset_ep_name_cmd);
 
 	install_element(mgw_node, &cfg_description_cmd);
 
@@ -739,7 +551,7 @@ void mgcp_client_pool_vty_init(int parent_node, int mgw_node, const char *indent
 	install_lib_element(ENABLE_NODE, &mgw_block_cmd);
 	install_lib_element(ENABLE_NODE, &mgw_unblock_cmd);
 
-	install_lib_element_ve(&mgw_show_cmd);
+	install_lib_element_ve(&mgw_snow_cmd);
 
 	global_mgcp_client_pool = pool;
 }

src/libosmo-mgcp/Makefile.am

@@ -16,6 +16,12 @@ AM_CFLAGS = \
 	$(NULL)
 
 AM_LDFLAGS = \
+	$(LIBOSMOCORE_LIBS) \
+	$(LIBOSMOGSM_LIBS) \
+	$(LIBOSMOVTY_LIBS) \
+	$(LIBOSMONETIF_LIBS) \
+	$(LIBOSMOABIS_LIBS) \
+	$(LIBOSMOTRAU_LIBS) \
 	$(COVERAGE_LDFLAGS) \
 	$(NULL)
 
@@ -39,7 +45,7 @@ libosmo_mgcp_a_SOURCES = \
 	mgcp_stat.c \
 	mgcp_endp.c \
 	mgcp_trunk.c \
+	mgcp_ctrl.c \
 	mgcp_ratectr.c \
 	mgcp_e1.c \
-	mgcp_iuup.c \
 	$(NULL)

src/libosmo-mgcp/g711common.h

@@ -14,6 +14,10 @@
  *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 static inline int val_seg(int val)

src/libosmo-mgcp/mgcp_codec.c

@@ -276,6 +276,75 @@ error:
 	return -EINVAL;
 }
 
+/* Check if the given codec is applicable on the specified endpoint
+ * Helper function for mgcp_codec_decide() */
+static bool is_codec_compatible(const struct mgcp_endpoint *endp, const struct mgcp_rtp_codec *codec)
+{
+	/* A codec name must be set, if not, this might mean that the codec
+	 * (payload type) that was assigned is unknown to us so we must stop
+	 * here. */
+	if (!strlen(codec->subtype_name))
+		return false;
+
+	/* FIXME: implement meaningful checks to make sure that the given codec
+	 * is compatible with the given endpoint */
+
+	return true;
+}
+
+/*! Decide for one suitable codec
+ *  \param[in] conn related rtp-connection.
+ *  \returns 0 on success, -EINVAL on failure. */
+int mgcp_codec_decide(struct mgcp_conn_rtp *conn)
+{
+	struct mgcp_rtp_end *rtp;
+	unsigned int i;
+	struct mgcp_endpoint *endp;
+	bool codec_assigned = false;
+
+	endp = conn->conn->endp;
+	rtp = &conn->end;
+
+	/* This function works on the results the SDP/LCO parser has extracted
+	 * from the MGCP message. The goal is to select a suitable codec for
+	 * the given connection. When transcoding is available, the first codec
+	 * from the codec list is taken without further checking. When
+	 * transcoding is not available, then the choice must be made more
+	 * carefully. Each codec in the list is checked until one is found that
+	 * is rated compatible. The rating is done by the helper function
+	 * is_codec_compatible(), which does the actual checking. */
+	for (i = 0; i < rtp->codecs_assigned; i++) {
+		/* When no transcoding is available, avoid codecs that would
+		 * require transcoding. */
+		if (endp->trunk->no_audio_transcoding && !is_codec_compatible(endp, &rtp->codecs[i])) {
+			LOGP(DLMGCP, LOGL_NOTICE, "transcoding not available, skipping codec: %d/%s\n",
+			     rtp->codecs[i].payload_type, rtp->codecs[i].subtype_name);
+			continue;
+		}
+
+		rtp->codec = &rtp->codecs[i];
+		codec_assigned = true;
+		break;
+	}
+
+	/* FIXME: To the reviewes: This is problematic. I do not get why we
+	 * need to reset the packet_duration_ms depending on the codec
+	 * selection. I thought it were all 20ms? Is this to address some
+	 * cornercase. (This piece of code was in the code path before,
+	 * together with the note: "TODO/XXX: Store this per codec and derive
+	 * it on use" */
+	if (codec_assigned) {
+		if (rtp->maximum_packet_time >= 0
+		    && rtp->maximum_packet_time * rtp->codec->frame_duration_den >
+		    rtp->codec->frame_duration_num * 1500)
+			rtp->packet_duration_ms = 0;
+
+		return 0;
+	}
+
+	return -EINVAL;
+}
+
 /* Return true if octet-aligned is set in the given codec. Default to octet-aligned=0, i.e. bandwidth-efficient mode.
  * See RFC4867 "RTP Payload Format for AMR and AMR-WB" sections "8.1. AMR Media Type Registration" and "8.2. AMR-WB
  * Media Type Registration":
@@ -286,7 +355,7 @@ error:
  *
  * https://tools.ietf.org/html/rfc4867
  */
-bool mgcp_codec_amr_is_octet_aligned(const struct mgcp_rtp_codec *codec)
+static bool amr_is_octet_aligned(const struct mgcp_rtp_codec *codec)
 {
 	if (!codec->param_present)
 		return false;
@@ -295,15 +364,10 @@ bool mgcp_codec_amr_is_octet_aligned(const struct mgcp_rtp_codec *codec)
 	return codec->param.amr_octet_aligned;
 }
 
-/* Compare two codecs, all parameters must match up */
+/* Compare two codecs, all parameters must match up, except for the payload type
+ * number. */
 static bool codecs_same(struct mgcp_rtp_codec *codec_a, struct mgcp_rtp_codec *codec_b)
 {
-	/* All codec properties must match up, except the payload type number. Even though standardisd payload numbers
-	 * exist for certain situations, the call agent may still assign them freely. Hence we must not insist on equal
-	 * payload type numbers. Also the audio_name is not checked since it is already parsed into subtype_name, rate,
-	 * and channels, which are checked. */
-	if (strcmp(codec_a->subtype_name, codec_b->subtype_name))
-		return false;
 	if (codec_a->rate != codec_b->rate)
 		return false;
 	if (codec_a->channels != codec_b->channels)
@@ -312,163 +376,61 @@ static bool codecs_same(struct mgcp_rtp_codec *codec_a, struct mgcp_rtp_codec *c
 		return false;
 	if (codec_a->frame_duration_den != codec_b->frame_duration_den)
 		return false;
-
-	/* AMR payload may be formatted in two different payload formats, it is still the same codec but since the
-	 * formatting of the payload is different, conversation is required, so we must treat it as a different
-	 * codec here. */
-	if (strcmp(codec_a->subtype_name, "AMR") == 0) {
-		if (mgcp_codec_amr_is_octet_aligned(codec_a) != mgcp_codec_amr_is_octet_aligned(codec_b))
+	if (strcmp(codec_a->subtype_name, codec_b->subtype_name))
+		return false;
+	if (!strcmp(codec_a->subtype_name, "AMR")) {
+		if (amr_is_octet_aligned(codec_a) != amr_is_octet_aligned(codec_b))
 			return false;
 	}
 
 	return true;
 }
 
-/* Compare two codecs, all parameters must match up, except parameters related to payload formatting (not checked). */
-static bool codecs_convertible(struct mgcp_rtp_codec *codec_a, struct mgcp_rtp_codec *codec_b)
+/*! Translate a given payload type number that belongs to the packet of a
+ *  source connection to the equivalent payload type number that matches the
+ *  configuration of a destination connection.
+ *  \param[in] conn_src related source rtp-connection.
+ *  \param[in] conn_dst related destination rtp-connection.
+ *  \param[in] payload_type number from the source packet or source connection.
+ *  \returns translated payload type number on success, -EINVAL on failure. */
+int mgcp_codec_pt_translate(struct mgcp_conn_rtp *conn_src, struct mgcp_conn_rtp *conn_dst, int payload_type)
 {
-	/* OsmoMGW currently has no ability to transcode from one codec to another. However OsmoMGW is still able to
-	 * translate between different payload formats as long as the encoded voice data itself does not change.
-	 * Therefore we must insist on equal codecs but still allow different payload formatting. */
-
-	/* In 3G IuUP, AMR may be encapsulated in IuFP, this means even though the codec name and negotiated rate is
-	 * different, the formatting can still be converted by OsmoMGW. Therefore we won't insist on equal
-	 * subtype_name and rate if we detect IuFP and AMR is used on the same tandem. */
-	if (strcmp(codec_a->subtype_name, "AMR") == 0 && strcmp(codec_b->subtype_name, "VND.3GPP.IUFP") == 0)
-		goto iufp;
-	if (strcmp(codec_a->subtype_name, "VND.3GPP.IUFP") == 0 && strcmp(codec_b->subtype_name, "AMR") == 0)
-		goto iufp;
-
-	if (strcmp(codec_a->subtype_name, codec_b->subtype_name))
-		return false;
-	if (codec_a->rate != codec_b->rate)
-		return false;
-iufp:
-	if (codec_a->channels != codec_b->channels)
-		return false;
-	if (codec_a->frame_duration_num != codec_b->frame_duration_num)
-		return false;
-	if (codec_a->frame_duration_den != codec_b->frame_duration_den)
-		return false;
-
-	return true;
-}
-
-struct mgcp_rtp_codec *mgcp_codec_find_same(struct mgcp_conn_rtp *conn, struct mgcp_rtp_codec *codec)
-{
-	struct mgcp_rtp_end *rtp_end;
+	struct mgcp_rtp_end *rtp_src;
+	struct mgcp_rtp_end *rtp_dst;
+	struct mgcp_rtp_codec *codec_src = NULL;
+	struct mgcp_rtp_codec *codec_dst = NULL;
 	unsigned int i;
 	unsigned int codecs_assigned;
 
-	rtp_end = &conn->end;
+	rtp_src = &conn_src->end;
+	rtp_dst = &conn_dst->end;
 
-	/* Use the codec information from the source and try to find the equivalent of it on the destination side. In
-	 * the first run we will look for an exact match. */
-	codecs_assigned = rtp_end->codecs_assigned;
+	/* Find the codec information that is used on the source side */
+	codecs_assigned = rtp_src->codecs_assigned;
 	OSMO_ASSERT(codecs_assigned <= MGCP_MAX_CODECS);
 	for (i = 0; i < codecs_assigned; i++) {
-		if (codecs_same(codec, &rtp_end->codecs[i])) {
-			return &rtp_end->codecs[i];
+		if (payload_type == rtp_src->codecs[i].payload_type) {
+			codec_src = &rtp_src->codecs[i];
 			break;
 		}
 	}
+	if (!codec_src)
+		return -EINVAL;
 
-	return NULL;
-}
-
-/* For a given codec, find a convertible codec in the given connection. */
-static struct mgcp_rtp_codec *codec_find_convertible(struct mgcp_conn_rtp *conn, struct mgcp_rtp_codec *codec)
-{
-	struct mgcp_rtp_end *rtp_end;
-	unsigned int i;
-	unsigned int codecs_assigned;
-	struct mgcp_rtp_codec *codec_convertible = NULL;
-
-	rtp_end = &conn->end;
-
-	/* Use the codec information from the source and try to find the equivalent of it on the destination side. In
-	 * the first run we will look for an exact match. */
-	codec_convertible = mgcp_codec_find_same(conn, codec);
-	if (codec_convertible)
-		return codec_convertible;
-
-	/* In case we weren't able to find an exact match, we will try to find a match that is the same codec, but the
-	 * payload format may be different. This alternative will require a frame format conversion (i.e. AMR bwe->oe) */
-	codecs_assigned = rtp_end->codecs_assigned;
+	/* Use the codec infrmation from the source and try to find the
+	 * equivalent of it on the destination side */
+	codecs_assigned = rtp_dst->codecs_assigned;
 	OSMO_ASSERT(codecs_assigned <= MGCP_MAX_CODECS);
 	for (i = 0; i < codecs_assigned; i++) {
-		if (codecs_convertible(codec, &rtp_end->codecs[i])) {
-			codec_convertible = &rtp_end->codecs[i];
+		if (codecs_same(codec_src, &rtp_dst->codecs[i])) {
+			codec_dst = &rtp_dst->codecs[i];
 			break;
 		}
 	}
+	if (!codec_dst)
+		return -EINVAL;
 
-	return codec_convertible;
-}
-
-/*! Decide for one suitable codec on both of the given connections. In case a destination connection is not available,
- *  a tentative decision is made.
- *  \param[inout] conn_src related rtp-connection.
- *  \param[inout] conn_dst related destination rtp-connection (NULL if not present).
- *  \returns 0 on success, -EINVAL on failure. */
-int mgcp_codec_decide(struct mgcp_conn_rtp *conn_src, struct mgcp_conn_rtp *conn_dst)
-{
-	unsigned int i;
-
-	/* In case no destination connection is available (yet), or in case the destination connection exists but has
-	 * no codecs assigned, we are forced to make a simple tentative decision:
-	 * We just use the first codec of the source connection (conn_src) */
-	OSMO_ASSERT(conn_src->end.codecs_assigned <= MGCP_MAX_CODECS);
-	if (!conn_dst || conn_dst->end.codecs_assigned == 0) {
-		if (conn_src->end.codecs_assigned >= 1) {
-			conn_src->end.codec = &conn_src->end.codecs[0];
-			return 0;
-		} else
-			return -EINVAL;
-	}
-
-	/* Compare all codecs of the source connection (conn_src) to the codecs of the destination connection (conn_dst). In case
-	 * of a match set this codec on both connections. This would be an ideal selection since no codec conversion would be
-	 * required. */
-	for (i = 0; i < conn_src->end.codecs_assigned; i++) {
-		struct mgcp_rtp_codec *codec_conn_dst = mgcp_codec_find_same(conn_dst, &conn_src->end.codecs[i]);
-		if (codec_conn_dst) {
-			/* We found the a codec that is exactly the same (same codec, same payload format etc.) on both
-			 * sides. We now set this codec on both connections. */
-			conn_dst->end.codec = codec_conn_dst;
-			conn_src->end.codec = mgcp_codec_find_same(conn_src, codec_conn_dst);
-			OSMO_ASSERT(conn_src->end.codec);
-			return 0;
-		}
-	}
-
-	/* In case we could not find a codec that is exactly the same, let's at least try to find a codec that we are able
-	 * to convert. */
-	for (i = 0; i < conn_src->end.codecs_assigned; i++) {
-		struct mgcp_rtp_codec *codec_conn_dst = codec_find_convertible(conn_dst, &conn_src->end.codecs[i]);
-		if (codec_conn_dst) {
-			/* We found the a codec that we are able to convert on both sides. We now set this codec on both
-			 * connections. */
-			conn_dst->end.codec = codec_conn_dst;
-			conn_src->end.codec = codec_find_convertible(conn_src, codec_conn_dst);
-			OSMO_ASSERT(conn_src->end.codec);
-			return 0;
-		}
-	}
-
-	return -EINVAL;
-}
-
-/* Check if the codec has a specific AMR mode (octet-aligned or bandwith-efficient) set. */
-bool mgcp_codec_amr_align_mode_is_indicated(const struct mgcp_rtp_codec *codec)
-{
-	if (codec->param_present == false)
-		return false;
-	if (!codec->param.amr_octet_aligned_present)
-		return false;
-	if (strcmp(codec->subtype_name, "AMR") != 0)
-		return false;
-	return true;
+	return codec_dst->payload_type;
 }
 
 /* Find the payload type number configured for a specific codec by SDP.
@@ -478,7 +440,8 @@ bool mgcp_codec_amr_align_mode_is_indicated(const struct mgcp_rtp_codec *codec)
  * \param subtype_name  SDP codec name without parameters (e.g. "AMR").
  * \param match_nr  Index for the match found, first being match_nr == 0. Iterate all matches by calling multiple times
  *                  with incrementing match_nr.
- * \return codec definition for that conn matching the subtype_name, or NULL if no such match_nr is found. */
+ * \return codec definition for that conn matching the subtype_name, or NULL if no such match_nr is found.
+ */
 const struct mgcp_rtp_codec *mgcp_codec_pt_find_by_subtype_name(struct mgcp_conn_rtp *conn,
 								const char *subtype_name, unsigned int match_nr)
 {
@@ -494,26 +457,3 @@ const struct mgcp_rtp_codec *mgcp_codec_pt_find_by_subtype_name(struct mgcp_conn
 	}
 	return NULL;
 }
-
-/*! Lookup a codec that is assigned to a connection by its payload type number.
- *  \param[in] conn related rtp-connection.
- *  \param[in] payload_type number of the codec to look up.
- *  \returns pointer to codec struct on success, NULL on failure. */
-struct mgcp_rtp_codec *mgcp_codec_from_pt(struct mgcp_conn_rtp *conn, int payload_type)
-{
-	struct mgcp_rtp_end *rtp_end = &conn->end;
-	unsigned int codecs_assigned = rtp_end->codecs_assigned;
-	struct mgcp_rtp_codec *codec = NULL;
-	size_t i;
-
-	OSMO_ASSERT(codecs_assigned <= MGCP_MAX_CODECS);
-
-	for (i = 0; i < codecs_assigned; i++) {
-		if (payload_type == rtp_end->codecs[i].payload_type) {
-			codec = &rtp_end->codecs[i];
-			break;
-		}
-	}
-
-	return codec;
-}

src/libosmo-mgcp/mgcp_conn.c

@@ -30,14 +30,12 @@
 #include <osmocom/mgcp/mgcp_trunk.h>
 #include <osmocom/mgcp/mgcp_sdp.h>
 #include <osmocom/mgcp/mgcp_codec.h>
-#include <osmocom/mgcp/mgcp_iuup.h>
-
 #include <osmocom/gsm/gsm_utils.h>
 #include <osmocom/core/rate_ctr.h>
 #include <osmocom/core/timer.h>
 #include <ctype.h>
 
-static const struct rate_ctr_group_desc rate_ctr_group_desc = {
+const static struct rate_ctr_group_desc rate_ctr_group_desc = {
 	.group_name_prefix = "conn_rtp",
 	.group_description = "rtp connection statistics",
 	.class_id = 1,
@@ -95,36 +93,30 @@ static int mgcp_rtp_conn_init(struct mgcp_conn_rtp *conn_rtp, struct mgcp_conn *
 	static atomic_uint rate_ctr_index = 0;
 
 	conn_rtp->type = MGCP_RTP_DEFAULT;
-
-	/* Osmux specific defaults, only used if conn is later on Osmux-enabled: */
-	conn_rtp->osmux.state = OSMUX_STATE_DISABLED;
-	conn_rtp->osmux.local_cid_allocated = false;
-	conn_rtp->osmux.local_cid = 0;
-	conn_rtp->osmux.remote_cid_present = false;
-	conn_rtp->osmux.remote_cid = 0;
+	conn_rtp->osmux.cid_allocated = false;
+	conn_rtp->osmux.cid = 0;
 
 	/* backpointer to the generic part of the connection */
 	conn->u.rtp.conn = conn;
 
 	end->rtp.fd = -1;
 	end->rtcp.fd = -1;
-	memset(&end->addr, 0, sizeof(end->addr));
-	end->rtcp_port = 0;
+	end->rtp_port = end->rtcp_port = 0;
 	talloc_free(end->fmtp_extra);
 	end->fmtp_extra = NULL;
 
 	/* Set default values */
 	end->frames_per_packet = 0;	/* unknown */
 	end->packet_duration_ms = DEFAULT_RTP_AUDIO_PACKET_DURATION_MS;
-	end->output_enabled = false;
+	end->output_enabled = 0;
 	end->maximum_packet_time = -1;
 
-	conn_rtp->ctrg = rate_ctr_group_alloc(conn, &rate_ctr_group_desc, rate_ctr_index++);
-	if (!conn_rtp->ctrg)
+	conn_rtp->rate_ctr_group = rate_ctr_group_alloc(conn, &rate_ctr_group_desc, rate_ctr_index++);
+	if (!conn_rtp->rate_ctr_group)
 		return -1;
 
-	conn_rtp->state.in_stream.err_ts_ctr = rate_ctr_group_get_ctr(conn_rtp->ctrg, IN_STREAM_ERR_TSTMP_CTR);
-	conn_rtp->state.out_stream.err_ts_ctr = rate_ctr_group_get_ctr(conn_rtp->ctrg, OUT_STREAM_ERR_TSTMP_CTR);
+	conn_rtp->state.in_stream.err_ts_ctr = rate_ctr_group_get_ctr(conn_rtp->rate_ctr_group, IN_STREAM_ERR_TSTMP_CTR);
+	conn_rtp->state.out_stream.err_ts_ctr = rate_ctr_group_get_ctr(conn_rtp->rate_ctr_group, OUT_STREAM_ERR_TSTMP_CTR);
 
 	/* Make sure codec table is reset */
 	mgcp_codec_reset_all(conn_rtp);
@@ -137,10 +129,8 @@ static void mgcp_rtp_conn_cleanup(struct mgcp_conn_rtp *conn_rtp)
 {
 	if (mgcp_conn_rtp_is_osmux(conn_rtp))
 		conn_osmux_disable(conn_rtp);
-	if (mgcp_conn_rtp_is_iuup(conn_rtp))
-		mgcp_conn_iuup_cleanup(conn_rtp);
 	mgcp_free_rtp_port(&conn_rtp->end);
-	rate_ctr_group_free(conn_rtp->ctrg);
+	rate_ctr_group_free(conn_rtp->rate_ctr_group);
 	mgcp_codec_reset_all(conn_rtp);
 }
 
@@ -173,8 +163,8 @@ struct mgcp_conn *mgcp_conn_alloc(void *ctx, struct mgcp_endpoint *endp,
 	struct mgcp_conn *conn;
 	int rc;
 
-	/* Do not allow more than the maximum number of connections */
-	if (endp->type->max_conns > 0 && llist_count(&endp->conns) >= endp->type->max_conns)
+	/* Do not allow more then two connections */
+	if (llist_count(&endp->conns) >= endp->type->max_conns)
 		return NULL;
 
 	/* Create new connection and add it to the list */
@@ -269,7 +259,7 @@ struct mgcp_conn_rtp *mgcp_conn_get_rtp(struct mgcp_endpoint *endp,
 static void aggregate_rtp_conn_stats(struct mgcp_endpoint *endp, struct mgcp_conn_rtp *conn_rtp)
 {
 	struct rate_ctr_group *all_stats = endp->trunk->ratectr.all_rtp_conn_stats;
-	struct rate_ctr_group *conn_stats = conn_rtp->ctrg;
+	struct rate_ctr_group *conn_stats = conn_rtp->rate_ctr_group;
 
 	if (all_stats == NULL || conn_stats == NULL)
 		return;
@@ -335,11 +325,6 @@ void mgcp_conn_free_oldest(struct mgcp_endpoint *endp)
 
 /*! free all connections at once.
  *  \param[in] endp associated endpoint */
-#if defined(__has_attribute)
-#if __has_attribute(no_sanitize)
-__attribute__((no_sanitize("undefined"))) /* ubsan detects a misaligned load */
-#endif
-#endif
 void mgcp_conn_free_all(struct mgcp_endpoint *endp)
 {
 	struct mgcp_conn *conn;
@@ -366,38 +351,14 @@ char *mgcp_conn_dump(struct mgcp_conn *conn)
 
 	switch (conn->type) {
 	case MGCP_CONN_TYPE_RTP:
-		switch (conn->u.rtp.type) {
-		case MGCP_RTP_DEFAULT:
-			/* Dump RTP connection */
-			snprintf(str, sizeof(str), "(%s/rtp, id:0x%s, ip:%s, "
-				"rtp:%u rtcp:%u)",
-				conn->name, conn->id,
-				osmo_sockaddr_ntop(&conn->u.rtp.end.addr.u.sa, ipbuf),
-				osmo_sockaddr_port(&conn->u.rtp.end.addr.u.sa),
-				ntohs(conn->u.rtp.end.rtcp_port));
-			break;
-		case MGCP_RTP_OSMUX:
-			snprintf(str, sizeof(str), "(%s/osmux, id:0x%s, ip:%s, "
-				"port:%u CID:%u)",
-				conn->name, conn->id,
-				osmo_sockaddr_ntop(&conn->u.rtp.end.addr.u.sa, ipbuf),
-				osmo_sockaddr_port(&conn->u.rtp.end.addr.u.sa),
-				conn->u.rtp.osmux.local_cid);
-			break;
-		case MGCP_RTP_IUUP:
-			snprintf(str, sizeof(str), "(%s/iuup, id:0x%s, ip:%s, "
-				"port:%u)",
-				conn->name, conn->id,
-				osmo_sockaddr_ntop(&conn->u.rtp.end.addr.u.sa, ipbuf),
-				osmo_sockaddr_port(&conn->u.rtp.end.addr.u.sa));
-			break;
-		default:
-			/* Should not happen, we should be able to dump
-			 * every possible connection type. */
-			snprintf(str, sizeof(str), "(unknown conn_rtp connection type %u)",
-				 conn->u.rtp.type);
-			break;
-		}
+		/* Dump RTP connection */
+		snprintf(str, sizeof(str), "(%s/rtp, id:0x%s, ip:%s, "
+			 "rtp:%u rtcp:%u)",
+			 conn->name,
+			 conn->id,
+			 osmo_sockaddr_ntop(&conn->u.rtp.end.addr.u.sa, ipbuf),
+			 ntohs(conn->u.rtp.end.rtp_port),
+			 ntohs(conn->u.rtp.end.rtcp_port));
 		break;
 
 	default:

src/libosmo-mgcp/mgcp_ctrl.c

@@ -0,0 +1,36 @@
+/*
+ * (C) 2020 by Harald Welte <laforge@gnumonks.org>
+ * All Rights Reserved
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <osmocom/ctrl/control_if.h>
+#include <osmocom/mgcp/mgcp.h>
+
+
+static int mgw_ctrl_node_lookup(void *data, vector vline, int *node_type,
+				void **node_data, int *i)
+{
+	return 0;
+}
+
+
+struct ctrl_handle *mgw_ctrl_interface_setup(struct mgcp_config *cfg,
+					     const char *bind_addr, uint16_t port)
+{
+	return ctrl_interface_setup_dynip2(cfg, bind_addr, port, mgw_ctrl_node_lookup,
+					   _LAST_CTRL_NODE);
+}

src/libosmo-mgcp/mgcp_e1.c

@@ -222,7 +222,7 @@ static void e1_i460_mux_empty_cb(struct osmo_i460_subchan *schan, void *user_dat
 	osmo_i460_mux_enqueue(endp->e1.schan, msg);
 }
 
-/* called by I.460 de-multiplexer; feed output of I.460 demux into TRAU frame sync */
+/* called by I.460 de-multeiplexer; feed output of I.460 demux into TRAU frame sync */
 static void e1_i460_demux_bits_cb(struct osmo_i460_subchan *schan, void *user_data, const ubit_t *bits,
 				  unsigned int num_bits)
 {
@@ -309,8 +309,8 @@ skip:
 	return;
 }
 
-/* handle outgoing E1 traffic */
-static void e1_send_ts_frame(struct e1inp_ts *ts, struct mgcp_trunk *trunk)
+/* Function to handle outgoing E1 traffic */
+static void e1_send(struct e1inp_ts *ts, struct mgcp_trunk *trunk)
 {
 	struct msgb *msg = msgb_alloc_c(trunk, E1_TS_BYTES, "E1-TX-timeslot-bytes");
 	uint8_t *ptr;
@@ -338,7 +338,6 @@ static void e1_recv_cb(struct e1inp_ts *ts, struct msgb *msg)
 	trunk = mgcp_trunk_by_line_num(cfg, ts->line->num);
 	if (!trunk) {
 		LOGP(DE1, LOGL_ERROR, "E1-RX: unable to find a trunk for E1-line %u!\n", ts->line->num);
-		msgb_free(msg);
 		return;
 	}
 
@@ -359,17 +358,16 @@ static void e1_recv_cb(struct e1inp_ts *ts, struct msgb *msg)
 	osmo_i460_demux_in(&trunk->e1.i460_ts[ts->num - 1], msgb_data(msg), msgb_length(msg));
 
 	/* Trigger sending of pending E1 traffic */
-	e1_send_ts_frame(ts, trunk);
-
-	/* e1inp_rx_ts(), the caller of this callback does not free() msgb. */
-	msgb_free(msg);
+	e1_send(ts, trunk);
 }
 
-static int e1_open(struct mgcp_trunk *trunk, uint8_t ts_nr)
+static int e1_init(struct mgcp_trunk *trunk, uint8_t ts_nr)
 {
-	/*! One E1 timeslot may serve multiple I.460 subslots. The timeslot is opened as soon as an I.460 subslot is
-	 *  opened and will stay open until the last I.460 subslot is closed (see e1_close below). This function must
-	 *  be called any time a new I.460 subslot is opened in order to maintain constancy of the ts_usecount counter. */
+	/*! Each timeslot needs only to be configured once. The Timeslot then
+	 *  stays open and permanently receives data. It is then up to the
+	 *  I.460 demultiplexer to add/remove subchannels as needed. It is
+	 *  allowed to call this function multiple times since we check if the
+	 *  timeslot is already configured. */
 
 	struct e1inp_line *e1_line;
 	int rc;
@@ -377,14 +375,12 @@ static int e1_open(struct mgcp_trunk *trunk, uint8_t ts_nr)
 	OSMO_ASSERT(ts_nr > 0 || ts_nr < NUM_E1_TS);
 	cfg = trunk->cfg;
 
-	if (trunk->e1.ts_usecount[ts_nr - 1] > 0) {
-		LOGPTRUNK(trunk, DE1, LOGL_INFO, "E1 timeslot %u already set up and in use by %u subslot(s), using it as it is...\n",
-			  ts_nr, trunk->e1.ts_usecount[ts_nr - 1]);
-		trunk->e1.ts_usecount[ts_nr - 1]++;
+	if (trunk->e1.ts_in_use[ts_nr - 1]) {
+		LOGPTRUNK(trunk, DE1, LOGL_INFO, "E1 timeslot %u already set up, skipping...\n", ts_nr);
 		return 0;
 	}
 
-	/* Find E1 line */
+	/* Get E1 line */
 	e1_line = e1inp_line_find(trunk->e1.vty_line_nr);
 	if (!e1_line) {
 		LOGPTRUNK(trunk, DE1, LOGL_ERROR, "no such E1 line %u - check VTY config!\n",
@@ -401,61 +397,12 @@ static int e1_open(struct mgcp_trunk *trunk, uint8_t ts_nr)
 	}
 	rc = e1inp_line_update(e1_line);
 	if (rc < 0) {
-		LOGPTRUNK(trunk, DE1, LOGL_ERROR, "failed to update E1 line %u.\n", ts_nr);
+		LOGPTRUNK(trunk, DE1, LOGL_ERROR, "failed to update E1 timeslot %u.\n", ts_nr);
 		return -EINVAL;
 	}
 
 	LOGPTRUNK(trunk, DE1, LOGL_INFO, "E1 timeslot %u set up successfully.\n", ts_nr);
-	trunk->e1.ts_usecount[ts_nr - 1]++;
-	OSMO_ASSERT(trunk->e1.ts_usecount[ts_nr - 1] == 1);
-
-	return 0;
-}
-
-static int e1_close(struct mgcp_trunk *trunk, uint8_t ts_nr)
-{
-	/* See also comment above (e1_open). This function must be called any time an I.460 subslot is closed */
-
-	struct e1inp_line *e1_line;
-	int rc;
-
-	OSMO_ASSERT(ts_nr > 0 || ts_nr < NUM_E1_TS);
-	cfg = trunk->cfg;
-
-	if (trunk->e1.ts_usecount[ts_nr - 1] > 1) {
-		trunk->e1.ts_usecount[ts_nr - 1]--;
-		LOGPTRUNK(trunk, DE1, LOGL_INFO, "E1 timeslot %u still in use by %u other subslot(s), leaving it open...\n",
-			  ts_nr, trunk->e1.ts_usecount[ts_nr - 1]);
-		return 0;
-	} else if (trunk->e1.ts_usecount[ts_nr - 1] == 0) {
-		/* This should not be as it means we close the timeslot too often. */
-		LOGPTRUNK(trunk, DE1, LOGL_ERROR, "E1 timeslot %u already closed, leaving it as it is...\n", ts_nr);
-		return -EINVAL;
-	}
-
-	/* Find E1 line */
-	e1_line = e1inp_line_find(trunk->e1.vty_line_nr);
-	if (!e1_line) {
-		LOGPTRUNK(trunk, DE1, LOGL_ERROR, "no such E1 line %u - check VTY config!\n",
-			  trunk->e1.vty_line_nr);
-		return -EINVAL;
-	}
-
-	/* Release E1 timeslot */
-	rc = e1inp_ts_config_none(&e1_line->ts[ts_nr - 1], e1_line);
-	if (rc < 0) {
-		LOGPTRUNK(trunk, DE1, LOGL_ERROR, "failed to disable E1 timeslot %u.\n", ts_nr);
-		return -EINVAL;
-	}
-	rc = e1inp_line_update(e1_line);
-	if (rc < 0) {
-		LOGPTRUNK(trunk, DE1, LOGL_ERROR, "failed to update E1 line %u.\n", trunk->e1.vty_line_nr);
-		return -EINVAL;
-	}
-
-	LOGPTRUNK(trunk, DE1, LOGL_INFO, "E1 timeslot %u closed.\n", ts_nr);
-	trunk->e1.ts_usecount[ts_nr - 1]--;
-	OSMO_ASSERT(trunk->e1.ts_usecount[ts_nr - 1] == 0);
+	trunk->e1.ts_in_use[ts_nr - 1] = true;
 
 	return 0;
 }
@@ -545,7 +492,7 @@ static bool tf_type_is_amr(enum osmo_trau_frame_type ft)
 	}
 }
 
-/*! Equip E1 endpoint with I.460 mux and E1 timeslot resources.
+/* !Equip E1 endpoint with I.460 mux resources.
  *  \param[in] endp endpoint to equip
  *  \param[in] ts E1 timeslot number.
  *  \param[in] ss E1 subslot number.
@@ -566,7 +513,7 @@ int mgcp_e1_endp_equip(struct mgcp_endpoint *endp, uint8_t ts, uint8_t ss, uint8
 	endp->e1.last_amr_ft = AMR_4_75;
 
 	/* Set up E1 line / timeslot */
-	rc = e1_open(endp->trunk, ts);
+	rc = e1_init(endp->trunk, ts);
 	if (rc != 0)
 		return -EINVAL;
 
@@ -653,15 +600,9 @@ void mgcp_e1_endp_update(struct mgcp_endpoint *endp)
 }
 
 /*! Remove E1 resources from endpoint
- *  \param[in] endp endpoint to release.
- *  \param[in] ts E1 timeslot number. */
-void mgcp_e1_endp_release(struct mgcp_endpoint *endp, uint8_t ts)
+ *  \param[in] endp endpoint to release. */
+void mgcp_e1_endp_release(struct mgcp_endpoint *endp)
 {
-	/* Guard against multiple calls. In case we don't see a subchannel anymore we can safely assume that all work
-	 * is done. */
-	if (!(endp->e1.schan || endp->e1.trau_rtp_st || endp->e1.trau_sync_fi))
-		return;
-
 	LOGPENDP(endp, DE1, LOGL_DEBUG, "removing I.460 subchannel and sync...\n");
 
 	if (endp->e1.schan)
@@ -670,10 +611,8 @@ void mgcp_e1_endp_release(struct mgcp_endpoint *endp, uint8_t ts)
 		talloc_free(endp->e1.trau_rtp_st);
 	if (endp->e1.trau_sync_fi)
 		osmo_fsm_inst_term(endp->e1.trau_sync_fi, OSMO_FSM_TERM_REGULAR, NULL);
-	memset(&endp->e1, 0, sizeof(endp->e1));
 
-	/* Close E1 timeslot */
-	e1_close(endp->trunk, ts);
+	memset(&endp->e1, 0, sizeof(endp->e1));
 }
 
 /*! Accept RTP message buffer with RTP data and enqueue voice data for E1 transmit.

src/libosmo-mgcp/mgcp_endp.c

@@ -38,6 +38,7 @@
 const struct mgcp_endpoint_typeset ep_typeset = {
 	/* Specify endpoint properties for RTP endpoint */
 	.rtp = {
+		.max_conns = 2,
 		.dispatch_rtp_cb = mgcp_dispatch_rtp_bridge_cb,
 		.cleanup_cb = mgcp_cleanup_rtp_bridge_cb,
 	},
@@ -109,6 +110,36 @@ struct mgcp_endpoint *mgcp_endp_alloc(struct mgcp_trunk *trunk,
 	return endp;
 }
 
+/*! release endpoint, all open connections are closed.
+ *  \param[in] endp endpoint to release */
+void mgcp_endp_release(struct mgcp_endpoint *endp)
+{
+	LOGPENDP(endp, DLMGCP, LOGL_DEBUG, "Releasing endpoint\n");
+
+	/* Normally this function should only be called when
+	 * all connections have been removed already. In case
+	 * that there are still connections open (e.g. when
+	 * RSIP is executed), free them all at once. */
+	mgcp_conn_free_all(endp);
+
+	/* We must only decrement the stat item when the endpoint as actually
+	 * claimed. An endpoint is claimed when a call-id is set */
+	if (endp->callid)
+		osmo_stat_item_dec(osmo_stat_item_group_get_item(endp->trunk->stats.common,
+								 TRUNK_STAT_ENDPOINTS_USED), 1);
+
+	/* Reset endpoint parameters and states */
+	talloc_free(endp->callid);
+	endp->callid = NULL;
+	talloc_free(endp->local_options.string);
+	endp->local_options.string = NULL;
+	talloc_free(endp->local_options.codec);
+	endp->local_options.codec = NULL;
+
+	if (endp->trunk->trunk_type == MGCP_TRUNK_E1)
+		mgcp_e1_endp_release(endp);
+}
+
 /* Check if the endpoint name contains the prefix (e.g. "rtpbridge/" or
  * "ds/e1-") and write the epname without the prefix back to the memory
  * pointed at by epname. (per trunk the prefix is the same for all endpoints,
@@ -156,6 +187,7 @@ static void chop_epname_suffix(char *epname, const struct mgcp_trunk *trunk)
 	}
 }
 
+
  /*! Convert all characters in epname to lowercase and strip trunk prefix and
  * endpoint name suffix (domain name) from epname. The result is written to
  * to the memory pointed at by epname_stripped. The expected size of the
@@ -192,9 +224,9 @@ static struct mgcp_endpoint *find_free_endpoint(const struct mgcp_trunk *trunk)
 }
 
 /*! Find an endpoint of a trunk specified by its name.
- *  \param[in] epname endpoint name to check.
- *  \param[in] trunk mgcp_trunk that might have this endpoint.
- *  \returns NULL if no ep found, else endpoint. */
+ *  \param[in] epname endpoint name to check
+ *  \param[in] trunk mgcp_trunk that might have this endpoint
+ *  \returns NULL if no ep found, else endpoint */
 struct mgcp_endpoint *mgcp_endp_find_specific(const char *epname,
 						    const struct mgcp_trunk *trunk)
 {
@@ -228,17 +260,6 @@ bool mgcp_endp_is_wildcarded(const char *epname)
 	return false;
 }
 
-/*! Check if the given epname refers to a "null" endpoint.
- *  \param[in] epname endpoint name to check
- *  \returns true if epname refers to "null"" endpoint, else false. */
-bool mgcp_endp_is_null(const char *epname)
-{
-	if (strncasecmp(epname, "null@", 5) == 0)
-		return true;
-
-	return false;
-}
-
 /*! Find an endpoint by its name on a specified trunk.
  *  \param[out] cause pointer to store cause code, can be NULL.
  *  \param[in] epname endpoint name to lookup.
@@ -654,36 +675,3 @@ void mgcp_endp_remove_conn(struct mgcp_endpoint *endp, struct mgcp_conn *conn)
 	if (llist_empty(&endp->conns))
 		mgcp_endp_release(endp);
 }
-
-/*! release endpoint, all open connections are closed.
- *  \param[in] endp endpoint to release */
-void mgcp_endp_release(struct mgcp_endpoint *endp)
-{
-	LOGPENDP(endp, DLMGCP, LOGL_DEBUG, "Releasing endpoint\n");
-
-	/* Normally this function should only be called when
-	 * all connections have been removed already. In case
-	 * that there are still connections open (e.g. when
-	 * RSIP is executed), free them all at once. */
-	mgcp_conn_free_all(endp);
-
-	/* We must only decrement the stat item when the endpoint as actually
-	 * claimed. An endpoint is claimed when a call-id is set */
-	if (endp->callid)
-		osmo_stat_item_dec(osmo_stat_item_group_get_item(endp->trunk->stats.common,
-								 TRUNK_STAT_ENDPOINTS_USED), 1);
-
-	/* Reset endpoint parameters and states */
-	talloc_free(endp->callid);
-	endp->callid = NULL;
-	talloc_free(endp->local_options.string);
-	endp->local_options.string = NULL;
-	talloc_free(endp->local_options.codec);
-	endp->local_options.codec = NULL;
-
-	if (endp->trunk->trunk_type == MGCP_TRUNK_E1) {
-		uint8_t ts = e1_ts_nr_from_epname(endp->name);
-		mgcp_e1_endp_release(endp, ts);
-	}
-}
-

src/libosmo-mgcp/mgcp_iuup.c

@@ -1,753 +0,0 @@
-/*
- * (C) 2021 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
- * All rights not specifically granted under this license are reserved.
- *
- * Author: Pau Espin Pedrol
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Affero General Public License as published by the
- * Free Software Foundation; either version 3 of the License, or (at your
- * option) any later version.
- */
-
-#include <stdint.h>
-
-#include <osmocom/core/byteswap.h>
-
-#include <osmocom/gsm/iuup.h>
-
-#include <osmocom/netif/rtp.h>
-#include <osmocom/netif/amr.h>
-
-#include <osmocom/mgcp/mgcp_conn.h>
-#include <osmocom/mgcp/mgcp_iuup.h>
-#include <osmocom/mgcp/mgcp_endp.h>
-#include <osmocom/mgcp/mgcp_codec.h>
-#include <osmocom/mgcp/mgcp_network.h>
-#include <osmocom/mgcp/debug.h>
-
-#define MGW_IUUP_MSGB_SIZE 4096
-
-static const struct osmo_iuup_rnl_config def_configure_req = {
-	.transparent = false,
-	.active = true,
-	.supported_versions_mask = 0x0003,
-	.num_rfci = 0,
-	.num_subflows = 0,
-	.IPTIs_present = false,
-	.t_init = { .t_ms = IUUP_TIMER_INIT_T_DEFAULT, .n_max = IUUP_TIMER_INIT_N_DEFAULT },
-	.t_ta = { .t_ms = IUUP_TIMER_TA_T_DEFAULT, .n_max = IUUP_TIMER_TA_N_DEFAULT },
-	.t_rc = { .t_ms = IUUP_TIMER_RC_T_DEFAULT, .n_max = IUUP_TIMER_RC_N_DEFAULT },
-};
-
-/* Find a destination connection. */
-static struct mgcp_conn *_find_dst_conn(struct mgcp_conn *conn)
-{
-	/* NOTE: This code path runs every time an RTP packet is received. The
-	 * function mgcp_find_dst_conn() we use to determine the detination
-	 * connection will iterate the connection list inside the endpoint.
-	 * Since list iterations are quite costly, we will figure out the
-	 * destination only once and use the optional private data pointer of
-	 * the connection to cache the destination connection pointer. */
-
-	struct mgcp_conn *conn_dst;
-	if (!conn->priv) {
-		conn_dst = mgcp_find_dst_conn(conn);
-		conn->priv = conn_dst;
-	} else {
-		conn_dst = (struct mgcp_conn *)conn->priv;
-	}
-	return conn_dst;
-}
-
-/* Find RFCI containing all 0 sizes, -1 if not found. irp is an Initialization.ind prim */
-static int _find_rfci_no_data(struct osmo_iuup_rnl_prim *irp)
-{
-	int i;
-	uint8_t rfci_cnt = 0;
-	/* Find RFCI containing NO_DATA: */
-	for (i = 0; i < ARRAY_SIZE(irp->u.status.u.initialization.rfci); i++) {
-		struct osmo_iuup_rfci *rfci = &irp->u.status.u.initialization.rfci[i];
-		int j;
-		bool is_no_data;
-		if (!rfci->used)
-			continue;
-		rfci_cnt++;
-
-		is_no_data = true;
-		for (j = 0; j < irp->u.status.u.initialization.num_subflows; j++) {
-			if (rfci->subflow_sizes[j]) {
-				is_no_data = false;
-				break;
-			}
-		}
-		if (is_no_data)
-			return rfci->id;
-
-		/* early loop termination: */
-		if (rfci_cnt == irp->u.status.u.initialization.num_subflows)
-			break;
-	}
-	return -1;
-}
-
-/* Lookup RFCI to use for specific AMR codec type. -1 if none found */
-static int8_t _conn_iuup_amr_ft_2_rfci(struct mgcp_conn_rtp *conn_rtp, uint8_t ft)
-{
-	int8_t i;
-	uint8_t rfci_cnt = 0;
-	unsigned match_bytes = (unsigned)osmo_amr_bytes(ft);
-	struct osmo_iuup_rnl_prim *irp = conn_rtp->iuup.init_ind;
-	if (!irp) {
-		/* No IuUP Initialization has occured on the IuUP side yet. Return error and drop the RTP data, until
-		 * the IuUP Initialization has configured the link. */
-		return -1;
-	}
-
-	/* TODO: cache this somehow */
-	for (i = 0; i < ARRAY_SIZE(irp->u.status.u.initialization.rfci); i++) {
-		struct osmo_iuup_rfci *rfci = &irp->u.status.u.initialization.rfci[i];
-		int j;
-		unsigned num_bits;
-		if (!rfci->used)
-			continue;
-		rfci_cnt++;
-
-		num_bits = 0;
-		for (j = 0; j < irp->u.status.u.initialization.num_subflows; j++)
-			num_bits += rfci->subflow_sizes[j];
-		if (match_bytes == (num_bits + 7)/8)
-			return rfci->id;
-
-		/* early loop termination: */
-		if (rfci_cnt == irp->u.status.u.initialization.num_subflows)
-			break;
-	}
-	return -1;
-}
-
-/* Helper function to configure IuUP layer FSM as Init-Passive, based on default config */
-static int _conn_iuup_configure_as_passive(struct mgcp_conn_rtp *conn_rtp)
-{
-	struct osmo_iuup_rnl_prim *irp;
-	int rc;
-
-	conn_rtp->iuup.active_init = false;
-
-	/* Tx CONFIG.req */
-	irp = osmo_iuup_rnl_prim_alloc(conn_rtp->conn, OSMO_IUUP_RNL_CONFIG, PRIM_OP_REQUEST, MGW_IUUP_MSGB_SIZE);
-	irp->u.config = def_configure_req;
-	irp->u.config.active = conn_rtp->iuup.active_init;
-	if ((rc = osmo_iuup_rnl_prim_down(conn_rtp->iuup.iui, irp)) == 0)
-		conn_rtp->iuup.configured = true;
-	else
-		LOG_CONN_RTP(conn_rtp, LOGL_ERROR, "Failed configuring IuUP layer\n");
-	return rc;
-}
-
-/* Helper function to configure IuUP layer FSM as Init-Active, based on received
- * RNL Status-Init primitive from the sister IuUP connection we will bridge to. */
-static int _conn_iuup_configure_as_active(struct mgcp_conn_rtp *conn_rtp, struct osmo_iuup_rnl_prim *init_ind)
-{
-	struct osmo_iuup_rnl_prim *irp = init_ind;
-	struct osmo_iuup_rnl_prim *irp2;
-	struct msgb *msg;
-	bool prev_output_enabled;
-	int rc;
-
-	conn_rtp->iuup.active_init = true;
-
-	/* Find RFCI containing NO_DATA: */
-	conn_rtp->iuup.rfci_id_no_data = _find_rfci_no_data(init_ind);
-
-	/* Copy over the rfci_id_no_data, since we reuse the same subflow set: */
-	msg = msgb_copy_c(conn_rtp->conn, irp->oph.msg, "iuup-init-copy");
-	conn_rtp->iuup.init_ind = (struct osmo_iuup_rnl_prim *)msgb_data(msg);
-	conn_rtp->iuup.init_ind->oph.msg = msg;
-
-	/* Tx CONFIG.req */
-	irp2 = osmo_iuup_rnl_prim_alloc(conn_rtp->conn, OSMO_IUUP_RNL_CONFIG, PRIM_OP_REQUEST, MGW_IUUP_MSGB_SIZE);
-	irp2->u.config.transparent = false;
-	irp2->u.config.active = conn_rtp->iuup.active_init;
-	irp2->u.config.data_pdu_type = irp->u.status.u.initialization.data_pdu_type;
-	irp2->u.config.supported_versions_mask = def_configure_req.supported_versions_mask;
-	irp2->u.config.num_rfci = irp->u.status.u.initialization.num_rfci;
-	irp2->u.config.num_subflows = irp->u.status.u.initialization.num_subflows;
-	irp2->u.config.IPTIs_present = irp->u.status.u.initialization.IPTIs_present;
-	memcpy(irp2->u.config.rfci, irp->u.status.u.initialization.rfci, sizeof(irp2->u.config.rfci));
-	irp2->u.config.t_init = def_configure_req.t_init;
-	irp2->u.config.t_ta = def_configure_req.t_ta;
-	irp2->u.config.t_rc = def_configure_req.t_rc;
-
-	/* We need to force allowance of RTP containing Init-ACK back: */
-	prev_output_enabled = conn_rtp->end.output_enabled;
-	conn_rtp->end.output_enabled = true;
-
-	if ((rc = osmo_iuup_rnl_prim_down(conn_rtp->iuup.iui, irp2)) == 0)
-		conn_rtp->iuup.configured = true;
-	else
-		LOG_CONN_RTP(conn_rtp, LOGL_ERROR, "Failed configuring IuUP layer\n");
-
-	conn_rtp->end.output_enabled = prev_output_enabled;
-	return rc;
-}
-
-/* Helper function to push an RTP+IuUP pkt up to the IuUP layer FSM through the
- * TNL primitive interface. */
-static int _conn_iuup_rtp_pl_up(struct mgcp_conn_rtp *conn_rtp, struct msgb *msg)
-{
-	/* Send RTP payload (IuUP) up the stack: */
-	struct osmo_iuup_tnl_prim *itp;
-	int rc;
-
-	msg->l2h = msgb_data(msg) + sizeof(struct rtp_hdr);
-
-	itp = osmo_iuup_tnl_prim_alloc(conn_rtp->conn, OSMO_IUUP_TNL_UNITDATA, PRIM_OP_INDICATION, MGW_IUUP_MSGB_SIZE);
-	itp->oph.msg->l2h = msgb_put(itp->oph.msg, msgb_l2len(msg));
-	memcpy(itp->oph.msg->l2h, msgb_l2(msg), msgb_l2len(msg));
-	if ((rc = osmo_iuup_tnl_prim_up(conn_rtp->iuup.iui, itp)) != 0) {
-		LOG_CONN_RTP(conn_rtp, LOGL_ERROR, "Failed passing IuUP-Init to IuUP layer\n");
-	}
-	return rc;
-}
-
-static int check_rtp_iuup(const struct mgcp_conn_rtp *conn_rtp, struct msgb *msg)
-{
-	size_t min_size = sizeof(struct rtp_hdr);
-	/* Check there's at least 2 bytes of RTP payload (IuUP header). This is
-	 ** mainly to avoid 0-byte payload copy cases */
-	if (msgb_length(msg) < sizeof(struct rtp_hdr) + 2) {
-		LOG_CONN_RTP(conn_rtp, LOGL_ERROR, "RTP-IuUP packet too short (%u < %zu)\n",
-			     msgb_length(msg), min_size);
-		return -1;
-	}
-	return 0;
-}
-
-/* Bridge received IuUP packet in conn_rtp_src to conn_rtp_dst, an IuUP sister
- * conn in the endpoint. The function takes ownsership of the irp */
-static int bridge_iuup_to_iuup_peer(struct mgcp_conn_rtp *conn_rtp_src, struct mgcp_conn_rtp *conn_rtp_dst, struct osmo_iuup_rnl_prim *irp)
-{
-	int rc;
-
-	/* If we are not configured and we received bridged data, it means
-	 * conn_rtp_src is already configured and INITed, and we can infer
-	 * conn_rtp_src is Init-passive (RNC side), so conn_rtp_dst needs to be
-	 * configured as INIT-active: */
-	if (!conn_rtp_dst->iuup.configured) {
-		OSMO_ASSERT(conn_rtp_src->iuup.init_ind);
-		rc = _conn_iuup_configure_as_active(conn_rtp_dst, conn_rtp_src->iuup.init_ind);
-		if (rc < 0) {
-			msgb_free(irp->oph.msg);
-			return rc;
-		}
-	}
-
-	/* We simply forward the msg, without freeing it: */
-	talloc_steal(conn_rtp_dst->conn, irp->oph.msg);
-	irp->oph.operation = PRIM_OP_REQUEST;
-	if ((rc = osmo_iuup_rnl_prim_down(conn_rtp_dst->iuup.iui, irp)) != 0)
-		LOG_CONN_RTP(conn_rtp_dst, LOGL_ERROR, "Failed Tx data down to IuUP layer\n");
-	return rc;
-}
-
-/* Bridge received IuUP packet in conn_rtp_src to conn_rtp_dst, an RTP (no IuUP)
- * sister conn in the endpoint. The function takes ownsership of the irp */
-static int bridge_iuup_to_rtp_peer(struct mgcp_conn_rtp *conn_rtp_src, struct mgcp_conn_rtp *conn_rtp_dst, struct osmo_iuup_rnl_prim *irp)
-{
-	/* FIXME: We probably need transcoding here?! Or at least look up AMR modes and translate to related RFCI */
-	uint8_t frame_nr = irp->u.data.frame_nr;
-	uint8_t fqc = irp->u.data.fqc;
-	struct msgb *msg = irp->oph.msg;
-	ssize_t amr_length = 0;
-	int ft;
-	uint8_t *amr_data;
-	struct rtp_hdr *rtp_hdr;
-	struct amr_hdr *amr_hdr;
-	int rc;
-
-	ft = osmo_amr_bytes_to_ft(msgb_l3len(msg));
-	if (ft < 0) {
-		LOGPCONN(conn_rtp_src->conn, DRTP, LOGL_ERROR,
-			 "Unknown AMR format for size %u\n", msgb_l3len(msg));
-		msgb_free(msg);
-		return ft;
-	}
-	msgb_pull_to_l3(msg);
-
-	if (mgcp_codec_amr_is_octet_aligned(conn_rtp_dst->end.codec)) {
-		LOGP(DLMGCP, LOGL_DEBUG, "Convert IuUP -> AMR OA: ft %d, len %d\n", ft, msgb_length(msg));
-		amr_hdr = (struct amr_hdr *) msgb_push(msg, sizeof(struct amr_hdr));
-		amr_hdr->cmr = 15; /* no change */
-		amr_hdr->f = 0;
-		amr_hdr->q = !fqc;
-		amr_hdr->ft = ft & 0xff;
-		amr_hdr->pad1 = 0;
-		amr_hdr->pad2 = 0;
-	} else {
-		OSMO_ASSERT(msgb_tailroom(msg) >= 2);
-		msgb_put(msg, 2);
-		osmo_amr_iuup_to_bwe(msgb_data(msg), msgb_length(msg) - 2, msgb_length(msg) + 2);
-		/* fill bwe header */
-		amr_data = msgb_data(msg);
-		/* CMR no change      | follow bit | ft (3 of 4 bits) */
-		amr_data[0] = 15 << 4 | (0 << 3) | (ft >> 1);
-		amr_data[1] |= ((ft & 0x1) << 7) | (((!fqc) & 0x1) << 6);
-		amr_length = (osmo_amr_bits(ft) + 10 + 7) / 8;
-		msgb_trim(msg, amr_length);
-		LOGP(DLMGCP, LOGL_DEBUG, "Convert IuUP -> AMR BE: ft %d, len %zd\n", ft, amr_length);
-	}
-	rtp_hdr = (struct rtp_hdr *) msgb_push(msg, sizeof(*rtp_hdr));
-	*rtp_hdr = (struct rtp_hdr){
-		.csrc_count = 0,
-		.extension = 0,
-		.padding = 0,
-		.version = 0,
-		.payload_type = conn_rtp_dst->end.codec->payload_type,
-		.marker = 0,
-		.sequence = frame_nr,
-		.timestamp = 0,
-		.ssrc = 0
-	};
-
-	rc = mgcp_send(conn_rtp_dst->conn->endp, true, NULL, msg, conn_rtp_src, conn_rtp_dst);
-	msgb_free(msg);
-	return rc;
-}
-
-/* Handle RNL Data primitive received from the IuUP layer FSM: Bridge it to the
- * sister connection in the endpoint: */
-static int _conn_iuup_rx_rnl_data(struct mgcp_conn_rtp *conn_rtp_src, struct osmo_iuup_rnl_prim *irp)
-{
-	struct mgcp_conn *conn_dst;
-	struct mgcp_conn_rtp *conn_rtp_dst;
-	int rc;
-
-	conn_dst = _find_dst_conn(conn_rtp_src->conn);
-
-	/* There is no destination conn, stop here */
-	if (!conn_dst) {
-		LOGPCONN(conn_rtp_src->conn, DRTP, LOGL_DEBUG,
-			 "no connection to forward an incoming IuUP payload to\n");
-		rc = -1;
-		goto free_ret;
-	}
-
-	/* The destination conn is not an RTP/IuUP connection */
-	if (conn_dst->type != MGCP_CONN_TYPE_RTP) {
-		LOGPCONN(conn_rtp_src->conn, DRTP, LOGL_ERROR,
-			 "unable to find suitable destination conn\n");
-		 rc = -1;
-		goto free_ret;
-	}
-	conn_rtp_dst = &conn_dst->u.rtp;
-
-	switch (conn_rtp_dst->type) {
-	case MGCP_RTP_IUUP:
-		return bridge_iuup_to_iuup_peer(conn_rtp_src, conn_rtp_dst, irp);
-	case MGCP_RTP_DEFAULT:
-		return bridge_iuup_to_rtp_peer(conn_rtp_src, conn_rtp_dst, irp);
-	case MGCP_RTP_OSMUX:
-	default:
-		LOGPCONN(conn_rtp_src->conn, DRTP, LOGL_ERROR,
-			 "Forward of IuUP payload to RTP connection type %u not supported!\n",
-			 conn_rtp_dst->type);
-		rc = 0;
-	}
-
-free_ret:
-	msgb_free(irp->oph.msg);
-	return rc;
-}
-
-/* Handle RNL Status-Init primitive received from the IuUP layer FSM.
- * Potentially configure sister conn as IuUP Init-Active: */
-static int _conn_iuup_rx_rnl_status_init(struct mgcp_conn_rtp *conn_rtp_src, struct osmo_iuup_rnl_prim *irp)
-{
-	struct mgcp_conn *conn_dst;
-	struct mgcp_conn_rtp *conn_rtp_dst;
-	int rc = 0;
-	struct msgb *msg;
-
-	if (conn_rtp_src->iuup.init_ind) {
-		/* We received more than one IuUP Initialization. It's probably
-		 * a retransmission, so simply ignore it (lower layers take care
-		 * of ACKing it). */
-		LOGPCONN(conn_rtp_src->conn, DRTP, LOGL_INFO,
-		  "Ignoring potential IuUP Initialization retrans\n");
-		return 0;
-	}
-
-	msg = msgb_copy_c(conn_rtp_src->conn, irp->oph.msg, "iuup-init-copy");
-	conn_rtp_src->iuup.init_ind = (struct osmo_iuup_rnl_prim *)msgb_data(msg);
-	conn_rtp_src->iuup.init_ind->oph.msg = msg;
-
-	/* Find RFCI containing NO_DATA: */
-	conn_rtp_src->iuup.rfci_id_no_data = _find_rfci_no_data(irp);
-
-	conn_dst = _find_dst_conn(conn_rtp_src->conn);
-	/* If not yet there, peer will potentially be IuUP-Initialized later
-	 * when we attempt to bridge audio towards it. See bridge_iuup_to_iuup_peer() */
-	if (!conn_dst)
-		return 0;
-	conn_rtp_dst = &conn_dst->u.rtp;
-	if (!mgcp_conn_rtp_is_iuup(conn_rtp_dst))
-		return 0; /* Nothing to do */
-
-	/* We received IuUP parameters on the peer (RNC), Init actively this conn (against CN): */
-	if (!conn_rtp_dst->iuup.configured)
-		rc = _conn_iuup_configure_as_active(conn_rtp_dst, irp);
-
-	return rc;
-}
-
-/* Handle RNL Status primitives received from the IuUP layer FSM: */
-static int _conn_iuup_rx_rnl_status(struct mgcp_conn_rtp *conn_rtp_src, struct osmo_iuup_rnl_prim *irp)
-{
-	int rc;
-
-	switch (irp->u.status.procedure) {
-	case IUUP_PROC_INIT:
-		rc = _conn_iuup_rx_rnl_status_init(conn_rtp_src, irp);
-		break;
-	case IUUP_PROC_RATE_CTRL:
-	case IUUP_PROC_TIME_ALIGN:
-	case IUUP_PROC_ERR_EVENT:
-	default:
-		LOG_CONN_RTP(conn_rtp_src, LOGL_ERROR,
-			     "Received IuUP RNL STATUS procedure type %u not handled\n",
-			     irp->u.status.procedure);
-		rc = 0;
-	}
-
-	return rc;
-}
-
-/* Received RNL primitive from the IuUP layer FSM containing IuUP Status or
- * data. Continue pushing it up the stack, either IuUP Status or Data: */
-static int _conn_iuup_user_prim_cb(struct osmo_prim_hdr *oph, void *ctx)
-{
-	struct mgcp_conn_rtp *conn_rtp_src = ctx;
-	struct osmo_iuup_rnl_prim *irp = (struct osmo_iuup_rnl_prim *)oph;
-	struct msgb *msg = oph->msg;
-	int rc;
-
-	switch (OSMO_PRIM_HDR(&irp->oph)) {
-	case OSMO_PRIM(OSMO_IUUP_RNL_DATA, PRIM_OP_INDICATION):
-		/* we pass ownsership of msg here: */
-		rc = _conn_iuup_rx_rnl_data(conn_rtp_src, irp);
-		break;
-	case OSMO_PRIM(OSMO_IUUP_RNL_STATUS, PRIM_OP_INDICATION):
-		rc = _conn_iuup_rx_rnl_status(conn_rtp_src, irp);
-		msgb_free(msg);
-		break;
-	default:
-		msgb_free(msg);
-		OSMO_ASSERT(false);
-	}
-
-	return rc;
-}
-
-/*! Send |RTP+IuUP| data down the stack of the specified destination connection.
- *  \param[in] endp associated endpoint (for configuration, logging).
- *  \param[in] buf buffer that contains the |RTP+IuUP| data.
- *  \param[in] len length of the buffer that contains the |RTP+IuUP| data.
- *  \param[in] conn_src associated source connection.
- *  \param[in] conn_dst associated destination connection.
- *  \returns 0 on success, -1 on ERROR. */
-static int mgcp_send_iuup(struct mgcp_endpoint *endp, struct msgb *msg,
-		   struct mgcp_conn_rtp *conn_src, struct mgcp_conn_rtp *conn_dst)
-{
-	/*! When no destination connection is available (e.g. when only one
-	 *  connection in loopback mode exists), then the source connection
-	 *  shall be specified as destination connection */
-
-	struct mgcp_rtp_end *rtp_end;
-	struct mgcp_rtp_state *rtp_state;
-	char ipbuf[INET6_ADDRSTRLEN];
-	struct rtp_hdr *hdr = (struct rtp_hdr *)msgb_data(msg);
-	int buflen = msgb_length(msg);
-	char *dest_name;
-	int len;
-
-	OSMO_ASSERT(conn_src);
-	OSMO_ASSERT(conn_dst);
-
-	LOGPENDP(endp, DRTP, LOGL_DEBUG, "delivering IuUP packet...\n");
-
-	/* Note: In case of loopback configuration, both, the source and the
-	 * destination will point to the same connection. */
-	rtp_end = &conn_dst->end;
-	rtp_state = &conn_src->state;
-	dest_name = conn_dst->conn->name;
-
-	/* Ensure we have an alternative SSRC in case we need it, see also
-	 * gen_rtp_header() */
-	if (rtp_state->alt_rtp_tx_ssrc == 0)
-		rtp_state->alt_rtp_tx_ssrc = rand();
-
-	if (!rtp_end->output_enabled) {
-		rtpconn_rate_ctr_add(conn_dst, endp, RTP_DROPPED_PACKETS_CTR, 1);
-		LOGPENDP(endp, DRTP, LOGL_DEBUG,
-			 "output disabled, drop to %s %s "
-			 "rtp_port:%u rtcp_port:%u\n",
-			 dest_name,
-			 osmo_sockaddr_ntop(&rtp_end->addr.u.sa, ipbuf),
-			 osmo_sockaddr_port(&rtp_end->addr.u.sa), ntohs(rtp_end->rtcp_port)
-			);
-		return 0;
-	}
-
-	/* Specs say, in IuUP, the RTP seqnum and timestamp should actually be
-	 * ignored by the receiver, but still it's useful for debug purposes
-	 * to set it. Moreover, it seems ip.access nano3g produces much worse
-	 * audio output on the air side if timestamp is not set properly. */
-	hdr->timestamp = osmo_htonl(mgcp_get_current_ts(rtp_end->codec->rate));
-	hdr->sequence = osmo_htons(rtp_state->alt_rtp_tx_sequence);
-	hdr->ssrc = rtp_state->alt_rtp_tx_ssrc;
-
-	LOGPENDP(endp, DRTP, LOGL_DEBUG,
-		 "process/send IuUP to %s %s rtp_port:%u rtcp_port:%u\n",
-		 dest_name, osmo_sockaddr_ntop(&rtp_end->addr.u.sa, ipbuf),
-		 osmo_sockaddr_port(&rtp_end->addr.u.sa), ntohs(rtp_end->rtcp_port));
-
-	/* Forward a copy of the RTP data to a debug ip/port */
-	forward_data_tap(rtp_end->rtp.fd, &conn_src->tap_out,
-		     msg);
-
-	len = mgcp_udp_send(rtp_end->rtp.fd, &rtp_end->addr, (char *)hdr, buflen);
-
-	if (len <= 0)
-		return len;
-
-	rtpconn_rate_ctr_add(conn_dst, endp, RTP_PACKETS_TX_CTR, 1);
-	rtpconn_rate_ctr_add(conn_dst, endp, RTP_OCTETS_TX_CTR, len);
-	rtp_state->alt_rtp_tx_sequence++;
-
-	return len;
-}
-
-/* Received TNL primitive from IuUP layer FSM, transmit it further down to the
- * socket towards destination peer. */
-static int _conn_iuup_transport_prim_cb(struct osmo_prim_hdr *oph, void *ctx)
-{
-	struct mgcp_conn_rtp *conn_rtp_dst = ctx;
-	struct mgcp_conn *conn_dst = conn_rtp_dst->conn;
-	struct osmo_iuup_tnl_prim *itp = (struct osmo_iuup_tnl_prim *)oph;
-	struct mgcp_conn *conn_src;
-	struct msgb *msg;
-	struct rtp_hdr *rtph;
-
-	OSMO_ASSERT(OSMO_PRIM_HDR(&itp->oph) == OSMO_PRIM(OSMO_IUUP_TNL_UNITDATA, PRIM_OP_REQUEST));
-
-	msg = oph->msg;
-	talloc_steal(conn_rtp_dst->conn, msg);
-
-	msgb_pull_to_l2(msg);
-	rtph = (struct rtp_hdr *)msgb_push(msg, sizeof(*rtph));
-	/* TODO: fill rtph properly: */
-	*rtph = (struct rtp_hdr){
-		.csrc_count = 0,
-		.extension = 0,
-		.padding = 0,
-		.version = 2,
-		.payload_type = conn_rtp_dst->end.codec->payload_type,
-		.marker = 0,
-		.sequence = 0,
-		.timestamp = 0,
-		.ssrc = 0
-	};
-
-	/* The destination of the destination conn is the source conn, right? */
-	conn_src = _find_dst_conn(conn_dst);
-	if (!conn_src) {
-		LOG_CONN_RTP(conn_rtp_dst, LOGL_NOTICE,
-			     "Couldn't find source conn for IuUP dst conn\n");
-		/* If there's no sister connection we are either still
-		 * initializing (so we want to send back Init (ACK)), or we are
-		 * probably in loopback mode anyway, so use dst as src. */
-		conn_src = conn_dst;
-	}
-
-	return mgcp_send_iuup(conn_dst->endp, msg, &conn_src->u.rtp, conn_rtp_dst);
-}
-
-/* Used to upgrade a regular RTP connection (MGCP_RTP_DEFAULT) to become a IuUP
- * connection (MGCP_RTP_IUUP) */
-int mgcp_conn_iuup_init(struct mgcp_conn_rtp *conn_rtp)
-{
-	conn_rtp->type = MGCP_RTP_IUUP;
-	conn_rtp->iuup.iui = osmo_iuup_instance_alloc(conn_rtp->conn, conn_rtp->conn->id);
-	OSMO_ASSERT(conn_rtp->iuup.iui);
-	osmo_iuup_instance_set_user_prim_cb(conn_rtp->iuup.iui, _conn_iuup_user_prim_cb, conn_rtp);
-	osmo_iuup_instance_set_transport_prim_cb(conn_rtp->iuup.iui, _conn_iuup_transport_prim_cb, conn_rtp);
-	conn_rtp->iuup.rfci_id_no_data = -1;
-	return 0;
-}
-
-/* Cleanup specific IuUP connection (MGCP_RTP_IUUP) state, allocated by mgcp_conn_iuup_init() */
-void mgcp_conn_iuup_cleanup(struct mgcp_conn_rtp *conn_rtp)
-{
-	osmo_iuup_instance_free(conn_rtp->iuup.iui);
-	conn_rtp->iuup.iui = NULL;
-}
-
-/* Received RTP+IuUP pkt from socket of conn_rtp_src, build a TNL primitive to
- * push it further up the stack to the IuUP layer FSM to handle and/or bridge it */
-int mgcp_conn_iuup_dispatch_rtp(struct msgb *msg)
-{
-	struct osmo_rtp_msg_ctx *mc = OSMO_RTP_MSG_CTX(msg);
-	struct mgcp_conn_rtp *conn_rtp_src = mc->conn_src;
-	int rc = 0;
-	bool force_output_enabled = false;
-	bool prev_output_enabled;
-	struct osmo_sockaddr prev_rem_addr;
-	uint16_t prev_rem_rtp_port;
-
-	OSMO_ASSERT(mgcp_conn_rtp_is_iuup(conn_rtp_src));
-
-	if ((rc = check_rtp_iuup(conn_rtp_src, msg)) < 0)
-		goto free_ret;
-
-	if (!conn_rtp_src->iuup.configured) {
-		/* We received the first message without sending any, the peer is the active side (RNC). */
-		rc = _conn_iuup_configure_as_passive(conn_rtp_src);
-		if (rc < 0)
-			goto free_ret;
-		/* We need to force allowance of RTP containing Init-ACK back: */
-		prev_output_enabled = conn_rtp_src->end.output_enabled;
-		conn_rtp_src->end.output_enabled = true;
-		force_output_enabled = true;
-		/* Fill in the peer address so that we can send Init-ACK back: */
-		prev_rem_addr = conn_rtp_src->end.addr;
-		prev_rem_rtp_port = osmo_sockaddr_port(&conn_rtp_src->end.addr.u.sa);
-		conn_rtp_src->end.addr = *mc->from_addr;
-	}
-
-	rc = _conn_iuup_rtp_pl_up(conn_rtp_src, msg);
-
-	if (force_output_enabled) {
-		conn_rtp_src->end.output_enabled = prev_output_enabled;
-		conn_rtp_src->end.addr = prev_rem_addr;
-		osmo_sockaddr_set_port(&conn_rtp_src->end.addr.u.sa, prev_rem_rtp_port);
-	}
-
-	return rc;
-free_ret:
-	msgb_free(msg);
-	return rc;
-}
-
-/* Build IuUP RNL Data primitive from msg containing an incoming RTP pkt from
- * peer and send it down the IuUP layer towards the destination as IuUP/RTP: */
-int mgcp_conn_iuup_send_rtp(struct mgcp_conn_rtp *conn_src_rtp, struct mgcp_conn_rtp *conn_dest_rtp, struct msgb *msg)
-{
-	struct osmo_iuup_rnl_prim *irp;
-	struct rtp_hdr *rtph;
-	int rc = -1;
-	int iuup_length = 0;
-	int8_t rfci;
-
-	/* Tx RNL-DATA.req */
-	rtph = (struct rtp_hdr *)msgb_data(msg);
-	msgb_pull(msg, sizeof(*rtph));
-
-	/* FIXME: validate amr packets */
-	irp = osmo_iuup_rnl_prim_alloc(conn_dest_rtp->conn, OSMO_IUUP_RNL_DATA, PRIM_OP_REQUEST, MGW_IUUP_MSGB_SIZE);
-	irp->u.data.frame_nr = htons(rtph->sequence) % 16;
-
-	/* TODO: CMR handling & multiple frames handling */
-
-	if (strcmp(conn_src_rtp->end.codec->subtype_name, "AMR") != 0) {
-		LOG_CONN_RTP(conn_src_rtp, LOGL_ERROR,
-			     "Bridge RTP=>IuUP: Bridging src codec %s to IuUP AMR not supported\n",
-			     conn_src_rtp->end.codec->subtype_name);
-		goto free_ret;
-	}
-	if (mgcp_codec_amr_is_octet_aligned(conn_src_rtp->end.codec)) {
-		struct amr_hdr *amr_hdr = (struct amr_hdr *) msgb_data(msg);
-		if (msgb_length(msg) < (sizeof(*amr_hdr))) {
-			LOG_CONN_RTP(conn_src_rtp, LOGL_NOTICE,
-				     "Bridge RTP=>IuUP: too short for AMR OA hdr (%u)\n", msgb_length(msg));
-			goto free_ret;
-		}
-		if (!osmo_amr_ft_valid(amr_hdr->ft)) {
-			LOG_CONN_RTP(conn_src_rtp, LOGL_NOTICE, "Bridge RTP=>IuUP: wrong AMR OA ft=%u\n", amr_hdr->ft);
-			goto free_ret;
-		}
-		if ((rfci =  _conn_iuup_amr_ft_2_rfci(conn_dest_rtp, amr_hdr->ft)) < 0) {
-			LOG_CONN_RTP(conn_dest_rtp, LOGL_NOTICE, "Bridge RTP=>IuUP: No RFCI found for AMR OA ft=%u\n", amr_hdr->ft);
-			goto free_ret;
-		}
-		irp->u.data.fqc = amr_hdr->q ? IUUP_FQC_FRAME_GOOD : IUUP_FQC_FRAME_BAD;
-		irp->u.data.rfci = rfci;
-		msgb_pull(msg, 2);
-		LOGP(DLMGCP, LOGL_DEBUG, "Convert AMR OA -> IuUP: ft %d -> rfci %d len %d\n",
-		     amr_hdr->ft, rfci, msgb_length(msg));
-	} else {
-		uint8_t *amr_bwe_hdr = (uint8_t *) msgb_data(msg);
-		int8_t ft;
-		uint8_t q;
-		if (msgb_length(msg) < 2) {
-			LOG_CONN_RTP(conn_src_rtp, LOGL_NOTICE,
-				     "Bridge RTP=>IuUP: too short for AMR BE hdr (%u)\n", msgb_length(msg));
-			goto free_ret;
-		}
-		ft = ((amr_bwe_hdr[0] & 0x07) << 1) | ((amr_bwe_hdr[1] & 0x80) >> 7);
-		if (!osmo_amr_ft_valid(ft)) {
-			LOG_CONN_RTP(conn_src_rtp, LOGL_NOTICE, "Bridge RTP=>IuUP: wrong AMR BE ft=%u\n", ft);
-			goto free_ret;
-		}
-		if ((rfci =  _conn_iuup_amr_ft_2_rfci(conn_dest_rtp, ft)) < 0) {
-			LOG_CONN_RTP(conn_dest_rtp, LOGL_NOTICE, "Bridge RTP=>IuUP: No RFCI found for AMR BE ft=%u\n", ft);
-			goto free_ret;
-		}
-		q = amr_bwe_hdr[1] & 0x40;
-		irp->u.data.fqc = q ? IUUP_FQC_FRAME_GOOD : IUUP_FQC_FRAME_BAD;
-		irp->u.data.rfci = rfci;
-		rc = iuup_length = osmo_amr_bwe_to_iuup(msgb_data(msg), msgb_length(msg));
-		if (rc < 0) {
-			LOG_CONN_RTP(conn_dest_rtp, LOGL_ERROR, "Bridge RTP=>IuUP: Failed convert the RTP/AMR to IuUP payload\n");
-			return rc;
-		}
-		msgb_trim(msg, iuup_length);
-		LOGP(DLMGCP, LOGL_DEBUG, "Convert AMR BE -> IuUP: ft %d -> rfci %d len %d\n",
-		     ft, rfci, msgb_length(msg));
-	}
-
-	irp->oph.msg->l3h = msgb_put(irp->oph.msg, msgb_length(msg));
-	memcpy(irp->oph.msg->l3h, msgb_data(msg), msgb_length(msg));
-	if ((rc = osmo_iuup_rnl_prim_down(conn_dest_rtp->iuup.iui, irp)) != 0)
-		LOG_CONN_RTP(conn_dest_rtp, LOGL_ERROR, "Bridge RTP=>IuUP: Failed Tx RTP payload down the IuUP layer\n");
-	return rc;
-
-free_ret:
-	msgb_free(irp->oph.msg);
-	return -1;
-}
-
-/* Build IuUP RNL Data primitive from msg containing dummy content and send it
- * down the IuUP layer towards the destination as IuUP/RTP: */
-int mgcp_conn_iuup_send_dummy(struct mgcp_conn_rtp *conn_rtp)
-{
-	struct osmo_iuup_rnl_prim *irp;
-	int rc;
-
-	if (conn_rtp->iuup.rfci_id_no_data == -1) {
-		LOG_CONN_RTP(conn_rtp, LOGL_NOTICE, "No RFCI NO_DATA found, unable to send dummy packet\n");
-		return -ENOTSUP;
-	}
-
-	irp = osmo_iuup_rnl_prim_alloc(conn_rtp->conn, OSMO_IUUP_RNL_DATA, PRIM_OP_REQUEST, MGW_IUUP_MSGB_SIZE);
-	irp->u.data.frame_nr = 0;
-	irp->u.data.fqc = IUUP_FQC_FRAME_GOOD;
-	irp->u.data.rfci = conn_rtp->iuup.rfci_id_no_data;
-	irp->oph.msg->l3h = irp->oph.msg->tail;
-	if ((rc = osmo_iuup_rnl_prim_down(conn_rtp->iuup.iui, irp)) != 0) {
-		LOG_CONN_RTP(conn_rtp, LOGL_ERROR, "Failed Tx RTP dummy payload down the IuUP layer\n");
-		return -EINVAL;
-	}
-
-	return 0;
-}

src/libosmo-mgcp/mgcp_msg.c

@@ -75,7 +75,7 @@ void mgcp_disp_msg(unsigned char *message, unsigned int len, char *preamble)
 }
 
 /*! Parse connection mode.
- *  \param[in] mode as string (recvonly, sendrecv, sendonly confecho or loopback)
+ *  \param[in] mode as string (recvonly, sendrecv, sendonly or loopback)
  *  \param[in] endp pointer to endpoint (only used for log output)
  *  \param[out] associated connection to be modified accordingly
  *  \returns 0 on success, -1 on error */
@@ -100,8 +100,6 @@ int mgcp_parse_conn_mode(const char *mode, struct mgcp_endpoint *endp,
 		conn->mode = MGCP_CONN_RECV_SEND;
 	else if (strcasecmp(mode, "sendonly") == 0)
 		conn->mode = MGCP_CONN_SEND_ONLY;
-	else if (strcasecmp(mode, "confecho") == 0)
-		conn->mode = MGCP_CONN_CONFECHO;
 	else if (strcasecmp(mode, "loopback") == 0)
 		conn->mode = MGCP_CONN_LOOPBACK;
 	else {
@@ -112,7 +110,8 @@ int mgcp_parse_conn_mode(const char *mode, struct mgcp_endpoint *endp,
 
 	/* Special handling for RTP connections */
 	if (conn->type == MGCP_CONN_TYPE_RTP) {
-		conn->u.rtp.end.output_enabled = !!(conn->mode & MGCP_CONN_SEND_ONLY);
+		conn->u.rtp.end.output_enabled =
+		    conn->mode & MGCP_CONN_SEND_ONLY ? 1 : 0;
 	}
 
 	LOGPENDP(endp, DLMGCP, LOGL_DEBUG, "conn:%s\n", mgcp_conn_dump(conn));
@@ -122,7 +121,7 @@ int mgcp_parse_conn_mode(const char *mode, struct mgcp_endpoint *endp,
 
 	/* Special handling für RTP connections */
 	if (conn->type == MGCP_CONN_TYPE_RTP) {
-		LOGPCONN(conn, DLMGCP, LOGL_DEBUG, "output_enabled %u\n",
+		LOGPCONN(conn, DLMGCP, LOGL_DEBUG, "output_enabled %d\n",
 			 conn->u.rtp.end.output_enabled);
 	}
 
@@ -204,7 +203,7 @@ int mgcp_parse_osmux_cid(const char *line)
 		     osmux_cid, OSMUX_CID_MAX);
 		return -2;
 	}
-	LOGP(DLMGCP, LOGL_DEBUG, "MGCP client offered Osmux CID %u\n", osmux_cid);
+	LOGP(DLMGCP, LOGL_DEBUG, "bsc-nat offered Osmux CID %u\n", osmux_cid);
 
 	return osmux_cid;
 }

src/libosmo-mgcp/mgcp_network.c

@@ -48,16 +48,21 @@
 #include <osmocom/mgcp/debug.h>
 #include <osmocom/codec/codec.h>
 #include <osmocom/mgcp/mgcp_e1.h>
-#include <osmocom/mgcp/mgcp_iuup.h>
+
 
 #define RTP_SEQ_MOD		(1 << 16)
 #define RTP_MAX_DROPOUT		3000
 #define RTP_MAX_MISORDER	100
 
-void rtpconn_rate_ctr_add(struct mgcp_conn_rtp *conn_rtp, struct mgcp_endpoint *endp,
+enum rtp_proto {
+	MGCP_PROTO_RTP,
+	MGCP_PROTO_RTCP,
+};
+
+static void rtpconn_rate_ctr_add(struct mgcp_conn_rtp *conn_rtp, struct mgcp_endpoint *endp,
 				 int id, int inc)
 {
-	struct rate_ctr_group *conn_stats = conn_rtp->ctrg;
+	struct rate_ctr_group *conn_stats = conn_rtp->rate_ctr_group;
 	struct rate_ctr_group *mgw_stats = endp->trunk->ratectr.all_rtp_conn_stats;
 
 	/* add to both the per-connection and the global stats */
@@ -65,68 +70,49 @@ void rtpconn_rate_ctr_add(struct mgcp_conn_rtp *conn_rtp, struct mgcp_endpoint *
 	rate_ctr_add(rate_ctr_group_get_ctr(mgw_stats, id), inc);
 }
 
-void rtpconn_rate_ctr_inc(struct mgcp_conn_rtp *conn_rtp, struct mgcp_endpoint *endp, int id)
+static void rtpconn_rate_ctr_inc(struct mgcp_conn_rtp *conn_rtp, struct mgcp_endpoint *endp, int id)
 {
 	rtpconn_rate_ctr_add(conn_rtp, endp, id, 1);
 }
 
 static int rx_rtp(struct msgb *msg);
 
+static bool addr_is_any(const struct osmo_sockaddr *osa)
+{
+	if (osa->u.sa.sa_family == AF_INET6) {
+		struct in6_addr ip6_any = IN6ADDR_ANY_INIT;
+		return memcmp(&osa->u.sin6.sin6_addr,
+				   &ip6_any, sizeof(ip6_any)) == 0;
+	} else {
+		return osa->u.sin.sin_addr.s_addr == 0;
+	}
+}
+
 bool mgcp_rtp_end_remote_addr_available(const struct mgcp_rtp_end *rtp_end)
 {
-	return (osmo_sockaddr_port(&rtp_end->addr.u.sa) != 0) &&
-	       (osmo_sockaddr_is_any(&rtp_end->addr) == 0);
+	return rtp_end->rtp_port && !addr_is_any(&rtp_end->addr);
 }
 
 /*! Determine the local rtp bind IP-address.
  *  \param[out] addr caller provided memory to store the resulting IP-Address.
  *  \param[in] endp mgcp endpoint, that holds a copy of the VTY parameters.
- * \ returns 0 on success, -1 if no local address could be provided.
  *
  *  The local bind IP-address is automatically selected by probing the
  *  IP-Address of the interface that is pointing towards the remote IP-Address,
  *  if no remote IP-Address is known yet, the statically configured
  *  IP-Addresses are used as fallback. */
-int mgcp_get_local_addr(char *addr, struct mgcp_conn_rtp *conn)
+void mgcp_get_local_addr(char *addr, struct mgcp_conn_rtp *conn)
 {
-	const struct mgcp_endpoint *endp = conn->conn->endp;
-	const struct mgcp_config *cfg = endp->trunk->cfg;
+
+	struct mgcp_endpoint *endp;
 	char ipbuf[INET6_ADDRSTRLEN];
 	int rc;
-	bool rem_addr_set = osmo_sockaddr_is_any(&conn->end.addr) == 0;
-	const char *bind_addr;
-
-	/* Osmux: No smart IP addresses allocation is supported yet. Simply
-	 * return the one set in VTY config: */
-	if (mgcp_conn_rtp_is_osmux(conn)) {
-		if (rem_addr_set) {
-			/* Match IP version with what was requested from remote: */
-			bind_addr = conn->end.addr.u.sa.sa_family == AF_INET6 ?
-				    cfg->osmux.local_addr_v6 :
-				    cfg->osmux.local_addr_v4;
-		} else {
-			/* Choose any of the bind addresses, preferring v6 over v4 if available: */
-			bind_addr = cfg->osmux.local_addr_v6;
-			if (!bind_addr)
-				bind_addr = cfg->osmux.local_addr_v4;
-		}
-		if (!bind_addr) {
-			LOGPCONN(conn->conn, DOSMUX, LOGL_ERROR,
-				"Unable to locate local Osmux address, check your configuration! v4=%u v6=%u remote_known=%s\n",
-				!!cfg->osmux.local_addr_v4,
-				!!cfg->osmux.local_addr_v6,
-				rem_addr_set ? osmo_sockaddr_ntop(&conn->end.addr.u.sa, ipbuf) : "no");
-			return -1;
-		}
-		LOGPCONN(conn->conn, DOSMUX, LOGL_DEBUG,
-			 "Using configured osmux bind ip as local bind ip %s\n",
-			 bind_addr);
-		osmo_strlcpy(addr, bind_addr, INET6_ADDRSTRLEN);
-		return 0;
-	}
+	endp = conn->conn->endp;
+	bool rem_addr_set = !addr_is_any(&conn->end.addr);
+	char *bind_addr;
 
 	/* Try probing the local IP-Address */
-	if (cfg->net_ports.bind_addr_probe && rem_addr_set) {
+	if (endp->trunk->cfg->net_ports.bind_addr_probe && rem_addr_set) {
 		rc = osmo_sock_local_ip(addr, osmo_sockaddr_ntop(&conn->end.addr.u.sa, ipbuf));
 		if (rc < 0)
 			LOGPCONN(conn->conn, DRTP, LOGL_ERROR,
@@ -135,22 +121,22 @@ int mgcp_get_local_addr(char *addr, struct mgcp_conn_rtp *conn)
 			LOGPCONN(conn->conn, DRTP, LOGL_DEBUG,
 				 "selected local rtp bind ip %s by probing using remote ip %s\n",
 				 addr, osmo_sockaddr_ntop(&conn->end.addr.u.sa, ipbuf));
-			return 0;
+			return;
 		}
 	}
 
-	/* Select from preconfigured IP-Addresses. */
+	/* Select from preconfigured IP-Addresses. We don't have bind_addr for Osmux (yet?). */
 	if (rem_addr_set) {
 		/* Check there is a bind IP for the RTP traffic configured,
 		 * if so, use that IP-Address */
 		bind_addr = conn->end.addr.u.sa.sa_family == AF_INET6 ?
-				cfg->net_ports.bind_addr_v6 :
-				cfg->net_ports.bind_addr_v4;
+				endp->trunk->cfg->net_ports.bind_addr_v6 :
+				endp->trunk->cfg->net_ports.bind_addr_v4;
 	} else {
 		/* Choose any of the bind addresses, preferring v6 over v4 */
-		bind_addr = cfg->net_ports.bind_addr_v6;
+		bind_addr = endp->trunk->cfg->net_ports.bind_addr_v6;
 		if (!strlen(bind_addr))
-			bind_addr = cfg->net_ports.bind_addr_v4;
+			bind_addr = endp->trunk->cfg->net_ports.bind_addr_v4;
 	}
 	if (strlen(bind_addr)) {
 		LOGPCONN(conn->conn, DRTP, LOGL_DEBUG,
@@ -160,18 +146,17 @@ int mgcp_get_local_addr(char *addr, struct mgcp_conn_rtp *conn)
 		/* No specific bind IP is configured for the RTP traffic, so
 		 * assume the IP where we listen for incoming MGCP messages
 		 * as bind IP */
-		bind_addr = cfg->source_addr;
+		bind_addr = endp->trunk->cfg->source_addr;
 		LOGPCONN(conn->conn, DRTP, LOGL_DEBUG,
 			"using mgcp bind ip as local rtp bind ip: %s\n", bind_addr);
 	}
 	osmo_strlcpy(addr, bind_addr, INET6_ADDRSTRLEN);
-	return 0;
 }
 
 /* This does not need to be a precision timestamp and
  * is allowed to wrap quite fast. The returned value is
  * 1/codec_rate seconds. */
-uint32_t mgcp_get_current_ts(unsigned codec_rate)
+static uint32_t get_current_ts(unsigned codec_rate)
 {
 	struct timespec tp;
 	uint64_t ret;
@@ -492,24 +477,28 @@ void mgcp_rtp_annex_count(const struct mgcp_endpoint *endp,
 
 /* There may be different payload type numbers negotiated for two connections.
  * Patch the payload type of an RTP packet so that it uses the payload type
- * of the codec that is set for the destination connection (conn_dst) */
-static int mgcp_patch_pt(struct mgcp_conn_rtp *conn_dst, struct msgb *msg)
+ * that is valid for the destination connection (conn_dst) */
+static int mgcp_patch_pt(struct mgcp_conn_rtp *conn_src,
+			 struct mgcp_conn_rtp *conn_dst, struct msgb *msg)
 {
 	struct rtp_hdr *rtp_hdr;
+	uint8_t pt_in;
+	int pt_out;
 
 	if (msgb_length(msg) < sizeof(struct rtp_hdr)) {
-		LOG_CONN_RTP(conn_dst, LOGL_NOTICE, "RTP packet too short (%u < %zu)\n",
+		LOG_CONN_RTP(conn_src, LOGL_ERROR, "RTP packet too short (%u < %zu)\n",
 			     msgb_length(msg), sizeof(struct rtp_hdr));
 		return -EINVAL;
 	}
+
 	rtp_hdr = (struct rtp_hdr *)msgb_data(msg);
 
-	if (!conn_dst->end.codec) {
-		LOG_CONN_RTP(conn_dst, LOGL_NOTICE, "no codec set on destination connection!\n");
+	pt_in = rtp_hdr->payload_type;
+	pt_out = mgcp_codec_pt_translate(conn_src, conn_dst, pt_in);
+	if (pt_out < 0)
 		return -EINVAL;
-	}
-	rtp_hdr->payload_type = (uint8_t) conn_dst->end.codec->payload_type;
 
+	rtp_hdr->payload_type = (uint8_t) pt_out;
 	return 0;
 }
 
@@ -540,7 +529,7 @@ void mgcp_patch_and_count(const struct mgcp_endpoint *endp,
 	rtp_hdr = (struct rtp_hdr *)msgb_data(msg);
 	seq = ntohs(rtp_hdr->sequence);
 	timestamp = ntohl(rtp_hdr->timestamp);
-	arrival_time = mgcp_get_current_ts(rtp_end->codec->rate);
+	arrival_time = get_current_ts(rtp_end->codec->rate);
 	ssrc = ntohl(rtp_hdr->ssrc);
 	marker_bit = !!rtp_hdr->marker;
 	transit = arrival_time - timestamp;
@@ -687,7 +676,7 @@ static int rfc5993_hr_convert(struct mgcp_endpoint *endp, struct msgb *msg)
 {
 	struct rtp_hdr *rtp_hdr;
 	if (msgb_length(msg) < sizeof(struct rtp_hdr)) {
-		LOGPENDP(endp, DRTP, LOGL_ERROR, "RTP packet too short (%d < %zu)\n",
+		LOGPENDP(endp, DRTP, LOGL_ERROR, "AMR RTP packet too short (%d < %zu)\n",
 			 msgb_length(msg), sizeof(struct rtp_hdr));
 		return -EINVAL;
 	}
@@ -713,18 +702,11 @@ static int rfc5993_hr_convert(struct mgcp_endpoint *endp, struct msgb *msg)
 	return 0;
 }
 
-/*! Convert msg to AMR RTP framing mode specified by target_is_oa.
- *  \param[in] endp MGCP Endpoint where this message belongs to (used for logging purposes)
- *  \param[in] msg Message containing an AMR RTP payload (in octet-aligned or bandwidth-efficient format).
- *  \param[in] target_is_oa the target framing mode that msg will contain after this function succeeds.
- *  \returns The size of the new RTP AMR content on success, negative on error.
- *
- * For AMR RTP two framing modes are defined RFC3267. There is a bandwidth
+/* For AMR RTP two framing modes are defined RFC3267. There is a bandwith
  * efficient encoding scheme where all fields are packed together one after
  * another and an octet aligned mode where all fields are aligned to octet
- * boundaries. This function is used to convert between the two modes.
- */
-int amr_oa_bwe_convert(struct mgcp_endpoint *endp, struct msgb *msg,
+ * boundaries. This function is used to convert between the two modes */
+static int amr_oa_bwe_convert(struct mgcp_endpoint *endp, struct msgb *msg,
 			      bool target_is_oa)
 {
 	/* NOTE: the msgb has an allocated length of RTP_BUF_SIZE, so there is
@@ -733,7 +715,6 @@ int amr_oa_bwe_convert(struct mgcp_endpoint *endp, struct msgb *msg,
 	struct rtp_hdr *rtp_hdr;
 	unsigned int payload_len;
 	int rc;
-	bool orig_is_oa;
 
 	if (msgb_length(msg) < sizeof(struct rtp_hdr)) {
 		LOGPENDP(endp, DRTP, LOGL_ERROR, "AMR RTP packet too short (%d < %zu)\n", msgb_length(msg), sizeof(struct rtp_hdr));
@@ -741,10 +722,10 @@ int amr_oa_bwe_convert(struct mgcp_endpoint *endp, struct msgb *msg,
 	}
 
 	rtp_hdr = (struct rtp_hdr *)msgb_data(msg);
-	payload_len = msgb_length(msg) - sizeof(struct rtp_hdr);
-	orig_is_oa = osmo_amr_is_oa(rtp_hdr->data, payload_len);
 
-	if (orig_is_oa) {
+	payload_len = msgb_length(msg) - sizeof(struct rtp_hdr);
+
+	if (osmo_amr_is_oa(rtp_hdr->data, payload_len)) {
 		if (!target_is_oa)
 			/* Input data is oa an target format is bwe
 			 * ==> convert */
@@ -766,16 +747,27 @@ int amr_oa_bwe_convert(struct mgcp_endpoint *endp, struct msgb *msg,
 	}
 	if (rc < 0) {
 		LOGPENDP(endp, DRTP, LOGL_ERROR,
-			 "RTP AMR packet conversion %s->%s failed: %s\n",
-			 orig_is_oa ? "OA" : "BWE",
-			 target_is_oa ? "OA" : "BWE",
-			 osmo_hexdump(rtp_hdr->data, payload_len));
+			 "AMR RTP packet conversion failed\n");
 		return -EINVAL;
 	}
 
 	return msgb_trim(msg, rc + sizeof(struct rtp_hdr));
 }
 
+/* Check if a conversion between octet-aligned and bandwith-efficient mode is
+ * indicated. */
+static bool amr_oa_bwe_convert_indicated(struct mgcp_rtp_codec *codec)
+{
+	if (codec->param_present == false)
+		return false;
+	if (!codec->param.amr_octet_aligned_present)
+		return false;
+	if (strcmp(codec->subtype_name, "AMR") != 0)
+		return false;
+	return true;
+}
+
+
 /* Return whether an RTP packet with AMR payload is in octet-aligned mode.
  * Return 0 if in bandwidth-efficient mode, 1 for octet-aligned mode, and negative if the RTP data is invalid. */
 static int amr_oa_check(char *data, int len)
@@ -797,7 +789,7 @@ static int amr_oa_check(char *data, int len)
 
 /* Forward data to a debug tap. This is debug function that is intended for
  * debugging the voice traffic with tools like gstreamer */
-void forward_data_tap(int fd, struct mgcp_rtp_tap *tap, struct msgb *msg)
+static void forward_data(int fd, struct mgcp_rtp_tap *tap, struct msgb *msg)
 {
 	int rc;
 
@@ -823,7 +815,7 @@ static void gen_rtp_header(struct msgb *msg, struct mgcp_rtp_end *rtp_end,
 
 	hdr->version = 2;
 	hdr->payload_type = rtp_end->codec->payload_type;
-	hdr->timestamp = osmo_htonl(mgcp_get_current_ts(rtp_end->codec->rate));
+	hdr->timestamp = osmo_htonl(get_current_ts(rtp_end->codec->rate));
 	hdr->sequence = osmo_htons(state->alt_rtp_tx_sequence);
 	hdr->ssrc = state->alt_rtp_tx_ssrc;
 }
@@ -834,7 +826,7 @@ static int check_rtp_origin(struct mgcp_conn_rtp *conn, struct osmo_sockaddr *ad
 {
 	char ipbuf[INET6_ADDRSTRLEN];
 
-	if (osmo_sockaddr_is_any(&conn->end.addr) != 0) {
+	if (addr_is_any(&conn->end.addr)) {
 		switch (conn->conn->mode) {
 		case MGCP_CONN_LOOPBACK:
 			/* HACK: for IuUP, we want to reply with an IuUP Initialization ACK upon the first RTP
@@ -883,14 +875,14 @@ static int check_rtp_origin(struct mgcp_conn_rtp *conn, struct osmo_sockaddr *ad
 	 * the same as the remote port where we transmit outgoing RTP traffic
 	 * to (set by MDCX). We use this to check the origin of the data for
 	 * plausibility. */
-	if (osmo_sockaddr_port(&conn->end.addr.u.sa) != osmo_sockaddr_port(&addr->u.sa) &&
+	if (ntohs(conn->end.rtp_port) != osmo_sockaddr_port(&addr->u.sa) &&
 	    ntohs(conn->end.rtcp_port) != osmo_sockaddr_port(&addr->u.sa)) {
 		LOGPCONN(conn->conn, DRTP, LOGL_ERROR,
 			 "data from wrong source port: %d, ",
 			 osmo_sockaddr_port(&addr->u.sa));
 		LOGPC(DRTP, LOGL_ERROR,
 		      "expected: %d for RTP or %d for RTCP\n",
-		      osmo_sockaddr_port(&conn->end.addr.u.sa), ntohs(conn->end.rtcp_port));
+		      ntohs(conn->end.rtp_port), ntohs(conn->end.rtcp_port));
 		LOGPCONN(conn->conn, DRTP, LOGL_ERROR, "packet tossed\n");
 		return -1;
 	}
@@ -903,29 +895,28 @@ static int check_rtp_origin(struct mgcp_conn_rtp *conn, struct osmo_sockaddr *ad
 static int check_rtp_destin(struct mgcp_conn_rtp *conn)
 {
 	char ipbuf[INET6_ADDRSTRLEN];
-	bool ip_is_any = osmo_sockaddr_is_any(&conn->end.addr) != 0;
-	uint16_t port = osmo_sockaddr_port(&conn->end.addr.u.sa);
+	bool ip_is_any = addr_is_any(&conn->end.addr);
 
 	/* Note: it is legal to create a connection but never setting a port
 	 * and IP-address for outgoing data. */
-	if (ip_is_any && port == 0) {
+	if (ip_is_any && conn->end.rtp_port == 0) {
 		LOGPCONN(conn->conn, DRTP, LOGL_DEBUG,
 			 "destination IP-address and rtp port is not (yet) known (%s:%u)\n",
-			 osmo_sockaddr_ntop(&conn->end.addr.u.sa, ipbuf), port);
+			 osmo_sockaddr_ntop(&conn->end.addr.u.sa, ipbuf), conn->end.rtp_port);
 		return -1;
 	}
 
 	if (ip_is_any) {
 		LOGPCONN(conn->conn, DRTP, LOGL_ERROR,
 			 "destination IP-address is invalid (%s:%u)\n",
-			 osmo_sockaddr_ntop(&conn->end.addr.u.sa, ipbuf), port);
+			 osmo_sockaddr_ntop(&conn->end.addr.u.sa, ipbuf), conn->end.rtp_port);
 		return -1;
 	}
 
-	if (port == 0) {
+	if (conn->end.rtp_port == 0) {
 		LOGPCONN(conn->conn, DRTP, LOGL_ERROR,
 			 "destination rtp port is invalid (%s:%u)\n",
-			 osmo_sockaddr_ntop(&conn->end.addr.u.sa, ipbuf), port);
+			 osmo_sockaddr_ntop(&conn->end.addr.u.sa, ipbuf), conn->end.rtp_port);
 		return -1;
 	}
 
@@ -984,21 +975,14 @@ static int check_rtp(struct mgcp_conn_rtp *conn_src, struct msgb *msg)
 	 * the length is because we currently handle IUUP packets as RTP
 	 * packets, so they must pass this check, if we weould be more
 	 * strict here, we would possibly break 3G. (see also FIXME note
-	 * below.*/
+	 * below */
 
 	return 0;
 }
 
-/*! Dispatch msg bridged from the sister conn in the endpoint.
- *  \param[in] conn_dst The destination conn that should handle and transmit the content to
- *			its peer outside MGW.
- *  \param[in] msg msgb containing an RTP pkt received by the sister conn in the endpoint,
- *  \returns bytes sent, -1 on error.
- *
- * Possible options are standard RTP packet transmission, transmission
- * via IuUP or transmission via an osmux connection.
- */
-static int mgcp_conn_rtp_dispatch_rtp(struct mgcp_conn_rtp *conn_dst, struct msgb *msg)
+/* Send RTP data. Possible options are standard RTP packet
+ * transmission or trsmission via an osmux connection */
+static int mgcp_send_rtp(struct mgcp_conn_rtp *conn_dst, struct msgb *msg)
 {
 	struct osmo_rtp_msg_ctx *mc = OSMO_RTP_MSG_CTX(msg);
 	enum rtp_proto proto = mc->proto;
@@ -1023,24 +1007,12 @@ static int mgcp_conn_rtp_dispatch_rtp(struct mgcp_conn_rtp *conn_dst, struct msg
 			 "using mgcp_send() to forward data directly\n");
 		return mgcp_send(endp, proto == MGCP_PROTO_RTP,
 				 mc->from_addr, msg, conn_src, conn_dst);
-	case MGCP_RTP_OSMUX:
+	case MGCP_OSMUX_BSC_NAT:
+	case MGCP_OSMUX_BSC:
 		LOGPENDP(endp, DRTP, LOGL_DEBUG,
-			 "endpoint type is MGCP_RTP_OSMUX, "
+			 "endpoint type is MGCP_OSMUX_BSC_NAT, "
 			 "using osmux_xfrm_to_osmux() to forward data through OSMUX\n");
-		return conn_osmux_send_rtp(conn_dst, msg);
-	case MGCP_RTP_IUUP:
-		if (proto == MGCP_PROTO_RTP) {
-			LOGPENDP(endp, DRTP, LOGL_DEBUG,
-				 "endpoint type is MGCP_RTP_IUUP, "
-				 "using mgcp_conn_iuup_send_rtp() to forward data over IuUP\n");
-			return mgcp_conn_iuup_send_rtp(conn_src, conn_dst, msg);
-		}
-		/* RTCP: we forward as usual for regular RTP connection */
-		LOGPENDP(endp, DRTP, LOGL_DEBUG,
-			 "endpoint type is MGCP_RTP_IUUP and proto!=MGCP_PROTO_RTP, "
-			 "using mgcp_send() to forward data directly\n");
-		return mgcp_send(endp, false,
-				 mc->from_addr, msg, conn_src, conn_dst);
+		return osmux_xfrm_to_osmux((char*)msgb_data(msg), msgb_length(msg), conn_dst);
 	}
 
 	/* If the data has not been handled/forwarded until here, it will
@@ -1054,22 +1026,26 @@ static int mgcp_conn_rtp_dispatch_rtp(struct mgcp_conn_rtp *conn_dst, struct msg
 /*! send udp packet.
  *  \param[in] fd associated file descriptor.
  *  \param[in] addr destination ip-address.
+ *  \param[in] port destination UDP port (network byte order).
  *  \param[in] buf buffer that holds the data to be send.
  *  \param[in] len length of the data to be sent.
  *  \returns bytes sent, -1 on error. */
-int mgcp_udp_send(int fd, const struct osmo_sockaddr *addr, const char *buf, int len)
+int mgcp_udp_send(int fd, struct osmo_sockaddr *addr, int port, const char *buf, int len)
 {
 	char ipbuf[INET6_ADDRSTRLEN];
 	size_t addr_len;
+	bool is_ipv6 =  addr->u.sa.sa_family == AF_INET6;
 
 	LOGP(DRTP, LOGL_DEBUG,
 	     "sending %i bytes length packet to %s:%u ...\n", len,
 	     osmo_sockaddr_ntop(&addr->u.sa, ipbuf),
-	     osmo_sockaddr_port(&addr->u.sa));
+	     ntohs(port));
 
-	if (addr->u.sa.sa_family == AF_INET6) {
+	if (is_ipv6) {
+		addr->u.sin6.sin6_port = port;
 		addr_len = sizeof(addr->u.sin6);
 	} else {
+		addr->u.sin.sin_port = port;
 		addr_len = sizeof(addr->u.sin);
 	}
 
@@ -1084,7 +1060,6 @@ int mgcp_send_dummy(struct mgcp_endpoint *endp, struct mgcp_conn_rtp *conn)
 {
 	int rc;
 	int was_rtcp = 0;
-	struct osmo_sockaddr rtcp_addr;
 
 	OSMO_ASSERT(endp);
 	OSMO_ASSERT(conn);
@@ -1098,11 +1073,8 @@ int mgcp_send_dummy(struct mgcp_endpoint *endp, struct mgcp_conn_rtp *conn)
 	if (check_rtp_destin(conn) != 0)
 		goto failed;
 
-	if (mgcp_conn_rtp_is_iuup(conn))
-		rc = mgcp_conn_iuup_send_dummy(conn);
-	else
-		rc = mgcp_udp_send(conn->end.rtp.fd, &conn->end.addr,
-				   rtp_dummy_payload, sizeof(rtp_dummy_payload));
+	rc = mgcp_udp_send(conn->end.rtp.fd, &conn->end.addr,
+			   conn->end.rtp_port, rtp_dummy_payload, sizeof(rtp_dummy_payload));
 
 	if (rc == -1)
 		goto failed;
@@ -1111,10 +1083,8 @@ int mgcp_send_dummy(struct mgcp_endpoint *endp, struct mgcp_conn_rtp *conn)
 		return rc;
 
 	was_rtcp = 1;
-	rtcp_addr = conn->end.addr;
-	osmo_sockaddr_set_port(&rtcp_addr.u.sa, ntohs(conn->end.rtcp_port));
-	rc = mgcp_udp_send(conn->end.rtcp.fd, &rtcp_addr,
-			   rtp_dummy_payload, sizeof(rtp_dummy_payload));
+	rc = mgcp_udp_send(conn->end.rtcp.fd, &conn->end.addr,
+			   conn->end.rtcp_port, rtp_dummy_payload, sizeof(rtp_dummy_payload));
 
 	if (rc >= 0)
 		return rc;
@@ -1130,11 +1100,12 @@ failed:
 /*! Send RTP/RTCP data to a specified destination connection.
  *  \param[in] endp associated endpoint (for configuration, logging).
  *  \param[in] is_rtp flag to specify if the packet is of type RTP or RTCP.
- *  \param[in] addr spoofed source address (set to NULL to disable).
- *  \param[in] msg message buffer that contains the RTP/RTCP data.
+ *  \param[in] spoofed source address (set to NULL to disable).
+ *  \param[in] buf buffer that contains the RTP/RTCP data.
+ *  \param[in] len length of the buffer that contains the RTP/RTCP data.
  *  \param[in] conn_src associated source connection.
  *  \param[in] conn_dst associated destination connection.
- *  \returns 0 on success, negative on ERROR. */
+ *  \returns 0 on success, -1 on ERROR. */
 int mgcp_send(struct mgcp_endpoint *endp, int is_rtp, struct osmo_sockaddr *addr,
 	      struct msgb *msg, struct mgcp_conn_rtp *conn_src,
 	      struct mgcp_conn_rtp *conn_dst)
@@ -1159,14 +1130,19 @@ int mgcp_send(struct mgcp_endpoint *endp, int is_rtp, struct osmo_sockaddr *addr
 	else
 		LOGPENDP(endp, DRTP, LOGL_DEBUG, "delivering RTCP packet...\n");
 
-	/* Patch the payload type number: translate from conn_src to conn_dst.
-	 * Do not patch for IuUP, where the correct payload type number is already set in bridge_iuup_to_rtp_peer():
-	 * IuUP -> AMR: calls this function, skip patching if conn_src is IuUP.
-	 * {AMR or IuUP} -> IuUP: calls mgcp_udp_send() directly, skipping this function: No need to examine dst. */
-	if (is_rtp && !mgcp_conn_rtp_is_iuup(conn_src)) {
-		if (mgcp_patch_pt(conn_dst, msg) < 0) {
-			LOGPENDP(endp, DRTP, LOGL_NOTICE, "unable to patch payload type RTP packet, discarding...\n");
-			return -EINVAL;
+	/* FIXME: It is legal that the payload type on the egress connection is
+	 * different from the payload type that has been negotiated on the
+	 * ingress connection. Essentially the codecs are the same so we can
+	 * match them and patch the payload type. However, if we can not find
+	 * the codec pendant (everything ist equal except the PT), we are of
+	 * course unable to patch the payload type. A situation like this
+	 * should not occur if transcoding is consequently avoided. Until
+	 * we have transcoding support in osmo-mgw we can not resolve this. */
+	if (is_rtp) {
+		rc = mgcp_patch_pt(conn_src, conn_dst, msg);
+		if (rc < 0) {
+			LOGPENDP(endp, DRTP, LOGL_DEBUG,
+				 "can not patch PT because no suitable egress codec was found.\n");
 		}
 	}
 
@@ -1188,7 +1164,7 @@ int mgcp_send(struct mgcp_endpoint *endp, int is_rtp, struct osmo_sockaddr *addr
 			 "rtp_port:%u rtcp_port:%u\n",
 			 dest_name,
 			 osmo_sockaddr_ntop(&rtp_end->addr.u.sa, ipbuf),
-			 osmo_sockaddr_port(&rtp_end->addr.u.sa), ntohs(rtp_end->rtcp_port)
+			 ntohs(rtp_end->rtp_port), ntohs(rtp_end->rtcp_port)
 		    );
 	} else if (is_rtp) {
 		int cont;
@@ -1209,15 +1185,12 @@ int mgcp_send(struct mgcp_endpoint *endp, int is_rtp, struct osmo_sockaddr *addr
 				mgcp_patch_and_count(endp, rtp_state, rtp_end,
 						     addr, msg);
 
-			if (mgcp_conn_rtp_is_iuup(conn_dst) || mgcp_conn_rtp_is_iuup(conn_src)) {
-				/* the iuup code will correctly transform to the correct AMR mode */
-			} else if (mgcp_codec_amr_align_mode_is_indicated(conn_dst->end.codec)) {
+			if (amr_oa_bwe_convert_indicated(conn_dst->end.codec)) {
 				rc = amr_oa_bwe_convert(endp, msg,
 							conn_dst->end.codec->param.amr_octet_aligned);
 				if (rc < 0) {
 					LOGPENDP(endp, DRTP, LOGL_ERROR,
-						 "Error in AMR octet-aligned <-> bandwidth-efficient mode conversion (target=%s)\n",
-						 conn_dst->end.codec->param.amr_octet_aligned ? "octet-aligned" : "bandwidth-efficient");
+						 "Error in AMR octet-aligned <-> bandwidth-efficient mode conversion\n");
 					break;
 				}
 			} else if (rtp_end->rfc5993_hr_convert &&
@@ -1234,14 +1207,32 @@ int mgcp_send(struct mgcp_endpoint *endp, int is_rtp, struct osmo_sockaddr *addr
 				 "rtp_port:%u rtcp_port:%u\n",
 				 dest_name,
 				 osmo_sockaddr_ntop(&rtp_end->addr.u.sa, ipbuf),
-				 osmo_sockaddr_port(&rtp_end->addr.u.sa), ntohs(rtp_end->rtcp_port)
+				 ntohs(rtp_end->rtp_port), ntohs(rtp_end->rtcp_port)
 				);
 
 			/* Forward a copy of the RTP data to a debug ip/port */
-			forward_data_tap(rtp_end->rtp.fd, &conn_src->tap_out,
+			forward_data(rtp_end->rtp.fd, &conn_src->tap_out,
 				     msg);
 
-			len = mgcp_udp_send(rtp_end->rtp.fd, &rtp_end->addr,
+			/* FIXME: HACK HACK HACK. See OS#2459.
+			 * The ip.access nano3G needs the first RTP payload's first two bytes to read hex
+			 * 'e400', or it will reject the RAB assignment. It seems to not harm other femto
+			 * cells (as long as we patch only the first RTP payload in each stream).
+			 */
+			if (!rtp_state->patched_first_rtp_payload
+			    && conn_src->conn->mode == MGCP_CONN_LOOPBACK) {
+				uint8_t *data = msgb_data(msg) + 12;
+				if (data[0] == 0xe0) {
+					data[0] = 0xe4;
+					data[1] = 0x00;
+					rtp_state->patched_first_rtp_payload = true;
+					LOGPENDP(endp, DRTP, LOGL_DEBUG,
+						 "Patching over first two bytes"
+						 " to fake an IuUP Initialization Ack\n");
+				}
+			}
+
+			len = mgcp_udp_send(rtp_end->rtp.fd, &rtp_end->addr, rtp_end->rtp_port,
 					    (char *)msgb_data(msg), msgb_length(msg));
 
 			if (len <= 0)
@@ -1256,17 +1247,15 @@ int mgcp_send(struct mgcp_endpoint *endp, int is_rtp, struct osmo_sockaddr *addr
 		} while (buflen > 0);
 		return nbytes;
 	} else if (!trunk->omit_rtcp) {
-		struct osmo_sockaddr rtcp_addr = rtp_end->addr;
-		osmo_sockaddr_set_port(&rtcp_addr.u.sa, rtp_end->rtcp_port);
 		LOGPENDP(endp, DRTP, LOGL_DEBUG,
 			 "send to %s %s rtp_port:%u rtcp_port:%u\n",
-			 dest_name, osmo_sockaddr_ntop(&rtcp_addr.u.sa, ipbuf),
-			 osmo_sockaddr_port(&rtp_end->addr.u.sa),
-			 osmo_sockaddr_port(&rtcp_addr.u.sa)
+			 dest_name, osmo_sockaddr_ntop(&rtp_end->addr.u.sa, ipbuf),
+			 ntohs(rtp_end->rtp_port), ntohs(rtp_end->rtcp_port)
 			);
 
-		len = mgcp_udp_send(rtp_end->rtcp.fd, &rtcp_addr,
-				    (char *)msgb_data(msg), msgb_length(msg));
+		len = mgcp_udp_send(rtp_end->rtcp.fd,
+				    &rtp_end->addr,
+				    rtp_end->rtcp_port, (char *)msgb_data(msg), msgb_length(msg));
 
 		rtpconn_rate_ctr_inc(conn_dst, endp, RTP_PACKETS_TX_CTR);
 		rtpconn_rate_ctr_add(conn_dst, endp, RTP_OCTETS_TX_CTR, len);
@@ -1278,22 +1267,21 @@ int mgcp_send(struct mgcp_endpoint *endp, int is_rtp, struct osmo_sockaddr *addr
 	return 0;
 }
 
-/*! Dispatch incoming RTP packet to opposite RTP connection.
- * \param[in] msg Message buffer to bridge, coming from source connection.
- *            msg shall contain "struct osmo_rtp_msg_ctx *" attached in
- *            "OSMO_RTP_MSG_CTX(msg)".
- *  \returns 0 on success, -1 on ERROR.
- */
+/*! dispatch incoming RTP packet to opposite RTP connection.
+ *  \param[in] proto protocol (MGCP_CONN_TYPE_RTP or MGCP_CONN_TYPE_RTCP).
+ *  \param[in] addr socket address where the RTP packet has been received from.
+ *  \param[in] buf buffer that hold the RTP payload.
+ *  \param[in] buf_size size data length of buf.
+ *  \param[in] conn originating connection.
+ *  \returns 0 on success, -1 on ERROR. */
 int mgcp_dispatch_rtp_bridge_cb(struct msgb *msg)
 {
 	struct osmo_rtp_msg_ctx *mc = OSMO_RTP_MSG_CTX(msg);
 	struct mgcp_conn_rtp *conn_src = mc->conn_src;
 	struct mgcp_conn *conn = conn_src->conn;
 	struct mgcp_conn *conn_dst;
-	struct mgcp_endpoint *endp = conn->endp;
 	struct osmo_sockaddr *from_addr = mc->from_addr;
 	char ipbuf[INET6_ADDRSTRLEN];
-	int rc = 0;
 
 	/*! NOTE: This callback function implements the endpoint specific
 	 *  dispatch behaviour of an rtp bridge/proxy endpoint. It is assumed
@@ -1303,9 +1291,6 @@ int mgcp_dispatch_rtp_bridge_cb(struct msgb *msg)
 	 *  destination connection is known the RTP packet is sent via
 	 *  the destination connection. */
 
-	/* If source is IuUP, we need to handle state, forward it through specific bridge path: */
-	if (mgcp_conn_rtp_is_iuup(conn_src) && mc->proto == MGCP_PROTO_RTP)
-		return mgcp_conn_iuup_dispatch_rtp(msg);
 
 	 /* Check if the connection is in loopback mode, if yes, just send the
 	 * incoming data back to the origin */
@@ -1314,46 +1299,57 @@ int mgcp_dispatch_rtp_bridge_cb(struct msgb *msg)
 		 * packets back to their origin. We will use the originating
 		 * address data from the UDP packet header to patch the
 		 * outgoing address in connection on the fly */
-		if (osmo_sockaddr_port(&conn->u.rtp.end.addr.u.sa) == 0) {
+		if (conn->u.rtp.end.rtp_port == 0) {
 			memcpy(&conn->u.rtp.end.addr, from_addr,
 			       sizeof(conn->u.rtp.end.addr));
+			switch (from_addr->u.sa.sa_family) {
+			case AF_INET:
+				conn->u.rtp.end.rtp_port = from_addr->u.sin.sin_port;
+				break;
+			case AF_INET6:
+				conn->u.rtp.end.rtp_port = from_addr->u.sin6.sin6_port;
+				break;
+			default:
+				OSMO_ASSERT(false);
+			}
 			LOG_CONN_RTP(conn_src, LOGL_NOTICE,
 				     "loopback mode: implicitly using source address (%s:%u) as destination address\n",
 				     osmo_sockaddr_ntop(&from_addr->u.sa, ipbuf),
-				     osmo_sockaddr_port(&conn->u.rtp.end.addr.u.sa));
+				     conn->u.rtp.end.rtp_port);
 		}
-		return mgcp_conn_rtp_dispatch_rtp(conn_src, msg);
+		return mgcp_send_rtp(conn_src, msg);
 	}
 
-	/* If the mode does not allow receiving RTP, we are done. */
-	switch (conn->mode) {
-	case MGCP_CONN_RECV_ONLY:
-	case MGCP_CONN_RECV_SEND:
-	case MGCP_CONN_CONFECHO:
-		break;
-	default:
-		return rc;
+	/* Find a destination connection. */
+	/* NOTE: This code path runs every time an RTP packet is received. The
+	 * function mgcp_find_dst_conn() we use to determine the detination
+	 * connection will iterate the connection list inside the endpoint.
+	 * Since list iterations are quite costly, we will figure out the
+	 * destination only once and use the optional private data pointer of
+	 * the connection to cache the destination connection pointer. */
+	if (!conn->priv) {
+		conn_dst = mgcp_find_dst_conn(conn);
+		conn->priv = conn_dst;
+	} else {
+		conn_dst = (struct mgcp_conn *)conn->priv;
 	}
 
-	/* If the mode is "confecho", send RTP back to the sender. */
-	if (conn->mode == MGCP_CONN_CONFECHO)
-		rc = mgcp_conn_rtp_dispatch_rtp(conn_src, msg);
-
-	/* Dispatch RTP packet to all other connection(s) that send audio. */
-	llist_for_each_entry(conn_dst, &endp->conns, entry) {
-		if (conn_dst == conn)
-			continue;
-		switch (conn_dst->mode) {
-		case MGCP_CONN_SEND_ONLY:
-		case MGCP_CONN_RECV_SEND:
-		case MGCP_CONN_CONFECHO:
-			rc = mgcp_conn_rtp_dispatch_rtp(&conn_dst->u.rtp, msg);
-			break;
-		default:
-			break;
-		}
+	/* There is no destination conn, stop here */
+	if (!conn_dst) {
+		LOGPCONN(conn, DRTP, LOGL_DEBUG,
+			 "no connection to forward an incoming RTP packet to\n");
+		return -1;
 	}
-	return rc;
+
+	/* The destination conn is not an RTP connection */
+	if (conn_dst->type != MGCP_CONN_TYPE_RTP) {
+		LOGPCONN(conn, DRTP, LOGL_ERROR,
+			 "unable to find suitable destination conn\n");
+		return -1;
+	}
+
+	/* Dispatch RTP packet to destination RTP connection */
+	return mgcp_send_rtp(&conn_dst->u.rtp, msg);
 }
 
 /*! dispatch incoming RTP packet to E1 subslot, handle RTCP packets locally.
@@ -1378,15 +1374,25 @@ int mgcp_dispatch_e1_bridge_cb(struct msgb *msg)
 		 * packets back to their origin. We will use the originating
 		 * address data from the UDP packet header to patch the
 		 * outgoing address in connection on the fly */
-		if (osmo_sockaddr_port(&conn->u.rtp.end.addr.u.sa) == 0) {
+		if (conn->u.rtp.end.rtp_port == 0) {
 			memcpy(&conn->u.rtp.end.addr, from_addr,
 			       sizeof(conn->u.rtp.end.addr));
+			switch (from_addr->u.sa.sa_family) {
+			case AF_INET:
+				conn->u.rtp.end.rtp_port = from_addr->u.sin.sin_port;
+				break;
+			case AF_INET6:
+				conn->u.rtp.end.rtp_port = from_addr->u.sin6.sin6_port;
+				break;
+			default:
+				OSMO_ASSERT(false);
+			}
 			LOG_CONN_RTP(conn_src, LOGL_NOTICE,
 				     "loopback mode: implicitly using source address (%s:%u) as destination address\n",
 				     osmo_sockaddr_ntop(&from_addr->u.sa, ipbuf),
-				     osmo_sockaddr_port(&conn->u.rtp.end.addr.u.sa));
+				     conn->u.rtp.end.rtp_port);
 		}
-		return mgcp_conn_rtp_dispatch_rtp(conn_src, msg);
+		return mgcp_send_rtp(conn_src, msg);
 	}
 
 	/* Forward to E1 */
@@ -1462,7 +1468,7 @@ static int rtp_data_net(struct osmo_fd *fd, unsigned int what)
 	msgb_put(msg, ret);
 
 	LOG_CONN_RTP(conn_src, LOGL_DEBUG, "%s: rx %u bytes from %s:%u\n",
-		     proto == MGCP_PROTO_RTP ? "RTP" : "RTCP",
+		     proto == MGCP_PROTO_RTP ? "RTP" : "RTPC",
 		     msgb_length(msg), osmo_sockaddr_ntop(&addr.u.sa, ipbuf),
 		     osmo_sockaddr_port(&addr.u.sa));
 
@@ -1495,12 +1501,12 @@ static int rtp_data_net(struct osmo_fd *fd, unsigned int what)
 					sizeof(struct sockaddr_in)));
 
 	/* Increment RX statistics */
-	rate_ctr_inc(rate_ctr_group_get_ctr(conn_src->ctrg, RTP_PACKETS_RX_CTR));
-	rate_ctr_add(rate_ctr_group_get_ctr(conn_src->ctrg, RTP_OCTETS_RX_CTR), msgb_length(msg));
+	rate_ctr_inc(rate_ctr_group_get_ctr(conn_src->rate_ctr_group, RTP_PACKETS_RX_CTR));
+	rate_ctr_add(rate_ctr_group_get_ctr(conn_src->rate_ctr_group, RTP_OCTETS_RX_CTR), msgb_length(msg));
 	/* FIXME: count RTP and RTCP separately, also count IuUP payload-less separately */
 
 	/* Forward a copy of the RTP data to a debug ip/port */
-	forward_data_tap(fd->fd, &conn_src->tap_in, msg);
+	forward_data(fd->fd, &conn_src->tap_in, msg);
 
 	rc = rx_rtp(msg);
 
@@ -1509,7 +1515,6 @@ out:
 	return rc;
 }
 
-/* Note: This function is able to handle RTP and RTCP */
 static int rx_rtp(struct msgb *msg)
 {
 	struct osmo_rtp_msg_ctx *mc = OSMO_RTP_MSG_CTX(msg);
@@ -1520,28 +1525,23 @@ static int rx_rtp(struct msgb *msg)
 
 	LOG_CONN_RTP(conn_src, LOGL_DEBUG, "rx_rtp(%u bytes)\n", msgb_length(msg));
 
-	/* Check if the origin of the RTP packet seems plausible */
-	if (!trunk->rtp_accept_all && check_rtp_origin(conn_src, from_addr))
-		return -1;
+	mgcp_conn_watchdog_kick(conn_src->conn);
 
-	/* Handle AMR frame format conversion (octet-aligned vs. bandwith-efficient) */
-	if (mc->proto == MGCP_PROTO_RTP &&
-	    mgcp_codec_amr_align_mode_is_indicated(conn_src->end.codec)) {
-		/* Make sure that the incoming AMR frame format matches the frame format that the call agent has
-		 * communicated via SDP when the connection was created/modfied. */
+	/* If AMR is configured for the ingress connection a conversion of the
+	 * framing mode (octet-aligned vs. bandwith-efficient is explicitly
+	 * define, then we check if the incoming payload matches that
+	 * expectation. */
+	if (amr_oa_bwe_convert_indicated(conn_src->end.codec)) {
 		int oa = amr_oa_check((char*)msgb_data(msg), msgb_length(msg));
 		if (oa < 0)
 			return -1;
-		if (((bool)oa) != conn_src->end.codec->param.amr_octet_aligned) {
-			LOG_CONN_RTP(conn_src, LOGL_NOTICE,
-				     "rx_rtp(%u bytes): Expected RTP AMR octet-aligned=%u but got octet-aligned=%u."
-				     " check the config of your call-agent!\n",
-				     msgb_length(msg), conn_src->end.codec->param.amr_octet_aligned, oa);
+		if (((bool)oa) != conn_src->end.codec->param.amr_octet_aligned)
 			return -1;
-		}
 	}
 
-	mgcp_conn_watchdog_kick(conn_src->conn);
+	/* Check if the origin of the RTP packet seems plausible */
+	if (!trunk->rtp_accept_all && check_rtp_origin(conn_src, from_addr))
+		return -1;
 
 	/* Execute endpoint specific implementation that handles the
 	 * dispatching of the RTP data */
@@ -1663,14 +1663,14 @@ int mgcp_bind_net_rtp_port(struct mgcp_endpoint *endp, int rtp_port,
 void mgcp_free_rtp_port(struct mgcp_rtp_end *end)
 {
 	if (end->rtp.fd != -1) {
-		osmo_fd_unregister(&end->rtp);
 		close(end->rtp.fd);
 		end->rtp.fd = -1;
+		osmo_fd_unregister(&end->rtp);
 	}
 
 	if (end->rtcp.fd != -1) {
-		osmo_fd_unregister(&end->rtcp);
 		close(end->rtcp.fd);
 		end->rtcp.fd = -1;
+		osmo_fd_unregister(&end->rtcp);
 	}
 }

src/libosmo-mgcp/mgcp_protocol.c

@@ -46,8 +46,6 @@
 #include <osmocom/mgcp/mgcp_sdp.h>
 #include <osmocom/mgcp/mgcp_codec.h>
 #include <osmocom/mgcp/mgcp_conn.h>
-#include <osmocom/mgcp/mgcp_iuup.h>
-#include <osmocom/mgcp/debug.h>
 
 /* Contains the last successfully resolved endpoint name. This variable is used
  * for the unit-tests to verify that the endpoint was correctly resolved. */
@@ -86,9 +84,6 @@ struct mgcp_request_data {
 	/* set to true when the request has been classified as wildcarded */
 	bool wildcarded;
 
-	/* Set to true when the request is targeted at the "null" endpoint */
-	bool null_endp;
-
 	/* contains cause code in case of problems during endp/trunk resolution */
 	int mgcp_cause;
 };
@@ -102,6 +97,10 @@ struct mgcp_request {
 	/* function pointer to the request handler */
 	struct msgb *(*handle_request)(struct mgcp_request_data *data);
 
+	/* true if the request requires an endpoint, false if only a trunk
+	 * is sufficient. (corner cases, e.g. wildcarded DLCX) */
+	bool require_endp;
+
 	/* a human readable name that describes the request */
 	char *debug_name;
 };
@@ -113,34 +112,32 @@ static struct msgb *handle_modify_con(struct mgcp_request_data *data);
 static struct msgb *handle_rsip(struct mgcp_request_data *data);
 static struct msgb *handle_noti_req(struct mgcp_request_data *data);
 static const struct mgcp_request mgcp_requests[] = {
-	{ .name = "AUEP", .handle_request = handle_audit_endpoint, .debug_name = "AuditEndpoint" },
-	{
-		.name = "CRCX",
-		.handle_request = handle_create_con,
-		.debug_name = "CreateConnection",
-	},
-	{
-		.name = "DLCX",
-		.handle_request = handle_delete_con,
-		.debug_name = "DeleteConnection",
-	},
-	{
-		.name = "MDCX",
-		.handle_request = handle_modify_con,
-		.debug_name = "ModifiyConnection",
-	},
-	{
-		.name = "RQNT",
-		.handle_request = handle_noti_req,
-		.debug_name = "NotificationRequest",
-	},
+	{ .name = "AUEP",
+	  .handle_request = handle_audit_endpoint,
+	  .debug_name = "AuditEndpoint",
+	  .require_endp = true },
+	{ .name = "CRCX",
+	  .handle_request = handle_create_con,
+	  .debug_name = "CreateConnection",
+	  .require_endp = true },
+	{ .name = "DLCX",
+	  .handle_request = handle_delete_con,
+	  .debug_name = "DeleteConnection",
+	  .require_endp = false },
+	{ .name = "MDCX",
+	  .handle_request = handle_modify_con,
+	  .debug_name = "ModifiyConnection",
+	  .require_endp = true },
+	{ .name = "RQNT",
+	  .handle_request = handle_noti_req,
+	  .debug_name = "NotificationRequest",
+	  .require_endp = true },
 
 	/* SPEC extension */
-	{
-		.name = "RSIP",
-		.handle_request = handle_rsip,
-		.debug_name = "ReSetInProgress",
-	},
+	{ .name = "RSIP",
+	  .handle_request = handle_rsip,
+	  .debug_name = "ReSetInProgress",
+	  .require_endp = true },
 };
 
 /* Initalize transcoder */
@@ -152,12 +149,7 @@ static int setup_rtp_processing(struct mgcp_endpoint *endp,
 	struct mgcp_conn_rtp *conn_dst = conn;
 	struct mgcp_conn *_conn;
 
-	switch (conn->type) {
-	case MGCP_RTP_DEFAULT:
-	case MGCP_RTP_OSMUX:
-	case MGCP_RTP_IUUP:
-		break;
-	default:
+	if (conn->type != MGCP_RTP_DEFAULT && !mgcp_conn_rtp_is_osmux(conn)) {
 		LOGPENDP(endp, DLMGCP, LOGL_NOTICE,
 			 "RTP-setup: Endpoint is not configured as RTP default, stopping here!\n");
 		return 0;
@@ -181,15 +173,12 @@ static int setup_rtp_processing(struct mgcp_endpoint *endp,
 }
 
 /* Helper function to allocate some memory for responses and retransmissions */
-static struct msgb *mgcp_msgb_alloc(void *ctx)
+static struct msgb *mgcp_msgb_alloc(void)
 {
 	struct msgb *msg;
-	msg = msgb_alloc_headroom_c(ctx, 4096, 128, "MGCP msg");
-
-	if (!msg) {
+	msg = msgb_alloc_headroom(4096, 128, "MGCP msg");
+	if (!msg)
 		LOGP(DLMGCP, LOGL_ERROR, "Failed to msgb for MGCP data.\n");
-		return NULL;
-	}
 
 	return msg;
 }
@@ -197,7 +186,7 @@ static struct msgb *mgcp_msgb_alloc(void *ctx)
 /* Helper function for do_retransmission() and create_resp() */
 static struct msgb *create_retransmission_response(const struct mgcp_endpoint *endp)
 {
-	struct msgb *msg = mgcp_msgb_alloc(endp->trunk);
+	struct msgb *msg = mgcp_msgb_alloc();
 	if (!msg)
 		return NULL;
 
@@ -207,14 +196,15 @@ static struct msgb *create_retransmission_response(const struct mgcp_endpoint *e
 	return msg;
 }
 
-static struct msgb *create_resp(void *msgctx, struct mgcp_endpoint *endp, int code, const char *txt, const char *msg,
-				const char *trans, const char *param, const char *sdp)
+static struct msgb *create_resp(struct mgcp_endpoint *endp, int code,
+				const char *txt, const char *msg,
+				const char *trans, const char *param,
+				const char *sdp)
 {
 	int len;
 	struct msgb *res;
 
-	OSMO_ASSERT(msgctx != 0);
-	res = mgcp_msgb_alloc(msgctx);
+	res = mgcp_msgb_alloc();
 	if (!res)
 		return NULL;
 
@@ -246,22 +236,26 @@ static struct msgb *create_resp(void *msgctx, struct mgcp_endpoint *endp, int co
 	return res;
 }
 
-static struct msgb *create_ok_resp_with_param(void *msgctx, struct mgcp_endpoint *endp, int code, const char *msg,
-					      const char *trans, const char *param)
+static struct msgb *create_ok_resp_with_param(struct mgcp_endpoint *endp,
+					      int code, const char *msg,
+					      const char *trans,
+					      const char *param)
 {
-	return create_resp(msgctx, endp, code, " OK", msg, trans, param, NULL);
+	return create_resp(endp, code, " OK", msg, trans, param, NULL);
 }
 
-static struct msgb *create_ok_response(void *msgctx, struct mgcp_endpoint *endp, int code, const char *msg,
+static struct msgb *create_ok_response(struct mgcp_endpoint *endp,
+				       int code, const char *msg,
 				       const char *trans)
 {
-	return create_ok_resp_with_param(msgctx, endp, code, msg, trans, NULL);
+	return create_ok_resp_with_param(endp, code, msg, trans, NULL);
 }
 
-static struct msgb *create_err_response(void *msgctx, struct mgcp_endpoint *endp, int code, const char *msg,
+static struct msgb *create_err_response(struct mgcp_endpoint *endp,
+					int code, const char *msg,
 					const char *trans)
 {
-	return create_resp(msgctx, endp, code, " FAIL", msg, trans, NULL, NULL);
+	return create_resp(endp, code, " FAIL", msg, trans, NULL, NULL);
 }
 
 /* Format MGCP response string (with SDP attached) */
@@ -284,7 +278,7 @@ static struct msgb *create_response_with_sdp(struct mgcp_endpoint *endp,
 	int rc;
 	struct msgb *result;
 
-	sdp = msgb_alloc_headroom_c(endp->trunk, 4096, 128, "sdp record");
+	sdp = msgb_alloc_headroom(4096, 128, "sdp record");
 	if (!sdp)
 		return NULL;
 
@@ -304,7 +298,7 @@ static struct msgb *create_response_with_sdp(struct mgcp_endpoint *endp,
 
 	/* Attach optional OSMUX parameters */
 	if (mgcp_conn_rtp_is_osmux(conn)) {
-		rc = msgb_printf(sdp, MGCP_X_OSMO_OSMUX_HEADER " %u\r\n", conn->osmux.local_cid);
+		rc = msgb_printf(sdp, "X-Osmux: %u\r\n", conn->osmux.cid);
 		if (rc < 0)
 			goto error;
 	}
@@ -315,7 +309,7 @@ static struct msgb *create_response_with_sdp(struct mgcp_endpoint *endp,
 	rc = mgcp_write_response_sdp(endp, conn, sdp, addr);
 	if (rc < 0)
 		goto error;
-	result = create_resp(endp->trunk, endp, 200, " OK", msg, trans_id, NULL, (char *)sdp->data);
+	result = create_resp(endp, 200, " OK", msg, trans_id, NULL, (char*) sdp->data);
 	msgb_free(sdp);
 	return result;
 error:
@@ -327,13 +321,8 @@ error:
  * osmux connection, send the dummy packet via OSMUX */
 static void send_dummy(struct mgcp_endpoint *endp, struct mgcp_conn_rtp *conn)
 {
-	/* Avoid sending dummy packet if the remote address was not yet
-	 * configured through CRCX/MDCX: */
-	if (!mgcp_rtp_end_remote_addr_available(&conn->end))
-		return;
-
-	if (mgcp_conn_rtp_is_osmux(conn))
-		osmux_send_dummy(conn);
+	if (conn->osmux.state != OSMUX_STATE_DISABLED)
+		osmux_send_dummy(endp, conn);
 	else
 		mgcp_send_dummy(endp, conn);
 }
@@ -387,16 +376,13 @@ struct msgb *mgcp_handle_message(struct mgcp_config *cfg, struct msgb *msg)
 	if (rc < 0) {
 		LOGP(DLMGCP, LOGL_ERROR, "%s: failed to parse MCGP message\n", rq.name);
 		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_GENERAL_RX_FAIL_MSG_PARSE));
-		return create_err_response(cfg, NULL, -rc, rq.name, "000000");
+		return create_err_response(NULL, -rc, rq.name, "000000");
 	}
 
 	/* Locate endpoint and trunk, if no endpoint can be located try at least to identify the trunk. */
 	rq.pdata = &pdata;
 	rq.wildcarded = mgcp_endp_is_wildcarded(pdata.epname);
-	if (!rq.wildcarded)
-		rq.null_endp = mgcp_endp_is_null(pdata.epname);
-	if (!rq.null_endp)
-		rq.endp = mgcp_endp_by_name(&rc, pdata.epname, pdata.cfg);
+	rq.endp = mgcp_endp_by_name(&rc, pdata.epname, pdata.cfg);
 	rq.mgcp_cause = rc;
 	if (!rq.endp) {
 		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_GENERAL_RX_FAIL_NO_ENDPOINT));
@@ -411,16 +397,16 @@ struct msgb *mgcp_handle_message(struct mgcp_config *cfg, struct msgb *msg)
 			if (!rq.trunk) {
 				LOGP(DLMGCP, LOGL_ERROR, "%s: failed to identify trunk for endpoint \"%s\" -- abort\n",
 				     rq.name, pdata.epname);
-				return create_err_response(cfg, NULL, -rq.mgcp_cause, rq.name, pdata.trans);
+				return create_err_response(NULL, -rq.mgcp_cause, rq.name, pdata.trans);
 			}
-		} else if (!rq.null_endp) {
+		} else {
 			/* If the endpoint name suggests that the request refers to a specific endpoint, then the
 			 * request cannot be handled and we must stop early. */
 			LOGP(DLMGCP, LOGL_NOTICE,
 			     "%s: cannot find endpoint \"%s\", cause=%d -- abort\n", rq.name,
 			     pdata.epname, -rq.mgcp_cause);
-			return create_err_response(cfg, NULL, -rq.mgcp_cause, rq.name, pdata.trans);
-		} /* else: Handle special "null" endpoint below (with rq.endp=NULL, rq.trunk=NULL) */
+			return create_err_response(NULL, -rq.mgcp_cause, rq.name, pdata.trans);
+		}
 	} else {
 		osmo_strlcpy(debug_last_endpoint_name, rq.endp->name, sizeof(debug_last_endpoint_name));
 		rq.trunk = rq.endp->trunk;
@@ -436,6 +422,15 @@ struct msgb *mgcp_handle_message(struct mgcp_config *cfg, struct msgb *msg)
 	/* Find an appropriate handler for the current request and execute it */
 	for (i = 0; i < ARRAY_SIZE(mgcp_requests); i++) {
 		if (strcmp(mgcp_requests[i].name, rq.name) == 0) {
+			/* Check if the request requires and endpoint, if yes, check if we have it, otherwise don't
+			 * execute the request handler. */
+			if (mgcp_requests[i].require_endp && !rq.endp) {
+				LOGP(DLMGCP, LOGL_ERROR,
+				     "%s: the request handler \"%s\" requires an endpoint resource for \"%s\", which is not available -- abort\n",
+				     rq.name, mgcp_requests[i].debug_name, pdata.epname);
+				return create_err_response(NULL, -rq.mgcp_cause, rq.name, pdata.trans);
+			}
+
 			/* Execute request handler */
 			if (rq.endp)
 				LOGP(DLMGCP, LOGL_INFO,
@@ -466,17 +461,7 @@ struct msgb *mgcp_handle_message(struct mgcp_config *cfg, struct msgb *msg)
 static struct msgb *handle_audit_endpoint(struct mgcp_request_data *rq)
 {
 	LOGPENDP(rq->endp, DLMGCP, LOGL_NOTICE, "AUEP: auditing endpoint ...\n");
-
-	/* Auditing "null" endpoint is allowed for keepalive purposes. There's no rq->endp nor rq->trunk in this case. */
-	if (rq->null_endp)
-		return create_ok_response(rq->pdata->cfg, NULL, 200, "AUEP", rq->pdata->trans);
-
-	if (!rq->endp || !mgcp_endp_avail(rq->endp)) {
-		LOGPENDP(rq->endp, DLMGCP, LOGL_ERROR, "AUEP: selected endpoint not available!\n");
-		return create_err_response(rq->trunk, NULL, 501, "AUEP", rq->pdata->trans);
-	}
-
-	return create_ok_response(rq->trunk, rq->endp, 200, "AUEP", rq->pdata->trans);
+	return create_ok_response(rq->endp, 200, "AUEP", rq->pdata->trans);
 }
 
 /* Try to find a free port by attempting to bind on it. Also handle the
@@ -672,8 +657,8 @@ static int set_local_cx_options(void *ctx, struct mgcp_lco *lco,
 		case 'a':
 			/* FIXME: LCO also supports the negotiation of more than one codec.
 			 * (e.g. a:PCMU;G726-32) But this implementation only supports a single
-			 * codec only. Ignoring all but the first codec. */
-			if (sscanf(lco_id + 1, ":%16[^,;]", codec) == 1) {
+			 * codec only. */
+			if (sscanf(lco_id + 1, ":%16[^,]", codec) == 1) {
 				talloc_free(lco->codec);
 				/* MGCP header is case insensive, and we'll need
 				   codec in uppercase when using it later: */
@@ -725,7 +710,7 @@ void mgcp_rtp_end_config(struct mgcp_endpoint *endp, int expect_ssrc_change,
 
 	LOGPENDP(endp, DLMGCP, LOGL_DEBUG,
 		 "Configuring RTP endpoint: local port %d%s%s\n",
-		 osmo_sockaddr_port(&rtp->addr.u.sa),
+		 ntohs(rtp->rtp_port),
 		 rtp->force_aligned_timing ? ", force constant timing" : "",
 		 rtp->force_constant_ssrc ? ", force constant ssrc" : "");
 }
@@ -756,12 +741,12 @@ uint32_t mgcp_rtp_packet_duration(const struct mgcp_endpoint *endp,
  */
 static int mgcp_osmux_setup(struct mgcp_endpoint *endp, const char *line)
 {
-	if (!endp->trunk->cfg->osmux.initialized) {
-		if (osmux_init(endp->trunk) < 0) {
-			LOGPENDP(endp, DOSMUX, LOGL_ERROR, "Cannot init OSMUX\n");
+	if (!endp->trunk->cfg->osmux_init) {
+		if (osmux_init(OSMUX_ROLE_BSC, endp->trunk->cfg) < 0) {
+			LOGPENDP(endp, DLMGCP, LOGL_ERROR, "Cannot init OSMUX\n");
 			return -3;
 		}
-		LOGPENDP(endp, DOSMUX, LOGL_NOTICE, "OSMUX socket has been set up\n");
+		LOGPENDP(endp, DLMGCP, LOGL_NOTICE, "OSMUX socket has been set up\n");
 	}
 
 	return mgcp_parse_osmux_cid(line);
@@ -772,9 +757,6 @@ static int handle_codec_info(struct mgcp_conn_rtp *conn,
 			     struct mgcp_request_data *rq, int have_sdp, bool crcx)
 {
 	struct mgcp_endpoint *endp = rq->endp;
-	struct mgcp_conn *conn_dst;
-	struct mgcp_conn_rtp *conn_dst_rtp;
-
 	int rc;
 	char *cmd;
 
@@ -816,15 +798,8 @@ static int handle_codec_info(struct mgcp_conn_rtp *conn,
 			goto error;
 	}
 
-	/* Try to find an destination RTP connection that we can include in the codec decision. */
-	conn_dst = mgcp_find_dst_conn(conn->conn);
-	if (conn_dst && conn_dst->type == MGCP_CONN_TYPE_RTP)
-		conn_dst_rtp = &conn_dst->u.rtp;
-	else
-		conn_dst_rtp = NULL;
-
 	/* Make codec decision */
-	if (mgcp_codec_decide(conn, conn_dst_rtp) != 0)
+	if (mgcp_codec_decide(conn) != 0)
 		goto error;
 
 	return 0;
@@ -866,13 +841,13 @@ static struct msgb *handle_create_con(struct mgcp_request_data *rq)
 	struct mgcp_parse_data *pdata = rq->pdata;
 	struct mgcp_trunk *trunk = rq->trunk;
 	struct mgcp_endpoint *endp = rq->endp;
-	struct rate_ctr_group *rate_ctrs;
+	struct rate_ctr_group *rate_ctrs = trunk->ratectr.mgcp_crcx_ctr_group;
 	int error_code = 400;
 	const char *local_options = NULL;
 	const char *callid = NULL;
 	const char *mode = NULL;
 	char *line;
-	int have_sdp = 0, remote_osmux_cid = -2;
+	int have_sdp = 0, osmux_cid = -2;
 	struct mgcp_conn_rtp *conn = NULL;
 	struct mgcp_conn *_conn = NULL;
 	char conn_name[512];
@@ -880,26 +855,11 @@ static struct msgb *handle_create_con(struct mgcp_request_data *rq)
 
 	LOGPENDP(endp, DLMGCP, LOGL_NOTICE, "CRCX: creating new connection ...\n");
 
-	if (rq->null_endp) {
-		/* trunk not available so rate_ctr aren't available either. */
-		LOGP(DLMGCP, LOGL_ERROR, "CRCX: Not allowed in 'null' endpoint!\n");
-		return create_err_response(pdata->cfg, NULL, 502, "CRCX", pdata->trans);
-	}
-
-	rate_ctrs = trunk->ratectr.mgcp_crcx_ctr_group;
-
-	/* we must have a free ep */
-	if (!endp) {
-		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_CRCX_FAIL_AVAIL));
-		LOGPENDP(endp, DLMGCP, LOGL_ERROR, "CRCX: no free endpoints available!\n");
-		return create_err_response(rq->trunk, NULL, 403, "CRCX", pdata->trans);
-	}
-
 	if (!mgcp_endp_avail(endp)) {
 		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_CRCX_FAIL_AVAIL));
 		LOGPENDP(endp, DLMGCP, LOGL_ERROR,
 			 "CRCX: selected endpoint not available!\n");
-		return create_err_response(rq->trunk, NULL, 501, "CRCX", pdata->trans);
+		return create_err_response(NULL, 501, "CRCX", pdata->trans);
 	}
 
 	/* parse CallID C: and LocalParameters L: */
@@ -919,7 +879,7 @@ static struct msgb *handle_create_con(struct mgcp_request_data *rq)
 			 * together with a CRCX, the MGW will assign the
 			 * connection identifier by itself on CRCX */
 			rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_CRCX_FAIL_BAD_ACTION));
-			return create_err_response(rq->trunk, NULL, 523, "CRCX", pdata->trans);
+			return create_err_response(NULL, 523, "CRCX", pdata->trans);
 			break;
 		case 'M':
 			mode = (const char *)line + 3;
@@ -927,9 +887,9 @@ static struct msgb *handle_create_con(struct mgcp_request_data *rq)
 		case 'X':
 			if (strncasecmp("Osmux: ", line + 2, strlen("Osmux: ")) == 0) {
 				/* If osmux is disabled, just skip setting it up */
-				if (rq->endp->trunk->cfg->osmux.usage == OSMUX_USAGE_OFF)
+				if (!rq->endp->trunk->cfg->osmux)
 					break;
-				remote_osmux_cid = mgcp_osmux_setup(endp, line);
+				osmux_cid = mgcp_osmux_setup(endp, line);
 				break;
 			}
 
@@ -945,7 +905,7 @@ static struct msgb *handle_create_con(struct mgcp_request_data *rq)
 			LOGPENDP(endp, DLMGCP, LOGL_NOTICE,
 				 "CRCX: unhandled option: '%c'/%d\n", *line, *line);
 			rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_CRCX_FAIL_UNHANDLED_PARAM));
-			return create_err_response(rq->trunk, NULL, 539, "CRCX", pdata->trans);
+			return create_err_response(NULL, 539, "CRCX", pdata->trans);
 			break;
 		}
 	}
@@ -956,18 +916,18 @@ mgcp_header_done:
 		LOGPENDP(endp, DLMGCP, LOGL_ERROR,
 			 "CRCX: insufficient parameters, missing callid\n");
 		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_CRCX_FAIL_MISSING_CALLID));
-		return create_err_response(endp, endp, 516, "CRCX", pdata->trans);
+		return create_err_response(endp, 516, "CRCX", pdata->trans);
 	}
 
 	if (!mode) {
 		LOGPENDP(endp, DLMGCP, LOGL_ERROR,
 			 "CRCX: insufficient parameters, missing mode\n");
 		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_CRCX_FAIL_INVALID_MODE));
-		return create_err_response(endp, endp, 517, "CRCX", pdata->trans);
+		return create_err_response(endp, 517, "CRCX", pdata->trans);
 	}
 
 	/* Check if we are able to accept the creation of another connection */
-	if (endp->type->max_conns > 0 && llist_count(&endp->conns) >= endp->type->max_conns) {
+	if (llist_count(&endp->conns) >= endp->type->max_conns) {
 		LOGPENDP(endp, DLMGCP, LOGL_ERROR,
 			"CRCX: endpoint full, max. %i connections allowed!\n",
 			endp->type->max_conns);
@@ -980,7 +940,7 @@ mgcp_header_done:
 			/* There is no more room for a connection, leave
 			 * everything as it is and return with an error */
 			rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_CRCX_FAIL_LIMIT_EXCEEDED));
-			return create_err_response(endp, endp, 540, "CRCX", pdata->trans);
+			return create_err_response(endp, 540, "CRCX", pdata->trans);
 		}
 	}
 
@@ -998,7 +958,7 @@ mgcp_header_done:
 			/* This is not our call, leave everything as it is and
 			 * return with an error. */
 			rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_CRCX_FAIL_UNKNOWN_CALLID));
-			return create_err_response(endp, endp, 400, "CRCX", pdata->trans);
+			return create_err_response(endp, 400, "CRCX", pdata->trans);
 		}
 	}
 
@@ -1009,7 +969,7 @@ mgcp_header_done:
 		rc = mgcp_endp_claim(endp, callid);
 		if (rc != 0) {
 			rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_CRCX_FAIL_CLAIM));
-			return create_err_response(endp, endp, 502, "CRCX", pdata->trans);
+			return create_err_response(endp, 502, "CRCX", pdata->trans);
 		}
 	}
 
@@ -1032,17 +992,16 @@ mgcp_header_done:
 		goto error2;
 	}
 
-	/* If X-Osmux (remote CID) was received (-1 is wilcard), alloc next avail CID as local CID */
-	if (remote_osmux_cid >= -1) {
-		if (osmux_init_conn(conn) < 0) {
+	/* Annotate Osmux circuit ID and set it to negotiating state until this
+	 * is fully set up from the dummy load. */
+	conn->osmux.state = OSMUX_STATE_DISABLED;
+	if (osmux_cid >= -1) { /* -1 is wilcard, alloc next avail CID */
+		conn->osmux.state = OSMUX_STATE_ACTIVATING;
+		if (conn_osmux_allocate_cid(conn, osmux_cid) == -1) {
 			rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_CRCX_FAIL_NO_OSMUX));
 			goto error2;
 		}
-		if (remote_osmux_cid >= 0) {
-			conn->osmux.remote_cid_present = true;
-			conn->osmux.remote_cid = remote_osmux_cid;
-		}
-	} else if (endp->trunk->cfg->osmux.usage == OSMUX_USAGE_ONLY) {
+	} else if (endp->trunk->cfg->osmux == OSMUX_USAGE_ONLY) {
 		LOGPCONN(_conn, DLMGCP, LOGL_ERROR,
 			 "CRCX: osmux only and no osmux offered\n");
 		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_CRCX_FAIL_NO_OSMUX));
@@ -1055,7 +1014,7 @@ mgcp_header_done:
 					  &endp->local_options, local_options);
 		if (rc != 0) {
 			LOGPCONN(_conn, DLMGCP, LOGL_ERROR,
-				 "CRCX: invalid local connection options!\n");
+				 "CRCX: inavlid local connection options!\n");
 			error_code = rc;
 			rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_CRCX_FAIL_INVALID_CONN_OPTIONS));
 			goto error2;
@@ -1070,11 +1029,6 @@ mgcp_header_done:
 		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_CRCX_FAIL_CODEC_NEGOTIATION));
 		goto error2;
 	}
-	/* Upgrade the conn type RTP_DEFAULT->RTP_IUUP if needed based on requested codec: */
-	/* TODO: "codec" probably needs to be moved from endp to conn */
-	if (conn->type == MGCP_RTP_DEFAULT && strcmp(conn->end.codec->subtype_name, "VND.3GPP.IUFP") == 0) {
-		rc = mgcp_conn_iuup_init(conn);
-	}
 
 	conn->end.fmtp_extra = talloc_strdup(trunk->endpoints,
 					     trunk->audio_fmtp_extra);
@@ -1089,7 +1043,7 @@ mgcp_header_done:
 	/* check connection mode setting */
 	if (conn->conn->mode != MGCP_CONN_LOOPBACK
 	    && conn->conn->mode != MGCP_CONN_RECV_ONLY
-	    && osmo_sockaddr_port(&conn->end.addr.u.sa) == 0) {
+	    && conn->end.rtp_port == 0) {
 		LOGPCONN(_conn, DLMGCP, LOGL_ERROR,
 			 "CRCX: selected connection mode type requires an opposite end!\n");
 		error_code = 527;
@@ -1099,10 +1053,7 @@ mgcp_header_done:
 
 	/* Find a local address for conn based on policy and initial SDP remote
 	   information, then find a free port for it */
-	if (mgcp_get_local_addr(conn->end.local_addr, conn) < 0) {
-		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_CRCX_FAIL_BIND_PORT));
-		goto error2;
-	}
+	mgcp_get_local_addr(conn->end.local_addr, conn);
 	if (allocate_port(endp, conn) != 0) {
 		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_CRCX_FAIL_BIND_PORT));
 		goto error2;
@@ -1115,20 +1066,13 @@ mgcp_header_done:
 		goto error2;
 	}
 
-	/* Notify Osmux conn that CRCX was received */
-	if (mgcp_conn_rtp_is_osmux(conn)) {
-		if (conn_osmux_event_rx_crcx_mdcx(conn) < 0) {
-			LOGPCONN(conn->conn, DLMGCP, LOGL_ERROR, "CRCX: Osmux handling failed!\n");
-			goto error2;
-		}
-	}
-
 	LOGPCONN(conn->conn, DLMGCP, LOGL_DEBUG,
 		 "CRCX: Creating connection: port: %u\n", conn->end.local_port);
 
 	/* Send dummy packet, see also comments in mgcp_keepalive_timer_cb() */
 	OSMO_ASSERT(trunk->keepalive_interval >= MGCP_KEEPALIVE_ONCE);
 	if (conn->conn->mode & MGCP_CONN_RECV_ONLY &&
+	    mgcp_rtp_end_remote_addr_available(&conn->end) &&
 	    trunk->keepalive_interval != MGCP_KEEPALIVE_NEVER)
 		send_dummy(endp, conn);
 
@@ -1144,7 +1088,7 @@ error2:
 	mgcp_endp_release(endp);
 	LOGPENDP(endp, DLMGCP, LOGL_NOTICE,
 		 "CRCX: unable to create connection\n");
-	return create_err_response(endp, endp, error_code, "CRCX", pdata->trans);
+	return create_err_response(endp, error_code, "CRCX", pdata->trans);
 }
 
 /* MDCX command handler, processes the received command */
@@ -1153,7 +1097,7 @@ static struct msgb *handle_modify_con(struct mgcp_request_data *rq)
 	struct mgcp_parse_data *pdata = rq->pdata;
 	struct mgcp_trunk *trunk = rq->trunk;
 	struct mgcp_endpoint *endp = rq->endp;
-	struct rate_ctr_group *rate_ctrs;
+	struct rate_ctr_group *rate_ctrs = trunk->ratectr.mgcp_mdcx_ctr_group;
 	char new_local_addr[INET6_ADDRSTRLEN];
 	int error_code = 500;
 	int silent = 0;
@@ -1163,37 +1107,31 @@ static struct msgb *handle_modify_con(struct mgcp_request_data *rq)
 	const char *mode = NULL;
 	struct mgcp_conn_rtp *conn = NULL;
         const char *conn_id = NULL;
-	int remote_osmux_cid = -2;
+	int osmux_cid = -2;
 	int rc;
 
 	LOGPENDP(endp, DLMGCP, LOGL_NOTICE, "MDCX: modifying existing connection ...\n");
 
-	if (rq->null_endp) {
-		/* trunk not available so rate_ctr aren't available either. */
-		LOGP(DLMGCP, LOGL_ERROR, "MDCX: Not allowed in 'null' endpoint!\n");
-		return create_err_response(pdata->cfg, NULL, 502, "MDCX", pdata->trans);
+	if (!mgcp_endp_avail(endp)) {
+		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_MDCX_FAIL_AVAIL));
+		LOGPENDP(endp, DLMGCP, LOGL_ERROR,
+			 "MDCX: selected endpoint not available!\n");
+		return create_err_response(NULL, 501, "MDCX", pdata->trans);
 	}
 
-	rate_ctrs = trunk->ratectr.mgcp_mdcx_ctr_group;
-
 	/* Prohibit wildcarded requests */
 	if (rq->wildcarded) {
 		LOGPENDP(endp, DLMGCP, LOGL_ERROR,
 			 "MDCX: wildcarded endpoint names not supported.\n");
 		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_MDCX_FAIL_WILDCARD));
-		return create_err_response(rq->trunk, endp, 507, "MDCX", pdata->trans);
+		return create_err_response(endp, 507, "MDCX", pdata->trans);
 	}
 
-	if (!endp || !mgcp_endp_avail(endp)) {
-		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_MDCX_FAIL_AVAIL));
-		LOGPENDP(endp, DLMGCP, LOGL_ERROR, "MDCX: selected endpoint not available!\n");
-		return create_err_response(rq->trunk, NULL, 501, "MDCX", pdata->trans);
-	}
 	if (llist_count(&endp->conns) <= 0) {
 		LOGPENDP(endp, DLMGCP, LOGL_ERROR,
 			 "MDCX: endpoint is not holding a connection.\n");
 		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_MDCX_FAIL_NO_CONN));
-		return create_err_response(endp, endp, 400, "MDCX", pdata->trans);
+		return create_err_response(endp, 400, "MDCX", pdata->trans);
 	}
 
 	for_each_line(line, pdata->save) {
@@ -1227,9 +1165,9 @@ static struct msgb *handle_modify_con(struct mgcp_request_data *rq)
 		case 'X':
 			if (strncasecmp("Osmux: ", line + 2, strlen("Osmux: ")) == 0) {
 				/* If osmux is disabled, just skip setting it up */
-				if (endp->trunk->cfg->osmux.usage == OSMUX_USAGE_OFF)
+				if (!endp->trunk->cfg->osmux)
 					break;
-				remote_osmux_cid = mgcp_osmux_setup(endp, line);
+				osmux_cid = mgcp_osmux_setup(endp, line);
 				break;
 			}
 			/* Ignore unknown X-headers */
@@ -1243,7 +1181,7 @@ static struct msgb *handle_modify_con(struct mgcp_request_data *rq)
 				 "MDCX: Unhandled MGCP option: '%c'/%d\n",
 				 line[0], line[0]);
 			rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_MDCX_FAIL_UNHANDLED_PARAM));
-			return create_err_response(rq->trunk, NULL, 539, "MDCX", pdata->trans);
+			return create_err_response(NULL, 539, "MDCX", pdata->trans);
 			break;
 		}
 	}
@@ -1253,13 +1191,13 @@ mgcp_header_done:
 		LOGPENDP(endp, DLMGCP, LOGL_ERROR,
 			 "MDCX: insufficient parameters, missing ci (connectionIdentifier)\n");
 		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_MDCX_FAIL_NO_CONNID));
-		return create_err_response(endp, endp, 515, "MDCX", pdata->trans);
+		return create_err_response(endp, 515, "MDCX", pdata->trans);
 	}
 
 	conn = mgcp_conn_get_rtp(endp, conn_id);
 	if (!conn) {
 		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_MDCX_FAIL_CONN_NOT_FOUND));
-		return create_err_response(endp, endp, 400, "MDCX", pdata->trans);
+		return create_err_response(endp, 400, "MDCX", pdata->trans);
 	}
 
 	mgcp_conn_watchdog_kick(conn->conn);
@@ -1293,10 +1231,6 @@ mgcp_header_done:
 		error_code = rc;
 		goto error3;
 	}
-	/* Upgrade the conn type RTP_DEFAULT->RTP_IUUP if needed based on requested codec: */
-	/* TODO: "codec" probably needs to be moved from endp to conn */
-	if (conn->type == MGCP_RTP_DEFAULT && strcmp(conn->end.codec->subtype_name, "VND.3GPP.IUFP") == 0)
-		rc = mgcp_conn_iuup_init(conn);
 
 	/* check connection mode setting */
 	if (conn->conn->mode != MGCP_CONN_LOOPBACK
@@ -1310,39 +1244,30 @@ mgcp_header_done:
 	}
 
 	if (mgcp_conn_rtp_is_osmux(conn)) {
-		OSMO_ASSERT(conn->osmux.local_cid_allocated);
-		if (remote_osmux_cid < -1) {
+		OSMO_ASSERT(conn->osmux.cid_allocated);
+		if (osmux_cid < -1) {
 			LOGPCONN(conn->conn, DLMGCP, LOGL_ERROR,
 				 "MDCX: Failed to parse Osmux CID!\n");
 			goto error3;
-		} else if (remote_osmux_cid == -1) {
+		} else if (osmux_cid == -1) {
 			LOGPCONN(conn->conn, DLMGCP, LOGL_ERROR,
 				 "MDCX: wilcard in MDCX is not supported!\n");
 			goto error3;
-		} else if (conn->osmux.remote_cid_present &&
-				remote_osmux_cid != conn->osmux.remote_cid) {
-				LOGPCONN(conn->conn, DLMGCP, LOGL_ERROR,
-					"MDCX: changing already allocated CID is not supported!\n");
-				goto error3;
-		} else {
-			conn->osmux.remote_cid_present = true;
-			conn->osmux.remote_cid = remote_osmux_cid;
-			if (conn_osmux_event_rx_crcx_mdcx(conn) < 0) {
-				LOGPCONN(conn->conn, DLMGCP, LOGL_ERROR,
-					"MDCX: Osmux handling failed!\n");
-				goto error3;
-			}
+		} else if (osmux_cid != (int) conn->osmux.cid) {
+			LOGPCONN(conn->conn, DLMGCP, LOGL_ERROR,
+				 "MDCX: changing already allocated CID is not supported!\n");
+			goto error3;
 		}
+		/* TODO: In the future (when we have recvCID!=sendCID), we need to
+		   tell Osmux code that osmux_cid is to be used as sendCID for
+		   that conn. */
 	}
 
 	/* MDCX may have provided a new remote address, which means we may need
 	   to update our announced IP addr and re-bind our local end. This can
 	   happen for instance if MGW initially provided an IPv4 during CRCX
 	   ACK, and now MDCX tells us the remote has an IPv6 address. */
-	if (mgcp_get_local_addr(new_local_addr, conn) < 0) {
-		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_CRCX_FAIL_BIND_PORT));
-		goto error3;
-	}
+	mgcp_get_local_addr(new_local_addr, conn);
 	if (strcmp(new_local_addr, conn->end.local_addr)) {
 		osmo_strlcpy(conn->end.local_addr, new_local_addr, sizeof(conn->end.local_addr));
 		mgcp_free_rtp_port(&conn->end);
@@ -1366,6 +1291,7 @@ mgcp_header_done:
 	/* Send dummy packet, see also comments in mgcp_keepalive_timer_cb() */
 	OSMO_ASSERT(trunk->keepalive_interval >= MGCP_KEEPALIVE_ONCE);
 	if (conn->conn->mode & MGCP_CONN_RECV_ONLY &&
+	    mgcp_rtp_end_remote_addr_available(&conn->end) &&
 	    trunk->keepalive_interval != MGCP_KEEPALIVE_NEVER)
 		send_dummy(endp, conn);
 
@@ -1378,7 +1304,7 @@ mgcp_header_done:
 	mgcp_endp_update(endp);
 	return create_response_with_sdp(endp, conn, "MDCX", pdata->trans, false, false);
 error3:
-	return create_err_response(endp, endp, error_code, "MDCX", pdata->trans);
+	return create_err_response(endp, error_code, "MDCX", pdata->trans);
 
 out_silent:
 	LOGPENDP(endp, DLMGCP, LOGL_DEBUG, "MDCX: silent exit\n");
@@ -1391,7 +1317,7 @@ static struct msgb *handle_delete_con(struct mgcp_request_data *rq)
 	struct mgcp_parse_data *pdata = rq->pdata;
 	struct mgcp_trunk *trunk = rq->trunk;
 	struct mgcp_endpoint *endp = rq->endp;
-	struct rate_ctr_group *rate_ctrs;
+	struct rate_ctr_group *rate_ctrs = trunk->ratectr.mgcp_dlcx_ctr_group;
 	int error_code = 400;
 	int silent = 0;
 	char *line;
@@ -1401,43 +1327,22 @@ static struct msgb *handle_delete_con(struct mgcp_request_data *rq)
 	unsigned int i;
 
 	/* NOTE: In this handler we can not take it for granted that the endp
-	 * pointer will be populated, however a trunk is always guaranteed (except for 'null' endp).
-	 */
+	 * pointer will be populated, however a trunk is always guaranteed. */
 
 	LOGPEPTR(endp, trunk, DLMGCP, LOGL_NOTICE, "DLCX: deleting connection(s) ...\n");
 
-	if (rq->null_endp) {
-		/* trunk not available so rate_ctr aren't available either. */
-		LOGP(DLMGCP, LOGL_ERROR, "DLCX: Not allowed in 'null' endpoint!\n");
-		return create_err_response(pdata->cfg, NULL, 502, "DLCX", pdata->trans);
-	}
-
-	rate_ctrs = trunk->ratectr.mgcp_dlcx_ctr_group;
 	if (endp && !mgcp_endp_avail(endp)) {
 		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_DLCX_FAIL_AVAIL));
 		LOGPENDP(endp, DLMGCP, LOGL_ERROR,
 			 "DLCX: selected endpoint not available!\n");
-		return create_err_response(rq->trunk, NULL, 501, "DLCX", pdata->trans);
+		return create_err_response(NULL, 501, "DLCX", pdata->trans);
 	}
 
 	if (endp && !rq->wildcarded && llist_empty(&endp->conns)) {
 		LOGPENDP(endp, DLMGCP, LOGL_ERROR,
 			 "DLCX: endpoint is not holding a connection.\n");
 		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_DLCX_FAIL_NO_CONN));
-		return create_err_response(endp, endp, 515, "DLCX", pdata->trans);
-	}
-
-	/* Handle wildcarded DLCX that refers to the whole trunk. This means
-	 * that we walk over all endpoints on the trunk in order to drop all
-	 * connections on the trunk. (see also RFC3435 Annex F.7) */
-	if (rq->wildcarded) {
-		int num_conns = 0;
-		for (i = 0; i < trunk->number_endpoints; i++) {
-			num_conns += llist_count(&trunk->endpoints[i]->conns);
-			mgcp_endp_release(trunk->endpoints[i]);
-		}
-		rate_ctr_add(rate_ctr_group_get_ctr(rate_ctrs, MGCP_DLCX_SUCCESS), num_conns);
-		return create_ok_response(trunk, NULL, 200, "DLCX", pdata->trans);
+		return create_err_response(endp, 515, "DLCX", pdata->trans);
 	}
 
 	for_each_line(line, pdata->save) {
@@ -1452,7 +1357,7 @@ static struct msgb *handle_delete_con(struct mgcp_request_data *rq)
 				LOGPTRUNK(trunk, DLMGCP, LOGL_NOTICE,
 					  "cannot handle requests with call-id (C) without endpoint -- abort!");
 				rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_DLCX_FAIL_UNHANDLED_PARAM));
-				return create_err_response(rq->trunk, NULL, 539, "DLCX", pdata->trans);
+				return create_err_response(NULL, 539, "DLCX", pdata->trans);
 			}
 
 			if (mgcp_verify_call_id(endp, line + 3) != 0) {
@@ -1468,7 +1373,7 @@ static struct msgb *handle_delete_con(struct mgcp_request_data *rq)
 				LOGPTRUNK(trunk, DLMGCP, LOGL_NOTICE,
 					  "cannot handle requests with conn-id (I) without endpoint -- abort!");
 				rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_DLCX_FAIL_UNHANDLED_PARAM));
-				return create_err_response(rq->trunk, NULL, 539, "DLCX", pdata->trans);
+				return create_err_response(NULL, 539, "DLCX", pdata->trans);
 			}
 
 			conn_id = (const char *)line + 3;
@@ -1484,11 +1389,24 @@ static struct msgb *handle_delete_con(struct mgcp_request_data *rq)
 			LOGPEPTR(endp, trunk, DLMGCP, LOGL_NOTICE, "DLCX: Unhandled MGCP option: '%c'/%d\n",
 				 line[0], line[0]);
 			rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_DLCX_FAIL_UNHANDLED_PARAM));
-			return create_err_response(rq->trunk, NULL, 539, "DLCX", pdata->trans);
+			return create_err_response(NULL, 539, "DLCX", pdata->trans);
 			break;
 		}
 	}
 
+	/* Handle wildcarded DLCX that refers to the whole trunk. This means
+	 * that we walk over all endpoints on the trunk in order to drop all
+	 * connections on the trunk. (see also RFC3435 Annex F.7) */
+	if (rq->wildcarded) {
+		int num_conns = 0;
+		for (i = 0; i < trunk->number_endpoints; i++) {
+			num_conns += llist_count(&trunk->endpoints[i]->conns);
+			mgcp_endp_release(trunk->endpoints[i]);
+		}
+		rate_ctr_add(rate_ctr_group_get_ctr(rate_ctrs, MGCP_DLCX_SUCCESS), num_conns);
+		return create_ok_response(NULL, 200, "DLCX", pdata->trans);
+	}
+
 	/* The logic does not permit to go past this point without having the
 	 * the endp pointer populated. */
 	OSMO_ASSERT(endp);
@@ -1511,7 +1429,7 @@ static struct msgb *handle_delete_con(struct mgcp_request_data *rq)
 		/* Note: In this case we do not return any statistics,
 		 * as we assume that the client is not interested in
 		 * this case. */
-		return create_ok_response(endp, endp, 200, "DLCX", pdata->trans);
+		return create_ok_response(endp, 200, "DLCX", pdata->trans);
 	}
 
 	/* Find the connection */
@@ -1540,10 +1458,10 @@ static struct msgb *handle_delete_con(struct mgcp_request_data *rq)
 	rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_DLCX_SUCCESS));
 	if (silent)
 		goto out_silent;
-	return create_ok_resp_with_param(endp, endp, 250, "DLCX", pdata->trans, stats);
+	return create_ok_resp_with_param(endp, 250, "DLCX", pdata->trans, stats);
 
 error3:
-	return create_err_response(endp, endp, error_code, "DLCX", pdata->trans);
+	return create_err_response(endp, error_code, "DLCX", pdata->trans);
 
 out_silent:
 	LOGPENDP(endp, DLMGCP, LOGL_DEBUG, "DLCX: silent exit\n");
@@ -1563,12 +1481,6 @@ static struct msgb *handle_rsip(struct mgcp_request_data *rq)
 
 	LOGP(DLMGCP, LOGL_NOTICE, "RSIP: resetting all endpoints ...\n");
 
-	if (rq->null_endp) {
-		/* trunk not available so rate_ctr aren't available either. */
-		LOGP(DLMGCP, LOGL_ERROR, "RSIP: Not allowed in 'null' endpoint!\n");
-		return create_err_response(rq->pdata->cfg, NULL, 502, "RSIP", rq->pdata->trans);
-	}
-
 	if (rq->pdata->cfg->reset_cb)
 		rq->pdata->cfg->reset_cb(rq->endp->trunk);
 	return NULL;
@@ -1594,12 +1506,6 @@ static struct msgb *handle_noti_req(struct mgcp_request_data *rq)
 
 	LOGP(DLMGCP, LOGL_NOTICE, "RQNT: processing request for notification ...\n");
 
-	if (rq->null_endp) {
-		/* trunk not available so rate_ctr aren't available either. */
-		LOGP(DLMGCP, LOGL_ERROR, "RQNT: Not allowed in 'null' endpoint!\n");
-		return create_err_response(rq->pdata->cfg, NULL, 502, "RQNT", rq->pdata->trans);
-	}
-
 	for_each_line(line, rq->pdata->save) {
 		switch (toupper(line[0])) {
 		case 'S':
@@ -1610,13 +1516,14 @@ static struct msgb *handle_noti_req(struct mgcp_request_data *rq)
 
 	/* we didn't see a signal request with a tone */
 	if (tone == CHAR_MAX)
-		return create_ok_response(rq->endp, rq->endp, 200, "RQNT", rq->pdata->trans);
+		return create_ok_response(rq->endp, 200, "RQNT", rq->pdata->trans);
 
 	if (rq->pdata->cfg->rqnt_cb)
 		res = rq->pdata->cfg->rqnt_cb(rq->endp, tone);
 
-	return res == 0 ? create_ok_response(rq->endp, rq->endp, 200, "RQNT", rq->pdata->trans) :
-				create_err_response(rq->endp, rq->endp, res, "RQNT", rq->pdata->trans);
+	return res == 0 ?
+	    create_ok_response(rq->endp, 200, "RQNT", rq->pdata->trans) :
+	    create_err_response(rq->endp, res, "RQNT", rq->pdata->trans);
 }
 
 /* Connection keepalive timer, will take care that dummy packets are send
@@ -1654,7 +1561,8 @@ static void mgcp_keepalive_timer_cb(void *_trunk)
 		struct mgcp_endpoint *endp = trunk->endpoints[i];
 		llist_for_each_entry(conn, &endp->conns, entry) {
 			if (conn->type == MGCP_CONN_TYPE_RTP &&
-			    conn->mode == MGCP_CONN_RECV_ONLY)
+			    conn->mode == MGCP_CONN_RECV_ONLY &&
+			     mgcp_rtp_end_remote_addr_available(&conn->u.rtp.end))
 				send_dummy(endp, &conn->u.rtp);
 		}
 	}
@@ -1708,6 +1616,7 @@ struct mgcp_config *mgcp_config_alloc(void)
 
 	cfg->source_port = 2427;
 	osmo_strlcpy(cfg->source_addr, "0.0.0.0", sizeof(cfg->source_addr));
+	osmo_strlcpy(cfg->osmux_addr, "0.0.0.0", sizeof(cfg->osmux_addr));
 
 	cfg->rtp_processing_cb = &mgcp_rtp_processing_default;
 	cfg->setup_rtp_processing_cb = &mgcp_setup_rtp_processing_default;

src/libosmo-mgcp/mgcp_ratectr.c

@@ -43,7 +43,7 @@ static const struct rate_ctr_desc mgcp_general_ctr_desc[] = {
 	    { "mgcp:err_rx_no_endpoint", "can't find MGCP endpoint, probably we've used all allocated endpoints." },
 };
 
-static const struct rate_ctr_group_desc mgcp_general_ctr_group_desc = {
+const static struct rate_ctr_group_desc mgcp_general_ctr_group_desc = {
 	.group_name_prefix = "mgcp",
 	.group_description = "mgcp general statistics",
 	.class_id = OSMO_STATS_CLASS_GLOBAL,
@@ -71,7 +71,7 @@ static const struct rate_ctr_desc mgcp_crcx_ctr_desc[] = {
 	[MGCP_CRCX_FAIL_CLAIM] = { "crcx:claim", "endpoint can not be claimed." },
 };
 
-static const struct rate_ctr_group_desc mgcp_crcx_ctr_group_desc = {
+const static struct rate_ctr_group_desc mgcp_crcx_ctr_group_desc = {
 	.group_name_prefix = "crcx",
 	.group_description = "crxc statistics",
 	.class_id = OSMO_STATS_CLASS_GLOBAL,
@@ -97,7 +97,7 @@ static const struct rate_ctr_desc mgcp_mdcx_ctr_desc[] = {
 	[MGCP_MDCX_FAIL_AVAIL] = { "mdcx:unavailable", "endpoint unavailable." },
 };
 
-static const struct rate_ctr_group_desc mgcp_mdcx_ctr_group_desc = {
+const static struct rate_ctr_group_desc mgcp_mdcx_ctr_group_desc = {
 	.group_name_prefix = "mdcx",
 	.group_description = "mdcx statistics",
 	.class_id = OSMO_STATS_CLASS_GLOBAL,
@@ -116,7 +116,7 @@ static const struct rate_ctr_desc mgcp_dlcx_ctr_desc[] = {
 	[MGCP_DLCX_FAIL_AVAIL] = { "dlcx:unavailable", "endpoint unavailable." },
 };
 
-static const struct rate_ctr_group_desc mgcp_dlcx_ctr_group_desc = {
+const static struct rate_ctr_group_desc mgcp_dlcx_ctr_group_desc = {
 	.group_name_prefix = "dlcx",
 	.group_description = "dlcx statistics",
 	.class_id = OSMO_STATS_CLASS_GLOBAL,
@@ -130,7 +130,7 @@ static const struct rate_ctr_desc e1_rate_ctr_desc[] = {
 	[E1_I460_TRAU_MUX_EMPTY_CTR] = { "e1:i460", "Outbound I.460 MUX queue empty." }
 };
 
-static const struct rate_ctr_group_desc e1_rate_ctr_group_desc = {
+const static struct rate_ctr_group_desc e1_rate_ctr_group_desc = {
 	.group_name_prefix = "e1",
 	.group_description = "e1 statistics",
 	.class_id = OSMO_STATS_CLASS_GLOBAL,
@@ -138,7 +138,7 @@ static const struct rate_ctr_group_desc e1_rate_ctr_group_desc = {
 	.ctr_desc = e1_rate_ctr_desc
 };
 
-static const struct rate_ctr_group_desc all_rtp_conn_rate_ctr_group_desc = {
+const static struct rate_ctr_group_desc all_rtp_conn_rate_ctr_group_desc = {
 	.group_name_prefix = "all_rtp_conn",
 	.group_description = "aggregated statistics for all rtp connections",
 	.class_id = 1,
@@ -146,14 +146,6 @@ static const struct rate_ctr_group_desc all_rtp_conn_rate_ctr_group_desc = {
 	.ctr_desc = all_rtp_conn_rate_ctr_desc
 };
 
-static const struct rate_ctr_group_desc all_osmux_conn_rate_ctr_group_desc = {
-	.group_name_prefix = "all_osmux_conn",
-	.group_description = "aggregated statistics for all osmux connections",
-	.class_id = 1,
-	.num_ctr = ARRAY_SIZE(all_osmux_conn_rate_ctr_desc),
-	.ctr_desc = all_osmux_conn_rate_ctr_desc
-};
-
 /*! allocate global rate counters
  *  (called once at startup).
  *  \param[in] cfg mgw configuration for which the rate counters are allocated.
@@ -199,7 +191,6 @@ int mgcp_ratectr_trunk_alloc(struct mgcp_trunk *trunk)
 	static atomic_uint mdcx_rate_ctr_index = 0;
 	static atomic_uint dlcx_rate_ctr_index = 0;
 	static atomic_uint all_rtp_conn_rate_ctr_index = 0;
-	static atomic_uint all_osmux_conn_rate_ctr_index = 0;
 	char ctr_name[256];
 
 	if (ratectr->mgcp_crcx_ctr_group == NULL) {
@@ -238,15 +229,6 @@ int mgcp_ratectr_trunk_alloc(struct mgcp_trunk *trunk)
 			 trunk->trunk_nr);
 		rate_ctr_group_set_name(ratectr->all_rtp_conn_stats, ctr_name);
 	}
-	if (ratectr->all_osmux_conn_stats == NULL) {
-		ratectr->all_osmux_conn_stats = rate_ctr_group_alloc(trunk, &all_osmux_conn_rate_ctr_group_desc,
-								   all_osmux_conn_rate_ctr_index++);
-		if (!ratectr->all_osmux_conn_stats)
-			return -EINVAL;
-		snprintf(ctr_name, sizeof(ctr_name), "%s-%u:osmux_conn", mgcp_trunk_type_strs_str(trunk->trunk_type),
-			 trunk->trunk_nr);
-		rate_ctr_group_set_name(ratectr->all_osmux_conn_stats, ctr_name);
-	}
 
 	/* E1 specific */
 	if (trunk->trunk_type == MGCP_TRUNK_E1 && ratectr->e1_stats == NULL) {
@@ -283,10 +265,6 @@ void mgcp_ratectr_trunk_free(struct mgcp_trunk *trunk)
 		rate_ctr_group_free(ratectr->all_rtp_conn_stats);
 		ratectr->all_rtp_conn_stats = NULL;
 	}
-	if (ratectr->all_osmux_conn_stats) {
-		rate_ctr_group_free(ratectr->all_osmux_conn_stats);
-		ratectr->all_osmux_conn_stats = NULL;
-	}
 
 	/* E1 specific */
 	if (ratectr->e1_stats) {

src/libosmo-mgcp/mgcp_sdp.c

@@ -98,7 +98,7 @@ static void codecs_initialize(void *ctx, struct sdp_rtp_map *codecs, int used)
 /* Helper function to update codec map information with additional data from
  * SDP, called from: mgcp_parse_sdp_data() */
 static void codecs_update(void *ctx, struct sdp_rtp_map *codecs, int used,
-			  int payload_type, const char *audio_name)
+			  int payload, const char *audio_name)
 {
 	int i;
 
@@ -110,7 +110,7 @@ static void codecs_update(void *ctx, struct sdp_rtp_map *codecs, int used,
 		/* Note: We can only update payload codecs that already exist
 		 * in our codec list. If we get an unexpected payload type,
 		 * we just drop it */
-		if (codecs[i].payload_type != payload_type)
+		if (codecs[i].payload_type != payload)
 			continue;
 
 		if (sscanf(audio_name, "%63[^/]/%d/%d",
@@ -127,7 +127,7 @@ static void codecs_update(void *ctx, struct sdp_rtp_map *codecs, int used,
 		return;
 	}
 
-	LOGP(DLMGCP, LOGL_ERROR, "Unconfigured PT(%d) with %s\n", payload_type,
+	LOGP(DLMGCP, LOGL_ERROR, "Unconfigured PT(%d) with %s\n", payload,
 	     audio_name);
 }
 
@@ -239,12 +239,13 @@ static int fmtp_from_sdp(void *ctx, struct sdp_fmtp_param *fmtp_param, char *sdp
 		if (delimiter == ';' || delimiter == ',')
 			str_ptr[strlen(str_ptr) - 1] = '\0';
 
-		/* AMR octet aligned parameter (see also RFC 3267, section 8.3) */
+		/* AMR octet aligned parameter */
 		if (sscanf(param_str, "octet-align=%d", &amr_octet_aligned) == 1) {
 			fmtp_param->param.amr_octet_aligned_present = true;
 			fmtp_param->param.amr_octet_aligned = false;
 			if (amr_octet_aligned == 1)
 				fmtp_param->param.amr_octet_aligned = true;
+
 		}
 
 		param_str = strtok(NULL, " ");
@@ -333,7 +334,7 @@ int mgcp_parse_sdp_data(const struct mgcp_endpoint *endp,
 	void *tmp_ctx = talloc_new(NULL);
 	struct mgcp_rtp_end *rtp;
 
-	int payload_type;
+	int payload;
 	int ptime, ptime2 = 0;
 	char audio_name[64];
 	int port, rc;
@@ -354,8 +355,8 @@ int mgcp_parse_sdp_data(const struct mgcp_endpoint *endp,
 			/* skip these SDP attributes */
 			break;
 		case 'a':
-			if (sscanf(line, "a=rtpmap:%d %63s", &payload_type, audio_name) == 2) {
-				codecs_update(tmp_ctx, codecs, codecs_used, payload_type, audio_name);
+			if (sscanf(line, "a=rtpmap:%d %63s", &payload, audio_name) == 2) {
+				codecs_update(tmp_ctx, codecs, codecs_used, payload, audio_name);
 				break;
 			}
 
@@ -383,7 +384,7 @@ int mgcp_parse_sdp_data(const struct mgcp_endpoint *endp,
 		case 'm':
 			rc = sscanf(line, "m=audio %d RTP/AVP", &port);
 			if (rc == 1) {
-				osmo_sockaddr_set_port(&rtp->addr.u.sa, port);
+				rtp->rtp_port = htons(port);
 				rtp->rtcp_port = htons(port + 1);
 			}
 
@@ -431,7 +432,7 @@ int mgcp_parse_sdp_data(const struct mgcp_endpoint *endp,
 
 	LOGPCONN(conn->conn, DLMGCP, LOGL_NOTICE,
 	     "Got media info via SDP: port:%d, addr:%s, duration:%d, payload-types:",
-	     osmo_sockaddr_port(&rtp->addr.u.sa), osmo_sockaddr_ntop(&rtp->addr.u.sa, ipbuf),
+	     ntohs(rtp->rtp_port), osmo_sockaddr_ntop(&rtp->addr.u.sa, ipbuf),
 	     rtp->packet_duration_ms);
 	if (codecs_used == 0)
 		LOGPC(DLMGCP, LOGL_NOTICE, "none");
@@ -600,7 +601,7 @@ int mgcp_write_response_sdp(const struct mgcp_endpoint *endp,
 
 		payload_types[0] = payload_type;
 		if (mgcp_conn_rtp_is_osmux(conn))
-			local_port = endp->trunk->cfg->osmux.local_port;
+			local_port = endp->trunk->cfg->osmux_port;
 		else
 			local_port = conn->end.local_port;
 		rc = add_audio(sdp, payload_types, 1, local_port);

src/libosmo-mgcp/mgcp_stat.c

@@ -39,7 +39,7 @@ __attribute__((no_sanitize("undefined")))
 void calc_loss(struct mgcp_conn_rtp *conn, uint32_t *expected, int *loss)
 {
 	struct mgcp_rtp_state *state = &conn->state;
-	struct rate_ctr *packets_rx = rate_ctr_group_get_ctr(conn->ctrg, RTP_PACKETS_RX_CTR);
+	struct rate_ctr *packets_rx = rate_ctr_group_get_ctr(conn->rate_ctr_group, RTP_PACKETS_RX_CTR);
 
 	*expected = state->stats.cycles + state->stats.max_seq;
 	*expected = *expected - state->stats.base_seq + 1;
@@ -80,10 +80,10 @@ static void mgcp_format_stats_rtp(char *str, size_t str_len,
 	int ploss;
 	int nchars;
 
-	struct rate_ctr *packets_rx = rate_ctr_group_get_ctr(conn->ctrg, RTP_PACKETS_RX_CTR);
-	struct rate_ctr *octets_rx = rate_ctr_group_get_ctr(conn->ctrg, RTP_OCTETS_RX_CTR);
-	struct rate_ctr *packets_tx = rate_ctr_group_get_ctr(conn->ctrg, RTP_PACKETS_TX_CTR);
-	struct rate_ctr *octets_tx = rate_ctr_group_get_ctr(conn->ctrg, RTP_OCTETS_TX_CTR);
+	struct rate_ctr *packets_rx = rate_ctr_group_get_ctr(conn->rate_ctr_group, RTP_PACKETS_RX_CTR);
+	struct rate_ctr *octets_rx = rate_ctr_group_get_ctr(conn->rate_ctr_group, RTP_OCTETS_RX_CTR);
+	struct rate_ctr *packets_tx = rate_ctr_group_get_ctr(conn->rate_ctr_group, RTP_PACKETS_TX_CTR);
+	struct rate_ctr *octets_tx = rate_ctr_group_get_ctr(conn->rate_ctr_group, RTP_OCTETS_TX_CTR);
 
 	calc_loss(conn, &expected, &ploss);
 	jitter = calc_jitter(&conn->state);
@@ -99,7 +99,7 @@ static void mgcp_format_stats_rtp(char *str, size_t str_len,
 	str += nchars;
 	str_len -= nchars;
 
-	if (conn->conn->endp->trunk->cfg->osmux.usage != OSMUX_USAGE_OFF) {
+	if (conn->conn->endp->trunk->cfg->osmux != OSMUX_USAGE_OFF) {
 		/* Error Counter */
 		nchars = snprintf(str, str_len,
 				  "\r\nX-Osmo-CP: EC TI=%" PRIu64 ", TO=%" PRIu64,
@@ -112,12 +112,9 @@ static void mgcp_format_stats_rtp(char *str, size_t str_len,
 		str_len -= nchars;
 
 		if (conn->osmux.state == OSMUX_STATE_ENABLED) {
-			struct rate_ctr *osmux_chunks_rx, *osmux_octets_rx;
-			osmux_chunks_rx = rate_ctr_group_get_ctr(conn->ctrg, OSMUX_CHUNKS_RX_CTR);
-			osmux_octets_rx = rate_ctr_group_get_ctr(conn->ctrg, OSMUX_OCTETS_RX_CTR);
 			snprintf(str, str_len,
-				 "\r\nX-Osmux-ST: CR=%" PRIu64 ", BR=%" PRIu64,
-				 osmux_chunks_rx->current, osmux_octets_rx->current);
+				 "\r\nX-Osmux-ST: CR=%u, BR=%u",
+				 conn->osmux.stats.chunks, conn->osmux.stats.octets);
 		}
 	}
 

src/libosmo-mgcp/mgcp_threads_queue.c

@@ -1,207 +0,0 @@
-/*
- * (C) 2021 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
- * All Rights Reserved
- *
- * Author: Eric Wild
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Affero 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 Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include <inttypes.h>
-#include <stdatomic.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/eventfd.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <talloc.h>
-
-#include <osmocom/mgcp/mgcp_threads_queue.h>
-
-/*
-classic lamport circular lockfree spsc queue:
-every "side" only writes its own ptr, but may read the other sides ptr
-
-notify reader using eventfd as soon as element is added, reader then reads until
-read fails
--> reader pops in a loop until FALSE and might get spurious events because it
-read before it was notified, which is fine
--> writing pushes *the same data* in a loop until TRUE, blocks
-
-shutting this down requires
-1) to stop reading and pushing
-2) ONE side to take care of the eventfds
-*/
-
-static struct spsc *spsc_init(void *talloc_ctx, unsigned int count, unsigned int size_per_buf, bool blockr, bool blockw)
-{
-	struct spsc *q = talloc_zero_size(talloc_ctx, sizeof(struct spsc) + sizeof(uintptr_t) * count);
-	atomic_init(&q->readptr, 0);
-	atomic_init(&q->writeptr, 0);
-	q->efd_r = eventfd(0, blockr ? 0 : EFD_NONBLOCK);
-	q->efd_w = eventfd(1, blockw ? 0 : EFD_NONBLOCK);
-	q->count = count;
-	q->size_per_buf = size_per_buf;
-	q->buf = talloc_zero_size(q, size_per_buf * count);
-
-	for (int i = 0; i < count; i++)
-		q->data[i] = (uintptr_t)q->buf + i * size_per_buf;
-	return q;
-}
-
-static void spsc_deinit(struct spsc *q)
-{
-	talloc_free(q->buf);
-	close(q->efd_r);
-	close(q->efd_w);
-	talloc_free(q);
-}
-
-static ssize_t spsc_check_r(struct spsc *q)
-{
-	uint64_t efdr;
-	return read(q->efd_r, &efdr, sizeof(uint64_t));
-}
-static ssize_t spsc_check_w(struct spsc *q)
-{
-	uint64_t efdr;
-	return read(q->efd_w, &efdr, sizeof(uint64_t));
-}
-static void spsc_notify_r(struct spsc *q)
-{
-	uint64_t efdu = 1;
-	write(q->efd_r, &efdu, sizeof(uint64_t));
-}
-static void spsc_notify_w(struct spsc *q)
-{
-	uint64_t efdu = 1;
-	write(q->efd_w, &efdu, sizeof(uint64_t));
-}
-
-/*! Adds element to the queue by copying the data.
- *  \param[in] q queue.
- *  \param[in] elem input buffer, must match the originally configured queue buffer size!.
- *  \returns true if queue was not full and element was successfully pushed */
-bool spsc_push(struct spsc *q, void *elem)
-{
-	size_t cur_wp, cur_rp;
-	cur_wp = atomic_load_explicit(&q->writeptr, memory_order_relaxed);
-	cur_rp = atomic_load_explicit(&q->readptr, memory_order_acquire);
-	if ((cur_wp + 1) % q->count == cur_rp) {
-		spsc_check_w(q); /* blocks, ensures next (!) call succeeds */
-		return false;
-	}
-	memcpy((void *)q->data[cur_wp], elem, q->size_per_buf);
-	atomic_store_explicit(&q->writeptr, (cur_wp + 1) % q->count, memory_order_release);
-	spsc_notify_r(q); /* fine after release */
-	return true;
-}
-
-/*! Reads the read-fd of the queue, which, depending on settings passed on queue creation, blocks.
- * This function can be used to deliberately wait for a non-empty queue on the read side.
- *  \param[in] q queue.
- *  \returns result of reading the fd. */
-ssize_t spsc_prep_pop(struct spsc *q)
-{
-	return spsc_check_r(q);
-}
-
-/*! Removes element from the queue by copying the data.
- *  \param[in] q queue.
- *  \param[in] elem output buffer, must match the originally configured queue buffer size!.
- *  \returns true if queue was not empty and element was successfully removed */
-bool spsc_pop(struct spsc *q, void *elem)
-{
-	size_t cur_wp, cur_rp;
-	cur_wp = atomic_load_explicit(&q->writeptr, memory_order_acquire);
-	cur_rp = atomic_load_explicit(&q->readptr, memory_order_relaxed);
-
-	if (cur_wp == cur_rp) /* blocks via prep_pop */
-		return false;
-	memcpy(elem, (void *)q->data[cur_rp], q->size_per_buf);
-	atomic_store_explicit(&q->readptr, (cur_rp + 1) % q->count, memory_order_release);
-	spsc_notify_w(q);
-	return true;
-}
-
-/*! Creates a bidirectional queue channel that consists of two queues, one in each direction,
- *  commonly referred to as a and b side.
- *  \param[in] talloc_ctx allocation context.
- *  \param[in] count number of buffers per queue.
- *  \param[in] size_per_buf size of buffers per queue.
- *  \param[in] blockr_a should reading the a-side read fd block?.
- *  \param[in] blockw_a should reading the a-side write fd block?.
- *  \param[in] blockr_b should reading the b-side read fd block?.
- *  \param[in] blockw_b should reading the b-side write fd block?.
-  *  \returns queue channel */
-struct qchan spsc_chan_init_ex(void *talloc_ctx, unsigned int count, unsigned int size_per_buf, bool blockr_a,
-			       bool blockw_a, bool blockr_b, bool blockw_b)
-{
-	struct qchan q;
-	q.a = spsc_init(talloc_ctx, count, size_per_buf, blockr_a, blockw_a);
-	q.b = spsc_init(talloc_ctx, count, size_per_buf, blockr_b, blockw_b);
-	return q;
-}
-
-/*! Creates a bidirectional queue channel that consists of two queues, one in each direction,
- *  commonly referred to as a and b side.
- *  \param[in] talloc_ctx allocation context.
- *  \param[in] count number of buffers per queue.
- *  \param[in] size_per_buf size of buffers per queue.
- *  \returns queue channel */
-struct qchan spsc_chan_init(void *talloc_ctx, unsigned int count, unsigned int size_per_buf)
-{
-	return spsc_chan_init_ex(talloc_ctx, count, size_per_buf, false, true, false, true);
-}
-
-/*! Closes a bidirectional queue channel.
- *  \param[in] q queue */
-void spsc_chan_close(struct qchan *q)
-{
-	spsc_deinit(q->a);
-	spsc_deinit(q->b);
-	free(q);
-}
-
-/*! Gets queue channel read/write fd for a/b side according to function name.
- *  \param[in] q queue channel.
- *  \returns fd */
-int spsc_get_a_rdfd(struct qchan *q)
-{
-	return q->a->efd_r;
-}
-/*! Gets queue channel read/write fd for a/b side according to function name.
- *  \param[in] q queue channel.
- *  \returns fd */
-int spsc_get_b_rdfd(struct qchan *q)
-{
-	return q->b->efd_r;
-}
-/*! Gets queue channel read/write fd for a/b side according to function name.
- *  \param[in] q queue channel.
- *  \returns fd */
-int spsc_get_a_wrfd(struct qchan *q)
-{
-	return q->a->efd_w;
-}
-/*! Gets queue channel read/write fd for a/b side according to function name.
- *  \param[in] q queue channel.
- *  \returns fd */
-int spsc_get_b_wrfd(struct qchan *q)
-{
-	return q->b->efd_w;
-}

src/libosmo-mgcp/mgcp_vty.c

@@ -120,6 +120,8 @@ static int config_write_mgcp(struct vty *vty)
 		trunk->audio_send_name ? "" : "no ", VTY_NEWLINE);
 	vty_out(vty, " number endpoints %u%s",
 		trunk->v.vty_number_endpoints, VTY_NEWLINE);
+	vty_out(vty, " %sallow-transcoding%s",
+		trunk->no_audio_transcoding ? "no " : "", VTY_NEWLINE);
 	if (strlen(g_cfg->call_agent_addr))
 		vty_out(vty, " call-agent ip %s%s", g_cfg->call_agent_addr,
 			VTY_NEWLINE);
@@ -127,7 +129,7 @@ static int config_write_mgcp(struct vty *vty)
 		vty_out(vty, " rtp force-ptime %d%s", g_cfg->force_ptime,
 			VTY_NEWLINE);
 
-	switch (g_cfg->osmux.usage) {
+	switch (g_cfg->osmux) {
 	case OSMUX_USAGE_ON:
 		vty_out(vty, " osmux on%s", VTY_NEWLINE);
 		break;
@@ -139,23 +141,17 @@ static int config_write_mgcp(struct vty *vty)
 		vty_out(vty, " osmux off%s", VTY_NEWLINE);
 		break;
 	}
-	if (g_cfg->osmux.usage != OSMUX_USAGE_OFF) {
-		if (g_cfg->osmux.local_addr_v4)
-			vty_out(vty, " osmux bind-ip %s%s",
-				g_cfg->osmux.local_addr_v4, VTY_NEWLINE);
-		if (g_cfg->osmux.local_addr_v6)
-			vty_out(vty, " osmux bind-ip-v6 %s%s",
-				g_cfg->osmux.local_addr_v6, VTY_NEWLINE);
+	if (g_cfg->osmux) {
+		vty_out(vty, " osmux bind-ip %s%s",
+			g_cfg->osmux_addr, VTY_NEWLINE);
 		vty_out(vty, " osmux batch-factor %d%s",
-			g_cfg->osmux.batch_factor, VTY_NEWLINE);
+			g_cfg->osmux_batch, VTY_NEWLINE);
 		vty_out(vty, " osmux batch-size %u%s",
-			g_cfg->osmux.batch_size, VTY_NEWLINE);
+			g_cfg->osmux_batch_size, VTY_NEWLINE);
 		vty_out(vty, " osmux port %u%s",
-			g_cfg->osmux.local_port, VTY_NEWLINE);
+			g_cfg->osmux_port, VTY_NEWLINE);
 		vty_out(vty, " osmux dummy %s%s",
-			g_cfg->osmux.dummy_padding ? "on" : "off", VTY_NEWLINE);
-		vty_out(vty, " osmux peer-behind-nat %s%s",
-			g_cfg->osmux.peer_behind_nat ? "on" : "off", VTY_NEWLINE);
+			g_cfg->osmux_dummy ? "on" : "off", VTY_NEWLINE);
 	}
 
 	if (g_cfg->conn_timeout)
@@ -173,11 +169,11 @@ static void dump_rtp_end(struct vty *vty, struct mgcp_conn_rtp *conn)
 	struct rate_ctr *rx_packets, *rx_bytes;
 	struct rate_ctr *dropped_packets;
 
-	tx_packets = rate_ctr_group_get_ctr(conn->ctrg, RTP_PACKETS_TX_CTR);
-	tx_bytes = rate_ctr_group_get_ctr(conn->ctrg, RTP_OCTETS_TX_CTR);
-	rx_packets = rate_ctr_group_get_ctr(conn->ctrg, RTP_PACKETS_RX_CTR);
-	rx_bytes = rate_ctr_group_get_ctr(conn->ctrg, RTP_OCTETS_RX_CTR);
-	dropped_packets = rate_ctr_group_get_ctr(conn->ctrg, RTP_DROPPED_PACKETS_CTR);
+	tx_packets = rate_ctr_group_get_ctr(conn->rate_ctr_group, RTP_PACKETS_TX_CTR);
+	tx_bytes = rate_ctr_group_get_ctr(conn->rate_ctr_group, RTP_OCTETS_TX_CTR);
+	rx_packets = rate_ctr_group_get_ctr(conn->rate_ctr_group, RTP_PACKETS_RX_CTR);
+	rx_bytes = rate_ctr_group_get_ctr(conn->rate_ctr_group, RTP_OCTETS_RX_CTR);
+	dropped_packets = rate_ctr_group_get_ctr(conn->rate_ctr_group, RTP_DROPPED_PACKETS_CTR);
 
 	vty_out(vty,
 		"   Packets Sent: %" PRIu64 " (%" PRIu64 " bytes total)%s"
@@ -193,7 +189,7 @@ static void dump_rtp_end(struct vty *vty, struct mgcp_conn_rtp *conn)
 		rx_packets->current, rx_bytes->current, VTY_NEWLINE,
 		state->in_stream.err_ts_ctr->current,
 		state->out_stream.err_ts_ctr->current,
-		VTY_NEWLINE,
+	        VTY_NEWLINE,
 		dropped_packets->current, VTY_NEWLINE,
 		codec->payload_type, codec->rate, codec->channels, VTY_NEWLINE,
 		codec->frame_duration_num, codec->frame_duration_den,
@@ -201,30 +197,6 @@ static void dump_rtp_end(struct vty *vty, struct mgcp_conn_rtp *conn)
 		VTY_NEWLINE, end->fmtp_extra, codec->audio_name,
 		codec->subtype_name, VTY_NEWLINE, end->output_enabled,
 		end->force_output_ptime, VTY_NEWLINE);
-	if (mgcp_conn_rtp_is_osmux(conn)) {
-		struct rate_ctr *rx_chunks, *rx_octets, *rtp_tx, *rtp_tx_dropped, *octets_tx;
-		rx_chunks = rate_ctr_group_get_ctr(conn->osmux.ctrg, OSMUX_CHUNKS_RX_CTR);
-		rx_octets = rate_ctr_group_get_ctr(conn->osmux.ctrg, OSMUX_OCTETS_RX_CTR);
-		rtp_tx = rate_ctr_group_get_ctr(conn->osmux.ctrg, OSMUX_RTP_PACKETS_TX_CTR);
-		rtp_tx_dropped =  rate_ctr_group_get_ctr(conn->osmux.ctrg, OSMUX_RTP_PACKETS_TX_DROPPED_CTR);
-		octets_tx = rate_ctr_group_get_ctr(conn->osmux.ctrg, OSMUX_AMR_OCTETS_TX_CTR);
-		vty_out(vty,
-		"   Osmux:%s"
-		"    State: %s%s"
-		"    Local CID: %d%s"
-		"    Remote CID: %d%s"
-		"    Chunks received: %" PRIu64 " (%" PRIu64 " bytes total)%s"
-		"    RTP Packets encoded (Tx): %" PRIu64 " (%" PRIu64 " AMR octets total)%s"
-		"    AMR payloads Dropped (Tx): %" PRIu64 "%s",
-		VTY_NEWLINE, osmux_state_str(conn->osmux.state), VTY_NEWLINE,
-		conn->osmux.local_cid_allocated ? conn->osmux.local_cid : -1, VTY_NEWLINE,
-		conn->osmux.remote_cid_present ? conn->osmux.remote_cid : -1, VTY_NEWLINE,
-		rx_chunks->current, rx_octets->current, VTY_NEWLINE,
-		rtp_tx->current, octets_tx->current, VTY_NEWLINE,
-		rtp_tx_dropped->current, VTY_NEWLINE
-		);
-
-	}
 }
 
 static void dump_endpoint(struct vty *vty, struct mgcp_endpoint *endp,
@@ -317,14 +289,6 @@ static void dump_ratectr_trunk(struct vty *vty, struct mgcp_trunk *trunk)
 					   "   %25n: %10c (%S/s %M/m %H/h %D/d) %d",
 					   ratectr->all_rtp_conn_stats);
 	}
-	if (ratectr->all_osmux_conn_stats) {
-		vty_out(vty, "   %s:%s",
-			ratectr->all_osmux_conn_stats->desc->group_description,
-			VTY_NEWLINE);
-		vty_out_rate_ctr_group_fmt(vty,
-					   "   %25n: %10c (%S/s %M/m %H/h %D/d) %d",
-					   ratectr->all_osmux_conn_stats);
-	}
 
 	if (ratectr->e1_stats && trunk->trunk_type == MGCP_TRUNK_E1) {
 		vty_out(vty, "   %s:%s",
@@ -378,7 +342,7 @@ static int mgcp_show(struct vty *vty, int argc, const char **argv,
 	llist_for_each_entry(trunk, &g_cfg->trunks, entry)
 		dump_trunk(vty, trunk, show_stats, active_only);
 
-	if (g_cfg->osmux.usage != OSMUX_USAGE_OFF)
+	if (g_cfg->osmux)
 		vty_out(vty, "Osmux used CID: %d%s", osmux_cid_pool_count_used(),
 			VTY_NEWLINE);
 
@@ -511,7 +475,6 @@ DEFUN_DEPRECATED(cfg_mgcp_bind_early,
 		 BIND_STR
 		 "Bind local ports on start up\n" "Bind on demand\n" "Bind on startup\n")
 {
-	vty_out(vty, "%% Deprecated 'bind early (0|1)' config no longer has any effect%s", VTY_NEWLINE);
 	return CMD_SUCCESS;
 }
 
@@ -699,19 +662,25 @@ DEFUN_USRATTR(cfg_mgcp_sdp_fmtp_extra,
 	return CMD_SUCCESS;
 }
 
-DEFUN_DEPRECATED(cfg_mgcp_allow_transcoding,
-		  cfg_mgcp_allow_transcoding_cmd,
-		  "allow-transcoding", "Allow transcoding\n")
+DEFUN_USRATTR(cfg_mgcp_allow_transcoding,
+	      cfg_mgcp_allow_transcoding_cmd,
+	      X(MGW_CMD_ATTR_NEWCONN),
+	      "allow-transcoding", "Allow transcoding\n")
 {
-	vty_out(vty, "%% Deprecated 'allow-transcoding' config no longer has any effect%s", VTY_NEWLINE);
+	struct mgcp_trunk *trunk = mgcp_trunk_by_num(g_cfg, MGCP_TRUNK_VIRTUAL, MGCP_VIRT_TRUNK_ID);
+	OSMO_ASSERT(trunk);
+	trunk->no_audio_transcoding = 0;
 	return CMD_SUCCESS;
 }
 
-DEFUN_DEPRECATED(cfg_mgcp_no_allow_transcoding,
-		 cfg_mgcp_no_allow_transcoding_cmd,
-		 "no allow-transcoding", NO_STR "Allow transcoding\n")
+DEFUN_USRATTR(cfg_mgcp_no_allow_transcoding,
+	      cfg_mgcp_no_allow_transcoding_cmd,
+	      X(MGW_CMD_ATTR_NEWCONN),
+	      "no allow-transcoding", NO_STR "Allow transcoding\n")
 {
-	vty_out(vty, "%% Deprecated 'no allow-transcoding' config no longer has any effect%s", VTY_NEWLINE);
+	struct mgcp_trunk *trunk = mgcp_trunk_by_num(g_cfg, MGCP_TRUNK_VIRTUAL, MGCP_VIRT_TRUNK_ID);
+	OSMO_ASSERT(trunk);
+	trunk->no_audio_transcoding = 1;
 	return CMD_SUCCESS;
 }
 
@@ -722,7 +691,6 @@ DEFUN_DEPRECATED(cfg_mgcp_sdp_payload_number,
       "sdp audio-payload number <0-255>",
       SDP_STR AUDIO_STR "Number\n" "Payload number\n")
 {
-	vty_out(vty, "%% Deprecated 'sdp audio-payload number <0-255>' config no longer has any effect%s", VTY_NEWLINE);
 	return CMD_SUCCESS;
 }
 
@@ -736,7 +704,6 @@ DEFUN_DEPRECATED(cfg_mgcp_sdp_payload_name,
       "sdp audio-payload name NAME",
       SDP_STR AUDIO_STR "Name\n" "Payload name\n")
 {
-	vty_out(vty, "%% Deprecated 'sdp audio-payload name NAME' config no longer has any effect%s", VTY_NEWLINE);
 	return CMD_SUCCESS;
 }
 
@@ -797,7 +764,6 @@ DEFUN_DEPRECATED(cfg_mgcp_loop,
 		 "loop (0|1)",
 		 "Loop audio for all endpoints on main trunk\n" "Don't Loop\n" "Loop\n")
 {
-	vty_out(vty, "%% Deprecated 'loop (0|1)' config no longer has any effect%s", VTY_NEWLINE);
 	return CMD_SUCCESS;
 }
 
@@ -1065,6 +1031,8 @@ static int config_write_trunk(struct vty *vty)
 		if (trunk->audio_fmtp_extra)
 			vty_out(vty, "   sdp audio fmtp-extra %s%s",
 				trunk->audio_fmtp_extra, VTY_NEWLINE);
+		vty_out(vty, "  %sallow-transcoding%s",
+			trunk->no_audio_transcoding ? "no " : "", VTY_NEWLINE);
 	}
 
 	return CMD_SUCCESS;
@@ -1092,7 +1060,6 @@ DEFUN_DEPRECATED(cfg_trunk_payload_number,
       "sdp audio-payload number <0-255>",
       SDP_STR AUDIO_STR "Number\n" "Payload Number\n")
 {
-	vty_out(vty, "%% Deprecated 'sdp audio-payload number <0-255>' config no longer has any effect%s", VTY_NEWLINE);
 	return CMD_SUCCESS;
 }
 
@@ -1105,7 +1072,6 @@ DEFUN_DEPRECATED(cfg_trunk_payload_name,
       "sdp audio-payload name NAME",
       SDP_STR AUDIO_STR "Payload\n" "Payload Name\n")
 {
-	vty_out(vty, "%% Deprecated 'sdp audio-payload name NAME' config no longer has any effect%s", VTY_NEWLINE);
 	return CMD_SUCCESS;
 }
 
@@ -1118,7 +1084,6 @@ DEFUN_DEPRECATED(cfg_trunk_loop,
 		 "loop (0|1)",
 		 "Loop audio for all endpoints on this trunk\n" "Don't Loop\n" "Loop\n")
 {
-	vty_out(vty, "%% Deprecated 'loop (0|1)' config no longer has any effect%s", VTY_NEWLINE);
 	return CMD_SUCCESS;
 }
 
@@ -1316,19 +1281,23 @@ DEFUN_ATTR(cfg_trunk_no_rtp_keepalive,
 	return CMD_SUCCESS;
 }
 
-DEFUN_DEPRECATED(cfg_trunk_allow_transcoding,
-		 cfg_trunk_allow_transcoding_cmd,
-		 "allow-transcoding", "Allow transcoding\n")
+DEFUN_USRATTR(cfg_trunk_allow_transcoding,
+	      cfg_trunk_allow_transcoding_cmd,
+	      X(MGW_CMD_ATTR_NEWCONN),
+	      "allow-transcoding", "Allow transcoding\n")
 {
-	vty_out(vty, "%% Deprecated 'allow-transcoding' config no longer has any effect%s", VTY_NEWLINE);
+	struct mgcp_trunk *trunk = vty->index;
+	trunk->no_audio_transcoding = 0;
 	return CMD_SUCCESS;
 }
 
-DEFUN_DEPRECATED(cfg_trunk_no_allow_transcoding,
-		 cfg_trunk_no_allow_transcoding_cmd,
-		 "no allow-transcoding", NO_STR "Allow transcoding\n")
+DEFUN_USRATTR(cfg_trunk_no_allow_transcoding,
+	      cfg_trunk_no_allow_transcoding_cmd,
+	      X(MGW_CMD_ATTR_NEWCONN),
+	      "no allow-transcoding", NO_STR "Allow transcoding\n")
 {
-	vty_out(vty, "%% Deprecated 'no allow-transcoding' config no longer has any effect%s", VTY_NEWLINE);
+	struct mgcp_trunk *trunk = vty->index;
+	trunk->no_audio_transcoding = 1;
 	return CMD_SUCCESS;
 }
 
@@ -1570,12 +1539,12 @@ DEFUN(cfg_mgcp_osmux,
 	OSMO_ASSERT(trunk);
 
 	if (strcmp(argv[0], "off") == 0) {
-		g_cfg->osmux.usage = OSMUX_USAGE_OFF;
+		g_cfg->osmux = OSMUX_USAGE_OFF;
 		return CMD_SUCCESS;
 	} else if (strcmp(argv[0], "on") == 0)
-		g_cfg->osmux.usage = OSMUX_USAGE_ON;
+		g_cfg->osmux = OSMUX_USAGE_ON;
 	else if (strcmp(argv[0], "only") == 0)
-		g_cfg->osmux.usage = OSMUX_USAGE_ONLY;
+		g_cfg->osmux = OSMUX_USAGE_ONLY;
 
 	return CMD_SUCCESS;
 
@@ -1583,29 +1552,12 @@ DEFUN(cfg_mgcp_osmux,
 
 DEFUN(cfg_mgcp_osmux_ip,
       cfg_mgcp_osmux_ip_cmd,
-      "osmux bind-ip " VTY_IPV4_CMD,
-      OSMUX_STR IP_STR
-      "IPv4 Address to bind to\n")
-{
-	osmo_talloc_replace_string(g_cfg, &g_cfg->osmux.local_addr_v4, argv[0]);
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_mgcp_osmux_ip_v6,
-      cfg_mgcp_osmux_ip_v6_cmd,
-      "osmux bind-ip-v6 " VTY_IPV6_CMD,
+      "osmux bind-ip " VTY_IPV46_CMD,
       OSMUX_STR IP_STR
+      "IPv4 Address to bind to\n"
       "IPv6 Address to bind to\n")
 {
-	osmo_talloc_replace_string(g_cfg, &g_cfg->osmux.local_addr_v6, argv[0]);
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_mgcp_osmux_port,
-      cfg_mgcp_osmux_port_cmd,
-      "osmux port <1-65535>", OSMUX_STR "port\n" "UDP port\n")
-{
-	g_cfg->osmux.local_port = atoi(argv[0]);
+	osmo_strlcpy(g_cfg->osmux_addr, argv[0], sizeof(g_cfg->osmux_addr));
 	return CMD_SUCCESS;
 }
 
@@ -1614,7 +1566,7 @@ DEFUN(cfg_mgcp_osmux_batch_factor,
       "osmux batch-factor <1-8>",
       OSMUX_STR "Batching factor\n" "Number of messages in the batch\n")
 {
-	g_cfg->osmux.batch_factor = atoi(argv[0]);
+	g_cfg->osmux_batch = atoi(argv[0]);
 	return CMD_SUCCESS;
 }
 
@@ -1623,7 +1575,15 @@ DEFUN(cfg_mgcp_osmux_batch_size,
       "osmux batch-size <1-65535>",
       OSMUX_STR "batch size\n" "Batch size in bytes\n")
 {
-	g_cfg->osmux.batch_size = atoi(argv[0]);
+	g_cfg->osmux_batch_size = atoi(argv[0]);
+	return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_osmux_port,
+      cfg_mgcp_osmux_port_cmd,
+      "osmux port <1-65535>", OSMUX_STR "port\n" "UDP port\n")
+{
+	g_cfg->osmux_port = atoi(argv[0]);
 	return CMD_SUCCESS;
 }
 
@@ -1634,24 +1594,9 @@ DEFUN(cfg_mgcp_osmux_dummy,
       "Disable dummy padding\n")
 {
 	if (strcmp(argv[0], "on") == 0)
-		g_cfg->osmux.dummy_padding = true;
+		g_cfg->osmux_dummy = 1;
 	else if (strcmp(argv[0], "off") == 0)
-		g_cfg->osmux.dummy_padding = false;
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_mgcp_osmux_peer_behind_nat,
-      cfg_mgcp_osmux_peer_behind_nat_cmd,
-      "osmux peer-behind-nat (on|off)",
-      OSMUX_STR "Define whether peer is behind NAT\n"
-      "Peer is behind NAT\n"
-      "Peer is NOT behind NAT\n")
-{
-	if (strcmp(argv[0], "on") == 0)
-		g_cfg->osmux.peer_behind_nat = true;
-	else if (strcmp(argv[0], "off") == 0)
-		g_cfg->osmux.peer_behind_nat = false;
+		g_cfg->osmux_dummy = 0;
 
 	return CMD_SUCCESS;
 }
@@ -1741,12 +1686,10 @@ int mgcp_vty_init(void)
 	install_element(MGCP_NODE, &cfg_mgcp_no_sdp_payload_send_name_cmd);
 	install_element(MGCP_NODE, &cfg_mgcp_osmux_cmd);
 	install_element(MGCP_NODE, &cfg_mgcp_osmux_ip_cmd);
-	install_element(MGCP_NODE, &cfg_mgcp_osmux_ip_v6_cmd);
-	install_element(MGCP_NODE, &cfg_mgcp_osmux_port_cmd);
 	install_element(MGCP_NODE, &cfg_mgcp_osmux_batch_factor_cmd);
 	install_element(MGCP_NODE, &cfg_mgcp_osmux_batch_size_cmd);
+	install_element(MGCP_NODE, &cfg_mgcp_osmux_port_cmd);
 	install_element(MGCP_NODE, &cfg_mgcp_osmux_dummy_cmd);
-	install_element(MGCP_NODE, &cfg_mgcp_osmux_peer_behind_nat_cmd);
 	install_element(MGCP_NODE, &cfg_mgcp_allow_transcoding_cmd);
 	install_element(MGCP_NODE, &cfg_mgcp_no_allow_transcoding_cmd);
 	install_element(MGCP_NODE, &cfg_mgcp_domain_cmd);
@@ -1791,9 +1734,9 @@ int mgcp_parse_config(const char *config_file, struct mgcp_config *cfg,
 	int rc;
 	struct mgcp_trunk *trunk;
 
-	cfg->osmux.local_port = OSMUX_DEFAULT_PORT;
-	cfg->osmux.batch_factor = 4;
-	cfg->osmux.batch_size = OSMUX_BATCH_DEFAULT_MAX;
+	cfg->osmux_port = OSMUX_PORT;
+	cfg->osmux_batch = 4;
+	cfg->osmux_batch_size = OSMUX_BATCH_DEFAULT_MAX;
 
 	g_cfg = cfg;
 	rc = vty_read_config_file(config_file, NULL);

src/osmo-mgw/mgw_main.c

@@ -41,6 +41,7 @@
 #include <osmocom/mgcp/debug.h>
 #include <osmocom/mgcp/mgcp_endp.h>
 #include <osmocom/mgcp/mgcp_trunk.h>
+#include <osmocom/mgcp/mgcp_ctrl.h>
 
 #include <osmocom/core/application.h>
 #include <osmocom/core/msgb.h>
@@ -50,7 +51,7 @@
 #include <osmocom/core/rate_ctr.h>
 #include <osmocom/core/logging.h>
 #include <osmocom/core/socket.h>
-#include <osmocom/ctrl/control_if.h>
+
 #include <osmocom/ctrl/control_vty.h>
 
 #include <osmocom/vty/telnet_interface.h>
@@ -82,7 +83,7 @@ static int daemonize = 0;
 
 const char *osmomgw_copyright =
 	"Copyright (C) 2009-2010 Holger Freyther and On-Waves\r\n"
-	"Copyright (C) 2017-2022 by sysmocom s.f.m.c. GmbH\r\n"
+	"Copyright (C) 2017 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>\r\n"
 	"Contributions by Pablo Neira Ayuso, Jacob Erlbeck, Neels Hofmeyr\r\n"
 	"Philipp Maier\r\n\r\n"
 	"License AGPLv3+: GNU AGPL version 3 or later <http://gnu.org/licenses/agpl-3.0.html>\r\n"
@@ -94,7 +95,7 @@ static char *config_file = "osmo-mgw.cfg";
 /* used by msgb and mgcp */
 void *tall_mgw_ctx = NULL;
 
-static void print_help(void)
+static void print_help()
 {
 	printf("Some useful options:\n");
 	printf(" -h --help is printing this text.\n");
@@ -294,22 +295,13 @@ static const struct log_info_cat log_categories[] = {
 		  .name = "DRTP",
 		  .description = "RTP stream handling",
 		  .color = "\033[1;30m",
-		  .enabled = 1,
-		  .loglevel = LOGL_NOTICE,
+		  .enabled = 1,.loglevel = LOGL_NOTICE,
 	},
 	[DE1] = {
 		  .name = "DE1",
 		  .description = "E1 line handling",
 		  .color = "\033[1;31m",
-		  .enabled = 1,
-		  .loglevel = LOGL_NOTICE,
-	},
-	[DOSMUX] = {
-		  .name = "DOSMUX",
-		  .description = "Osmux (Osmocom RTP multiplexing)",
-		  .color = "\033[1;32m",
-		  .enabled = 1,
-		  .loglevel = LOGL_NOTICE,
+		  .enabled = 1,.loglevel = LOGL_NOTICE,
 	},
 };
 
@@ -360,11 +352,12 @@ int main(int argc, char **argv)
 		return rc;
 
 	/* start telnet after reading config for vty_get_bind_addr() */
-	rc = telnet_init_default(tall_mgw_ctx, NULL, OSMO_VTY_PORT_MGW);
+	rc = telnet_init_dynif(tall_mgw_ctx, NULL,
+			       vty_get_bind_addr(), OSMO_VTY_PORT_MGW);
 	if (rc < 0)
 		return rc;
 
-	cfg->ctrl = ctrl_interface_setup(cfg, OSMO_CTRL_PORT_MGW, NULL);
+	cfg->ctrl = mgw_ctrl_interface_setup(cfg, ctrl_vty_get_bind_addr(), OSMO_CTRL_PORT_MGW);
 	if (!cfg->ctrl) {
 		fprintf(stderr, "Failed to init the control interface on %s:%u. Exiting\n",
 			ctrl_vty_get_bind_addr(), OSMO_CTRL_PORT_MGW);

tests/Makefile.am

@@ -34,11 +34,11 @@ DISTCLEANFILES = \
 	$(NULL)
 
 if ENABLE_EXT_TESTS
-python-tests: $(top_builddir)/src/osmo-mgw/osmo-mgw
+python-tests: $(BUILT_SOURCES)
 	osmotestvty.py -p $(abs_top_srcdir) -w $(abs_top_builddir) -v
 	osmotestconfig.py -p $(abs_top_srcdir) -w $(abs_top_builddir) -v
 else
-python-tests:
+python-tests: $(BUILT_SOURCES)
 	echo "Not running python-based tests (determined at configure-time)"
 endif
 

tests/mgcp/Makefile.am

@@ -18,14 +18,13 @@ AM_CFLAGS = \
 
 AM_LDFLAGS = \
 	$(COVERAGE_LDFLAGS) \
-	-no-install \
 	$(NULL)
 
 EXTRA_DIST = \
 	mgcp_test.ok \
 	$(NULL)
 
-check_PROGRAMS = \
+noinst_PROGRAMS = \
 	mgcp_test \
 	$(NULL)
 

tests/mgcp/mgcp_test.c

@@ -77,8 +77,6 @@ static void test_strline(void)
 #define AUEP1_RET "500 158663169 FAIL\r\n"
 #define AUEP2	"AUEP 18983213 ds/e1-2/1@mgw MGCP 1.0\r\n"
 #define AUEP2_RET "500 18983213 FAIL\r\n"
-#define AUEP_NULL "AUEP 18983215 null@mgw MGCP 1.0\r\n"
-#define AUEP_NULL_RET "200 18983215 OK\r\n"
 #define EMPTY	"\r\n"
 #define EMPTY_RET NULL
 #define SHORT	"CRCX \r\n"
@@ -276,12 +274,6 @@ static void test_strline(void)
 
 #define MDCX_TOO_LONG_CI_RET "510 18983224 FAIL\r\n"
 
-#define MDCX_NULL \
-	"MDCX 9 null@mgw MGCP 1.0\r\n" \
-	"I: %s\n"
-
-#define MDCX_NULL_RET "502 9 FAIL\r\n"
-
 #define SHORT2	"CRCX 1"
 #define SHORT2_RET "510 000000 FAIL\r\n"
 #define SHORT3	"CRCX 1 1@mgw"
@@ -400,13 +392,6 @@ static void test_strline(void)
  #define DLCX_RET_OSMUX DLCX_RET \
 	"X-Osmo-CP: EC TI=0, TO=0\r\n"
 
-#define DLCX_NULL \
-	"DLCX 8 null@mgw MGCP 1.0\r\n" \
-	"I: %s\r\n" \
-	"C: 2\r\n"
-
-#define DLCX_NULL_RET "502 8 FAIL\r\n"
-
 #define RQNT \
 	"RQNT 186908780 1@mgw MGCP 1.0\r\n" \
 	"X: B244F267488\r\n" \
@@ -420,13 +405,6 @@ static void test_strline(void)
 #define RQNT1_RET "200 186908780 OK\r\n"
 #define RQNT2_RET "200 186908781 OK\r\n"
 
-#define RQNT_NULL \
-	"RQNT 186908782 null@mgw MGCP 1.0\r\n" \
-	"X: B244F267488\r\n" \
-	"S: D/9\r\n"
-
-#define RQNT_NULL_RET "502 186908782 FAIL\r\n"
-
 #define PTYPE_IGNORE 0		/* == default initializer */
 #define PTYPE_NONE 128
 #define PTYPE_NYI  PTYPE_NONE
@@ -567,20 +545,6 @@ static void test_strline(void)
 	"m=audio 16008 RTP/AVP 0\r\n" \
 	"a=ptime:20\r\n"
 
-#define CRCX_NULL \
-	"CRCX 2 null@mgw MGCP 1.0\r\n" \
-	"m: recvonly\r\n" \
-	"C: 2\r\n" \
-	"L: p:20\r\n" \
-	"\r\n" \
-	"v=0\r\n" \
-	"c=IN IP4 123.12.12.123\r\n" \
-	"m=audio 5904 RTP/AVP 97\r\n" \
-	"a=rtpmap:97 GSM-EFR/8000\r\n" \
-	"a=ptime:40\r\n"
-
-#define CRCX_NULL_RET "502 2 FAIL\r\n"
-
 struct mgcp_test {
 	const char *name;
 	const char *req;
@@ -622,11 +586,6 @@ static const struct mgcp_test tests[] = {
 	{"CRCX", CRCX_X_OSMO_IGN, CRCX_X_OSMO_IGN_RET, 97},
 	{"MDCX_TOO_LONG_CI", MDCX_TOO_LONG_CI, MDCX_TOO_LONG_CI_RET},
 	{"CRCX", CRCX_AMR_WITH_FMTP, CRCX_AMR_WITH_FMTP_RET},
-	{"AUEP_NULL", AUEP_NULL, AUEP_NULL_RET},
-	{"CRCX_NULL", CRCX_NULL, CRCX_NULL_RET},
-	{"MDCX_NULL", MDCX_NULL, MDCX_NULL_RET},
-	{"DLCX_NULL", DLCX_NULL, DLCX_NULL_RET},
-	{"RQNT_NULL", RQNT_NULL, RQNT_NULL_RET},
 };
 
 static const struct mgcp_test retransmit[] = {
@@ -879,7 +838,7 @@ static void test_messages(void)
 				if (endp->local_options.pkt_period_min ||
 				    endp->local_options.pkt_period_max)
 					printf
-					    ("Requested packetization period: "
+					    ("Requested packetetization period: "
 					     "%d-%d\n",
 					     endp->local_options.pkt_period_min,
 					     endp->
@@ -909,7 +868,7 @@ static void test_messages(void)
 					printf("Connection mode not set\n");
 
 				OSMO_ASSERT(conn->end.output_enabled
-					    == !!(conn->conn->mode & MGCP_CONN_SEND_ONLY));
+					    == (conn->conn->mode & MGCP_CONN_SEND_ONLY ? 1 : 0));
 
 				conn->conn->mode |= CONN_UNMODIFIED;
 
@@ -1112,7 +1071,7 @@ static void test_packet_loss_calc(void)
 				    "test-connection");
 		conn = mgcp_conn_get_rtp(&endp, _conn->id);
 		state = &conn->state;
-		packets_rx = rate_ctr_group_get_ctr(conn->ctrg, RTP_PACKETS_RX_CTR);
+		packets_rx = rate_ctr_group_get_ctr(conn->rate_ctr_group, RTP_PACKETS_RX_CTR);
 
 		state->stats.initialized = 1;
 		state->stats.base_seq = pl_test_dat[i].base_seq;
@@ -1508,6 +1467,7 @@ static void test_multilple_codec(void)
 	/* Allocate 5@mgw and let osmo-mgw pick a codec from the list */
 	last_endpoint[0] = '\0';
 	inp = create_msg(CRCX_MULT_GSM_EXACT, NULL);
+	trunk->no_audio_transcoding = 1;
 	resp = mgcp_handle_message(cfg, inp);
 	OSMO_ASSERT(get_conn_id_from_response(resp->data, conn_id,
 					      sizeof(conn_id)) == 0);
@@ -1532,7 +1492,7 @@ static void test_multilple_codec(void)
 	conn = mgcp_conn_get_rtp(endp, conn_id);
 	OSMO_ASSERT(conn);
 	OSMO_ASSERT(conn->end.codec->payload_type == 3);
-	OSMO_ASSERT(osmo_sockaddr_port(&conn->end.addr.u.sa) == 16434);
+	OSMO_ASSERT(conn->end.rtp_port == htons(16434));
 	memset(&addr, 0, sizeof(addr));
 	inet_aton("8.8.8.8", &addr);
 	OSMO_ASSERT(conn->end.addr.u.sa.sa_family == AF_INET);
@@ -1551,6 +1511,7 @@ static void test_multilple_codec(void)
 
 	last_endpoint[0] = '\0';
 	inp = create_msg(CRCX_MULT_GSM_EXACT, NULL);
+	trunk->no_audio_transcoding = 0;
 	resp = mgcp_handle_message(cfg, inp);
 	OSMO_ASSERT(get_conn_id_from_response(resp->data, conn_id,
 					      sizeof(conn_id)) == 0);
@@ -1671,8 +1632,7 @@ static void test_osmux_cid(void)
 
 	for (i = 0; i < 256; ++i) {
 		id = osmux_cid_pool_get_next();
-		/* We called osmux_cid_pool_get_next() above, so next CID is i+1. */
-		OSMO_ASSERT(id == ((i + 1) & 0xff));
+		OSMO_ASSERT(id == i);
 		OSMO_ASSERT(osmux_cid_pool_count_used() == i + 1);
 	}
 
@@ -1808,25 +1768,26 @@ static const struct mgcp_codec_param amr_param_octet_aligned_unset = {
 	.amr_octet_aligned_present = false,
 };
 
-struct testcase_mgcp_codec_decide_codec {
+struct testcase_mgcp_codec_pt_translate_codec {
 	int payload_type;
 	const char *audio_name;
 	const struct mgcp_codec_param *param;
 	int expect_rc;
 };
 
-struct testcase_mgcp_codec_decide_expect {
+struct testcase_mgcp_codec_pt_translate_expect {
+	bool end;
 	int payload_type_map[2];
 };
 
-struct testcase_mgcp_codec_decide {
+struct testcase_mgcp_codec_pt_translate {
 	const char *descr;
 	/* two conns on an endpoint, each with N configured codecs */
-	struct testcase_mgcp_codec_decide_codec codecs[2][10];
-	struct testcase_mgcp_codec_decide_expect expect[2];
+	struct testcase_mgcp_codec_pt_translate_codec codecs[2][10];
+	struct testcase_mgcp_codec_pt_translate_expect expect[32];
 };
 
-static const struct testcase_mgcp_codec_decide test_mgcp_codec_find_convertible_cases[] = {
+static const struct testcase_mgcp_codec_pt_translate test_mgcp_codec_pt_translate_cases[] = {
 	{
 		.descr = "same order, but differing payload type numbers",
 		.codecs = {
@@ -1843,7 +1804,10 @@ static const struct testcase_mgcp_codec_decide test_mgcp_codec_find_convertible_
 		},
 		.expect = {
 			{ .payload_type_map = {112, 96}, },
-			{ .payload_type_map = {112, 96}, },
+			{ .payload_type_map = {0, 0}, },
+			{ .payload_type_map = {111, 97} },
+			{ .payload_type_map = {123, -EINVAL} },
+			{ .end = true },
 		},
 	},
 	{
@@ -1861,8 +1825,11 @@ static const struct testcase_mgcp_codec_decide test_mgcp_codec_find_convertible_
 			},
 		},
 		.expect = {
+			{ .payload_type_map = {112, 96}, },
 			{ .payload_type_map = {0, 0}, },
-			{ .payload_type_map = {111, 97}, },
+			{ .payload_type_map = {111, 97} },
+			{ .payload_type_map = {123, -EINVAL} },
+			{ .end = true },
 		},
 	},
 	{
@@ -1880,8 +1847,10 @@ static const struct testcase_mgcp_codec_decide test_mgcp_codec_find_convertible_
 			},
 		},
 		.expect = {
-			{ .payload_type_map = {0, 0}, },
 			{ .payload_type_map = {96, 97}, },
+			{ .payload_type_map = {97, 96}, },
+			{ .payload_type_map = {0, 0}, },
+			{ .end = true },
 		},
 	},
 	{
@@ -1897,8 +1866,10 @@ static const struct testcase_mgcp_codec_decide test_mgcp_codec_find_convertible_
 			},
 		},
 		.expect = {
-			{ .payload_type_map = {-EINVAL, -EINVAL}, },
-			{ .payload_type_map = {-EINVAL, 96}, },
+			{ .payload_type_map = {112, -EINVAL}, },
+			{ .payload_type_map = {0, -EINVAL}, },
+			{ .payload_type_map = {111, -EINVAL} },
+			{ .end = true },
 		},
 	},
 	{
@@ -1915,11 +1886,13 @@ static const struct testcase_mgcp_codec_decide test_mgcp_codec_find_convertible_
 		},
 		.expect = {
 			{ .payload_type_map = {112, -EINVAL}, },
-			{ .payload_type_map = {-EINVAL, -EINVAL}, },
+			{ .payload_type_map = {0, -EINVAL}, },
+			{ .payload_type_map = {111, -EINVAL} },
+			{ .end = true },
 		},
 	},
 	{
-		.descr = "test AMR with differing octet-aligned settings (both <-> both)",
+		.descr = "test AMR with differing octet-aligned settings",
 		.codecs = {
 			{
 				{ 111, "AMR/8000", &amr_param_octet_aligned_true, },
@@ -1933,90 +1906,31 @@ static const struct testcase_mgcp_codec_decide test_mgcp_codec_find_convertible_
 		.expect = {
 			{ .payload_type_map = {111, 121}, },
 			{ .payload_type_map = {112, 122} },
+			{ .end = true },
 		},
 	},
 	{
-		.descr = "test AMR with differing octet-aligned settings (oa <-> both)",
+		.descr = "test AMR with missing octet-aligned settings (defaults to 0)",
 		.codecs = {
 			{
 				{ 111, "AMR/8000", &amr_param_octet_aligned_true, },
-			},
-			{
-				{ 122, "AMR/8000", &amr_param_octet_aligned_false, },
-				{ 121, "AMR/8000", &amr_param_octet_aligned_true, },
-			},
-		},
-		.expect = {
-			{ .payload_type_map = {111, 121}, },
-			{ .payload_type_map = {111, 121}, },
-		},
-	},
-	{
-		.descr = "test AMR with differing octet-aligned settings (bwe <-> both)",
-		.codecs = {
-			{
 				{ 112, "AMR/8000", &amr_param_octet_aligned_false, },
 			},
 			{
-				{ 122, "AMR/8000", &amr_param_octet_aligned_false, },
-				{ 121, "AMR/8000", &amr_param_octet_aligned_true, },
+				{ 122, "AMR/8000", &amr_param_octet_aligned_unset, },
 			},
 		},
 		.expect = {
-			{ .payload_type_map = {112, 122}, },
-			{ .payload_type_map = {112, 122}, },
+			{ .payload_type_map = {111, -EINVAL}, },
+			{ .payload_type_map = {112, 122} },
+			{ .end = true },
 		},
 	},
 	{
-		.descr = "test AMR with missing octet-aligned settings (oa <-> unset)",
+		.descr = "test AMR with NULL param (defaults to 0)",
 		.codecs = {
 			{
 				{ 111, "AMR/8000", &amr_param_octet_aligned_true, },
-			},
-			{
-				{ 122, "AMR/8000", &amr_param_octet_aligned_unset, },
-			},
-		},
-		.expect = {
-			{ .payload_type_map = {111, 122}, },
-			{ .payload_type_map = {111, 122}, },
-		},
-	},
-	{
-		.descr = "test AMR with missing octet-aligned settings (bwe <-> unset)",
-		.codecs = {
-			{
-				{ 111, "AMR/8000", &amr_param_octet_aligned_false, },
-			},
-			{
-				{ 122, "AMR/8000", &amr_param_octet_aligned_unset, },
-			},
-		},
-		.expect = {
-			{ .payload_type_map = {111, 122}, },
-			{ .payload_type_map = {111, 122}, },
-		},
-	},
-	{
-		.descr = "test AMR with NULL param (oa <-> null)",
-		.codecs = {
-			{
-				{ 112, "AMR/8000", &amr_param_octet_aligned_true, },
-			},
-			{
-				{ 122, "AMR/8000", NULL, },
-			},
-		},
-		.expect = {
-			/* Note: Both 111, anbd 112 will translate to 122. The translation from 112 */
-			{ .payload_type_map = {112, 122} },
-			{ .payload_type_map = {112, 122}, },
-		},
-	},
-	{
-		.descr = "test AMR with NULL param (bwe <-> null)",
-		.codecs = {
-			{
 				{ 112, "AMR/8000", &amr_param_octet_aligned_false, },
 			},
 			{
@@ -2024,9 +1938,9 @@ static const struct testcase_mgcp_codec_decide test_mgcp_codec_find_convertible_
 			},
 		},
 		.expect = {
-			/* Note: Both 111, anbd 112 will translate to 122. The translation from 112 */
+			{ .payload_type_map = {111, -EINVAL}, },
 			{ .payload_type_map = {112, 122} },
-			{ .payload_type_map = {112, 122}, },
+			{ .end = true },
 		},
 	},
 	{
@@ -2044,8 +1958,11 @@ static const struct testcase_mgcp_codec_decide test_mgcp_codec_find_convertible_
 			},
 		},
 		.expect = {
+			{ .payload_type_map = {112, 96}, },
 			{ .payload_type_map = {0, 0}, },
-			{ .payload_type_map = {111, 97}, },
+			{ .payload_type_map = {111, 97} },
+			{ .payload_type_map = {123, -EINVAL} },
+			{ .end = true },
 		},
 	},
 	{
@@ -2063,8 +1980,11 @@ static const struct testcase_mgcp_codec_decide test_mgcp_codec_find_convertible_
 			},
 		},
 		.expect = {
+			{ .payload_type_map = {112, 96}, },
 			{ .payload_type_map = {0, 0}, },
-			{ .payload_type_map = {111, 97}, },
+			{ .payload_type_map = {111, 97} },
+			{ .payload_type_map = {123, -EINVAL} },
+			{ .end = true },
 		},
 	},
 	{
@@ -2082,97 +2002,45 @@ static const struct testcase_mgcp_codec_decide test_mgcp_codec_find_convertible_
 		},
 		.expect = {
 			{ .payload_type_map = {111, 121}, },
-			{ .payload_type_map = {111, 121} },
+			{ .payload_type_map = {112, -EINVAL} },
+			{ .payload_type_map = {113, -EINVAL} },
+			{ .end = true },
 		},
 	},
 };
 
-static bool codec_decision(struct mgcp_conn_rtp *conn, unsigned int index_conn_src, unsigned int index_conn_dst,
-			   const struct testcase_mgcp_codec_decide_expect *expect)
-{
-	bool ok = true;
-	int payload_type_conn_src;
-	int payload_type_conn_dst;
-
-	printf(" - mgcp_codec_decide(&conn[%u], &conn[%u]):\n", index_conn_src, index_conn_dst);
-	if (mgcp_codec_decide(&conn[index_conn_src], &conn[index_conn_dst]) != 0) {
-		if (expect->payload_type_map[index_conn_src] == -EINVAL
-		    && expect->payload_type_map[index_conn_dst] == -EINVAL)
-			printf("    codec decision failed (expected)!\n");
-		else {
-			printf("    ERROR: codec decision failed!\n");
-			ok = false;
-		}
-	} else {
-		printf("    Codec decision result:\n");
-		if (conn[index_conn_src].end.codec) {
-			payload_type_conn_src = conn[index_conn_src].end.codec->payload_type;
-			printf("    conn[%u]: codec:%s, pt:%d\n",
-			       index_conn_src, conn[index_conn_src].end.codec->subtype_name, payload_type_conn_src);
-		} else {
-			payload_type_conn_src = -EINVAL;
-			printf("    conn[%u]: codec:none, pt:none\n", index_conn_src);
-		}
-
-		if (conn[index_conn_dst].end.codec) {
-			payload_type_conn_dst = conn[index_conn_dst].end.codec->payload_type;
-			printf("    conn[%u]: codec:%s, pt:%d\n",
-			       index_conn_dst, conn[index_conn_dst].end.codec->subtype_name,
-			       payload_type_conn_dst);
-		} else {
-			payload_type_conn_dst = -EINVAL;
-			printf("    conn[%u]: codec:none, pt:none\n", index_conn_dst);
-		}
-
-		if (payload_type_conn_src != expect->payload_type_map[index_conn_src]) {
-			printf("    ERROR: conn[%u] unexpected codec decision, expected pt=%d, got pt=%d\n",
-			       index_conn_src, expect->payload_type_map[index_conn_src], payload_type_conn_src);
-			ok = false;
-		}
-
-		if (payload_type_conn_dst != expect->payload_type_map[index_conn_dst]) {
-			printf("    ERROR: conn[%u] unexpected codec decision, expected pt=%d, got pt=%d\n",
-			       index_conn_dst, expect->payload_type_map[index_conn_dst],
-			       payload_type_conn_dst);
-			ok = false;
-		}
-	}
-
-	return ok;
-}
-
-static void test_mgcp_codec_decide(void)
+static void test_mgcp_codec_pt_translate(void)
 {
 	int i;
 	bool ok = true;
-	printf("\nTesting mgcp_codec_find_convertible()\n");
+	printf("\nTesting mgcp_codec_pt_translate()\n");
 
-	for (i = 0; i < ARRAY_SIZE(test_mgcp_codec_find_convertible_cases); i++) {
-		const struct testcase_mgcp_codec_decide *t = &test_mgcp_codec_find_convertible_cases[i];
-		struct mgcp_conn_rtp conn[2] = { };
+	for (i = 0; i < ARRAY_SIZE(test_mgcp_codec_pt_translate_cases); i++) {
+		const struct testcase_mgcp_codec_pt_translate *t = &test_mgcp_codec_pt_translate_cases[i];
+		struct mgcp_conn_rtp conn[2] = {};
 		int rc;
 		int conn_i;
 		int c;
 
 		printf("#%d: %s\n", i, t->descr);
 
-		/* Build testvector (add codecs to conn, set properties etc... */
 		for (conn_i = 0; conn_i < 2; conn_i++) {
 			printf(" - add codecs on conn%d:\n", conn_i);
 			for (c = 0; c < ARRAY_SIZE(t->codecs[conn_i]); c++) {
-				const struct testcase_mgcp_codec_decide_codec *codec = &t->codecs[conn_i][c];
+				const struct testcase_mgcp_codec_pt_translate_codec *codec = &t->codecs[conn_i][c];
 				if (!codec->audio_name)
 					break;
 
-				rc = mgcp_codec_add(&conn[conn_i], codec->payload_type, codec->audio_name,
-						    codec->param);
+				rc = mgcp_codec_add(&conn[conn_i], codec->payload_type, codec->audio_name, codec->param);
 
 				printf("   %2d: %3d %s%s  -> rc=%d\n", c, codec->payload_type, codec->audio_name,
 				       codec->param ?
-				       (codec->param->amr_octet_aligned_present ?
-					(codec->param->amr_octet_aligned ? " octet-aligned=1" : " octet-aligned=0")
-					: " octet-aligned=unset")
-				       : "", rc);
+					       (codec->param->amr_octet_aligned_present?
+							(codec->param->amr_octet_aligned ?
+								" octet-aligned=1" : " octet-aligned=0")
+							: " octet-aligned=unset")
+						: "",
+						rc);
 				if (rc != codec->expect_rc) {
 					printf("     ERROR: expected rc=%d\n", codec->expect_rc);
 					ok = false;
@@ -2182,23 +2050,42 @@ static void test_mgcp_codec_decide(void)
 				printf("    (none)\n");
 		}
 
-		/* Run codec decision and check expectation */
-		if (!codec_decision(conn, 0, 1, &t->expect[0]))
-			ok = false;
+		for (c = 0; c < ARRAY_SIZE(t->expect); c++) {
+			const struct testcase_mgcp_codec_pt_translate_expect *expect = &t->expect[c];
+			int result;
 
-		if (!codec_decision(conn, 1, 0, &t->expect[1]))
-			ok = false;
+			if (expect->end)
+				break;
 
-		if (ok)
-			printf(" ===> SUCCESS: codec decision as expected!\n");
-		else
-			printf(" ===> FAIL: unexpected codec decision!\n");
+			result = mgcp_codec_pt_translate(&conn[0], &conn[1], expect->payload_type_map[0]);
+			printf(" - mgcp_codec_pt_translate(conn0, conn1, %d) -> %d\n",
+			       expect->payload_type_map[0], result);
+			if (result != expect->payload_type_map[1]) {
+				printf("     ERROR: expected -> %d\n", expect->payload_type_map[1]);
+				ok = false;
+			}
+
+			/* If the expected result is an error, don't do reverse map test */
+			if (expect->payload_type_map[1] < 0)
+				continue;
+
+			result = mgcp_codec_pt_translate(&conn[1], &conn[0], expect->payload_type_map[1]);
+			printf(" - mgcp_codec_pt_translate(conn1, conn0, %d) -> %d\n",
+			       expect->payload_type_map[1], result);
+			if (result != expect->payload_type_map[0]) {
+				printf("     ERROR: expected -> %d\n", expect->payload_type_map[0]);
+				ok = false;
+			}
+		}
+
+		for (conn_i = 0; conn_i < 2; conn_i++)
+			mgcp_codec_reset_all(&conn[conn_i]);
 	}
 
 	OSMO_ASSERT(ok);
 }
 
-void test_conn_id_matching(void)
+void test_conn_id_matching()
 {
 	struct mgcp_endpoint endp = {};
 	struct mgcp_conn *conn;
@@ -2238,7 +2125,7 @@ void test_conn_id_matching(void)
 	talloc_free(conn);
 }
 
-void test_e1_trunk_nr_from_epname(void)
+void test_e1_trunk_nr_from_epname()
 {
 	unsigned int trunk_nr;
 	int rc;
@@ -2288,7 +2175,7 @@ void test_e1_trunk_nr_from_epname(void)
 	return;
 }
 
-void test_mgcp_is_rtp_dummy_payload(void)
+void test_mgcp_is_rtp_dummy_payload()
 {
 	/* realistic rtp packet */
 	static const char rtp_payload[] =
@@ -2352,7 +2239,7 @@ int main(int argc, char **argv)
 	test_osmux_cid();
 	test_get_lco_identifier();
 	test_check_local_cx_options(ctx);
-	test_mgcp_codec_decide();
+	test_mgcp_codec_pt_translate();
 	test_conn_id_matching();
 	test_e1_trunk_nr_from_epname();
 	test_mgcp_is_rtp_dummy_payload();

tests/mgcp/mgcp_test.ok

@@ -525,80 +525,6 @@ Response matches our expectations.
 L: p:20
 
 v=0
-c=IN IP4 123.12.12.123
-m=audio 5904 RTP/AVP 111
-a=rtpmap:111 AMR/8000/1
-a=ptime:20
-a=fmtp:111 mode-change-capability=2; octet-align=1
-
----------8<---------
-checking response:
-using message with patched conn_id for comparison
-Response matches our expectations.
-(response contains a connection id)
-Dummy packets: 2
-
-================================================
-Testing AUEP_NULL
-creating message from statically defined input:
----------8<---------
-AUEP 18983215 null@mgw MGCP 1.0
-
----------8<---------
-checking response:
-using message as statically defined for comparison
-Response matches our expectations.
-(response does not contain a connection id)
-
-================================================
-Testing CRCX_NULL
-creating message from statically defined input:
----------8<---------
-CRCX 2 null@mgw MGCP 1.0
-m: recvonly
-C: 2
-L: p:20
-
-v=0
-c=IN IP4 123.12.12.123
-m=audio 5904 RTP/AVP 97
-a=rtpmap:97 GSM-EFR/8000
-a=ptime:40
-
----------8<---------
-checking response:
-using message as statically defined for comparison
-Response matches our expectations.
-(response does not contain a connection id)
-
-================================================
-Testing MDCX_NULL
-creating message from statically defined input:
----------8<---------
-MDCX 9 null@mgw MGCP 1.0
-I: %s
-
----------8<---------
-checking response:
-using message as statically defined for comparison
-Response matches our expectations.
-(response does not contain a connection id)
-
-================================================
-Testing DLCX_NULL
-creating message from statically defined input:
----------8<---------
-DLCX 8 null@mgw MGCP 1.0
-I: %s
-C: 2
-
----------8<---------
-checking response:
-using message as statically defined for comparison
-Response matches our expectations.
-(response does not contain a connection id)
-
-================================================
 c=IN IP4 123.12.12.123
 m=audio 5904 RTP/AVP 111
 a=rtpmap:111 AMR/8000/1
@@ -1350,7 +1276,7 @@ p:10, a:PCMU -> p:10, a:PCMU
 Response matches our expectations.
 Testing get_lco_identifier()
 p:10, a:PCMU -> p:10, a:PCMU
-p:10, a:PCMU -> p:10, a:PCMU
+p:10, a:PCMU -> p:10, a:PCMU
 'XXXX, p:10, a:PCMU' -> 'p:10, a:PCMU'
 'XXXX,p:10,a:PCMU' -> 'p:10,a:PCMU'
 '10,a:PCMU' -> 'a:PCMU'
@@ -1360,15 +1286,13 @@ Testing mgcp_codec_find_convertible()
 ', a:PCMU' -> 'a:PCMU'
 ' a:PCMU' -> 'a:PCMU'
 '' -> '(null)'
-p10, aPCMU -> (null)
-'10,a :PCMU' -> '(null)'
-
-Testing mgcp_codec_find_convertible()
-#0: same order, but differing payload type numbers
- - add codecs on conn0:
-    0: 112 AMR/8000/1 octet-aligned=1  -> rc=0
-    1:   0 PCMU/8000/1  -> rc=0
-    2: 111 GSM-HR-08/8000/1  -> rc=0
+p10, aPCMU -> (null)
+'10,a :PCMU' -> '(null)'
+
+Testing mgcp_codec_pt_translate()
+#0: same order, but differing payload type numbers
+ - add codecs on conn0:
+    0: 112 AMR/8000/1 octet-aligned=1  -> rc=0
     1:   0 PCMU/8000/1  -> rc=0
     2: 111 GSM-HR-08/8000/1  -> rc=0
  - add codecs on conn1:
@@ -1378,15 +1302,13 @@ Testing mgcp_codec_find_convertible()
  - mgcp_codec_pt_translate(conn0, conn1, 112) -> 96
  - mgcp_codec_pt_translate(conn1, conn0, 96) -> 112
  - mgcp_codec_pt_translate(conn0, conn1, 0) -> 0
-    Codec decision result:
-    conn[1]: codec:AMR, pt:96
-    conn[0]: codec:AMR, pt:112
- ===> SUCCESS: codec decision as expected!
-#1: different order and different payload type numbers
- - add codecs on conn0:
-    0:   0 PCMU/8000/1  -> rc=0
-    1: 111 GSM-HR-08/8000/1  -> rc=0
-    2: 112 AMR/8000/1 octet-aligned=1  -> rc=0
+ - mgcp_codec_pt_translate(conn1, conn0, 0) -> 0
+ - mgcp_codec_pt_translate(conn0, conn1, 111) -> 97
+ - mgcp_codec_pt_translate(conn1, conn0, 97) -> 111
+ - mgcp_codec_pt_translate(conn0, conn1, 123) -> -22
+#1: different order and different payload type numbers
+ - add codecs on conn0:
+    0:   0 PCMU/8000/1  -> rc=0
     1: 111 GSM-HR-08/8000/1  -> rc=0
     2: 112 AMR/8000/1 octet-aligned=1  -> rc=0
  - add codecs on conn1:
@@ -1396,15 +1318,12 @@ Testing mgcp_codec_find_convertible()
  - mgcp_codec_pt_translate(conn0, conn1, 112) -> 96
  - mgcp_codec_pt_translate(conn1, conn0, 96) -> 112
  - mgcp_codec_pt_translate(conn0, conn1, 0) -> 0
-    Codec decision result:
-    conn[1]: codec:GSM-HR-08, pt:97
-    conn[0]: codec:GSM-HR-08, pt:111
- ===> SUCCESS: codec decision as expected!
-#2: both sides have the same payload_type numbers assigned to differing codecs
- - add codecs on conn0:
-    0:   0 PCMU/8000/1  -> rc=0
-    1:  96 GSM-HR-08/8000/1  -> rc=0
-    2:  97 AMR/8000/1 octet-aligned=1  -> rc=0
+ - mgcp_codec_pt_translate(conn1, conn0, 0) -> 0
+ - mgcp_codec_pt_translate(conn0, conn1, 111) -> 97
+ - mgcp_codec_pt_translate(conn1, conn0, 97) -> 111
+ - mgcp_codec_pt_translate(conn0, conn1, 123) -> -22
+#2: both sides have the same payload_type numbers assigned to differing codecs
+ - add codecs on conn0:
     0:   0 PCMU/8000/1  -> rc=0
     1:  96 GSM-HR-08/8000/1  -> rc=0
     2:  97 AMR/8000/1 octet-aligned=1  -> rc=0
@@ -1412,13 +1331,9 @@ Testing mgcp_codec_find_convertible()
     0:  97 GSM-HR-08/8000/1  -> rc=0
     1:   0 PCMU/8000/1  -> rc=0
     2:  96 AMR/8000/1 octet-aligned=1  -> rc=0
-    conn[1]: codec:PCMU, pt:0
- - mgcp_codec_decide(&conn[1], &conn[0]):
-    Codec decision result:
-    conn[1]: codec:GSM-HR-08, pt:97
-    conn[0]: codec:GSM-HR-08, pt:96
- ===> SUCCESS: codec decision as expected!
-#3: conn0 has no codecs
+ - mgcp_codec_pt_translate(conn0, conn1, 96) -> 97
+ - mgcp_codec_pt_translate(conn1, conn0, 97) -> 96
+ - mgcp_codec_pt_translate(conn0, conn1, 97) -> 96
  - mgcp_codec_pt_translate(conn1, conn0, 96) -> 97
  - mgcp_codec_pt_translate(conn0, conn1, 0) -> 0
  - mgcp_codec_pt_translate(conn1, conn0, 0) -> 0
@@ -1426,116 +1341,39 @@ Testing mgcp_codec_find_convertible()
  - add codecs on conn0:
     (none)
  - add codecs on conn1:
-    codec decision failed (expected)!
- - mgcp_codec_decide(&conn[1], &conn[0]):
-    Codec decision result:
-    conn[1]: codec:AMR, pt:96
-    conn[0]: codec:none, pt:none
- ===> SUCCESS: codec decision as expected!
-#4: conn1 has no codecs
- - add codecs on conn0:
+    0:  96 AMR/8000/1 octet-aligned=1  -> rc=0
+    1:   0 PCMU/8000/1  -> rc=0
+    2:  97 GSM-HR-08/8000/1  -> rc=0
+ - mgcp_codec_pt_translate(conn0, conn1, 112) -> -22
  - mgcp_codec_pt_translate(conn0, conn1, 0) -> -22
  - mgcp_codec_pt_translate(conn0, conn1, 111) -> -22
 #4: conn1 has no codecs
  - add codecs on conn0:
     0: 112 AMR/8000/1 octet-aligned=1  -> rc=0
     1:   0 PCMU/8000/1  -> rc=0
-    Codec decision result:
-    conn[0]: codec:AMR, pt:112
-    conn[1]: codec:none, pt:none
- - mgcp_codec_decide(&conn[1], &conn[0]):
-    codec decision failed (expected)!
- ===> SUCCESS: codec decision as expected!
-#5: test AMR with differing octet-aligned settings (both <-> both)
- - add codecs on conn0:
-    0: 111 AMR/8000 octet-aligned=1  -> rc=0
-    1: 112 AMR/8000 octet-aligned=0  -> rc=0
+    2: 111 GSM-HR-08/8000/1  -> rc=0
+ - add codecs on conn1:
+    (none)
+ - mgcp_codec_pt_translate(conn0, conn1, 112) -> -22
+ - mgcp_codec_pt_translate(conn0, conn1, 0) -> -22
  - mgcp_codec_pt_translate(conn0, conn1, 111) -> -22
 #5: test AMR with differing octet-aligned settings
+ - add codecs on conn0:
     0: 111 AMR/8000 octet-aligned=1  -> rc=0
- - mgcp_codec_decide(&conn[0], &conn[1]):
-    Codec decision result:
-    conn[0]: codec:AMR, pt:111
-    conn[1]: codec:AMR, pt:121
- - mgcp_codec_decide(&conn[1], &conn[0]):
-    Codec decision result:
-    conn[1]: codec:AMR, pt:122
-    conn[0]: codec:AMR, pt:112
- ===> SUCCESS: codec decision as expected!
-#6: test AMR with differing octet-aligned settings (oa <-> both)
- - add codecs on conn0:
-    0: 111 AMR/8000 octet-aligned=1  -> rc=0
- - add codecs on conn1:
-    0: 122 AMR/8000 octet-aligned=0  -> rc=0
-    1: 121 AMR/8000 octet-aligned=1  -> rc=0
- - mgcp_codec_decide(&conn[0], &conn[1]):
-    Codec decision result:
-    conn[0]: codec:AMR, pt:111
-    conn[1]: codec:AMR, pt:121
- - mgcp_codec_decide(&conn[1], &conn[0]):
-    Codec decision result:
-    conn[1]: codec:AMR, pt:121
-    conn[0]: codec:AMR, pt:111
- ===> SUCCESS: codec decision as expected!
-#7: test AMR with differing octet-aligned settings (bwe <-> both)
- - add codecs on conn0:
-    0: 112 AMR/8000 octet-aligned=0  -> rc=0
+    1: 112 AMR/8000 octet-aligned=0  -> rc=0
+ - add codecs on conn1:
+    0: 122 AMR/8000 octet-aligned=0  -> rc=0
+    1: 121 AMR/8000 octet-aligned=1  -> rc=0
+ - mgcp_codec_pt_translate(conn0, conn1, 111) -> 121
  - mgcp_codec_pt_translate(conn1, conn0, 121) -> 111
  - mgcp_codec_pt_translate(conn0, conn1, 112) -> 122
-    1: 121 AMR/8000 octet-aligned=1  -> rc=0
- - mgcp_codec_decide(&conn[0], &conn[1]):
-    Codec decision result:
-    conn[0]: codec:AMR, pt:112
-    conn[1]: codec:AMR, pt:122
- - mgcp_codec_decide(&conn[1], &conn[0]):
-    Codec decision result:
-    conn[1]: codec:AMR, pt:122
-    conn[0]: codec:AMR, pt:112
- ===> SUCCESS: codec decision as expected!
-#8: test AMR with missing octet-aligned settings (oa <-> unset)
- - add codecs on conn0:
-    0: 111 AMR/8000 octet-aligned=1  -> rc=0
- - add codecs on conn1:
-    0: 122 AMR/8000 octet-aligned=unset  -> rc=0
- - mgcp_codec_decide(&conn[0], &conn[1]):
-    Codec decision result:
-    conn[0]: codec:AMR, pt:111
-    conn[1]: codec:AMR, pt:122
- - mgcp_codec_decide(&conn[1], &conn[0]):
-    Codec decision result:
-    conn[1]: codec:AMR, pt:122
-    conn[0]: codec:AMR, pt:111
- ===> SUCCESS: codec decision as expected!
-#9: test AMR with missing octet-aligned settings (bwe <-> unset)
- - add codecs on conn0:
-    0: 111 AMR/8000 octet-aligned=0  -> rc=0
- - add codecs on conn1:
+ - mgcp_codec_pt_translate(conn1, conn0, 122) -> 112
 #6: test AMR with missing octet-aligned settings (defaults to 0)
  - add codecs on conn0:
-    Codec decision result:
-    conn[0]: codec:AMR, pt:111
-    conn[1]: codec:AMR, pt:122
- - mgcp_codec_decide(&conn[1], &conn[0]):
-    Codec decision result:
-    conn[1]: codec:AMR, pt:122
-    conn[0]: codec:AMR, pt:111
- ===> SUCCESS: codec decision as expected!
-#10: test AMR with NULL param (oa <-> null)
- - add codecs on conn0:
-    0: 112 AMR/8000 octet-aligned=1  -> rc=0
- - add codecs on conn1:
-    0: 122 AMR/8000  -> rc=0
- - mgcp_codec_decide(&conn[0], &conn[1]):
-    Codec decision result:
-    conn[0]: codec:AMR, pt:112
-    conn[1]: codec:AMR, pt:122
- - mgcp_codec_decide(&conn[1], &conn[0]):
-    Codec decision result:
-    conn[1]: codec:AMR, pt:122
-    conn[0]: codec:AMR, pt:112
- ===> SUCCESS: codec decision as expected!
-#11: test AMR with NULL param (bwe <-> null)
- - add codecs on conn0:
+    0: 111 AMR/8000 octet-aligned=1  -> rc=0
+    1: 112 AMR/8000 octet-aligned=0  -> rc=0
+ - add codecs on conn1:
+    0: 122 AMR/8000 octet-aligned=unset  -> rc=0
  - mgcp_codec_pt_translate(conn0, conn1, 111) -> -22
  - mgcp_codec_pt_translate(conn0, conn1, 112) -> 122
  - mgcp_codec_pt_translate(conn1, conn0, 122) -> 112
@@ -1544,16 +1382,14 @@ Testing mgcp_codec_find_convertible()
     0: 111 AMR/8000 octet-aligned=1  -> rc=0
     1: 112 AMR/8000 octet-aligned=0  -> rc=0
  - add codecs on conn1:
-    Codec decision result:
-    conn[1]: codec:AMR, pt:122
-    conn[0]: codec:AMR, pt:112
- ===> SUCCESS: codec decision as expected!
-#12: match FOO/8000/1 and FOO/8000 as identical, single channel is implicit
- - add codecs on conn0:
-    0:   0 PCMU/8000/1  -> rc=0
-    1: 111 GSM-HR-08/8000/1  -> rc=0
-    2: 112 AMR/8000/1 octet-aligned=1  -> rc=0
- - add codecs on conn1:
+    0: 122 AMR/8000  -> rc=0
+ - mgcp_codec_pt_translate(conn0, conn1, 111) -> -22
+ - mgcp_codec_pt_translate(conn0, conn1, 112) -> 122
+ - mgcp_codec_pt_translate(conn1, conn0, 122) -> 112
+#8: match FOO/8000/1 and FOO/8000 as identical, single channel is implicit
+ - add codecs on conn0:
+    0:   0 PCMU/8000/1  -> rc=0
+    1: 111 GSM-HR-08/8000/1  -> rc=0
     2: 112 AMR/8000/1 octet-aligned=1  -> rc=0
  - add codecs on conn1:
     0:  97 GSM-HR-08/8000  -> rc=0
@@ -1562,16 +1398,14 @@ Testing mgcp_codec_find_convertible()
  - mgcp_codec_pt_translate(conn0, conn1, 112) -> 96
  - mgcp_codec_pt_translate(conn1, conn0, 96) -> 112
  - mgcp_codec_pt_translate(conn0, conn1, 0) -> 0
-    Codec decision result:
-    conn[1]: codec:GSM-HR-08, pt:97
-    conn[0]: codec:GSM-HR-08, pt:111
- ===> SUCCESS: codec decision as expected!
-#13: match FOO/8000/1 and FOO as identical, 8k and single channel are implicit
- - add codecs on conn0:
-    0:   0 PCMU/8000/1  -> rc=0
-    1: 111 GSM-HR-08/8000/1  -> rc=0
-    2: 112 AMR/8000/1 octet-aligned=1  -> rc=0
- - add codecs on conn1:
+ - mgcp_codec_pt_translate(conn1, conn0, 0) -> 0
+ - mgcp_codec_pt_translate(conn0, conn1, 111) -> 97
+ - mgcp_codec_pt_translate(conn1, conn0, 97) -> 111
+ - mgcp_codec_pt_translate(conn0, conn1, 123) -> -22
+#9: match FOO/8000/1 and FOO as identical, 8k and single channel are implicit
+ - add codecs on conn0:
+    0:   0 PCMU/8000/1  -> rc=0
+    1: 111 GSM-HR-08/8000/1  -> rc=0
     2: 112 AMR/8000/1 octet-aligned=1  -> rc=0
  - add codecs on conn1:
     0:  97 GSM-HR-08  -> rc=0
@@ -1579,15 +1413,10 @@ Testing mgcp_codec_find_convertible()
     2:  96 AMR octet-aligned=1  -> rc=0
  - mgcp_codec_pt_translate(conn0, conn1, 112) -> 96
  - mgcp_codec_pt_translate(conn1, conn0, 96) -> 112
- - mgcp_codec_decide(&conn[1], &conn[0]):
-    Codec decision result:
-    conn[1]: codec:GSM-HR-08, pt:97
-    conn[0]: codec:GSM-HR-08, pt:111
- ===> SUCCESS: codec decision as expected!
-#14: test whether channel number matching is waterproof
- - add codecs on conn0:
-    0: 111 GSM-HR-08/8000  -> rc=0
-    1: 112 GSM-HR-08/8000/2  -> rc=-22
+ - mgcp_codec_pt_translate(conn0, conn1, 0) -> 0
+ - mgcp_codec_pt_translate(conn1, conn0, 0) -> 0
+ - mgcp_codec_pt_translate(conn0, conn1, 111) -> 97
+ - mgcp_codec_pt_translate(conn1, conn0, 97) -> 111
  - mgcp_codec_pt_translate(conn0, conn1, 123) -> -22
 #10: test whether channel number matching is waterproof
  - add codecs on conn0:

tests/mgcp_client/Makefile.am

@@ -15,7 +15,6 @@ AM_CFLAGS = \
 
 AM_LDFLAGS = \
 	$(COVERAGE_LDFLAGS) \
-	-no-install \
 	$(NULL)
 
 EXTRA_DIST = \
@@ -23,7 +22,7 @@ EXTRA_DIST = \
 	mgcp_client_test.err \
 	$(NULL)
 
-check_PROGRAMS = \
+noinst_PROGRAMS = \
 	mgcp_client_test \
 	$(NULL)
 

tests/mgcp_client/mgcp_client_test.c

@@ -73,7 +73,7 @@ static struct msgb *from_str(const char *str)
 	return msg;
 }
 
-static struct mgcp_client_conf *conf;
+static struct mgcp_client_conf conf;
 struct mgcp_client *mgcp = NULL;
 
 static int reply_to(mgcp_trans_id_t trans_id, int code, const char *comment,
@@ -162,7 +162,7 @@ void test_mgcp_msg(void)
 
 	if (mgcp)
 		talloc_free(mgcp);
-	mgcp = mgcp_client_init(ctx, conf);
+	mgcp = mgcp_client_init(ctx, &conf);
 
 	printf("\n");
 
@@ -315,7 +315,7 @@ void test_mgcp_msg(void)
 	msgb_free(msg);
 }
 
-void test_mgcp_client_cancel(void)
+void test_mgcp_client_cancel()
 {
 	mgcp_trans_id_t trans_id;
 	struct msgb *msg;
@@ -339,7 +339,7 @@ void test_mgcp_client_cancel(void)
 
 	if (mgcp)
 		talloc_free(mgcp);
-	mgcp = mgcp_client_init(ctx, conf);
+	mgcp = mgcp_client_init(ctx, &conf);
 
 	msg = mgcp_msg_gen(mgcp, &mgcp_msg);
 	trans_id = mgcp_msg_trans_id(msg);
@@ -487,7 +487,7 @@ static struct sdp_section_start_test sdp_section_start_tests[] = {
 	},
 };
 
-void test_sdp_section_start(void)
+void test_sdp_section_start()
 {
 	int i;
 	int failures = 0;
@@ -630,7 +630,7 @@ void test_mgcp_client_e1_epname(void)
 
 	if (mgcp)
 		talloc_free(mgcp);
-	mgcp = mgcp_client_init(ctx, conf);
+	mgcp = mgcp_client_init(ctx, &conf);
 
 	/* Valid endpoint names */
 	epname = (char *)mgcp_client_e1_epname(ctx, mgcp, 1, 15, 64, 0);
@@ -697,7 +697,7 @@ int main(int argc, char **argv)
 
 	log_set_category_filter(osmo_stderr_target, DLMGCP, 1, LOGL_DEBUG);
 
-	conf = mgcp_client_conf_alloc(ctx);
+	mgcp_client_conf_init(&conf);
 
 	test_mgcp_msg();
 	test_mgcp_client_cancel();

tests/mgcp_client/mgcp_client_test.err

@@ -1,6 +1,5 @@
 DLMGCP MGW(mgw) MGCP client: using endpoint domain '@mgw'
-DLMGCP MGW(mgw) Message buffer too small, can not generate MGCP message (SDP)
-DLMGCP MGW(mgw) Failed to add SDP, can not generate MGCP message
+DLMGCP MGW(mgw) Message buffer to small, can not generate MGCP message (SDP)
 
 test_mgcp_client_cancel():
 DLMGCP MGW(mgw) MGCP client: using endpoint domain '@mgw'
@@ -11,7 +10,6 @@ DLMGCP MGW(mgw) Cannot cancel, no such transaction: 1
 - cancel succeeds
 DLMGCP MGW(mgw) Canceled transaction 1
 - late response gets discarded
-DLMGCP MGW(mgw) MGCP link to MGW now considered UP
 DLMGCP MGW(mgw) MGCP client: Rx 200 1 OK
 DLMGCP MGW(mgw) Cannot find matching MGCP transaction for trans_id 1
 - canceling again does nothing