@voipsdk/react-native-voipcloud 1.0.6 → 1.0.8

package/CHANGELOG.md

@@ -5,6 +5,33 @@ All notable changes to `@voipsdk/react-native-voipcloud` are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.8] - 2026-08-26
+Update libraries voipcloud-release.aar 16kb for android
+
+
+## [1.0.7] - 2026-08-13
+
+Folds in the SDP bandwidth-modifier fixes that were living as app-side
+`patch-package` patches (`@voipsdk+react-native-voipcloud+1.0.6.patch`), so a
+fresh install behaves correctly without any patch. Root-cause mitigation for a
+malformed `b=` line (e.g. `=:40` / `=:4000` / `:=4000`) that some PBX/proxy SDP
+rewriters produce and that breaks SDP parsing / call negotiation.
+
+### Changed / Fixed
+
+- **iOS:** disable pjmedia's `b=TIAS:<bps>` SDP bandwidth modifier by setting
+  `pjmedia_add_bandwidth_tias_in_sdp = PJ_FALSE` right after `libInit`. pjmedia
+  stamps that line onto every SDP we author (offer + answer), and some
+  PBX/proxy SDP rewriters mangle it (leaving `=:40` / `=:4000`) → corrupt SDP /
+  broken call info. We never rely on TIAS, so it is disabled at the source; only
+  SDP we author is affected, remote SDP is untouched.
+- **Android:** `ManagedCall.onCallSdpCreated` now sanitizes both the local and
+  the remote SDP just before/after negotiation (`sanitizeSdp`). It keeps only
+  strictly RFC 4566 well-formed `<type>=<value>` lines (single `a-z` key,
+  non-empty value) and drops every bandwidth (`b=`) line, so a single corrupt
+  line can never invalidate the whole SDP. Line endings are normalized to CRLF
+  and the session is only rewritten when something actually changed.
+
 ## [1.0.6] - 2026-08-10
 
 Folds in the push-wake registration-refresh fixes that were living as an app-side

package/README.md

@@ -1,7 +1,7 @@
 # @voipsdk/react-native-voipcloud
 
 > Public VoIP SDK for React Native — Android **and** iOS (RN 0.70+).  
-> Package: `@voipsdk/react-native-voipcloud@1.0.5`
+> Package: `@voipsdk/react-native-voipcloud@1.0.7`
 
 Android and iOS expose the **same** JS API, events and `VC_*` error codes.
 

package/android/src/main/java/com/voipcloud/sdk/rn/internal/ManagedCall.java

@@ -12,9 +12,11 @@ import com.voipcloud.sdk.CallInfo;
 import com.voipcloud.sdk.CallMediaInfo;
 import com.voipcloud.sdk.Endpoint;
 import com.voipcloud.sdk.OnCallMediaStateParam;
+import com.voipcloud.sdk.OnCallSdpCreatedParam;
 import com.voipcloud.sdk.OnCallStateParam;
 import com.voipcloud.sdk.OnCallTransferStatusParam;
 import com.voipcloud.sdk.OnDtmfDigitParam;
+import com.voipcloud.sdk.SdpSession;
 import com.voipcloud.sdk.pjmedia_type;
 import com.voipcloud.sdk.pjsip_inv_state;
 import com.voipcloud.sdk.pjsua_call_media_status;
@@ -189,6 +191,72 @@ public final class ManagedCall extends Call {
         emitMediaState();
     }
 
