138 lines
4.1 KiB
C++
138 lines
4.1 KiB
C++
//
|
|
// utils.cpp
|
|
//
|
|
// Copyright (c) 2019 2020 Andrea Bondavalli. 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 3 of the License, or
|
|
// 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 "utils.hpp"
|
|
#include "log.hpp"
|
|
|
|
#include <boost/algorithm/string.hpp>
|
|
#include <boost/format.hpp>
|
|
|
|
uint16_t crc16(const uint8_t* p, size_t len) {
|
|
uint8_t x;
|
|
uint16_t crc = 0xFFFF;
|
|
|
|
while (len--) {
|
|
x = crc >> 8 ^ *p++;
|
|
x ^= x >> 4;
|
|
crc = (crc << 8) ^ (static_cast<uint16_t>(x << 12)) ^
|
|
(static_cast<uint16_t>(x << 5)) ^ (static_cast<uint16_t>(x));
|
|
}
|
|
return crc;
|
|
}
|
|
|
|
std::tuple<bool /* res */,
|
|
std::string /* protocol */,
|
|
std::string /* host */,
|
|
std::string /* port */,
|
|
std::string /* path */>
|
|
parse_url(const std::string& _url) {
|
|
std::string url = httplib::detail::decode_url(_url, false);
|
|
size_t protocol_sep_pos = url.find_first_of("://");
|
|
if (protocol_sep_pos == std::string::npos) {
|
|
/* no protocol, invalid URL */
|
|
return {false, "", "", "", ""};
|
|
}
|
|
|
|
std::string port, host, path("/");
|
|
std::string protocol = url.substr(0, protocol_sep_pos);
|
|
std::string url_new = url.substr(protocol_sep_pos + 3);
|
|
size_t path_sep_pos = url_new.find_first_of("/");
|
|
size_t port_sep_pos = url_new.find_first_of(":");
|
|
if (port_sep_pos != std::string::npos) {
|
|
/* port specified */
|
|
if (path_sep_pos != std::string::npos) {
|
|
/* path specified */
|
|
port = url_new.substr(port_sep_pos + 1, path_sep_pos - port_sep_pos - 1);
|
|
path = url_new.substr(path_sep_pos);
|
|
} else {
|
|
/* path not specified */
|
|
port = url_new.substr(port_sep_pos + 1);
|
|
}
|
|
host = url_new.substr(0, port_sep_pos);
|
|
} else if (path_sep_pos != std::string::npos) {
|
|
/* port not specified, path specified */
|
|
host = url_new.substr(0, path_sep_pos);
|
|
path = url_new.substr(path_sep_pos);
|
|
} else {
|
|
/* port and path not specified */
|
|
host = url_new;
|
|
}
|
|
return {host.length() > 0, protocol, host, port, path};
|
|
}
|
|
|
|
std::string get_host_node_id(uint32_t ip_addr) {
|
|
std::stringstream ss;
|
|
ip_addr = htonl(ip_addr);
|
|
/* we create an host ID based on the current IP */
|
|
ss << "AES67 daemon "
|
|
<< boost::format("%08x") % ((ip_addr << 16) | (ip_addr >> 16));
|
|
return ss.str();
|
|
}
|
|
|
|
std::string sdp_get_subject(const std::string& sdp) {
|
|
std::stringstream sstrem(sdp);
|
|
std::string line;
|
|
while (getline(sstrem, line, '\n')) {
|
|
if (line.substr(0, 2) == "s=") {
|
|
auto subject = line.substr(2);
|
|
boost::trim(subject);
|
|
return subject;
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
SDPOrigin sdp_get_origin(const std::string sdp) {
|
|
SDPOrigin origin;
|
|
try {
|
|
std::stringstream sstream(sdp);
|
|
std::string line;
|
|
while (getline(sstream, line, '\n')) {
|
|
boost::trim(line);
|
|
if (line[1] != '=') {
|
|
BOOST_LOG_TRIVIAL(error) << "session_manager:: invalid SDP file";
|
|
break;
|
|
}
|
|
std::string val = line.substr(2);
|
|
if (line[0] == 'o') {
|
|
std::vector<std::string> fields;
|
|
boost::split(fields, val, [line](char c) { return c == ' '; });
|
|
if (fields.size() < 6) {
|
|
BOOST_LOG_TRIVIAL(error) << "session_manager:: invalid origin";
|
|
break;
|
|
}
|
|
|
|
origin.username = fields[0];
|
|
origin.session_id = fields[1];
|
|
origin.session_version = std::stoull(fields[2]);
|
|
origin.network_type = fields[3];
|
|
origin.address_type = fields[4];
|
|
origin.unicast_address = fields[5];
|
|
break;
|
|
}
|
|
}
|
|
} catch (...) {
|
|
BOOST_LOG_TRIVIAL(fatal) << "session_manager:: invalid SDP"
|
|
<< ", cannot extract SDP identifier";
|
|
}
|
|
|
|
return origin;
|
|
}
|