"session Id" and "session version" are an numeric string which accept leading zeros

Author: lo-simon

Development/nmos/sdp_utils.cpp

@@ -1624,4 +1624,14 @@ namespace nmos
     {
         details::validate_sdp_parameters(details::format_constraints, sdp_params, details::get_format(sdp_params), details::get_format_parameters(sdp_params), receiver);
     }
+
+    // Validate the numeric string
+    const utility::string_t& valid_numeric_string(const utility::string_t& s)
+    {
+        if (!std::all_of(s.begin(), s.end(), ::isdigit))
+        {
+            throw std::invalid_argument("not a numeric string");
+        }
+        return s;
+    }
 }

Development/nmos/sdp_utils.h

@@ -5,7 +5,6 @@
 #include <functional>
 #include <map>
 #include <stdexcept>
-#include <boost/lexical_cast.hpp>
 #include "bst/any.h"
 #include "bst/optional.h"
 #include "cpprest/basic_utils.h"
@@ -64,6 +63,11 @@ namespace nmos
     // Validate the SDP parameters against a receiver for "video/raw", "audio/L", "video/smpte291" or "video/SMPTE2022-6"
     void validate_sdp_parameters(const web::json::value& receiver, const sdp_parameters& sdp_params);
 
+    // sdp_parameters helper functions
+
+    // Validate the numeric string
+    const utility::string_t& valid_numeric_string(const utility::string_t& s);
+
     // Format-specific types
 
     struct video_raw_parameters;
@@ -86,30 +90,17 @@ namespace nmos
             utility::string_t session_id;
             utility::string_t session_version;
 
-            origin_t() : session_id(), session_version() {}
+            origin_t() {}
             origin_t(const utility::string_t& user_name, uint64_t session_id, uint64_t session_version)
                 : user_name(user_name)
-                , session_id(boost::lexical_cast<utility::string_t>(session_id))
-                , session_version(boost::lexical_cast<utility::string_t>(session_version))
+                , session_id(utility::conversions::details::to_string_t(session_id))
+                , session_version(utility::conversions::details::to_string_t(session_version))
             {}
             origin_t(const utility::string_t& user_name, const utility::string_t& session_id, const utility::string_t& session_version)
                 : user_name(user_name)
-                , session_version(session_version)
-            {
-                // validate session_id is a numeric string
-                if (!std::all_of(session_id.begin(), session_id.end(), ::isdigit))
-                {
-                    throw std::invalid_argument("session id must be a numeric string");
-                }
-                this->session_id = session_id;
-
-                // validate session_version is a numeric string
-                if (!std::all_of(session_version.begin(), session_version.end(), ::isdigit))
-                {
-                    throw std::invalid_argument("session version must be a numeric string");
-                }
-                this->session_version = session_version;
-            }
+                , session_id(valid_numeric_string(session_id))
+                , session_version(valid_numeric_string(session_version))
+            {}
             origin_t(const utility::string_t& user_name, uint64_t session_id_version)
                 : origin_t{ user_name, session_id_version, session_id_version }
             {}

Development/sdp/sdp_grammar.cpp

@@ -2,7 +2,6 @@
 #include "sdp/sdp.h"
 
 #include <stdexcept>
-#include <boost/lexical_cast.hpp>
 #include "bst/regex.h"
 #include "cpprest/basic_utils.h"
 #include "cpprest/json_visit.h"
@@ -77,12 +76,7 @@ namespace sdp
         inline web::json::value digits2jns(const std::string& s)
         {
             if (!std::all_of(s.begin(), s.end(), ::isdigit)) throw sdp_parse_error("expected a sequence of digits");
-
-            uint64_t v;
-            std::istringstream is(s);
-            is >> v;
-            if (is.fail() || !is.eof()) return s2js(s);
-            return web::json::value(boost::lexical_cast<utility::string_t>(v));
+            return s2js(s);
         }
 
         // find the first delimiter in str, beginning at pos, and return the substring from pos to the delimiter (or end)