+    /**
+     * Fired after PJSIP builds the local SDP (our offer for outgoing calls, our
+     * answer for incoming ones, and re-offer/answer on hold/unhold) but BEFORE
+     * it is sent. We sanitize both the SDP we send and PJSIP's copy of the
+     * remote SDP so a malformed line or a bandwidth modifier can never break
+     * negotiation — see {@link #sanitizeSdp}.
+     */
+    @Override
+    public void onCallSdpCreated(OnCallSdpCreatedParam prm) {
+        try {
+            sanitizeSdp(prm.getSdp());
+            sanitizeSdp(prm.getRemSdp());
+        } catch (Throwable ignored) {}
+    }
+
+    /**
+     * Rewrite an SdpSession in place, keeping ONLY strictly well-formed lines
+     * and dropping every bandwidth ("b=") line.
+     *
+     * Per RFC 4566 every SDP line is {@code <type>=<value>} where {@code <type>}
+     * is exactly one letter and {@code <value>} is non-empty. We enforce that
+     * grammar and treat anything else as corruption to be removed — not just the
+     * one observed artifact ({@code :=4000}) but ANY bad key or value:
+     * <ul>
+     *   <li>key is not a single {@code a-z} letter — {@code :=4}, {@code S=4},
+     *       {@code =64000}, {@code 3=x}, {@code " b=…"} (leading space)…</li>
+     *   <li>second char is not {@code '='} — {@code ba=…}, {@code b:AS…}…</li>
+     *   <li>empty value — {@code a=} with nothing after {@code '='}</li>
+     * </ul>
+     * Dropping a bad line (rather than trusting it) means a single corrupt line
+     * can never invalidate the whole SDP, and the value it carried is irrelevant.
+     * Line endings are normalized to CRLF. No-op when the SDP is absent; the
+     * session is only rewritten if something actually changed.
+     */
+    private static void sanitizeSdp(SdpSession session) {
+        if (session == null) return;
+        String sdp;
+        try { sdp = session.getWholeSdp(); } catch (Throwable e) { return; }
+        if (sdp == null || sdp.isEmpty()) return;
+
+        // Split on any newline style (CRLF / CR / LF) so a stray ending cannot
+        // smuggle a corrupt token through as part of another line.
+        String[] lines = sdp.split("\r\n|\r|\n");
+        StringBuilder out = new StringBuilder(sdp.length());
+        boolean changed = false;
+        for (String line : lines) {
+            int len = line.length();
+            if (len == 0) { continue; }
+            char key = line.charAt(0);
+            boolean wellFormed =
+                    len >= 3                    // key + '=' + at least one value char
+                    && line.charAt(1) == '='    // "<key>=" separator
+                    && key >= 'a' && key <= 'z'; // key is a single a-z letter only
+            if (!wellFormed || key == 'b') {    // corrupt/invalid line, or bandwidth
+                changed = true;
+                continue;
+            }
+            out.append(line).append("\r\n");
+        }
+        // Only push back a non-empty result; a real SDP always keeps v=/o=/… so
+        // out is never empty in practice, but guard against wiping the session.
+        if (changed && out.length() > 0) {
+            try { session.setWholeSdp(out.toString()); } catch (Throwable ignored) {}
+        }
+    }
+
     /**
      * Multi-stage progress notifications for a REFER (call transfer)
      * we initiated.  Fires for each NOTIFY received from the remote

package/ios/VoipCloudEngine.mm

@@ -14,6 +14,15 @@
 
 using namespace pj;
 
+// pjmedia run-time flag (defined in pjmedia endpoint.c, C linkage). Default 1 →
+// pjmedia stamps a "b=TIAS:<bps>" bandwidth modifier onto every SDP it generates
+// (our outgoing offer + our answer). Some PBX/proxy SDP rewriters mangle that line
+// (e.g. leaving "=:40"/"=:4000") → corrupt SDP / broken call info. We never rely on
+// TIAS, so disable at the source. Only touches SDP *we* author; remote SDP is
+// untouched (strip those at the PBX). Declared here because config.h only mentions
+// it in a doc comment, not as a real extern.
+extern "C" pj_bool_t pjmedia_add_bandwidth_tias_in_sdp;
+
 static NSString *const kVCErrorDomain = @"VoipCloudEngine";
 
 static NSError *VCMakeError(NSInteger code, NSString *msg) {
@@ -323,6 +332,11 @@ void VCCall::onDtmfDigit(OnDtmfDigitParam &prm) {
 
         _ep->libInit(epCfg);
 
+        // Never emit the SDP "b=TIAS:" bandwidth modifier — it triggers broken
+        // SDP rewrites downstream (=:40 / =:4000) and we don't use it. Safe to set
+        // once the pjmedia endpoint exists (after libInit); read at SDP-gen time.
+        pjmedia_add_bandwidth_tias_in_sdp = PJ_FALSE;
+
         // Ephemeral ports (0) avoid "Address already in use" for SIP clients.
         // Keep each transport id so registerAccountWithConfig can pin the
         // account to the matching one (0 is a valid id → init to -1).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voipsdk/react-native-voipcloud",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Public React Native VoIP SDK (VoipCloud).",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",