773 lines
22 KiB
C++
773 lines
22 KiB
C++
/*
|
|
* Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#include "udp_socket_windows.h"
|
|
|
|
// Disable deprication warning from traffic.h
|
|
#pragma warning(disable : 4995)
|
|
|
|
#ifndef WIN32_LEAN_AND_MEAN
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#endif
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <windows.h>
|
|
#include <Qos.h>
|
|
// Don't change include order for these header files.
|
|
#include <Winsock2.h>
|
|
#include <Ntddndis.h>
|
|
#include <traffic.h>
|
|
|
|
#include "traffic_control_windows.h"
|
|
#include "udp_socket_manager_wrapper.h"
|
|
|
|
namespace webrtc {
|
|
typedef struct _QOS_DESTADDR
|
|
{
|
|
QOS_OBJECT_HDR ObjectHdr;
|
|
const struct sockaddr* SocketAddress;
|
|
ULONG SocketAddressLength;
|
|
} QOS_DESTADDR, *LPQOS_DESTADDR;
|
|
|
|
typedef const QOS_DESTADDR* LPCQOS_DESTADDR;
|
|
|
|
#define QOS_GENERAL_ID_BASE 2000
|
|
#define QOS_OBJECT_DESTADDR (0x00000004 + QOS_GENERAL_ID_BASE)
|
|
|
|
#define MAX_PACKET_SIZE 2048
|
|
|
|
class UDPPacket
|
|
{
|
|
public:
|
|
UDPPacket()
|
|
{
|
|
_length = 0;
|
|
}
|
|
WebRtc_Word32 Set(const WebRtc_Word8* buf, WebRtc_Word32 length)
|
|
{
|
|
if(length > MAX_PACKET_SIZE)
|
|
return 0;
|
|
|
|
_length = length;
|
|
memcpy(_buffer,buf,length);
|
|
return length;
|
|
}
|
|
WebRtc_Word32 Set(const WebRtc_Word8* buf, WebRtc_Word32 length,
|
|
const SocketAddress* addr)
|
|
{
|
|
if(length > MAX_PACKET_SIZE)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
_length = length;
|
|
memcpy(&_remoteAddr,addr,sizeof(SocketAddress));
|
|
memcpy(_buffer,buf,length);
|
|
return length;
|
|
}
|
|
|
|
SocketAddress _remoteAddr;
|
|
WebRtc_Word8 _buffer[MAX_PACKET_SIZE];
|
|
WebRtc_Word32 _length;
|
|
};
|
|
|
|
UdpSocketWindows::UdpSocketWindows(const WebRtc_Word32 id,
|
|
UdpSocketManager* mgr, bool ipV6Enable)
|
|
: _id(id),
|
|
_qos(true)
|
|
{
|
|
_wantsIncoming = false;
|
|
_error = 0;
|
|
_mgr = mgr;
|
|
_addedToMgr = false;
|
|
|
|
_obj = NULL;
|
|
_incomingCb = NULL;
|
|
_socket = INVALID_SOCKET;
|
|
_terminate=false;
|
|
|
|
_clientHandle = INVALID_HANDLE_VALUE;
|
|
_flowHandle = INVALID_HANDLE_VALUE;
|
|
_filterHandle = INVALID_HANDLE_VALUE;
|
|
|
|
WEBRTC_TRACE(kTraceMemory, kTraceTransport, _id,
|
|
"UdpSocketWindows::UdpSocketWindows()");
|
|
|
|
_gtc = NULL;
|
|
|
|
// Check if QoS is supported.
|
|
WSAPROTOCOL_INFO pProtocolInfo;
|
|
DWORD dwBufLen = 0;
|
|
BOOL bProtocolFound = FALSE;
|
|
WSAPROTOCOL_INFO* lpProtocolBuf = NULL;
|
|
|
|
// Set dwBufLen to the size needed to retreive all the requested information
|
|
// from WSAEnumProtocols.
|
|
WebRtc_Word32 nRet = WSAEnumProtocols(NULL, lpProtocolBuf, &dwBufLen);
|
|
lpProtocolBuf = (WSAPROTOCOL_INFO*)malloc(dwBufLen);
|
|
nRet = WSAEnumProtocols(NULL, lpProtocolBuf, &dwBufLen);
|
|
|
|
WebRtc_Word32 iProtocol;
|
|
if (ipV6Enable)
|
|
{
|
|
iProtocol = AF_INET6;
|
|
} else {
|
|
iProtocol = AF_INET;
|
|
}
|
|
|
|
for (WebRtc_Word32 i = 0; i < nRet; i++)
|
|
{
|
|
if (iProtocol == lpProtocolBuf[i].iAddressFamily && IPPROTO_UDP ==
|
|
lpProtocolBuf[i].iProtocol)
|
|
{
|
|
if ((XP1_QOS_SUPPORTED ==
|
|
(XP1_QOS_SUPPORTED & lpProtocolBuf[i].dwServiceFlags1)))
|
|
{
|
|
pProtocolInfo = lpProtocolBuf[i];
|
|
bProtocolFound = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!bProtocolFound)
|
|
{
|
|
_socket = INVALID_SOCKET;
|
|
_qos = false;
|
|
free(lpProtocolBuf);
|
|
_error = SOCKET_ERROR_NO_QOS;
|
|
}else {
|
|
_socket = WSASocket(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
|
|
FROM_PROTOCOL_INFO,&pProtocolInfo, 0,
|
|
WSA_FLAG_OVERLAPPED);
|
|
free(lpProtocolBuf);
|
|
if (_socket != INVALID_SOCKET)
|
|
{
|
|
return;
|
|
}else
|
|
{
|
|
_qos = false;
|
|
_error = SOCKET_ERROR_NO_QOS;
|
|
}
|
|
}
|
|
// QoS not supported.
|
|
if(ipV6Enable)
|
|
{
|
|
_socket = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
|
|
}else
|
|
{
|
|
_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
|
|
}
|
|
// Non-blocking mode.
|
|
WebRtc_Word32 iMode = 1;
|
|
ioctlsocket(_socket, FIONBIO, (u_long FAR*) &iMode);
|
|
}
|
|
|
|
UdpSocketWindows::~UdpSocketWindows()
|
|
{
|
|
WEBRTC_TRACE(kTraceMemory, kTraceTransport, _id,
|
|
"UdpSocketWindows::~UdpSocketWindows()");
|
|
if (_gtc)
|
|
{
|
|
TrafficControlWindows::Release(_gtc);
|
|
}
|
|
}
|
|
|
|
WebRtc_Word32 UdpSocketWindows::ChangeUniqueId(const WebRtc_Word32 id)
|
|
{
|
|
_id = id;
|
|
if (_gtc)
|
|
{
|
|
_gtc->ChangeUniqueId(id);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool UdpSocketWindows::ValidHandle()
|
|
{
|
|
return GetFd() != INVALID_SOCKET;
|
|
}
|
|
|
|
bool UdpSocketWindows::SetCallback(CallbackObj obj, IncomingSocketCallback cb)
|
|
{
|
|
_obj = obj;
|
|
_incomingCb = cb;
|
|
|
|
if (_mgr->AddSocket(this))
|
|
{
|
|
_addedToMgr = true;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool UdpSocketWindows::SetSockopt(WebRtc_Word32 level, WebRtc_Word32 optname,
|
|
const WebRtc_Word8* optval,
|
|
WebRtc_Word32 optlen)
|
|
{
|
|
if(0 == setsockopt(_socket, level, optname, optval, optlen))
|
|
{
|
|
return true;
|
|
}
|
|
_error = WSAGetLastError();
|
|
return false;
|
|
}
|
|
|
|
bool UdpSocketWindows::Bind(const SocketAddress& name)
|
|
{
|
|
const struct sockaddr* socketName =
|
|
reinterpret_cast<const struct sockaddr*>(&name);
|
|
|
|
if (0 == bind(_socket, socketName, sizeof(SocketAddress)))
|
|
{
|
|
_localAddr = name;
|
|
return true;
|
|
}
|
|
_error = WSAGetLastError();
|
|
return false;
|
|
}
|
|
|
|
WebRtc_Word32 UdpSocketWindows::SendTo(const WebRtc_Word8* buf,
|
|
WebRtc_Word32 len,
|
|
const SocketAddress& to)
|
|
{
|
|
// Don't try to send this packet if there are older packets queued up.
|
|
if(!_notSentPackets.Empty())
|
|
{
|
|
UDPPacket* packet = new UDPPacket();
|
|
packet->Set(buf, len, &to);
|
|
if(!_notSentPackets.Empty())
|
|
{
|
|
_notSentPackets.PushBack(packet);
|
|
return len;
|
|
}else {
|
|
// No old packets queued up. Free to try to send.
|
|
delete packet;
|
|
}
|
|
}
|
|
|
|
WebRtc_Word32 retVal;
|
|
retVal = sendto(_socket, buf, len, 0,
|
|
reinterpret_cast<const struct sockaddr*>(&to),
|
|
sizeof(SocketAddress));
|
|
|
|
if(retVal == SOCKET_ERROR)
|
|
{
|
|
_error = WSAGetLastError();
|
|
if (_error == WSAEWOULDBLOCK)
|
|
{
|
|
UDPPacket* packet = new UDPPacket();
|
|
packet->Set(buf,len, &to);
|
|
_notSentPackets.PushBack(packet);
|
|
return len;
|
|
}
|
|
}
|
|
return retVal;
|
|
}
|
|
|
|
void UdpSocketWindows::HasIncoming()
|
|
{
|
|
WebRtc_Word8 buf[MAX_PACKET_SIZE];
|
|
SocketAddress from;
|
|
int fromlen = sizeof(from);
|
|
WebRtc_Word32 retval = recvfrom(_socket,buf, sizeof(buf), 0,
|
|
reinterpret_cast<struct sockaddr*>(&from),
|
|
&fromlen);
|
|
|
|
switch(retval)
|
|
{
|
|
case 0:
|
|
// The connection has been gracefully closed.
|
|
break;
|
|
case SOCKET_ERROR:
|
|
_error = WSAGetLastError();
|
|
break;
|
|
default:
|
|
if(_wantsIncoming && _incomingCb)
|
|
_incomingCb(_obj,buf, retval, &from);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void UdpSocketWindows::CleanUp()
|
|
{
|
|
WEBRTC_TRACE(kTraceDebug, kTraceTransport, _id,
|
|
"UdpSocketWindows::CleanUp()");
|
|
_wantsIncoming = false;
|
|
|
|
if(_clientHandle != INVALID_HANDLE_VALUE)
|
|
{
|
|
assert(_filterHandle != INVALID_HANDLE_VALUE);
|
|
assert(_flowHandle != INVALID_HANDLE_VALUE);
|
|
|
|
if (_gtc)
|
|
{
|
|
_gtc->TcDeleteFilter(_filterHandle);
|
|
_gtc->TcDeleteFlow(_flowHandle);
|
|
_gtc->TcDeregisterClient(_clientHandle);
|
|
}
|
|
|
|
_clientHandle = INVALID_HANDLE_VALUE;
|
|
_filterHandle = INVALID_HANDLE_VALUE;
|
|
_flowHandle = INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
while(!_notSentPackets.Empty())
|
|
{
|
|
UDPPacket* packet = (UDPPacket*)_notSentPackets.First()->GetItem();
|
|
if(!packet)
|
|
{
|
|
break;
|
|
}
|
|
delete packet;
|
|
_notSentPackets.PopFront();
|
|
}
|
|
|
|
if (_socket != INVALID_SOCKET)
|
|
{
|
|
if (closesocket(_socket) == SOCKET_ERROR)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
|
|
"closesocket() => error = %d", WSAGetLastError());
|
|
}
|
|
WEBRTC_TRACE(kTraceDebug, kTraceTransport, _id,
|
|
"WinSock::closesocket() done");
|
|
|
|
if(_addedToMgr)
|
|
{
|
|
WEBRTC_TRACE(kTraceDebug, kTraceTransport, _id,
|
|
"calling UdpSocketManager::RemoveSocket()");
|
|
_mgr->RemoveSocket(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
void UdpSocketWindows::SetWritable()
|
|
{
|
|
// Try to send packets that have been queued up.
|
|
while(!_notSentPackets.Empty())
|
|
{
|
|
UDPPacket* packet = (UDPPacket*)_notSentPackets.First()->GetItem();
|
|
if(!packet)
|
|
{
|
|
break;
|
|
}
|
|
if(sendto(
|
|
_socket,packet->_buffer,
|
|
packet->_length,
|
|
0,
|
|
reinterpret_cast<const struct sockaddr*>(
|
|
&(packet->_remoteAddr)),
|
|
sizeof(SocketAddress)) == SOCKET_ERROR)
|
|
{
|
|
_error = WSAGetLastError();
|
|
if (_error == WSAEWOULDBLOCK)
|
|
{
|
|
return;
|
|
}
|
|
} else {
|
|
delete packet;
|
|
_notSentPackets.PopFront();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool UdpSocketWindows::SetQos(WebRtc_Word32 serviceType,
|
|
WebRtc_Word32 tokenRate,
|
|
WebRtc_Word32 bucketSize,
|
|
WebRtc_Word32 peekBandwith,
|
|
WebRtc_Word32 minPolicedSize,
|
|
WebRtc_Word32 maxSduSize,
|
|
const SocketAddress &stRemName,
|
|
WebRtc_Word32 overrideDSCP)
|
|
{
|
|
if(_qos == false)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
|
|
"UdpSocket2Windows::SetQos(), socket not capable of QOS");
|
|
return false;
|
|
}
|
|
QOS Qos;
|
|
WebRtc_Word32 result;
|
|
DWORD BytesRet;
|
|
|
|
if(overrideDSCP != 0)
|
|
{
|
|
FLOWSPEC f;
|
|
WebRtc_Word32 err = CreateFlowSpec(serviceType, tokenRate, bucketSize,
|
|
peekBandwith, minPolicedSize,
|
|
maxSduSize, &f);
|
|
if(err == -1)
|
|
{
|
|
return false;
|
|
}
|
|
return SetTOSByte(overrideDSCP, &f, &f) == 0;
|
|
}
|
|
memset(&Qos, QOS_NOT_SPECIFIED, sizeof(QOS));
|
|
|
|
Qos.SendingFlowspec.ServiceType = serviceType;
|
|
Qos.SendingFlowspec.TokenRate = tokenRate;
|
|
Qos.SendingFlowspec.TokenBucketSize = bucketSize;
|
|
Qos.SendingFlowspec.PeakBandwidth = peekBandwith;
|
|
Qos.SendingFlowspec.DelayVariation = QOS_NOT_SPECIFIED;
|
|
Qos.SendingFlowspec.Latency = QOS_NOT_SPECIFIED;
|
|
Qos.SendingFlowspec.MinimumPolicedSize = minPolicedSize;
|
|
Qos.SendingFlowspec.MaxSduSize = maxSduSize;
|
|
|
|
// Only ServiceType is needed for receiving.
|
|
Qos.ReceivingFlowspec.ServiceType = serviceType;
|
|
Qos.ReceivingFlowspec.TokenRate = QOS_NOT_SPECIFIED;
|
|
Qos.ReceivingFlowspec.TokenBucketSize = QOS_NOT_SPECIFIED;
|
|
Qos.ReceivingFlowspec.PeakBandwidth = QOS_NOT_SPECIFIED;
|
|
Qos.ReceivingFlowspec.Latency = QOS_NOT_SPECIFIED;
|
|
Qos.ReceivingFlowspec.DelayVariation = QOS_NOT_SPECIFIED;
|
|
Qos.ReceivingFlowspec.MinimumPolicedSize = QOS_NOT_SPECIFIED;
|
|
Qos.ReceivingFlowspec.MaxSduSize = QOS_NOT_SPECIFIED;
|
|
|
|
Qos.ProviderSpecific.len = 0;
|
|
Qos.ProviderSpecific.buf = NULL;
|
|
WebRtc_Word8* p = (WebRtc_Word8*)malloc(sizeof(QOS_DESTADDR) +
|
|
sizeof(QOS_DS_CLASS));
|
|
|
|
QOS_DESTADDR* QosDestaddr = (QOS_DESTADDR*)p;
|
|
ZeroMemory((WebRtc_Word8 *)QosDestaddr, sizeof(QOS_DESTADDR));
|
|
QosDestaddr->ObjectHdr.ObjectType = QOS_OBJECT_DESTADDR;
|
|
QosDestaddr->ObjectHdr.ObjectLength = sizeof(QOS_DESTADDR);
|
|
QosDestaddr->SocketAddress = (SOCKADDR*)&stRemName;
|
|
QosDestaddr->SocketAddressLength = sizeof(SocketAddress);
|
|
Qos.ProviderSpecific.len = QosDestaddr->ObjectHdr.ObjectLength;
|
|
Qos.ProviderSpecific.buf = (WebRtc_Word8*)p;
|
|
|
|
// Socket must be bound for this call to be successfull. If socket is not
|
|
// bound WSAGetLastError() will return 10022.
|
|
result = WSAIoctl(GetFd(),SIO_SET_QOS, &Qos,sizeof(QOS),NULL, 0, &BytesRet,
|
|
NULL,NULL);
|
|
if (result == SOCKET_ERROR)
|
|
{
|
|
_error = WSAGetLastError();
|
|
free(p);
|
|
return false;
|
|
}
|
|
free(p);
|
|
return true;
|
|
}
|
|
|
|
WebRtc_Word32 UdpSocketWindows::SetTOS(WebRtc_Word32 serviceType)
|
|
{
|
|
WebRtc_Word32 res = SetTOSByte(serviceType, NULL, NULL);
|
|
|
|
if (res == -1)
|
|
{
|
|
OSVERSIONINFO OsVersion;
|
|
OsVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
|
|
GetVersionEx (&OsVersion);
|
|
|
|
if ((OsVersion.dwMajorVersion == 4))
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
WebRtc_Word32 UdpSocketWindows::CreateFlowSpec(WebRtc_Word32 serviceType,
|
|
WebRtc_Word32 tokenRate,
|
|
WebRtc_Word32 bucketSize,
|
|
WebRtc_Word32 peekBandwith,
|
|
WebRtc_Word32 minPolicedSize,
|
|
WebRtc_Word32 maxSduSize,
|
|
FLOWSPEC *f)
|
|
{
|
|
if(!f)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
f->ServiceType = serviceType;
|
|
f->TokenRate = tokenRate;
|
|
f->TokenBucketSize = bucketSize;
|
|
f->PeakBandwidth = peekBandwith;
|
|
f->DelayVariation = QOS_NOT_SPECIFIED;
|
|
f->Latency = QOS_NOT_SPECIFIED;
|
|
f->MinimumPolicedSize = minPolicedSize;
|
|
f->MaxSduSize = maxSduSize;
|
|
return 0;
|
|
}
|
|
|
|
WebRtc_Word32 UdpSocketWindows::SetTOSByte(WebRtc_Word32 serviceType,
|
|
FLOWSPEC* send, FLOWSPEC* recv)
|
|
{
|
|
if(_socket == INVALID_SOCKET)
|
|
{
|
|
return -1;
|
|
}
|
|
if (!_gtc)
|
|
{
|
|
_gtc = TrafficControlWindows::GetInstance(_id);
|
|
}
|
|
if (!_gtc)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
TCI_CLIENT_FUNC_LIST QoSFunctions;
|
|
QoSFunctions.ClAddFlowCompleteHandler = NULL;
|
|
QoSFunctions.ClDeleteFlowCompleteHandler = NULL;
|
|
QoSFunctions.ClModifyFlowCompleteHandler = NULL;
|
|
QoSFunctions.ClNotifyHandler = (TCI_NOTIFY_HANDLER)MyClNotifyHandler;
|
|
// Register the client with Traffic control interface.
|
|
HANDLE ClientHandle;
|
|
ULONG result = _gtc->TcRegisterClient(CURRENT_TCI_VERSION, NULL,
|
|
&QoSFunctions,&ClientHandle);
|
|
if(result != NO_ERROR)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
|
|
"TcRegisterClient returned %d", result);
|
|
return result;
|
|
}
|
|
|
|
// Find traffic control-enabled network interfaces.
|
|
ULONG BufferSize = 0;
|
|
result = _gtc->TcEnumerateInterfaces(ClientHandle, &BufferSize, NULL);
|
|
|
|
if(result != NO_ERROR && result != ERROR_INSUFFICIENT_BUFFER)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
|
|
"Error enumerating interfaces, %d", result);
|
|
_gtc->TcDeregisterClient(ClientHandle);
|
|
return result;
|
|
}
|
|
|
|
if(result != ERROR_INSUFFICIENT_BUFFER)
|
|
{
|
|
// Empty buffer contains all control-enabled network interfaces. I.e.
|
|
// ToS is not enabled.
|
|
WEBRTC_TRACE(
|
|
kTraceError,
|
|
kTraceTransport,
|
|
_id,
|
|
"Error enumerating interfaces: passed in 0 and received\
|
|
NO_ERROR when expecting INSUFFICIENT_BUFFER, %d");
|
|
_gtc->TcDeregisterClient(ClientHandle);
|
|
return -1;
|
|
}
|
|
|
|
PTC_IFC_DESCRIPTOR pInterfaceBuffer =
|
|
(PTC_IFC_DESCRIPTOR)malloc(BufferSize);
|
|
if(pInterfaceBuffer == NULL)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
|
|
"Out ot memory failure");
|
|
_gtc->TcDeregisterClient(ClientHandle);
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
result = _gtc->TcEnumerateInterfaces(ClientHandle, &BufferSize,
|
|
pInterfaceBuffer);
|
|
|
|
if(result != NO_ERROR)
|
|
{
|
|
WEBRTC_TRACE(
|
|
kTraceError,
|
|
kTraceTransport,
|
|
_id,
|
|
"Critical: error enumerating interfaces when passing in correct\
|
|
buffer size: %d", result);
|
|
_gtc->TcDeregisterClient(ClientHandle);
|
|
free(pInterfaceBuffer);
|
|
return result;
|
|
}
|
|
|
|
|
|
PTC_IFC_DESCRIPTOR oneinterface;
|
|
HANDLE ifcHandle, iFilterHandle, iflowHandle;
|
|
bool addrFound = false;
|
|
ULONG filterSourceAddress = ULONG_MAX;
|
|
|
|
const struct sockaddr_in* name;
|
|
name = reinterpret_cast<const struct sockaddr_in*>(&_localAddr);
|
|
|
|
// Find the interface corresponding to the local address.
|
|
for(oneinterface = pInterfaceBuffer;
|
|
oneinterface != (PTC_IFC_DESCRIPTOR)
|
|
(((WebRtc_Word8*)pInterfaceBuffer) + BufferSize);
|
|
oneinterface = (PTC_IFC_DESCRIPTOR)
|
|
((WebRtc_Word8*)oneinterface + oneinterface->Length))
|
|
{
|
|
|
|
WebRtc_Word8 interfaceName[500];
|
|
WideCharToMultiByte(CP_ACP, 0, oneinterface->pInterfaceName, -1,
|
|
interfaceName, sizeof(interfaceName), 0, 0);
|
|
|
|
PNETWORK_ADDRESS_LIST addresses =
|
|
&(oneinterface->AddressListDesc.AddressList);
|
|
for(LONG i = 0; i < addresses->AddressCount; i++)
|
|
{
|
|
// Only look at TCP/IP addresses.
|
|
if(addresses->Address[i].AddressType != NDIS_PROTOCOL_ID_TCP_IP)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
NETWORK_ADDRESS_IP* pIpAddr =
|
|
(NETWORK_ADDRESS_IP*)&(addresses->Address[i].Address);
|
|
|
|
WEBRTC_TRACE(kTraceDebug, kTraceTransport, _id,
|
|
"Examining Interface %s", interfaceName);
|
|
if(pIpAddr->in_addr == name->sin_addr.S_un.S_addr)
|
|
{
|
|
filterSourceAddress = pIpAddr->in_addr;
|
|
WEBRTC_TRACE(kTraceDebug, kTraceTransport, _id,
|
|
"Found ip addr: %s", inet_ntoa(name->sin_addr));
|
|
addrFound = true;
|
|
}
|
|
}
|
|
if(!addrFound)
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!addrFound)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceTransport, _id, "IP Address not found");
|
|
_gtc->TcDeregisterClient(ClientHandle);
|
|
free(pInterfaceBuffer);
|
|
return -1;
|
|
}
|
|
|
|
|
|
result = _gtc->TcOpenInterfaceW(oneinterface->pInterfaceName, ClientHandle,
|
|
NULL, &ifcHandle);
|
|
|
|
if(result != NO_ERROR)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
|
|
"Error opening interface: %d", result);
|
|
_gtc->TcDeregisterClient(ClientHandle);
|
|
free(pInterfaceBuffer);
|
|
return result;
|
|
}
|
|
|
|
FLOWSPEC defaultSend, defaultRecv;
|
|
if(send == NULL)
|
|
{
|
|
defaultSend.DelayVariation = QOS_NOT_SPECIFIED;
|
|
defaultSend.Latency = QOS_NOT_SPECIFIED;
|
|
defaultSend.MaxSduSize = QOS_NOT_SPECIFIED;
|
|
defaultSend.MinimumPolicedSize = QOS_NOT_SPECIFIED;
|
|
defaultSend.PeakBandwidth = QOS_NOT_SPECIFIED;
|
|
defaultSend.ServiceType = SERVICETYPE_BESTEFFORT;
|
|
defaultSend.TokenBucketSize = QOS_NOT_SPECIFIED;
|
|
defaultSend.TokenRate = 10000;
|
|
}
|
|
else
|
|
{
|
|
defaultSend = *send;
|
|
}
|
|
if(recv == NULL)
|
|
{
|
|
defaultRecv = defaultSend;
|
|
defaultRecv.ServiceType = SERVICETYPE_CONTROLLEDLOAD;
|
|
}
|
|
else
|
|
{
|
|
defaultRecv = *recv;
|
|
}
|
|
|
|
|
|
PTC_GEN_FLOW flow =
|
|
(PTC_GEN_FLOW)malloc(sizeof(TC_GEN_FLOW) + sizeof(QOS_DS_CLASS));
|
|
|
|
flow->ReceivingFlowspec = defaultRecv;
|
|
flow->SendingFlowspec = defaultSend;
|
|
|
|
QOS_DS_CLASS dsClass;
|
|
|
|
ZeroMemory((WebRtc_Word8*)&dsClass, sizeof(QOS_DS_CLASS));
|
|
|
|
dsClass.DSField = serviceType;
|
|
|
|
dsClass.ObjectHdr.ObjectType = QOS_OBJECT_DS_CLASS;
|
|
dsClass.ObjectHdr.ObjectLength = sizeof(dsClass);
|
|
|
|
memcpy(flow->TcObjects, (void*)&dsClass, sizeof(QOS_DS_CLASS));
|
|
flow->TcObjectsLength = sizeof(dsClass);
|
|
|
|
result = _gtc->TcAddFlow(ifcHandle, NULL, 0, flow, &iflowHandle);
|
|
if(result != NO_ERROR)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
|
|
"Error adding flow: %d", result);
|
|
_gtc->TcCloseInterface(ifcHandle);
|
|
_gtc->TcDeregisterClient(ClientHandle);
|
|
free(pInterfaceBuffer);
|
|
return -1;
|
|
}
|
|
|
|
free(flow);
|
|
IP_PATTERN filterPattern, mask;
|
|
|
|
ZeroMemory((WebRtc_Word8*)&filterPattern, sizeof(IP_PATTERN));
|
|
ZeroMemory((WebRtc_Word8*)&mask, sizeof(IP_PATTERN));
|
|
|
|
filterPattern.ProtocolId = IPPROTO_UDP;
|
|
// "name" fields are in network order.
|
|
filterPattern.S_un.S_un_ports.s_srcport = name->sin_port;
|
|
filterPattern.SrcAddr = filterSourceAddress;
|
|
|
|
// Unsigned max of a type corresponds to a bitmask with all bits set to 1.
|
|
// I.e. the filter should allow all ProtocolIds, any source port and any
|
|
// IP address.
|
|
mask.ProtocolId = UCHAR_MAX;
|
|
mask.S_un.S_un_ports.s_srcport = USHRT_MAX;
|
|
mask.SrcAddr = ULONG_MAX;
|
|
|
|
TC_GEN_FILTER filter;
|
|
filter.AddressType = NDIS_PROTOCOL_ID_TCP_IP;
|
|
filter.Mask = (LPVOID)&mask;
|
|
filter.Pattern = (LPVOID)&filterPattern;
|
|
filter.PatternSize = sizeof(IP_PATTERN);
|
|
if(_filterHandle != INVALID_HANDLE_VALUE)
|
|
{
|
|
_gtc->TcDeleteFilter(_filterHandle);
|
|
}
|
|
|
|
result = _gtc->TcAddFilter(iflowHandle, &filter, &iFilterHandle);
|
|
if(result != NO_ERROR)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
|
|
"Error adding filter: %d", result);
|
|
_gtc->TcDeleteFlow(iflowHandle);
|
|
_gtc->TcCloseInterface(ifcHandle);
|
|
_gtc->TcDeregisterClient(ClientHandle);
|
|
free(pInterfaceBuffer);
|
|
return result;
|
|
}
|
|
|
|
_flowHandle = iflowHandle;
|
|
_filterHandle = iFilterHandle;
|
|
_clientHandle = ClientHandle;
|
|
|
|
_gtc->TcCloseInterface(ifcHandle);
|
|
free(pInterfaceBuffer);
|
|
|
|
WEBRTC_TRACE(kTraceDebug, kTraceTransport, _id,
|
|
"Successfully created flow and filter.");
|
|
return 0;
|
|
}
|
|
} // namespace webrtc
|