Development/sdp/test/sdp_test.cpp

@@ -396,7 +396,7 @@ m=video 000000000000000000050020 RTP/AVP 0096
 )";
 
     const std::string expected_sdp = R"(v=0
-o=- 7 987654321098765432 IN IP4 192.0.2.0
+o=- 007 0987654321098765432 IN IP4 192.0.2.0
 s=Leading zeros
 b=AS:9876543210
 t=0 0
@@ -577,10 +577,21 @@ BST_TEST_CASE(testSdpSessionId)
 {
     const std::string before = "v=0\r\no=- ";
     const std::string after = " 42 IN IP4 10.0.0.1\r\ns= \r\nt=0 0\r\n";
-    BST_REQUIRE_NO_THROW(sdp::parse_session_description(before + "0" + after));
-    BST_REQUIRE_NO_THROW(sdp::parse_session_description(before + "007" + after));
-    BST_REQUIRE_NO_THROW(sdp::parse_session_description(before + "18446744073709551615" + after));  // session id to UINT64_MAX
-    BST_REQUIRE_NO_THROW(sdp::parse_session_description(before + "184467440737095516150" + after)); // session id greater than UINT64_MAX
+
+    const std::vector<std::pair<utility::string_t, std::string>> session_id_params = {
+        {U("1"), before + "1" + after},
+        {U("00000000000000000000"), before + "00000000000000000000" + after},
+        {U("0018446744073709551615"), before + "0018446744073709551615" + after},
+        {U("001844674407370955161500"), before + "001844674407370955161500" + after}
+    };
+    for (const auto& session_id_param : session_id_params)
+    {
+        auto session_description = sdp::parse_session_description(session_id_param.second);
+        auto origin = sdp::fields::origin(session_description);
+        auto session_id = sdp::fields::session_id(origin);
+        BST_CHECK_EQUAL(session_id_param.first, session_id);
+    }
+
     // an invalid session id results in "sdp parse error - expected a sequence of digits at line 2"
     BST_REQUIRE_THROW(sdp::parse_session_description(before + "foo" + after), std::runtime_error);
     BST_REQUIRE_THROW(sdp::parse_session_description(before + "0foo" + after), std::runtime_error);
@@ -593,10 +604,21 @@ BST_TEST_CASE(testSdpSessionVersion)
 {
     const std::string before = "v=0\r\no=- 42 ";
     const std::string after = " IN IP4 10.0.0.1\r\ns= \r\nt=0 0\r\n";
-    BST_REQUIRE_NO_THROW(sdp::parse_session_description(before + "0" + after));
-    BST_REQUIRE_NO_THROW(sdp::parse_session_description(before + "007" + after));
-    BST_REQUIRE_NO_THROW(sdp::parse_session_description(before + "18446744073709551615" + after));  // session version to UINT64_MAX
-    BST_REQUIRE_NO_THROW(sdp::parse_session_description(before + "184467440737095516150" + after)); // session version greater than UINT64_MAX
+
+    const std::vector<std::pair<utility::string_t, std::string>> session_version_params = {
+    {U("1"), before + "1" + after},
+    {U("00000000000000000000"), before + "00000000000000000000" + after},
+    {U("0018446744073709551615"), before + "0018446744073709551615" + after},
+    {U("001844674407370955161500"), before + "001844674407370955161500" + after}
+    };
+    for (const auto& session_version_param : session_version_params)
+    {
+        auto session_description = sdp::parse_session_description(session_version_param.second);
+        auto origin = sdp::fields::origin(session_description);
+        auto session_version = sdp::fields::session_version(origin);
+        BST_CHECK_EQUAL(session_version_param.first, session_version);
+    }
+
     // an invalid session version results in "sdp parse error - expected a sequence of digits at line 2"
     BST_REQUIRE_THROW(sdp::parse_session_description(before + "foo" + after), std::runtime_error);
     BST_REQUIRE_THROW(sdp::parse_session_description(before + "0foo" + after), std::runtime_error);