public/rtphone
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

- removed old Sevana routines (they are moved to pvqa++ / aqua++ header files)

Browse Source 
- cleanups
This commit is contained in:
Dmytro Bogovych
2019-06-22 12:00:49 +03:00
parent 477932459f
commit 682362c6fe
11 changed files with 875 additions and 2117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/engine/helper/HL_SocketHeap.cpp
View File

@@ -1,4 +1,4 @@
/* Copyright(C) 2007-2014 VoIP objects (voipobjects.com)
/* Copyright(C) 2007-2019 VoIP objects (voipobjects.com)
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
@@ -29,6 +29,10 @@
#endif
// ----------------------------- SocketSink -------------------------
SocketSink::~SocketSink()
{}
// ----------------------------- SocketHeap -------------------------
SocketHeap::SocketHeap(unsigned short start, unsigned short finish)
@@ -132,7 +136,7 @@ PDatagramSocket SocketHeap::allocSocket(int family, SocketSink* sink, int port)
// Obtain port number
sockaddr_in addr;
sockaddr_in6 addr6;
int result;
int result = 0;
int testport;
do
{
@@ -144,7 +148,7 @@ PDatagramSocket SocketHeap::allocSocket(int family, SocketSink* sink, int port)
memset(&addr, 0, sizeof addr);
addr.sin_family = AF_INET;
addr.sin_port = htons(testport);
result = ::bind(sock, (const sockaddr*)&addr, sizeof addr);
result = ::bind(sock, reinterpret_cast<const sockaddr*>(&addr), sizeof addr);
if (result)
result = WSAGetLastError();
break;
@@ -153,7 +157,7 @@ PDatagramSocket SocketHeap::allocSocket(int family, SocketSink* sink, int port)
memset(&addr6, 0, sizeof addr6);
addr6.sin6_family = AF_INET6;
addr6.sin6_port = htons(testport);
result = ::bind(sock, (const sockaddr*)&addr6, sizeof addr6);
result = ::bind(sock, reinterpret_cast<const sockaddr*>(&addr6), sizeof addr6);
if (result)
result = WSAGetLastError();
break;

127
src/engine/helper/HL_SocketHeap.h
View File

@@ -11,11 +11,7 @@
#include <vector>
#include <algorithm>
#ifdef USE_RESIP_INTEGRATION
# include "resiprocate/rutil/ThreadIf.hxx"
#else
# include <thread>
#endif
#include <thread>
#include "HL_NetworkSocket.h"
#include "HL_Sync.h"
@@ -25,91 +21,92 @@
class SocketSink
{
public:
virtual void onReceivedData(PDatagramSocket socket, InternetAddress& src, const void* receivedPtr, unsigned receivedSize) = 0;
virtual ~SocketSink();
virtual void onReceivedData(PDatagramSocket socket, InternetAddress& src, const void* receivedPtr, unsigned receivedSize) = 0;
};
// Class allocates new UDP sockets and tracks incoming packets on them. It runs in separate thread
class SocketHeap
{
public:
enum Multiplex
{
DoMultiplexing,
DontMultiplexing
};
enum Multiplex
{
DoMultiplexing,
DontMultiplexing
};
SocketHeap(unsigned short start, unsigned short finish);
virtual ~SocketHeap();
SocketHeap(unsigned short start, unsigned short finish);
virtual ~SocketHeap();
static SocketHeap& instance();
static SocketHeap& instance();
void start();
void stop();
void start();
void stop();
// Specifies ne\ port number range. The sockets will be allocated in range [start..finish]
void setRange(unsigned short start, unsigned short finish);
// Specifies ne\ port number range. The sockets will be allocated in range [start..finish]
void setRange(unsigned short start, unsigned short finish);
// Returns used port number range
void range(unsigned short& start, unsigned short& finish);
// Attempts to allocate and return socket + allocated port number. REQUIRES pointer to data sink - it will be used to process incoming datagrams
PDatagramSocket allocSocket(int family, SocketSink* sink, int port = 0);
RtpPair<PDatagramSocket> allocSocketPair(int family, SocketSink* sink, Multiplex m);
// Returns used port number range
void range(unsigned short& start, unsigned short& finish);
// Stops receiving data for specified socket and frees socket itself.
void freeSocket(PDatagramSocket socket);
void freeSocketPair(const RtpPair<PDatagramSocket>& p);
// Attempts to allocate and return socket + allocated port number. REQUIRES pointer to data sink - it will be used to process incoming datagrams
PDatagramSocket allocSocket(int family, SocketSink* sink, int port = 0);
RtpPair<PDatagramSocket> allocSocketPair(int family, SocketSink* sink, Multiplex m);
// Stops receiving data for specified socket and frees socket itself.
void freeSocket(PDatagramSocket socket);
void freeSocketPair(const RtpPair<PDatagramSocket>& p);
// Sends data to specified address on specified socket.
void sendData(DatagramSocket& socket, InternetAddress& dest, const void* dataPtr, int dataSize);
// Sends data to specified address on specified socket.
void sendData(DatagramSocket& socket, InternetAddress& dest, const void* dataPtr, int dataSize);
protected:
struct SocketItem
{
// Local port number for socket
PDatagramSocket mSocket;
// Data sink pointer
SocketSink* mSink;
SocketItem()
:mSink(NULL)
{ }
struct SocketItem
{
// Local port number for socket
PDatagramSocket mSocket;
SocketItem(unsigned short portnumber, SocketSink* sink)
:mSink(sink)
{
mSocket->mLocalPort = portnumber;
}
~SocketItem()
{ }
};
// Data sink pointer
SocketSink* mSink;
typedef std::map<SOCKET, SocketItem> SocketMap;
typedef std::vector<unsigned short> PortVector;
typedef std::vector<PDatagramSocket> SocketVector;
SocketItem()
:mSink(nullptr)
{ }
Mutex mGuard;
SocketMap mSocketMap;
PortVector mPortVector;
unsigned short mStart,
mFinish;
SocketVector mDeleteVector;
Mutex mDeleteGuard;
SocketItem(unsigned short portnumber, SocketSink* sink)
:mSink(sink)
{
mSocket->mLocalPort = portnumber;
}
char mTempPacket[MAX_UDPPACKET_SIZE];
~SocketItem()
{ }
};
typedef std::map<SOCKET, SocketItem> SocketMap;
typedef std::vector<unsigned short> PortVector;
typedef std::vector<PDatagramSocket> SocketVector;
Mutex mGuard;
SocketMap mSocketMap;
PortVector mPortVector;
unsigned short mStart,
mFinish;
SocketVector mDeleteVector;
Mutex mDeleteGuard;
char mTempPacket[MAX_UDPPACKET_SIZE];
std::shared_ptr<std::thread> mWorkerThread;
std::thread::id mThreadId;
std::thread::id mThreadId;
bool mShutdown = false;
bool isShutdown() const { return mShutdown; }
void thread();
// Processes mDeleteVector -> updates mSocketMap, removes socket items and closes sockets specified in mDeleteVector
void processDeleted();
// Processes mDeleteVector -> updates mSocketMap, removes socket items and closes sockets specified in mDeleteVector
void processDeleted();
};

358
src/engine/helper/HL_VariantMap.cpp
View File

@@ -16,13 +16,13 @@
Variant::Variant()
{
mType = VTYPE_INT;
mInt = 0;
mInt64 = 0;
mBool = 0;
mFloat = 0;
mPointer = nullptr;
mType = VTYPE_INT;
mInt = 0;
mInt64 = 0;
mBool = 0;
mFloat = 0;
mPointer = nullptr;
}
Variant::~Variant()
@@ -30,315 +30,319 @@ Variant::~Variant()
}
Variant::Variant(bool value)
:mType(VTYPE_BOOL), mBool(value)
:mType(VTYPE_BOOL), mBool(value)
{}
Variant::Variant(int value)
:mType(VTYPE_INT), mInt(value)
:mType(VTYPE_INT), mInt(value)
{}
Variant::Variant(int64_t value)
:mType(VTYPE_INT64), mInt64(value)
:mType(VTYPE_INT64), mInt64(value)
{}
Variant::Variant(float value)
:mType(VTYPE_FLOAT), mFloat(value)
:mType(VTYPE_FLOAT), mFloat(value)
{}
Variant::Variant(double value)
:mType(VTYPE_FLOAT), mFloat((float)value)
:mType(VTYPE_FLOAT), mFloat((float)value)
{}
Variant::Variant(const std::string& value)
:mType(VTYPE_STRING), mString(value)
:mType(VTYPE_STRING), mString(value)
{}
Variant& Variant::operator = (bool value)
{
mType = VTYPE_BOOL;
mBool = value;
mType = VTYPE_BOOL;
mBool = value;
return *this;
return *this;
}
Variant& Variant::operator = (int value)
{
mType = VTYPE_INT;
mInt = value;
mType = VTYPE_INT;
mInt = value;
return *this;
return *this;
}
Variant& Variant::operator = (int64_t value)
{
mType = VTYPE_INT64;
mInt64 = value;
mType = VTYPE_INT64;
mInt64 = value;
return *this;
return *this;
}
Variant& Variant::operator = (float value)
{
mType = VTYPE_FLOAT;
mFloat = value;
mType = VTYPE_FLOAT;
mFloat = value;
return *this;
return *this;
}
Variant& Variant::operator = (const std::string& value)
{
mType = VTYPE_STRING;
mString = value;
mType = VTYPE_STRING;
mString = value;
return *this;
return *this;
}
Variant& Variant::operator = (const char* value)
{
mType = VTYPE_STRING;
mString = value;
mType = VTYPE_STRING;
mString = value;
return *this;
return *this;
}
Variant& Variant::operator = (void* value)
{
mType = VTYPE_POINTER;
mPointer = value;
mType = VTYPE_POINTER;
mPointer = value;
return *this;
return *this;
}
Variant& Variant::operator = (PVariantMap map)
{
mType = VTYPE_VMAP;
mVMap = map;
mType = VTYPE_VMAP;
mVMap = map;
return *this;
return *this;
}
Variant Variant::operator + (const Variant& rhs)
{
switch (type())
{
case VTYPE_BOOL:
case VTYPE_INT: return asInt() + rhs.asInt();
case VTYPE_INT64: return asInt64() + rhs.asInt64();
case VTYPE_FLOAT: return asFloat() + rhs.asFloat();
case VTYPE_STRING: return asStdString() + rhs.asStdString();
default:
return false;
}
switch (type())
{
case VTYPE_BOOL:
case VTYPE_INT: return asInt() + rhs.asInt();
case VTYPE_INT64: return asInt64() + rhs.asInt64();
case VTYPE_FLOAT: return asFloat() + rhs.asFloat();
case VTYPE_STRING: return asStdString() + rhs.asStdString();
default:
return false;
}
}
Variant Variant::operator - (const Variant& rhs)
{
switch (type())
{
case VTYPE_BOOL:
case VTYPE_STRING:
case VTYPE_INT: return asInt() - rhs.asInt();
case VTYPE_INT64: return asInt64() - rhs.asInt64();
case VTYPE_FLOAT: return asFloat() - rhs.asFloat();
switch (type())
{
case VTYPE_BOOL:
case VTYPE_STRING:
case VTYPE_INT: return asInt() - rhs.asInt();
case VTYPE_INT64: return asInt64() - rhs.asInt64();
case VTYPE_FLOAT: return asFloat() - rhs.asFloat();
default:
return false;
}
default:
return false;
}
}
Variant Variant::operator * (const Variant& rhs)
{
switch (type())
{
case VTYPE_BOOL:
case VTYPE_STRING:
case VTYPE_INT: return asInt() * rhs.asInt();
case VTYPE_INT64: return asInt64() * rhs.asInt64();
case VTYPE_FLOAT: return asFloat() * rhs.asFloat();
default:
return false;
}
switch (type())
{
case VTYPE_BOOL:
case VTYPE_STRING:
case VTYPE_INT: return asInt() * rhs.asInt();
case VTYPE_INT64: return asInt64() * rhs.asInt64();
case VTYPE_FLOAT: return asFloat() * rhs.asFloat();
default:
return false;
}
}
Variant Variant::operator / (const Variant& rhs)
{
switch (type())
{
case VTYPE_BOOL:
case VTYPE_STRING:
case VTYPE_INT: return asInt() / rhs.asInt();
case VTYPE_INT64: return asInt64() / rhs.asInt64();
case VTYPE_FLOAT: return asFloat() / rhs.asFloat();
switch (type())
{
case VTYPE_BOOL:
case VTYPE_STRING:
case VTYPE_INT: return asInt() / rhs.asInt();
case VTYPE_INT64: return asInt64() / rhs.asInt64();
case VTYPE_FLOAT: return asFloat() / rhs.asFloat();
default:
return false;
}
default:
return false;
}
}
bool Variant::operator < (const Variant& rhs) const
{
switch (type())
{
case VTYPE_STRING: return asStdString() < rhs.asStdString();
case VTYPE_BOOL:
case VTYPE_INT: return asInt() < rhs.asInt();
case VTYPE_INT64: return asInt64() < rhs.asInt64();
case VTYPE_FLOAT: return asFloat() < rhs.asFloat();
default:
return false;
}
switch (type())
{
case VTYPE_STRING: return asStdString() < rhs.asStdString();
case VTYPE_BOOL:
case VTYPE_INT: return asInt() < rhs.asInt();
case VTYPE_INT64: return asInt64() < rhs.asInt64();
case VTYPE_FLOAT: return asFloat() < rhs.asFloat();
default:
return false;
}
}
bool Variant::operator > (const Variant& rhs) const
{
return !(*this == rhs) && !(*this < rhs);
return !(*this == rhs) && !(*this < rhs);
}
bool Variant::operator == (const Variant& rhs) const
{
switch (type())
{
case VTYPE_STRING: return asStdString() == rhs.asStdString();
case VTYPE_BOOL: return asBool() == rhs.asBool();
case VTYPE_INT: return asInt() == rhs.asInt();
case VTYPE_INT64: return asInt64() == rhs.asInt64();
case VTYPE_FLOAT: return asFloat() == rhs.asFloat();
case VTYPE_POINTER: return asPointer() == rhs.asPointer();
case VTYPE_VMAP: assert(0); break;
default:
return false;
}
switch (type())
{
case VTYPE_STRING: return asStdString() == rhs.asStdString();
case VTYPE_BOOL: return asBool() == rhs.asBool();
case VTYPE_INT: return asInt() == rhs.asInt();
case VTYPE_INT64: return asInt64() == rhs.asInt64();
case VTYPE_FLOAT: return asFloat() == rhs.asFloat();
case VTYPE_POINTER: return asPointer() == rhs.asPointer();
case VTYPE_VMAP: assert(0); break;
default:
return false;
}
return false;
return false;
}
bool Variant::operator != (const Variant& rhs) const
{
return !(*this == rhs);
return !(*this == rhs);
}
bool Variant::operator <= (const Variant& rhs) const
{
return (*this < rhs) || (*this == rhs);
return (*this < rhs) || (*this == rhs);
}
bool Variant::operator >= (const Variant& rhs) const
{
return (*this > rhs) || (*this == rhs);
return (*this > rhs) || (*this == rhs);
}
int Variant::asInt() const
{
if (mType != VTYPE_INT)
throw Exception(ERR_BAD_VARIANT_TYPE);
return mInt;
if (mType != VTYPE_INT)
throw Exception(ERR_BAD_VARIANT_TYPE);
return mInt;
}
int64_t Variant::asInt64() const
{
if (mType != VTYPE_INT64)
throw Exception(ERR_BAD_VARIANT_TYPE);
if (mType != VTYPE_INT64)
throw Exception(ERR_BAD_VARIANT_TYPE);
return mInt;
return mInt;
}
bool Variant::asBool() const
{
switch (mType)
{
case VTYPE_INT:
return mInt != 0;
switch (mType)
{
case VTYPE_INT:
return mInt != 0;
case VTYPE_INT64:
return mInt64 != 0;
case VTYPE_INT64:
return mInt64 != 0;
case VTYPE_BOOL:
return mBool;
case VTYPE_BOOL:
return mBool;
case VTYPE_FLOAT:
return mFloat != 0;
case VTYPE_FLOAT:
return mFloat != 0;
case VTYPE_STRING:
return mString.length() != 0;
case VTYPE_STRING:
return mString.length() != 0;
default:
throw Exception(ERR_BAD_VARIANT_TYPE);
}
default:
throw Exception(ERR_BAD_VARIANT_TYPE);
}
}
float Variant::asFloat() const
{
switch (mType)
{
case VTYPE_INT:
return (float)mInt;
switch (mType)
{
case VTYPE_INT:
return (float)mInt;
case VTYPE_INT64:
return (float)mInt64;
case VTYPE_INT64:
return (float)mInt64;
case VTYPE_FLOAT:
return mFloat;
case VTYPE_FLOAT:
return mFloat;
default:
throw Exception(ERR_BAD_VARIANT_TYPE);
}
default:
throw Exception(ERR_BAD_VARIANT_TYPE);
}
}
double Variant::asDouble() const
{
return static_cast<double>(asFloat());
}
std::string Variant::asStdString() const
{
char buffer[32];
switch (mType)
{
case VTYPE_STRING:
return mString;
case VTYPE_INT:
sprintf(buffer, "%d", mInt);
return buffer;
char buffer[32];
switch (mType)
{
case VTYPE_STRING:
return mString;
case VTYPE_INT64:
sprintf(buffer, "%lli", static_cast<long long int>(mInt64));
return buffer;
case VTYPE_INT:
sprintf(buffer, "%d", mInt);
return buffer;
case VTYPE_BOOL:
return mBool ? "true" : "false";
case VTYPE_INT64:
sprintf(buffer, "%lli", static_cast<long long int>(mInt64));
return buffer;
case VTYPE_FLOAT:
sprintf(buffer, "%f", mFloat);
return buffer;
case VTYPE_BOOL:
return mBool ? "true" : "false";
default:
throw Exception(ERR_BAD_VARIANT_TYPE);
}
case VTYPE_FLOAT:
sprintf(buffer, "%f", mFloat);
return buffer;
default:
throw Exception(ERR_BAD_VARIANT_TYPE);
}
}
void* Variant::asPointer() const
{
switch (mType)
{
case VTYPE_POINTER:
return mPointer;
default:
throw Exception(ERR_BAD_VARIANT_TYPE);
}
switch (mType)
{
case VTYPE_POINTER:
return mPointer;
default:
throw Exception(ERR_BAD_VARIANT_TYPE);
}
}
PVariantMap Variant::asVMap()
{
switch (mType)
{
case VTYPE_VMAP:
return mVMap;
default:
throw Exception(ERR_BAD_VARIANT_TYPE);
}
switch (mType)
{
case VTYPE_VMAP:
return mVMap;
default:
throw Exception(ERR_BAD_VARIANT_TYPE);
}
}
VariantType Variant::type() const
{
return mType;
return mType;
}
VariantMap::VariantMap()
@@ -351,25 +355,25 @@ VariantMap::~VariantMap()
bool VariantMap::empty() const
{
return mData.empty();
return mData.empty();
}
void VariantMap::clear()
{
mData.clear();
mData.clear();
}
bool VariantMap::exists(int itemId) const
{
return mData.find(itemId) != mData.end();
return mData.find(itemId) != mData.end();
}
Variant& VariantMap::operator [](int itemId)
{
return mData[itemId];
return mData[itemId];
}
Variant& VariantMap::at(int itemId)
{
return mData[itemId];
return mData[itemId];
}

3
src/engine/helper/HL_VariantMap.h
View File

@@ -60,7 +60,8 @@ public:
int asInt() const;
int64_t asInt64() const;
bool asBool() const;
float asFloat() const ;
float asFloat() const;
double asDouble() const;
std::string asStdString() const;
//const char* asString();
void* asPointer() const;