Outbound registration not working?

Hi!!
I’m trying to use Yeti-switch between my SIP trunk provider and my internal PBX’s, so I can keep CDR/Billing separated for each PBX. I’ve managed to connect one PBX to Yeti, and Yeti to my SIP trunk provider, and it’s working properly for outgoing calls.
For incoming calls, my SIP provider gives me a username/password for registration, so they can route my public number to the trunk. I’ve used these to create an entry on the Equipment->Registration page, but it seems that Yeti never sends any registration message to the trunk. If I do a tcpdump while I’m calling, I see proper SIP signalling. If I reload SEMS/Yeti, I never see any SIP traffic to the trunk provider at all.
Is there anything else to do, to enable outgoing registration in Yeti?
Just to discard any issue on my network side, I’ve installed Issabel (Asterisk fork), and it registered properly without any issue to the SIP trunk provider.

This is a screenshot of the configuration:
Screenshot-From-2025-05-29-16-45-14

The server is on a private network, with a firewall doing one-to-one NAT. The server has 2 IP addresses (10.x.x.2 and 10.x.x.3). The .3 is used for internal traffic to the PBX’s, and the .2 is used for the NAT with the public IP 164.x.x.3.

The relevant part of the sems.conf file:

signaling-interfaces {
interface internal {
default-media-interface = internal
ip4 {
sip-udp {
address = 10.x.x.3
port = 5060
use-raw-sockets = off
}
sip-tcp {
address = 10.x.x.3
port = 5060
connect-timeout = 2000
static-client-port = on
idle-timeout=900000
use-raw-sockets = off
}
}
}
interface external {
default-media-interface = external
ip4 {
sip-udp {
public-address = 164.163.81.3
address = 10.x.x.2
port = 5060
use-raw-sockets = off
}
sip-tcp {
public-address = 164.x.x.3
address = 10.x.x.2
port = 5060
connect-timeout = 2000
static-client-port = on
idle-timeout=900000
use-raw-sockets = off
}
}
}

media-interfaces {
interface internal {
ip4 {
rtp {
address = 10.x.x.3
low-port = 16384
high-port = 32769
dscp = 46
use-raw-sockets = off
}
}
}
interface external {
ip4 {
rtp {
public-address = 164.x.x.3
address = 10.x.x.2
low-port = 10000
high-port = 30001
dscp = 46
use-raw-sockets = off
}
}
}
}

thanks a lot for your help!!!

Francisco

The sems.conf that I’m using is the one at SEMS node installation — Yeti documentation

But I see that some users got other options, for example, in this thread (How to route calls - #6 by EAfang) there seems to be another configuration settings related to registration:

module “yeti”

registrar {
enabled = true
redis {
host = 127.0.0.1
port = 6379
}
}

I’ve added that to my sems.conf but it won’t start ( 1748556272.155541 [#ffffffffc1a1f000/148789] [cfg_reader_error, yeti:yeti.cpp:58] ERROR: line:90 section ‘root’: no such option ‘registrar’ )

So, what I’m missing? why SEMS won’t try to register to my SIP trunk provider? it only connects when I call, and works without problems for outgoing calls… but I can’t call back to my PSTN number because the trunk isn’t registering.
Maybe I’m missing something on my sems.conf?? (I’m using the one at the installation docs, and I did the full install just today!)

regards!
Francisco.

Could you show how this registration looks in Real-time data → outgoing registration page?

it just says “No Outgoing Registrations found” :frowning:

This is my full sems.conf file:

general {
    stderr = no
    syslog_loglevel = 5
    syslog_facility = LOCAL0

    node_id = 8

    shutdown_mode {
        code = 508
        reason = "Yeti node in shutdown mode"
        allow_uac = true
    }

    media_processor_threads = 4
    rtp_receiver_threads = 4
    session_processor_threads = 20
    sip_udp_server_threads = 2
    sip_tcp_server_threads = 2

    dead_rtp_time = 30

    default_bl_ttl = 0

    symmetric_rtp_mode = packets
    symmetric_rtp_packets = 20
}

signaling-interfaces {
    interface internal {
        default-media-interface = internal
        ip4 {
            sip-udp {
                address = 10.x.x.3
                port = 5060
                use-raw-sockets = off
            }
            sip-tcp {
                address = 10.x.x.3
                port = 5060
                connect-timeout = 2000
                static-client-port = on
                idle-timeout=900000
                use-raw-sockets = off
            }
        }
    }
    interface external {
        default-media-interface = external
        ip4 {
            sip-udp {
		public-address = 164.x.x.3
                address = 10.x.x.2
                port = 5060
                use-raw-sockets = off
            }
            sip-tcp {
		public-address = 164.x.x.3
                address = 10.x.x.2
                port = 5060
                connect-timeout = 2000
                static-client-port = on
                idle-timeout=900000
                use-raw-sockets = off
            }
        }
    }
}

media-interfaces {
    interface internal {
        ip4 {
            rtp {
                address = 10.x.x.3
                low-port = 16384
                high-port = 32769
                dscp = 46
                use-raw-sockets = off
            }
        }
    }
    interface external {
        ip4 {
            rtp {
		public-address = 164.x.x.3
                address = 10.x.x.2
                low-port = 10000
                high-port = 30001
                dscp = 46
                use-raw-sockets = off
            }
        }
    }
}

modules {
    module "di_log" {}

    module "mp3" {}
    module "opus" {}
    module "wav" {}
    module "gsm" {}
    module "ilbc" {}
    module "adpcm" {}
    module "l16" {}
    module "g722" {}
    module "g729bcg" {}

    module "registrar_client" {}
    module "postgresql" {}

    module "session_timer" {}
    module "jsonrpc" {
        listen {
            address = 127.0.0.1
            port = 7080
        }
        server_threads = 1
    }

    module "http_client" {}

    module-global "uac_auth" {}
    module "options_prober" {}

    module "radius_client" {}

    module "redis" {
        max_batch_size = 10
        batch_timeout = 100
        max_queue_size = 1000
    }

	module "registrar" {
	    expires_min = 5
	    expires_max = 7200
	    expires_default = 1200
	    keepalive_interval = 30
	    bindings_max = 15
	    process_subscriptions = true
	    redis {
		use_functions = no
		scripts_dir = /usr/lib/sems/scripts/registrar
		write {
		    hosts = localhost:6379
		}
		read {
		    hosts = localhost:6379
		}
	    }
	}

    module "yeti" {
        pop_id = 1
        lega_cdr_headers {
            header(p-charge-info, string)
            header(diversion, array)
        }

        auth {
            realm = yeti-switch
        }

        msg_logger_dir = /var/spool/sems/dump
        audio_recorder_dir = /var/spool/sems/records
        audio_recorder_compress = false

        db_refresh_interval = 5
        ip_auth_reject_if_no_matched = true

        routing {
            schema = switch21
            function = route_release
            init = init
            pass_input_interface_name = true
            master_pool {
                host = 127.0.0.1
                port = 5432
                name = yeti
                user = yeti
                pass = xxxxxx
                size = 4
                check_interval = 10
                max_exceptions = 0
                statement_timeout = 3000
            }
            failover_to_slave = false
            slave_pool {
                host = 127.0.0.1
                port = 5432
                name = yeti
                user = yeti
                pass = xxxxxxx
                size = 4
                check_interval = 10
                max_exceptions = 0
                statement_timeout = 3000
            }
        }
        cdr {
            dir = /var/spool/sems/cdrs
            completed_dir = /var/spool/sems/cdrs/completed
            pool_size = 2
            auth_pool_size = 2
            schema = switch
            function = writecdr
            master {
                host = 127.0.0.1
                port = 5432
                name = cdr
                user = cdr
                pass = xxxxxx
            }
            failover_to_slave = false
            slave {
                host = 127.0.0.1
                port = 5432
                name = cdr
                user = cdr
                pass = xxxxxxx
            }
            failover_requeue = true
            failover_to_file = false
            serialize_dynamic_fields = true
            batch_size = 1
            batch_timeout = 5000
            auth_batch_size = 1
            auth_batch_timeout = 20000
        }
        resources {
            reject_on_error = false
            reduce_operations = true
            write {
                hosts = { 127.0.0.1:6379 }
                timeout = 500
            }
            read {
                hosts = { 127.0.0.1:6379 }
                timeout = 1000
            }
        }
        registrations {
            check_interval = 5000
        }
        rpc {
            calls_show_limit = 10000
        }
        core_options_handling = yes
    }
}

routing {
    application = yeti
}

Everything is installed on the same server…

Node id in sems config not matching node id configured in web ui.

Thanks Dimitry!! that was the problem!! Now I can see the registration attempts.
I’ll try to fix that and keep you posted.

Thank you very much!!!