如何用PJSIP检测SIP服务器及端口可达性？含pjsip_options_method咨询

Great question—using the OPTIONS method is exactly the right call for a SIP "ping" since it's lightweight, standardized, and designed specifically for checking reachability and server capabilities. Let me walk you through how to implement this with pjsip_options_method, plus some pro tips to make your detection robust.

The pjsip_options_method function in PJSIP handles constructing a valid OPTIONS request, which is the SIP equivalent of a ping. Here's a step-by-step implementation with code:

Prerequisites #

First, ensure your PJSIP environment is fully initialized: you've created an endpoint, set up a transport (UDP/TCP/TLS), and started the event loop.

Step-by-Step Code Implementation #

#include <pjsip.h>
#include <pjsip_ua.h>
#include <pjlib.h>

// Callback to handle OPTIONS responses or timeouts
static void on_options_response(pjsip_inv_session *inv, pjsip_event *e) {
    if (e->type == PJSIP_EVENT_RX_MSG) {
        pjsip_msg *response = e->body.rx_msg.msg;
        int status_code = response->line.status.code;
        
        if (status_code >= 200 && status_code < 300) {
            PJ_LOG(3, (__FILE__, "✅ SIP server is reachable! Response: %d %s", 
                status_code, pj_strbuf(&response->line.status.reason)));
        } else {
            // Even error responses mean the server is reachable (it sent a reply)
            PJ_LOG(3, (__FILE__, "⚠️ SIP server responded with error: %d %s", 
                status_code, pj_strbuf(&response->line.status.reason)));
        }
    } else if (e->type == PJSIP_EVENT_TIMER) {
        // Timeout = server is unreachable
        PJ_LOG(3, (__FILE__, "❌ SIP server is unreachable (timeout)"));
    }

    // Clean up the session after handling the response
    pjsip_inv_end_session(inv, PJSIP_SC_OK, NULL);
    pjsip_dlg_dec_ref(inv->dlg);
}

// Send a SIP OPTIONS "ping" to the target server
pj_status_t send_sip_ping(pjsip_endpoint *endpt, const char *target_sip_uri) {
    pj_status_t status;
    pjsip_tx_data *tx_data;
    pjsip_dialog *dlg;
    pjsip_inv_session *inv;
    pjsip_uri *dest_uri;

    // Parse the target SIP URI (e.g., "sip:example.com:5060")
    status = pjsip_uri_parse(endpt->pool, pj_str((char*)target_sip_uri), &dest_uri);
    if (status != PJ_SUCCESS) {
        PJ_LOG(1, (__FILE__, "Failed to parse target URI: %d", status));
        return status;
    }

    // Create a temporary UAC dialog (no registration required)
    status = pjsip_dlg_create_uac(endpt, NULL, dest_uri, NULL, NULL, &dlg);
    if (status != PJ_SUCCESS) {
        PJ_LOG(1, (__FILE__, "Failed to create UAC dialog: %d", status));
        return status;
    }

    // Create an INV session (PJSIP uses this to manage transaction state)
    status = pjsip_inv_create_uac(dlg, NULL, &inv);
    if (status != PJ_SUCCESS) {
        pjsip_dlg_dec_ref(dlg);
        PJ_LOG(1, (__FILE__, "Failed to create UAC INV session: %d", status));
        return status;
    }

    // Attach our callback to handle responses/timeouts
    pjsip_inv_callback cb = {0};
    cb.on_rx_response = on_options_response;
    cb.on_timer = on_options_response;
    pjsip_inv_set_callback(inv, &cb);

    // Build the OPTIONS request
    status = pjsip_options_method(dlg, inv, NULL, &tx_data);
    if (status != PJ_SUCCESS) {
        pjsip_inv_end_session(inv, PJSIP_SC_OK, NULL);
        pjsip_dlg_dec_ref(dlg);
        PJ_LOG(1, (__FILE__, "Failed to build OPTIONS request: %d", status));
        return status;
    }

    // Send the request with a custom timeout (e.g., 3000ms = 3s)
    status = pjsip_dlg_send_request(dlg, tx_data, 3000, NULL);
    if (status != PJ_SUCCESS) {
        pjsip_inv_end_session(inv, PJSIP_SC_OK, NULL);
        pjsip_dlg_dec_ref(dlg);
        PJ_LOG(1, (__FILE__, "Failed to send OPTIONS request: %d", status));
        return status;
    }

    return PJ_SUCCESS;
}

Key Notes on the Code #

• Dialog & INV Session: PJSIP uses dialogs and INV sessions to manage SIP transactions, even for non-INVITE requests like OPTIONS. This handles retransmissions and state management automatically.
• Callback Handling: The callback distinguishes between successful responses, error responses (which still mean the server is reachable), and timeouts (unreachable).
• Timeout Configuration: The third parameter in pjsip_dlg_send_request sets a custom timeout (in milliseconds) to avoid waiting too long for unresponsive servers.

To make your implementation more reliable, consider these tweaks:

• Retry Mechanism: If the first request times out, retry 1-2 times (with a small delay) to account for temporary network blips.
• Distinguish Reachability vs. Authorization: A 401/403 response means the server is reachable but doesn’t allow your request—don’t mark it as unreachable. Only timeouts or no response mean true unreachability.
• Reuse Dialogs: For frequent checks to the same server, reuse the existing dialog instead of creating a new one each time to reduce resource overhead.
• Async Processing: Always run this in the PJSIP event loop (don’t block your main thread) to avoid impacting other application functionality.

Some SIP servers disable OPTIONS for security reasons. In that case, you can use:

• REGISTER: Send an anonymous REGISTER request. Even a 401 Unauthorized response confirms the server is reachable.
• MESSAGE: Send a lightweight empty MESSAGE request (if supported).

Just replace pjsip_options_method with pjsip_register_method or pjsip_message_method in the code above, and adjust the callback logic to handle those response codes.

内容的提问来源于stack exchange，提问作者RJV Kumar