Update to 0.5.2: improved builds, encryption option on call.
git-svn-id: http://libjingle.googlecode.com/svn/trunk@51 dd674b97-3498-5ee5-1854-bdd07cd0ff33
diff --git a/CHANGELOG b/CHANGELOG
index d1574d8..e0c746e 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,5 +1,13 @@
Libjingle
+0.5.2 - Jan 11, 2010
+ - Fixed build on Windows 7 with VS 2010
+ - Fixed build on Windows x64
+ - Fixed build on Mac OSX
+ - Added option to examples/call to enable encryption
+ - Improved logging
+ - Bug fixes
+
0.5.1 - Nov 2, 2010
- Added support for call encryption.
- Added addtional XEP-166 and XEP-167 features:
diff --git a/README b/README
index b127b56..f70b726 100644
--- a/README
+++ b/README
@@ -30,6 +30,8 @@
Libjingle is built with swtoolkit (http://code.google.com/p/swtoolkit/), which
is a set of extensions to the open-source SCons build tool (www.scons.org).
* First, install Python 2.4 or later from http://www.python.org/.
+ Please note that since swtoolkit only works with Python 2.x, you will
+ not be able to use Python 3.x.
* Second, install the stand alone scons-local package 2.0.0 or later from
http://www.scons.org/download.php and set an environment variable,
diff --git a/talk/base/buffer.h b/talk/base/buffer.h
new file mode 100644
index 0000000..311cfad
--- /dev/null
+++ b/talk/base/buffer.h
@@ -0,0 +1,119 @@
+/*
+ * libjingle
+ * Copyright 2004-2010, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TALK_BASE_BUFFER_H_
+#define TALK_BASE_BUFFER_H_
+
+#include <cstring>
+
+#include "talk/base/scoped_ptr.h"
+
+namespace talk_base {
+
+// Basic buffer class, can be grown and shrunk dynamically.
+// Unlike std::string/vector, does not initialize data when expanding capacity.
+class Buffer {
+ public:
+ Buffer() {
+ Construct(NULL, 0, 0);
+ }
+ Buffer(const void* data, size_t length) {
+ Construct(data, length, length);
+ }
+ Buffer(const void* data, size_t length, size_t capacity) {
+ Construct(data, length, capacity);
+ }
+ Buffer(const Buffer& buf) {
+ Construct(buf.data(), buf.length(), buf.length());
+ }
+
+ const char* data() const { return data_.get(); }
+ char* data() { return data_.get(); }
+ // TODO: should this be size(), like STL?
+ size_t length() const { return length_; }
+ size_t capacity() const { return capacity_; }
+
+ Buffer& operator=(const Buffer& buf) {
+ if (&buf != this) {
+ Construct(buf.data(), buf.length(), buf.length());
+ }
+ return *this;
+ }
+ bool operator==(const Buffer& buf) const {
+ return (length_ == buf.length() &&
+ memcmp(data_.get(), buf.data(), length_) == 0);
+ }
+ bool operator!=(const Buffer& buf) const {
+ return !operator==(buf);
+ }
+
+ void SetData(const void* data, size_t length) {
+ ASSERT(data != NULL || length == 0);
+ SetLength(length);
+ memcpy(data_.get(), data, length);
+ }
+ void AppendData(const void* data, size_t length) {
+ ASSERT(data != NULL || length == 0);
+ size_t old_length = length_;
+ SetLength(length_ + length);
+ memcpy(data_.get() + old_length, data, length);
+ }
+ void SetLength(size_t length) {
+ SetCapacity(length);
+ length_ = length;
+ }
+ void SetCapacity(size_t capacity) {
+ if (capacity > capacity_) {
+ talk_base::scoped_array<char> data(new char[capacity]);
+ memcpy(data.get(), data_.get(), length_);
+ data_.swap(data);
+ capacity_ = capacity;
+ }
+ }
+
+ void TransferTo(Buffer* buf) {
+ ASSERT(buf != NULL);
+ buf->data_.reset(data_.release());
+ buf->length_ = length_;
+ buf->capacity_ = capacity_;
+ Construct(NULL, 0, 0);
+ }
+
+ protected:
+ void Construct(const void* data, size_t length, size_t capacity) {
+ data_.reset(new char[capacity_ = capacity]);
+ SetData(data, length);
+ }
+
+ scoped_array<char> data_;
+ size_t length_;
+ size_t capacity_;
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_BUFFER_H_
diff --git a/talk/base/latebindingsymboltable.cc b/talk/base/latebindingsymboltable.cc
new file mode 100644
index 0000000..f9d59ab
--- /dev/null
+++ b/talk/base/latebindingsymboltable.cc
@@ -0,0 +1,111 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "talk/base/latebindingsymboltable.h"
+
+#ifdef LINUX
+#include <dlfcn.h>
+#endif
+
+#include "talk/base/logging.h"
+
+namespace talk_base {
+
+inline static const char *GetDllError() {
+#ifdef LINUX
+ char *err = dlerror();
+ if (err) {
+ return err;
+ } else {
+ return "No error";
+ }
+#else
+#error Not implemented
+#endif
+}
+
+DllHandle InternalLoadDll(const char dll_name[]) {
+#ifdef LINUX
+ DllHandle handle = dlopen(dll_name, RTLD_NOW);
+#else
+#error Not implemented
+#endif
+ if (handle == kInvalidDllHandle) {
+ LOG(LS_WARNING) << "Can't load " << dll_name << ": " << GetDllError();
+ }
+ return handle;
+}
+
+void InternalUnloadDll(DllHandle handle) {
+#ifdef LINUX
+ if (dlclose(handle) != 0) {
+ LOG(LS_ERROR) << GetDllError();
+ }
+#else
+#error Not implemented
+#endif
+}
+
+static bool LoadSymbol(DllHandle handle,
+ const char *symbol_name,
+ void **symbol) {
+#ifdef LINUX
+ *symbol = dlsym(handle, symbol_name);
+ char *err = dlerror();
+ if (err) {
+ LOG(LS_ERROR) << "Error loading symbol " << symbol_name << ": " << err;
+ return false;
+ } else if (!*symbol) {
+ LOG(LS_ERROR) << "Symbol " << symbol_name << " is NULL";
+ return false;
+ }
+ return true;
+#else
+#error Not implemented
+#endif
+}
+
+// This routine MUST assign SOME value for every symbol, even if that value is
+// NULL, or else some symbols may be left with uninitialized data that the
+// caller may later interpret as a valid address.
+bool InternalLoadSymbols(DllHandle handle,
+ int num_symbols,
+ const char *const symbol_names[],
+ void *symbols[]) {
+#ifdef LINUX
+ // Clear any old errors.
+ dlerror();
+#endif
+ for (int i = 0; i < num_symbols; ++i) {
+ if (!LoadSymbol(handle, symbol_names[i], &symbols[i])) {
+ return false;
+ }
+ }
+ return true;
+}
+
+} // namespace talk_base
diff --git a/talk/base/latebindingsymboltable.h b/talk/base/latebindingsymboltable.h
new file mode 100644
index 0000000..994c26a
--- /dev/null
+++ b/talk/base/latebindingsymboltable.h
@@ -0,0 +1,193 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TALK_BASE_LATEBINDINGSYMBOLTABLE_H_
+#define TALK_BASE_LATEBINDINGSYMBOLTABLE_H_
+
+#include <stddef.h> // for NULL
+#include <string.h>
+
+#include "talk/base/common.h"
+#include "talk/base/logging.h"
+
+// This file provides macros for creating "symbol table" classes to simplify the
+// dynamic loading of symbols from DLLs. Currently the implementation only
+// supports Linux and pure C symbols.
+// See talk/sound/pulseaudiosymboltable.(h|cc) for an example.
+
+namespace talk_base {
+
+#ifdef LINUX
+typedef void *DllHandle;
+
+const DllHandle kInvalidDllHandle = NULL;
+#else
+#error Not implemented
+#endif
+
+// These are helpers for use only by the class below.
+DllHandle InternalLoadDll(const char dll_name[]);
+
+void InternalUnloadDll(DllHandle handle);
+
+bool InternalLoadSymbols(DllHandle handle,
+ int num_symbols,
+ const char *const symbol_names[],
+ void *symbols[]);
+
+template <int SYMBOL_TABLE_SIZE,
+ const char kDllName[],
+ const char *const kSymbolNames[]>
+class LateBindingSymbolTable {
+ public:
+ LateBindingSymbolTable()
+ : handle_(kInvalidDllHandle),
+ undefined_symbols_(false) {
+ memset(symbols_, 0, sizeof(symbols_));
+ }
+
+ ~LateBindingSymbolTable() {
+ Unload();
+ }
+
+ static int NumSymbols() {
+ return SYMBOL_TABLE_SIZE;
+ }
+
+ // We do not use this, but we offer it for theoretical convenience.
+ static const char *GetSymbolName(int index) {
+ ASSERT(index < NumSymbols());
+ return kSymbolNames[index];
+ }
+
+ bool IsLoaded() const {
+ return handle_ != kInvalidDllHandle;
+ }
+
+ // Loads the DLL and the symbol table. Returns true iff the DLL and symbol
+ // table loaded successfully.
+ bool Load() {
+ if (IsLoaded()) {
+ return true;
+ }
+ if (undefined_symbols_) {
+ // We do not attempt to load again because repeated attempts are not
+ // likely to succeed and DLL loading is costly.
+ LOG(LS_ERROR) << "We know there are undefined symbols";
+ return false;
+ }
+ handle_ = InternalLoadDll(kDllName);
+ if (!IsLoaded()) {
+ return false;
+ }
+ if (!InternalLoadSymbols(handle_, NumSymbols(), kSymbolNames, symbols_)) {
+ undefined_symbols_ = true;
+ Unload();
+ return false;
+ }
+ return true;
+ }
+
+ void Unload() {
+ if (!IsLoaded()) {
+ return;
+ }
+ InternalUnloadDll(handle_);
+ handle_ = kInvalidDllHandle;
+ memset(symbols_, 0, sizeof(symbols_));
+ }
+
+ // Retrieves the given symbol. NOTE: Recommended to use LATESYM_GET below
+ // instead of this.
+ void *GetSymbol(int index) const {
+ ASSERT(IsLoaded());
+ ASSERT(index < NumSymbols());
+ return symbols_[index];
+ }
+
+ private:
+ DllHandle handle_;
+ bool undefined_symbols_;
+ void *symbols_[SYMBOL_TABLE_SIZE];
+
+ DISALLOW_COPY_AND_ASSIGN(LateBindingSymbolTable);
+};
+
+// This macro must be invoked in a header to declare a symbol table class.
+#define LATE_BINDING_SYMBOL_TABLE_DECLARE_BEGIN(ClassName) \
+enum {
+
+// This macro must be invoked in the header declaration once for each symbol
+// (recommended to use an X-Macro to avoid duplication).
+// This macro defines an enum with names built from the symbols, which
+// essentially creates a hash table in the compiler from symbol names to their
+// indices in the symbol table class.
+#define LATE_BINDING_SYMBOL_TABLE_DECLARE_ENTRY(ClassName, sym) \
+ ClassName##_SYMBOL_TABLE_INDEX_##sym,
+
+// This macro completes the header declaration.
+#define LATE_BINDING_SYMBOL_TABLE_DECLARE_END(ClassName) \
+ ClassName##_SYMBOL_TABLE_SIZE \
+}; \
+\
+extern const char ClassName##_kDllName[]; \
+extern const char *const \
+ ClassName##_kSymbolNames[ClassName##_SYMBOL_TABLE_SIZE]; \
+\
+typedef ::talk_base::LateBindingSymbolTable<ClassName##_SYMBOL_TABLE_SIZE, \
+ ClassName##_kDllName, \
+ ClassName##_kSymbolNames> \
+ ClassName;
+
+// This macro must be invoked in a .cc file to define a previously-declared
+// symbol table class.
+#define LATE_BINDING_SYMBOL_TABLE_DEFINE_BEGIN(ClassName, dllName) \
+const char ClassName##_kDllName[] = dllName; \
+const char *const ClassName##_kSymbolNames[ClassName##_SYMBOL_TABLE_SIZE] = {
+
+// This macro must be invoked in the .cc definition once for each symbol
+// (recommended to use an X-Macro to avoid duplication).
+// This would have to use the mangled name if we were to ever support C++
+// symbols.
+#define LATE_BINDING_SYMBOL_TABLE_DEFINE_ENTRY(ClassName, sym) \
+ #sym,
+
+#define LATE_BINDING_SYMBOL_TABLE_DEFINE_END(ClassName) \
+};
+
+// Index of a given symbol in the given symbol table class.
+#define LATESYM_INDEXOF(ClassName, sym) \
+ (ClassName##_SYMBOL_TABLE_INDEX_##sym)
+
+// Returns a reference to the given late-binded symbol, with the correct type.
+#define LATESYM_GET(ClassName, inst, sym) \
+ (*reinterpret_cast<typeof(&sym)>( \
+ (inst)->GetSymbol(LATESYM_INDEXOF(ClassName, sym))))
+
+} // namespace talk_base
+
+#endif // TALK_BASE_LATEBINDINGSYMBOLTABLE_H_
diff --git a/talk/base/physicalsocketserver.cc b/talk/base/physicalsocketserver.cc
index d97cba7..adddb0d 100644
--- a/talk/base/physicalsocketserver.cc
+++ b/talk/base/physicalsocketserver.cc
@@ -78,12 +78,6 @@
namespace talk_base {
-const int kfRead = 0x0001;
-const int kfWrite = 0x0002;
-const int kfConnect = 0x0004;
-const int kfClose = 0x0008;
-const int kfAccept = 0x0010;
-
// Standard MTUs, from RFC 1191
const uint16 PACKET_MAXIMUMS[] = {
65535, // Theoretical maximum, Hyperchannel
@@ -125,7 +119,7 @@
EnsureWinsockInit();
#endif
if (s_ != INVALID_SOCKET) {
- enabled_events_ = kfRead | kfWrite;
+ enabled_events_ = DE_READ | DE_WRITE;
int type = SOCK_STREAM;
socklen_t len = sizeof(type);
@@ -145,7 +139,7 @@
udp_ = (SOCK_DGRAM == type);
UpdateLastError();
if (udp_)
- enabled_events_ = kfRead | kfWrite;
+ enabled_events_ = DE_READ | DE_WRITE;
return s_ != INVALID_SOCKET;
}
@@ -226,12 +220,12 @@
state_ = CS_CONNECTED;
} else if (IsBlockingError(error_)) {
state_ = CS_CONNECTING;
- enabled_events_ |= kfConnect;
+ enabled_events_ |= DE_CONNECT;
} else {
return SOCKET_ERROR;
}
- enabled_events_ |= kfRead | kfWrite;
+ enabled_events_ |= DE_READ | DE_WRITE;
return 0;
}
@@ -292,7 +286,7 @@
//LOG(INFO) << "SOCK[" << static_cast<int>(s_) << "] Send(" << cb << ") Ret: " << sent << " Error: " << error_;
ASSERT(sent <= static_cast<int>(cb)); // We have seen minidumps where this may be false
if ((sent < 0) && IsBlockingError(error_)) {
- enabled_events_ |= kfWrite;
+ enabled_events_ |= DE_WRITE;
}
return sent;
}
@@ -312,7 +306,7 @@
UpdateLastError();
ASSERT(sent <= static_cast<int>(cb)); // We have seen minidumps where this may be false
if ((sent < 0) && IsBlockingError(error_)) {
- enabled_events_ |= kfWrite;
+ enabled_events_ |= DE_WRITE;
}
//LOG_F(LS_INFO) << cb << ":" << addr.ToString() << ":" << sent << ":" << error_;
return sent;
@@ -327,14 +321,14 @@
LOG(LS_WARNING) << "EOF from socket; deferring close event";
// Must turn this back on so that the select() loop will notice the close
// event.
- enabled_events_ |= kfRead;
+ enabled_events_ |= DE_READ;
error_ = EWOULDBLOCK;
return SOCKET_ERROR;
}
UpdateLastError();
bool success = (received >= 0) || IsBlockingError(error_);
if (udp_ || success) {
- enabled_events_ |= kfRead;
+ enabled_events_ |= DE_READ;
}
if (!success) {
LOG_F(LS_VERBOSE) << "Error = " << error_;
@@ -352,7 +346,7 @@
paddr->FromSockAddr(saddr);
bool success = (received >= 0) || IsBlockingError(error_);
if (udp_ || success) {
- enabled_events_ |= kfRead;
+ enabled_events_ |= DE_READ;
}
if (!success) {
LOG_F(LS_VERBOSE) << "Error = " << error_;
@@ -365,7 +359,7 @@
UpdateLastError();
if (err == 0) {
state_ = CS_CONNECTING;
- enabled_events_ |= kfAccept;
+ enabled_events_ |= DE_ACCEPT;
#ifdef _DEBUG
dbg_addr_ = "Listening @ ";
dbg_addr_.append(GetLocalAddress().ToString());
@@ -381,7 +375,7 @@
UpdateLastError();
if (s == INVALID_SOCKET)
return NULL;
- enabled_events_ |= kfAccept;
+ enabled_events_ |= DE_ACCEPT;
if (paddr != NULL)
paddr->FromSockAddr(saddr);
return ss_->WrapSocket(s);
@@ -528,16 +522,6 @@
};
#ifdef POSIX
-class Dispatcher {
- public:
- virtual ~Dispatcher() { }
- virtual uint32 GetRequestedEvents() = 0;
- virtual void OnPreEvent(uint32 ff) = 0;
- virtual void OnEvent(uint32 ff, int err) = 0;
- virtual int GetDescriptor() = 0;
- virtual bool IsDescriptorClosed() = 0;
-};
-
class EventDispatcher : public Dispatcher {
public:
EventDispatcher(PhysicalSocketServer* ss) : ss_(ss), fSignaled_(false) {
@@ -563,7 +547,7 @@
}
virtual uint32 GetRequestedEvents() {
- return kfRead;
+ return DE_READ;
}
virtual void OnPreEvent(uint32 ff) {
@@ -609,7 +593,7 @@
}
virtual uint32 GetRequestedEvents() {
- return kfRead;
+ return DE_READ;
}
virtual void OnPreEvent(uint32 ff) {
@@ -833,30 +817,30 @@
}
virtual void OnPreEvent(uint32 ff) {
- if ((ff & kfConnect) != 0)
+ if ((ff & DE_CONNECT) != 0)
state_ = CS_CONNECTED;
- if ((ff & kfClose) != 0)
+ if ((ff & DE_CLOSE) != 0)
state_ = CS_CLOSED;
}
virtual void OnEvent(uint32 ff, int err) {
- if ((ff & kfRead) != 0) {
- enabled_events_ &= ~kfRead;
+ if ((ff & DE_READ) != 0) {
+ enabled_events_ &= ~DE_READ;
SignalReadEvent(this);
}
- if ((ff & kfWrite) != 0) {
- enabled_events_ &= ~kfWrite;
+ if ((ff & DE_WRITE) != 0) {
+ enabled_events_ &= ~DE_WRITE;
SignalWriteEvent(this);
}
- if ((ff & kfConnect) != 0) {
- enabled_events_ &= ~kfConnect;
+ if ((ff & DE_CONNECT) != 0) {
+ enabled_events_ &= ~DE_CONNECT;
SignalConnectEvent(this);
}
- if ((ff & kfAccept) != 0) {
- enabled_events_ &= ~kfAccept;
+ if ((ff & DE_ACCEPT) != 0) {
+ enabled_events_ &= ~DE_ACCEPT;
SignalReadEvent(this);
}
- if ((ff & kfClose) != 0) {
+ if ((ff & DE_CLOSE) != 0) {
// The socket is now dead to us, so stop checking it.
enabled_events_ = 0;
SignalCloseEvent(this, err);
@@ -904,28 +888,28 @@
}
virtual void OnEvent(uint32 ff, int err) {
- if ((ff & kfRead) != 0)
+ if ((ff & DE_READ) != 0)
SignalReadEvent(this);
- if ((ff & kfWrite) != 0)
+ if ((ff & DE_WRITE) != 0)
SignalWriteEvent(this);
- if ((ff & kfClose) != 0)
+ if ((ff & DE_CLOSE) != 0)
SignalCloseEvent(this, err);
}
virtual bool readable() {
- return (flags_ & kfRead) != 0;
+ return (flags_ & DE_READ) != 0;
}
virtual void set_readable(bool value) {
- flags_ = value ? (flags_ | kfRead) : (flags_ & ~kfRead);
+ flags_ = value ? (flags_ | DE_READ) : (flags_ & ~DE_READ);
}
virtual bool writable() {
- return (flags_ & kfWrite) != 0;
+ return (flags_ & DE_WRITE) != 0;
}
virtual void set_writable(bool value) {
- flags_ = value ? (flags_ | kfWrite) : (flags_ & ~kfWrite);
+ flags_ = value ? (flags_ | DE_WRITE) : (flags_ & ~DE_WRITE);
}
private:
@@ -941,26 +925,15 @@
#endif // POSIX
#ifdef WIN32
-class Dispatcher {
- public:
- virtual ~Dispatcher() {}
- virtual uint32 GetRequestedEvents() = 0;
- virtual void OnPreEvent(uint32 ff) = 0;
- virtual void OnEvent(uint32 ff, int err) = 0;
- virtual WSAEVENT GetWSAEvent() = 0;
- virtual SOCKET GetSocket() = 0;
- virtual bool CheckSignalClose() = 0;
-};
-
static uint32 FlagsToEvents(uint32 events) {
uint32 ffFD = FD_CLOSE;
- if (events & kfRead)
+ if (events & DE_READ)
ffFD |= FD_READ;
- if (events & kfWrite)
+ if (events & DE_WRITE)
ffFD |= FD_WRITE;
- if (events & kfConnect)
+ if (events & DE_CONNECT)
ffFD |= FD_CONNECT;
- if (events & kfAccept)
+ if (events & DE_ACCEPT)
ffFD |= FD_ACCEPT;
return ffFD;
}
@@ -1065,36 +1038,36 @@
}
virtual void OnPreEvent(uint32 ff) {
- if ((ff & kfConnect) != 0)
+ if ((ff & DE_CONNECT) != 0)
state_ = CS_CONNECTED;
// We set CS_CLOSED from CheckSignalClose.
}
virtual void OnEvent(uint32 ff, int err) {
int cache_id = id_;
- if ((ff & kfRead) != 0) {
- enabled_events_ &= ~kfRead;
+ if ((ff & DE_READ) != 0) {
+ enabled_events_ &= ~DE_READ;
SignalReadEvent(this);
}
- if (((ff & kfWrite) != 0) && (id_ == cache_id)) {
- enabled_events_ &= ~kfWrite;
+ if (((ff & DE_WRITE) != 0) && (id_ == cache_id)) {
+ enabled_events_ &= ~DE_WRITE;
SignalWriteEvent(this);
}
- if (((ff & kfConnect) != 0) && (id_ == cache_id)) {
- if (ff != kfConnect)
- LOG(LS_VERBOSE) << "Signalled with kfConnect: " << ff;
- enabled_events_ &= ~kfConnect;
+ if (((ff & DE_CONNECT) != 0) && (id_ == cache_id)) {
+ if (ff != DE_CONNECT)
+ LOG(LS_VERBOSE) << "Signalled with DE_CONNECT: " << ff;
+ enabled_events_ &= ~DE_CONNECT;
#ifdef _DEBUG
dbg_addr_ = "Connected @ ";
dbg_addr_.append(GetRemoteAddress().ToString());
#endif // _DEBUG
SignalConnectEvent(this);
}
- if (((ff & kfAccept) != 0) && (id_ == cache_id)) {
- enabled_events_ &= ~kfAccept;
+ if (((ff & DE_ACCEPT) != 0) && (id_ == cache_id)) {
+ enabled_events_ &= ~DE_ACCEPT;
SignalReadEvent(this);
}
- if (((ff & kfClose) != 0) && (id_ == cache_id)) {
+ if (((ff & DE_CLOSE) != 0) && (id_ == cache_id)) {
//LOG(INFO) << "SOCK[" << static_cast<int>(s_) << "] OnClose() Error: " << err;
signal_close_ = true;
signal_err_ = err;
@@ -1275,9 +1248,9 @@
fdmax = fd;
uint32 ff = pdispatcher->GetRequestedEvents();
- if (ff & (kfRead | kfAccept))
+ if (ff & (DE_READ | DE_ACCEPT))
FD_SET(fd, &fdsRead);
- if (ff & (kfWrite | kfConnect))
+ if (ff & (DE_WRITE | DE_CONNECT))
FD_SET(fd, &fdsWrite);
}
}
@@ -1323,12 +1296,12 @@
// TODO: Only peek at TCP descriptors.
if (FD_ISSET(fd, &fdsRead)) {
FD_CLR(fd, &fdsRead);
- if (pdispatcher->GetRequestedEvents() & kfAccept) {
- ff |= kfAccept;
+ if (pdispatcher->GetRequestedEvents() & DE_ACCEPT) {
+ ff |= DE_ACCEPT;
} else if (errcode || pdispatcher->IsDescriptorClosed()) {
- ff |= kfClose;
+ ff |= DE_CLOSE;
} else {
- ff |= kfRead;
+ ff |= DE_READ;
}
}
@@ -1336,14 +1309,14 @@
// success versus failure by the reaped error code.
if (FD_ISSET(fd, &fdsWrite)) {
FD_CLR(fd, &fdsWrite);
- if (pdispatcher->GetRequestedEvents() & kfConnect) {
+ if (pdispatcher->GetRequestedEvents() & DE_CONNECT) {
if (!errcode) {
- ff |= kfConnect;
+ ff |= DE_CONNECT;
} else {
- ff |= kfClose;
+ ff |= DE_CLOSE;
}
} else {
- ff |= kfWrite;
+ ff |= DE_WRITE;
}
}
@@ -1556,21 +1529,21 @@
uint32 ff = 0;
int errcode = 0;
if (wsaEvents.lNetworkEvents & FD_READ)
- ff |= kfRead;
+ ff |= DE_READ;
if (wsaEvents.lNetworkEvents & FD_WRITE)
- ff |= kfWrite;
+ ff |= DE_WRITE;
if (wsaEvents.lNetworkEvents & FD_CONNECT) {
if (wsaEvents.iErrorCode[FD_CONNECT_BIT] == 0) {
- ff |= kfConnect;
+ ff |= DE_CONNECT;
} else {
- ff |= kfClose;
+ ff |= DE_CLOSE;
errcode = wsaEvents.iErrorCode[FD_CONNECT_BIT];
}
}
if (wsaEvents.lNetworkEvents & FD_ACCEPT)
- ff |= kfAccept;
+ ff |= DE_ACCEPT;
if (wsaEvents.lNetworkEvents & FD_CLOSE) {
- ff |= kfClose;
+ ff |= DE_CLOSE;
errcode = wsaEvents.iErrorCode[FD_CLOSE_BIT];
}
if (ff != 0) {
diff --git a/talk/base/physicalsocketserver.h b/talk/base/physicalsocketserver.h
index 282e14c..d2b40aa 100644
--- a/talk/base/physicalsocketserver.h
+++ b/talk/base/physicalsocketserver.h
@@ -38,14 +38,38 @@
typedef int SOCKET;
#endif // POSIX
-namespace talk_base {
+namespace talk_base {
-class Dispatcher;
+// Event constants for the Dispatcher class.
+enum DispatcherEvent {
+ DE_READ = 0x0001,
+ DE_WRITE = 0x0002,
+ DE_CONNECT = 0x0004,
+ DE_CLOSE = 0x0008,
+ DE_ACCEPT = 0x0010,
+};
+
class Signaler;
#ifdef POSIX
class PosixSignalDeliveryDispatcher;
#endif
+class Dispatcher {
+ public:
+ virtual ~Dispatcher() {}
+ virtual uint32 GetRequestedEvents() = 0;
+ virtual void OnPreEvent(uint32 ff) = 0;
+ virtual void OnEvent(uint32 ff, int err) = 0;
+#ifdef WIN32
+ virtual WSAEVENT GetWSAEvent() = 0;
+ virtual SOCKET GetSocket() = 0;
+ virtual bool CheckSignalClose() = 0;
+#elif POSIX
+ virtual int GetDescriptor() = 0;
+ virtual bool IsDescriptorClosed() = 0;
+#endif
+};
+
// A socket server that provides the real sockets of the underlying OS.
class PhysicalSocketServer : public SocketServer {
public:
diff --git a/talk/base/ratetracker.cc b/talk/base/ratetracker.cc
new file mode 100644
index 0000000..d5207cd
--- /dev/null
+++ b/talk/base/ratetracker.cc
@@ -0,0 +1,80 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "talk/base/ratetracker.h"
+#include "talk/base/time.h"
+
+namespace talk_base {
+
+RateTracker::RateTracker()
+ : total_units_(0), units_second_(0),
+ last_units_second_time_(static_cast<uint32>(-1)),
+ last_units_second_calc_(0) {
+}
+
+size_t RateTracker::total_units() const {
+ return total_units_;
+}
+
+size_t RateTracker::units_second() {
+ // Snapshot units / second calculator. Determine how many seconds have
+ // elapsed since our last reference point. If over 1 second, establish
+ // a new reference point that is an integer number of seconds since the
+ // last one, and compute the units over that interval.
+ uint32 current_time = Time();
+ if (last_units_second_time_ != static_cast<uint32>(-1)) {
+ int delta = talk_base::TimeDiff(current_time, last_units_second_time_);
+ if (delta >= 1000) {
+ int fraction_time = delta % 1000;
+ int seconds = delta / 1000;
+ int fraction_units =
+ static_cast<int>(total_units_ - last_units_second_calc_) *
+ fraction_time / delta;
+ // Compute "units received during the interval" / "seconds in interval"
+ units_second_ =
+ (total_units_ - last_units_second_calc_ - fraction_units) / seconds;
+ last_units_second_time_ = current_time - fraction_time;
+ last_units_second_calc_ = total_units_ - fraction_units;
+ }
+ }
+ if (last_units_second_time_ == static_cast<uint32>(-1)) {
+ last_units_second_time_ = current_time;
+ last_units_second_calc_ = total_units_;
+ }
+
+ return units_second_;
+}
+
+void RateTracker::Update(size_t units) {
+ total_units_ += units;
+}
+
+uint32 RateTracker::Time() const {
+ return talk_base::Time();
+}
+
+} // namespace talk_base
diff --git a/talk/base/ratetracker.h b/talk/base/ratetracker.h
new file mode 100644
index 0000000..28c7bb3
--- /dev/null
+++ b/talk/base/ratetracker.h
@@ -0,0 +1,59 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TALK_BASE_RATETRACKER_H_
+#define TALK_BASE_RATETRACKER_H_
+
+#include <stdlib.h>
+#include "talk/base/basictypes.h"
+
+namespace talk_base {
+
+// Computes instantaneous units per second.
+class RateTracker {
+ public:
+ RateTracker();
+ virtual ~RateTracker() {}
+
+ size_t total_units() const;
+ size_t units_second();
+ void Update(size_t units);
+
+ protected:
+ // overrideable for tests
+ virtual uint32 Time() const;
+
+ private:
+ size_t total_units_;
+ size_t units_second_;
+ uint32 last_units_second_time_;
+ size_t last_units_second_calc_;
+};
+
+} // namespace talk_base
+
+#endif // TALK_BASE_RATETRACKER_H_
diff --git a/talk/base/socket.h b/talk/base/socket.h
index 3094918..a55b3dc 100644
--- a/talk/base/socket.h
+++ b/talk/base/socket.h
@@ -50,55 +50,89 @@
// Win32 compatibility.
#ifdef WIN32
+#undef EWOULDBLOCK // Remove errno.h's definition for each macro below.
#define EWOULDBLOCK WSAEWOULDBLOCK
+#undef EINPROGRESS
#define EINPROGRESS WSAEINPROGRESS
+#undef EALREADY
#define EALREADY WSAEALREADY
+#undef ENOTSOCK
#define ENOTSOCK WSAENOTSOCK
+#undef EDESTADDRREQ
#define EDESTADDRREQ WSAEDESTADDRREQ
+#undef EMSGSIZE
#define EMSGSIZE WSAEMSGSIZE
+#undef EPROTOTYPE
#define EPROTOTYPE WSAEPROTOTYPE
+#undef ENOPROTOOPT
#define ENOPROTOOPT WSAENOPROTOOPT
+#undef EPROTONOSUPPORT
#define EPROTONOSUPPORT WSAEPROTONOSUPPORT
+#undef ESOCKTNOSUPPORT
#define ESOCKTNOSUPPORT WSAESOCKTNOSUPPORT
+#undef EOPNOTSUPP
#define EOPNOTSUPP WSAEOPNOTSUPP
+#undef EPFNOSUPPORT
#define EPFNOSUPPORT WSAEPFNOSUPPORT
+#undef EAFNOSUPPORT
#define EAFNOSUPPORT WSAEAFNOSUPPORT
+#undef EADDRINUSE
#define EADDRINUSE WSAEADDRINUSE
+#undef EADDRNOTAVAIL
#define EADDRNOTAVAIL WSAEADDRNOTAVAIL
+#undef ENETDOWN
#define ENETDOWN WSAENETDOWN
+#undef ENETUNREACH
#define ENETUNREACH WSAENETUNREACH
+#undef ENETRESET
#define ENETRESET WSAENETRESET
+#undef ECONNABORTED
#define ECONNABORTED WSAECONNABORTED
+#undef ECONNRESET
#define ECONNRESET WSAECONNRESET
+#undef ENOBUFS
#define ENOBUFS WSAENOBUFS
+#undef EISCONN
#define EISCONN WSAEISCONN
+#undef ENOTCONN
#define ENOTCONN WSAENOTCONN
+#undef ESHUTDOWN
#define ESHUTDOWN WSAESHUTDOWN
+#undef ETOOMANYREFS
#define ETOOMANYREFS WSAETOOMANYREFS
-#undef ETIMEDOUT // remove pthreads.h's definition
+#undef ETIMEDOUT
#define ETIMEDOUT WSAETIMEDOUT
+#undef ECONNREFUSED
#define ECONNREFUSED WSAECONNREFUSED
+#undef ELOOP
#define ELOOP WSAELOOP
-#undef ENAMETOOLONG // remove errno.h's definition
+#undef ENAMETOOLONG
#define ENAMETOOLONG WSAENAMETOOLONG
+#undef EHOSTDOWN
#define EHOSTDOWN WSAEHOSTDOWN
+#undef EHOSTUNREACH
#define EHOSTUNREACH WSAEHOSTUNREACH
-#undef ENOTEMPTY // remove errno.h's definition
+#undef ENOTEMPTY
#define ENOTEMPTY WSAENOTEMPTY
+#undef EPROCLIM
#define EPROCLIM WSAEPROCLIM
+#undef EUSERS
#define EUSERS WSAEUSERS
+#undef EDQUOT
#define EDQUOT WSAEDQUOT
+#undef ESTALE
#define ESTALE WSAESTALE
+#undef EREMOTE
#define EREMOTE WSAEREMOTE
#undef EACCES
#define SOCKET_EACCES WSAEACCES
-#endif // WIN32
+#endif // WIN32
#ifdef POSIX
#define INVALID_SOCKET (-1)
#define SOCKET_ERROR (-1)
#define closesocket(s) close(s)
-#endif // POSIX
+#endif // POSIX
namespace talk_base {
@@ -109,9 +143,9 @@
// General interface for the socket implementations of various networks. The
// methods match those of normal UNIX sockets very closely.
class Socket {
-public:
+ public:
virtual ~Socket() {}
-
+
// Returns the address to which the socket is bound. If the socket is not
// bound, then the any-address is returned.
virtual SocketAddress GetLocalAddress() const = 0;
@@ -146,20 +180,20 @@
enum Option {
OPT_DONTFRAGMENT,
- OPT_RCVBUF, // receive buffer size
- OPT_SNDBUF, // send buffer size
- OPT_NODELAY // whether Nagle algorithm is enabled
+ OPT_RCVBUF, // receive buffer size
+ OPT_SNDBUF, // send buffer size
+ OPT_NODELAY // whether Nagle algorithm is enabled
};
virtual int GetOption(Option opt, int* value) = 0;
virtual int SetOption(Option opt, int value) = 0;
-protected:
+ protected:
Socket() {}
-private:
+ private:
DISALLOW_EVIL_CONSTRUCTORS(Socket);
};
-} // namespace talk_base
+} // namespace talk_base
-#endif // TALK_BASE_SOCKET_H__
+#endif // TALK_BASE_SOCKET_H__
diff --git a/talk/base/stringencode.cc b/talk/base/stringencode.cc
index d588514..bc80e24 100644
--- a/talk/base/stringencode.cc
+++ b/talk/base/stringencode.cc
@@ -512,18 +512,21 @@
}
size_t split(const std::string& source, char delimiter,
- std::vector<std::string>* fields)
-{
+ std::vector<std::string>* fields) {
ASSERT(NULL != fields);
fields->clear();
size_t last = 0;
- for (size_t i=0; i<source.length(); ++i) {
+ for (size_t i = 0; i < source.length(); ++i) {
if (source[i] == delimiter) {
- fields->push_back(source.substr(last, i - last));
- last = i+1;
+ if (i != last) {
+ fields->push_back(source.substr(last, i - last));
+ }
+ last = i + 1;
}
}
- fields->push_back(source.substr(last, source.length() - last));
+ if (last != source.length()) {
+ fields->push_back(source.substr(last, source.length() - last));
+ }
return fields->size();
}
diff --git a/talk/examples/call/call_main.cc b/talk/examples/call/call_main.cc
index 541aca8..4312399 100644
--- a/talk/examples/call/call_main.cc
+++ b/talk/examples/call/call_main.cc
@@ -44,6 +44,7 @@
#include "talk/examples/call/callclient.h"
#include "talk/examples/call/console.h"
#include "talk/session/phone/filemediaengine.h"
+#include "talk/session/phone/mediasessionclient.h"
class DebugLog : public sigslot::has_slots<> {
public:
@@ -218,6 +219,9 @@
DEFINE_string(
protocol, "hybrid",
"Initial signaling protocol to use: jingle, gingle, or hybrid.");
+ DEFINE_string(
+ secure, "disable",
+ "Disable or enable encryption: disable, enable, require.");
DEFINE_bool(testserver, false, "Use test server");
DEFINE_bool(plainserver, false, "Turn off tls and allow plain password.");
DEFINE_int(portallocator, 0, "Filter out unwanted connection types.");
@@ -245,6 +249,7 @@
int32 portallocator_flags = FLAG_portallocator;
std::string pmuc_domain = FLAG_pmuc;
std::string server = FLAG_s;
+ std::string secure = FLAG_secure;
cricket::SignalingProtocol initial_protocol = cricket::PROTOCOL_HYBRID;
if (protocol == "jingle") {
@@ -254,7 +259,19 @@
} else if (protocol == "hybrid") {
initial_protocol = cricket::PROTOCOL_HYBRID;
} else {
- printf("Invalid protocol. Must be jingle, gingle, or hybrid.");
+ printf("Invalid protocol. Must be jingle, gingle, or hybrid.\n");
+ return 1;
+ }
+
+ cricket::SecureMediaPolicy secure_policy = cricket::SEC_DISABLED;
+ if (secure == "disable") {
+ secure_policy = cricket::SEC_DISABLED;
+ } else if (secure == "enable") {
+ secure_policy = cricket::SEC_ENABLED;
+ } else if (secure == "require") {
+ secure_policy = cricket::SEC_REQUIRED;
+ } else {
+ printf("Invalid encryption. Must be enable, disable, or require.\n");
return 1;
}
@@ -354,6 +371,7 @@
client->SetPortAllocatorFlags(portallocator_flags);
client->SetAllowLocalIps(true);
client->SetInitialProtocol(initial_protocol);
+ client->SetSecurePolicy(secure_policy);
console->Start();
if (debug) {
diff --git a/talk/examples/call/callclient.cc b/talk/examples/call/callclient.cc
index eb761d1..ecfc0b3 100644
--- a/talk/examples/call/callclient.cc
+++ b/talk/examples/call/callclient.cc
@@ -237,12 +237,20 @@
}
CallClient::CallClient(buzz::XmppClient* xmpp_client)
- : xmpp_client_(xmpp_client), media_engine_(NULL), media_client_(NULL),
- call_(NULL), incoming_call_(false),
- auto_accept_(false), pmuc_domain_("groupchat.google.com"),
- local_renderer_(NULL), remote_renderer_(NULL),
- roster_(new RosterMap), portallocator_flags_(0),
- allow_local_ips_(false), initial_protocol_(cricket::PROTOCOL_HYBRID)
+ : xmpp_client_(xmpp_client),
+ media_engine_(NULL),
+ media_client_(NULL),
+ call_(NULL),
+ incoming_call_(false),
+ auto_accept_(false),
+ pmuc_domain_("groupchat.google.com"),
+ local_renderer_(NULL),
+ remote_renderer_(NULL),
+ roster_(new RosterMap),
+ portallocator_flags_(0),
+ allow_local_ips_(false),
+ initial_protocol_(cricket::PROTOCOL_HYBRID),
+ secure_policy_(cricket::SEC_DISABLED)
#ifdef USE_TALK_SOUND
, sound_system_factory_(NULL)
#endif
@@ -385,6 +393,7 @@
media_client_->SignalCallCreate.connect(this, &CallClient::OnCallCreate);
media_client_->SignalDevicesChange.connect(this,
&CallClient::OnDevicesChange);
+ media_client_->set_secure(secure_policy_);
}
void CallClient::OnRequestSignaling() {
diff --git a/talk/examples/call/callclient.h b/talk/examples/call/callclient.h
index a5686b4..846b785 100644
--- a/talk/examples/call/callclient.h
+++ b/talk/examples/call/callclient.h
@@ -34,6 +34,7 @@
#include "talk/p2p/base/session.h"
#include "talk/session/phone/mediachannel.h"
+#include "talk/session/phone/mediasessionclient.h"
#include "talk/xmpp/xmppclient.h"
#include "talk/examples/call/status.h"
#include "talk/examples/call/console.h"
@@ -68,7 +69,6 @@
class Call;
struct CallOptions;
class SessionManagerTask;
-enum SignalingProtocol;
}
struct RosterItem {
@@ -114,6 +114,10 @@
initial_protocol_ = initial_protocol;
}
+ void SetSecurePolicy(cricket::SecureMediaPolicy secure_policy) {
+ secure_policy_ = secure_policy;
+ }
+
typedef std::map<buzz::Jid, buzz::Muc*> MucMap;
@@ -193,6 +197,7 @@
bool allow_local_ips_;
cricket::SignalingProtocol initial_protocol_;
+ cricket::SecureMediaPolicy secure_policy_;
std::string last_sent_to_;
#ifdef USE_TALK_SOUND
cricket::SoundSystemFactory* sound_system_factory_;
diff --git a/talk/libjingle.scons b/talk/libjingle.scons
index 09a3bc1..d5ca366 100644
--- a/talk/libjingle.scons
+++ b/talk/libjingle.scons
@@ -100,6 +100,7 @@
"base/httpclient.cc",
"base/httpcommon.cc",
"base/httprequest.cc",
+ "base/latebindingsymboltable.cc",
"base/logging.cc",
"base/md5c.c",
"base/messagehandler.cc",
@@ -111,6 +112,7 @@
"base/physicalsocketserver.cc",
"base/proxydetect.cc",
"base/proxyinfo.cc",
+ "base/ratetracker.cc",
"base/signalthread.cc",
"base/socketadapters.cc",
"base/socketaddress.cc",
@@ -164,11 +166,13 @@
"session/phone/channelmanager.cc",
"session/phone/codec.cc",
"session/phone/devicemanager.cc",
+ "session/phone/libudevsymboltable.cc",
"session/phone/filemediaengine.cc",
"session/phone/mediaengine.cc",
"session/phone/mediamonitor.cc",
"session/phone/mediasessionclient.cc",
"session/phone/rtpdump.cc",
+ "session/phone/rtcpmuxfilter.cc",
"session/phone/soundclip.cc",
"session/phone/srtpfilter.cc",
"xmllite/qname.cc",
@@ -190,6 +194,7 @@
"xmpp/xmpptask.cc",
],
includedirs = [
+ "third_party/libudev",
"third_party/expat-2.0.1/",
"third_party/srtp/include",
"third_party/srtp/crypto/include",
diff --git a/talk/main.scons b/talk/main.scons
index a1348ff..7394066 100644
--- a/talk/main.scons
+++ b/talk/main.scons
@@ -92,6 +92,8 @@
CCPDBFLAGS = '',
CCFLAGS_DEBUG = '',
CCFLAGS_OPTIMIZED = '',
+ # We force a x86 target even when building on x64 Windows platforms.
+ TARGET_ARCH = 'x86',
)
win_env.Append(
@@ -210,6 +212,9 @@
'/MT', # link with LIBCMT.LIB (multi-threaded, static linked crt)
'/GS', # enable security checks
],
+ LINKFLAGS = [
+ '/safeseh',
+ ],
)
envs.append(win_opt_env)
@@ -230,7 +235,6 @@
'_REENTRANT',
],
CCFLAGS = [
- '-m32',
'-Wall',
'-Werror',
'-Wno-switch',
@@ -241,9 +245,6 @@
'-Wno-ctor-dtor-privacy',
'-fno-rtti',
],
- LINKFLAGS = [
- '-m32',
- ],
)
#-------------------------------------------------------------------------------
@@ -262,6 +263,7 @@
'MAC_OS_X_VERSION_MIN_REQUIRED=1040',
],
CCFLAGS = [
+ '-m32',
'-arch', 'i386',
'-isysroot', '/Developer/SDKs/MacOSX10.5.sdk',
'-fasm-blocks',
@@ -274,6 +276,7 @@
# TODO: consider only defining for libs that actually have objc.
'-ObjC',
'-arch', 'i386',
+ '-m32',
],
FRAMEWORKS = [
'CoreServices',
@@ -281,6 +284,10 @@
'Security',
'SystemConfiguration',
'OpenGL',
+ 'CoreAudio',
+ 'QuickTime',
+ 'Cocoa',
+ 'QTKit',
]
)
@@ -373,6 +380,14 @@
# product would end up being broken on any computer with a different version
# installed. So instead we build it ourself and statically link to it.
linux_env.SetBits('use_static_openssl')
+linux_env.Append(
+ CCFLAGS = [
+ '-m32',
+ ],
+ LINKFLAGS = [
+ '-m32',
+ ],
+)
linux_dbg_env = linux_env.Clone(
BUILD_TYPE = 'dbg',
diff --git a/talk/p2p/base/constants.cc b/talk/p2p/base/constants.cc
index 1becb39..12d26f5 100644
--- a/talk/p2p/base/constants.cc
+++ b/talk/p2p/base/constants.cc
@@ -63,6 +63,8 @@
const std::string GINGLE_ACTION_REJECT("reject");
const std::string GINGLE_ACTION_TERMINATE("terminate");
const std::string GINGLE_ACTION_CANDIDATES("candidates");
+const std::string GINGLE_ACTION_NOTIFY("notify");
+const std::string GINGLE_ACTION_UPDATE("update");
const std::string LN_ERROR("error");
const buzz::QName QN_GINGLE_REDIRECT(true, NS_GINGLE, "redirect");
diff --git a/talk/p2p/base/constants.h b/talk/p2p/base/constants.h
index 9f93cbc..55f12c6 100644
--- a/talk/p2p/base/constants.h
+++ b/talk/p2p/base/constants.h
@@ -79,6 +79,8 @@
extern const std::string GINGLE_ACTION_REJECT;
extern const std::string GINGLE_ACTION_TERMINATE;
extern const std::string GINGLE_ACTION_CANDIDATES;
+extern const std::string GINGLE_ACTION_NOTIFY;
+extern const std::string GINGLE_ACTION_UPDATE;
extern const std::string LN_ERROR;
extern const buzz::QName QN_GINGLE_REDIRECT;
diff --git a/talk/p2p/base/port.cc b/talk/p2p/base/port.cc
index 2aa66a4..0f38913 100644
--- a/talk/p2p/base/port.cc
+++ b/talk/p2p/base/port.cc
@@ -25,9 +25,7 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#if defined(_MSC_VER) && _MSC_VER < 1300
-#pragma warning(disable:4786)
-#endif
+#include "talk/p2p/base/port.h"
#include <algorithm>
#include <vector>
@@ -40,13 +38,6 @@
#include "talk/base/socketadapters.h"
#include "talk/base/stringutils.h"
#include "talk/p2p/base/common.h"
-#include "talk/p2p/base/port.h"
-
-#if defined(_MSC_VER) && _MSC_VER < 1300
-namespace std {
- using ::memcmp;
-}
-#endif
namespace {
@@ -894,19 +885,19 @@
}
size_t Connection::recv_bytes_second() {
- return recv_rate_tracker_.bytes_second();
+ return recv_rate_tracker_.units_second();
}
size_t Connection::recv_total_bytes() {
- return recv_rate_tracker_.total_bytes();
+ return recv_rate_tracker_.total_units();
}
size_t Connection::sent_bytes_second() {
- return send_rate_tracker_.bytes_second();
+ return send_rate_tracker_.units_second();
}
size_t Connection::sent_total_bytes() {
- return send_rate_tracker_.total_bytes();
+ return send_rate_tracker_.total_units();
}
ProxyConnection::ProxyConnection(Port* port, size_t index,
@@ -929,48 +920,4 @@
return sent;
}
-RateTracker::RateTracker()
- : total_bytes_(0), bytes_second_(0),
- last_bytes_second_time_(static_cast<uint32>(-1)),
- last_bytes_second_calc_(0) {
-}
-
-size_t RateTracker::total_bytes() const {
- return total_bytes_;
-}
-
-size_t RateTracker::bytes_second() {
- // Snapshot bytes / second calculator. Determine how many seconds have
- // elapsed since our last reference point. If over 1 second, establish
- // a new reference point that is an integer number of seconds since the
- // last one, and compute the bytes over that interval.
-
- uint32 current_time = talk_base::Time();
- if (last_bytes_second_time_ != static_cast<uint32>(-1)) {
- int delta = talk_base::TimeDiff(current_time, last_bytes_second_time_);
- if (delta >= 1000) {
- int fraction_time = delta % 1000;
- int seconds = delta / 1000;
- int fraction_bytes =
- static_cast<int>(total_bytes_ - last_bytes_second_calc_) *
- fraction_time / delta;
- // Compute "bytes received during the interval" / "seconds in interval"
- bytes_second_ =
- (total_bytes_ - last_bytes_second_calc_ - fraction_bytes) / seconds;
- last_bytes_second_time_ = current_time - fraction_time;
- last_bytes_second_calc_ = total_bytes_ - fraction_bytes;
- }
- }
- if (last_bytes_second_time_ == static_cast<uint32>(-1)) {
- last_bytes_second_time_ = current_time;
- last_bytes_second_calc_ = total_bytes_;
- }
-
- return bytes_second_;
-}
-
-void RateTracker::Update(size_t bytes) {
- total_bytes_ += bytes;
-}
-
} // namespace cricket
diff --git a/talk/p2p/base/port.h b/talk/p2p/base/port.h
index 88b15c6..af40655 100644
--- a/talk/p2p/base/port.h
+++ b/talk/p2p/base/port.h
@@ -35,6 +35,7 @@
#include "talk/base/network.h"
#include "talk/base/socketaddress.h"
#include "talk/base/proxyinfo.h"
+#include "talk/base/ratetracker.h"
#include "talk/base/sigslot.h"
#include "talk/base/thread.h"
#include "talk/p2p/base/candidate.h"
@@ -67,21 +68,6 @@
: address(a), proto(p) { }
};
-// Computes instantaneous bytes per second.
-class RateTracker {
- public:
- RateTracker();
- size_t total_bytes() const;
- size_t bytes_second();
- void Update(size_t bytes);
-
- private:
- size_t total_bytes_;
- size_t bytes_second_;
- uint32 last_bytes_second_time_;
- size_t last_bytes_second_calc_;
-};
-
// Represents a local communication mechanism that can be used to create
// connections to similar mechanisms of the other client. Subclasses of this
// one add support for specific mechanisms like local UDP ports.
@@ -384,8 +370,8 @@
// side
std::vector<uint32> pings_since_last_response_;
- RateTracker recv_rate_tracker_;
- RateTracker send_rate_tracker_;
+ talk_base::RateTracker recv_rate_tracker_;
+ talk_base::RateTracker send_rate_tracker_;
// Callbacks from ConnectionRequest
void OnConnectionRequestResponse(StunMessage *response, uint32 rtt);
diff --git a/talk/p2p/base/session.cc b/talk/p2p/base/session.cc
index 38b91ff..8ed4ae8 100644
--- a/talk/p2p/base/session.cc
+++ b/talk/p2p/base/session.cc
@@ -646,6 +646,14 @@
case ACTION_TRANSPORT_ACCEPT:
valid = OnTransportAcceptMessage(msg, &error);
break;
+ case ACTION_NOTIFY:
+ case ACTION_UPDATE:
+ // TODO: Process these non-standard messages, but
+ // only once we figure out how in a jingle-specific way (or
+ // remove the need altogether). For now, just don't send an
+ // error back, because it disrupts call establishment.
+ valid = true;
+ break;
default:
valid = BadMessage(buzz::QN_STANZA_BAD_REQUEST,
"unknown session message type",
diff --git a/talk/p2p/base/sessionmessages.cc b/talk/p2p/base/sessionmessages.cc
index cfd035d..a71c6f0 100644
--- a/talk/p2p/base/sessionmessages.cc
+++ b/talk/p2p/base/sessionmessages.cc
@@ -70,6 +70,10 @@
return ACTION_TRANSPORT_INFO;
if (type == JINGLE_ACTION_TRANSPORT_ACCEPT)
return ACTION_TRANSPORT_ACCEPT;
+ if (type == GINGLE_ACTION_NOTIFY)
+ return ACTION_NOTIFY;
+ if (type == GINGLE_ACTION_UPDATE)
+ return ACTION_UPDATE;
return ACTION_UNKNOWN;
}
diff --git a/talk/p2p/base/sessionmessages.h b/talk/p2p/base/sessionmessages.h
index eee8452..6ff7c30 100644
--- a/talk/p2p/base/sessionmessages.h
+++ b/talk/p2p/base/sessionmessages.h
@@ -60,6 +60,12 @@
ACTION_TRANSPORT_INFO,
ACTION_TRANSPORT_ACCEPT,
+
+ // TODO: Make better names for these when we think of a
+ // "jingley" way of signaling them. Even better, remove them from
+ // being needed at all.
+ ACTION_NOTIFY,
+ ACTION_UPDATE,
};
// Abstraction of a <jingle> element within an <iq> stanza, per XMPP
diff --git a/talk/p2p/base/transportchannelproxy.cc b/talk/p2p/base/transportchannelproxy.cc
index 405ed76..1be9194 100644
--- a/talk/p2p/base/transportchannelproxy.cc
+++ b/talk/p2p/base/transportchannelproxy.cc
@@ -75,6 +75,13 @@
return impl_->GetError();
}
+P2PTransportChannel* TransportChannelProxy::GetP2PChannel() {
+ if (impl_) {
+ return impl_->GetP2PChannel();
+ }
+ return NULL;
+}
+
void TransportChannelProxy::OnReadableState(TransportChannel* channel) {
ASSERT(channel == impl_);
set_readable(impl_->readable());
diff --git a/talk/p2p/base/transportchannelproxy.h b/talk/p2p/base/transportchannelproxy.h
index 2184477..4601185 100644
--- a/talk/p2p/base/transportchannelproxy.h
+++ b/talk/p2p/base/transportchannelproxy.h
@@ -55,6 +55,7 @@
virtual int SendPacket(const char *data, size_t len);
virtual int SetOption(talk_base::Socket::Option opt, int value);
virtual int GetError();
+ virtual P2PTransportChannel* GetP2PChannel();
private:
typedef std::pair<talk_base::Socket::Option, int> OptionPair;
diff --git a/talk/session/phone/channel.cc b/talk/session/phone/channel.cc
index 76c1cb4..1f8b0e1 100644
--- a/talk/session/phone/channel.cc
+++ b/talk/session/phone/channel.cc
@@ -26,6 +26,8 @@
*/
#include "talk/session/phone/channel.h"
+
+#include "talk/base/buffer.h"
#include "talk/base/byteorder.h"
#include "talk/base/common.h"
#include "talk/base/logging.h"
@@ -33,15 +35,40 @@
#include "talk/session/phone/channelmanager.h"
#include "talk/session/phone/mediasessionclient.h"
#include "talk/session/phone/mediasink.h"
+#include "talk/session/phone/rtcpmuxfilter.h"
namespace cricket {
-static const size_t kMaxPacketLen = 2048;
+struct PacketMessageData : public talk_base::MessageData {
+ talk_base::Buffer packet;
+};
static const char* PacketType(bool rtcp) {
return (!rtcp) ? "RTP" : "RTCP";
}
+static bool ValidPacket(bool rtcp, const talk_base::Buffer* packet) {
+ // Check the packet size. We could check the header too if needed.
+ return (packet &&
+ packet->length() >= (!rtcp ? kMinRtpPacketLen : kMinRtcpPacketLen) &&
+ packet->length() <= kMaxRtpPacketLen);
+}
+
+static uint16 GetRtpSeqNum(const talk_base::Buffer* packet) {
+ return (packet->length() >= kMinRtpPacketLen) ?
+ talk_base::GetBE16(packet->data() + 2) : 0;
+}
+
+static uint32 GetRtpSsrc(const talk_base::Buffer* packet) {
+ return (packet->length() >= kMinRtpPacketLen) ?
+ talk_base::GetBE32(packet->data() + 8) : 0;
+}
+
+static int GetRtcpType(const talk_base::Buffer* packet) {
+ return (packet->length() >= kMinRtcpPacketLen) ?
+ static_cast<int>(packet->data()[1]) : 0;
+}
+
BaseChannel::BaseChannel(talk_base::Thread* thread, MediaEngine* media_engine,
MediaChannel* media_channel, BaseSession* session,
const std::string& content_name,
@@ -74,7 +101,7 @@
BaseChannel::~BaseChannel() {
ASSERT(worker_thread_ == talk_base::Thread::Current());
StopConnectionMonitor();
- Clear();
+ Clear(); // eats any outstanding messages or packets
// We must destroy the media channel before the transport channel, otherwise
// the media channel may try to send on the dead transport channel. NULLing
// is not an effective strategy since the sends will come on another thread.
@@ -160,17 +187,12 @@
}
}
-int BaseChannel::SendPacket(const void *data, size_t len) {
- // SendPacket gets called from MediaEngine; send to socket
- // MediaEngine will call us on a random thread. The Send operation on the
- // socket is special in that it can handle this.
- // TODO: Actually, SendPacket cannot handle this. Need to fix ASAP.
-
- return SendPacket(false, data, len);
+bool BaseChannel::SendPacket(talk_base::Buffer* packet) {
+ return SendPacket(false, packet);
}
-int BaseChannel::SendRtcp(const void *data, size_t len) {
- return SendPacket(true, data, len);
+bool BaseChannel::SendRtcp(talk_base::Buffer* packet) {
+ return SendPacket(true, packet);
}
int BaseChannel::SetOption(SocketType type, talk_base::Socket::Option opt,
@@ -197,19 +219,29 @@
// OnChannelRead gets called from P2PSocket; now pass data to MediaEngine
ASSERT(worker_thread_ == talk_base::Thread::Current());
+ talk_base::Buffer packet(data, len);
// When using RTCP multiplexing we might get RTCP packets on the RTP
// transport. We feed RTP traffic into the demuxer to determine if it is RTCP.
bool rtcp = (channel == rtcp_transport_channel_ ||
- rtcp_mux_filter_.DemuxRtcp(data, len));
- HandlePacket(rtcp, data, len);
+ rtcp_mux_filter_.DemuxRtcp(packet.data(), packet.length()));
+ HandlePacket(rtcp, &packet);
}
-int BaseChannel::SendPacket(bool rtcp, const void* data, size_t len) {
- // Protect ourselves against crazy data.
- if (len > kMaxPacketLen) {
- LOG(LS_ERROR) << "Dropping outgoing large "
- << PacketType(rtcp) << " packet, size " << len;
- return -1;
+bool BaseChannel::SendPacket(bool rtcp, talk_base::Buffer* packet) {
+ // SendPacket gets called from MediaEngine, typically on an encoder thread.
+ // If the thread is not our worker thread, we will post to our worker
+ // so that the real work happens on our worker. This avoids us having to
+ // synchronize access to all the pieces of the send path, including
+ // SRTP and the inner workings of the transport channels.
+ // The only downside is that we can't return a proper failure code if
+ // needed. Since UDP is unreliable anyway, this should be a non-issue.
+ if (talk_base::Thread::Current() != worker_thread_) {
+ // Avoid a copy by transferring the ownership of the packet data.
+ int message_id = (!rtcp) ? MSG_RTPPACKET : MSG_RTCPPACKET;
+ PacketMessageData* data = new PacketMessageData;
+ packet->TransferTo(&data->packet);
+ worker_thread_->Post(this, message_id, data);
+ return true;
}
// Make sure we have a place to send this packet before doing anything.
@@ -218,89 +250,114 @@
TransportChannel* channel = (!rtcp || rtcp_mux_filter_.IsActive()) ?
transport_channel_ : rtcp_transport_channel_;
if (!channel) {
- return -1;
+ return false;
}
- // Protect if needed.
- uint8 work[kMaxPacketLen];
- const char* real_data = static_cast<const char*>(data);
- int real_len = len;
- if (srtp_filter_.IsActive()) {
- bool res;
- memcpy(work, data, len);
- if (!rtcp) {
- res = srtp_filter_.ProtectRtp(work, len, sizeof(work), &real_len);
- } else {
- res = srtp_filter_.ProtectRtcp(work, len, sizeof(work), &real_len);
- }
- if (!res) {
- LOG(LS_ERROR) << "Failed to protect "
- << PacketType(rtcp) << " packet, size " << len;
- return -1;
- }
-
- real_data = reinterpret_cast<const char*>(work);
+ // Protect ourselves against crazy data.
+ if (!ValidPacket(rtcp, packet)) {
+ LOG(LS_ERROR) << "Dropping outgoing " << content_name_ << " "
+ << PacketType(rtcp) << " packet: wrong size="
+ << packet->length();
+ return false;
}
+ // Push the packet down to the media sink.
+ // Need to do this before protecting the packet.
{
talk_base::CritScope cs(&sink_critical_section_);
if (sent_media_sink_) {
- // Put the sent RTP or RTCP packet to the sink.
if (!rtcp) {
- sent_media_sink_->OnRtpPacket(real_data, real_len);
+ sent_media_sink_->OnRtpPacket(packet->data(), packet->length());
} else {
- sent_media_sink_->OnRtcpPacket(real_data, real_len);
+ sent_media_sink_->OnRtcpPacket(packet->data(), packet->length());
}
}
}
- // Bon voyage. Return a number that the caller can understand.
- return (channel->SendPacket(real_data, real_len) == real_len) ? len : -1;
+ // Protect if needed.
+ if (srtp_filter_.IsActive()) {
+ bool res;
+ char* data = packet->data();
+ int len = packet->length();
+ if (!rtcp) {
+ res = srtp_filter_.ProtectRtp(data, len, packet->capacity(), &len);
+ if (!res) {
+ LOG(LS_ERROR) << "Failed to protect " << content_name_
+ << " RTP packet: size=" << len
+ << ", seqnum=" << GetRtpSeqNum(packet)
+ << ", SSRC=" << GetRtpSsrc(packet);
+ return false;
+ }
+ } else {
+ res = srtp_filter_.ProtectRtcp(data, len, packet->capacity(), &len);
+ if (!res) {
+ LOG(LS_ERROR) << "Failed to protect " << content_name_
+ << " RTCP packet: size=" << len
+ << ", type=" << GetRtcpType(packet);
+ return false;
+ }
+ }
+
+ // Update the length of the packet now that we've added the auth tag.
+ packet->SetLength(len);
+ }
+
+ // Bon voyage.
+ return (channel->SendPacket(packet->data(), packet->length())
+ == static_cast<int>(packet->length()));
}
-void BaseChannel::HandlePacket(bool rtcp, const char* data, size_t len) {
+void BaseChannel::HandlePacket(bool rtcp, talk_base::Buffer* packet) {
// Protect ourselvs against crazy data.
- if (len > kMaxPacketLen) {
- LOG(LS_ERROR) << "Dropping incoming large "
- << PacketType(rtcp) << " packet, size " << len;
+ if (!ValidPacket(rtcp, packet)) {
+ LOG(LS_ERROR) << "Dropping incoming " << content_name_ << " "
+ << PacketType(rtcp) << " packet: wrong size="
+ << packet->length();
return;
}
// Unprotect the packet, if needed.
- uint8 work[kMaxPacketLen];
- const char* real_data = data;
- int real_len = len;
if (srtp_filter_.IsActive()) {
+ char* data = packet->data();
+ int len = packet->length();
bool res;
- memcpy(work, data, len);
if (!rtcp) {
- res = srtp_filter_.UnprotectRtp(work, len, &real_len);
+ res = srtp_filter_.UnprotectRtp(data, len, &len);
+ if (!res) {
+ LOG(LS_ERROR) << "Failed to unprotect " << content_name_
+ << " RTP packet: size=" << len
+ << ", seqnum=" << GetRtpSeqNum(packet)
+ << ", SSRC=" << GetRtpSsrc(packet);
+ return;
+ }
} else {
- res = srtp_filter_.UnprotectRtcp(work, len, &real_len);
+ res = srtp_filter_.UnprotectRtcp(data, len, &len);
+ if (!res) {
+ LOG(LS_ERROR) << "Failed to unprotect " << content_name_
+ << " RTCP packet: size=" << len
+ << ", type=" << GetRtcpType(packet);
+ return;
+ }
}
- if (!res) {
- LOG(LS_ERROR) << "Failed to unprotect "
- << PacketType(rtcp) << " packet, size " << len;
- return;
- }
- real_data = reinterpret_cast<const char*>(work);
+
+ packet->SetLength(len);
}
// Push it down to the media channel.
if (!rtcp) {
- media_channel_->OnPacketReceived(real_data, real_len);
+ media_channel_->OnPacketReceived(packet);
} else {
- media_channel_->OnRtcpReceived(real_data, real_len);
+ media_channel_->OnRtcpReceived(packet);
}
+ // Push it down to the media sink.
{
talk_base::CritScope cs(&sink_critical_section_);
if (received_media_sink_) {
- // Put the received RTP or RTCP packet to the sink.
if (!rtcp) {
- received_media_sink_->OnRtpPacket(real_data, real_len);
+ received_media_sink_->OnRtpPacket(packet->data(), packet->length());
} else {
- received_media_sink_->OnRtcpPacket(real_data, real_len);
+ received_media_sink_->OnRtcpPacket(packet->data(), packet->length());
}
}
}
@@ -493,6 +550,14 @@
data->result = SetMaxSendBandwidth_w(data->value);
break;
}
+
+ case MSG_RTPPACKET:
+ case MSG_RTCPPACKET: {
+ PacketMessageData* data = static_cast<PacketMessageData*>(pmsg->pdata);
+ SendPacket(pmsg->message_id == MSG_RTCPPACKET, &data->packet);
+ delete data; // because it is Posted
+ break;
+ }
}
}
@@ -1007,64 +1072,4 @@
}
-// TODO: Move to own file in a future CL.
-// Leaving here for now to avoid having to mess with the Mac build.
-RtcpMuxFilter::RtcpMuxFilter() : state_(ST_INIT), offer_enable_(false) {
-}
-
-bool RtcpMuxFilter::IsActive() const {
- // We can receive muxed media prior to the accept, so we have to be able to
- // deal with that.
- return (state_ == ST_SENTOFFER || state_ == ST_ACTIVE);
-}
-
-bool RtcpMuxFilter::SetOffer(bool offer_enable, ContentSource source) {
- bool ret = false;
- if (state_ == ST_INIT) {
- offer_enable_ = offer_enable;
- state_ = (source == CS_LOCAL) ? ST_SENTOFFER : ST_RECEIVEDOFFER;
- ret = true;
- } else {
- LOG(LS_ERROR) << "Invalid state for RTCP mux offer";
- }
- return ret;
-}
-
-bool RtcpMuxFilter::SetAnswer(bool answer_enable, ContentSource source) {
- bool ret = false;
- if ((state_ == ST_SENTOFFER && source == CS_REMOTE) ||
- (state_ == ST_RECEIVEDOFFER && source == CS_LOCAL)) {
- if (offer_enable_) {
- state_ = (answer_enable) ? ST_ACTIVE : ST_INIT;
- ret = true;
- } else {
- // If the offer didn't specify RTCP mux, the answer shouldn't either.
- if (!answer_enable) {
- ret = true;
- state_ = ST_INIT;
- } else {
- LOG(LS_WARNING) << "Invalid parameters in RTCP mux answer";
- }
- }
- } else {
- LOG(LS_ERROR) << "Invalid state for RTCP mux answer";
- }
- return ret;
-}
-
-bool RtcpMuxFilter::DemuxRtcp(const char* data, int len) {
- // If we're muxing RTP/RTCP, we must inspect each packet delivered and
- // determine whether it is RTP or RTCP. We do so by checking the packet type,
- // and assuming RTP if type is 0-63 or 96-127. For additional details, see
- // http://tools.ietf.org/html/draft-ietf-avt-rtp-and-rtcp-mux-07.
- // Note that if we offer RTCP mux, we may receive muxed RTCP before we
- // receive the answer, so we operate in that state too.
- if (!IsActive()) {
- return false;
- }
-
- int type = (len >= 2) ? (static_cast<uint8>(data[1]) & 0x7F) : 0;
- return (type >= 64 && type < 96);
-}
-
} // namespace cricket
diff --git a/talk/session/phone/channel.h b/talk/session/phone/channel.h
index b82a4bf..c57f9ab 100644
--- a/talk/session/phone/channel.h
+++ b/talk/session/phone/channel.h
@@ -41,6 +41,7 @@
#include "talk/session/phone/mediaengine.h"
#include "talk/session/phone/mediachannel.h"
#include "talk/session/phone/mediamonitor.h"
+#include "talk/session/phone/rtcpmuxfilter.h"
#include "talk/session/phone/srtpfilter.h"
namespace cricket {
@@ -67,37 +68,13 @@
MSG_SETRTCPCNAME = 18,
MSG_SENDINTRAFRAME = 19,
MSG_REQUESTINTRAFRAME = 20,
-};
-
-// TODO: Move to own file.
-class RtcpMuxFilter {
- public:
- RtcpMuxFilter();
-
- // Whether the filter is active, i.e. has RTCP mux been properly negotiated.
- bool IsActive() const;
-
- // Specifies whether the offer indicates the use of RTCP mux.
- bool SetOffer(bool offer_enable, ContentSource src);
-
- // Specifies whether the answer indicates the use of RTCP mux.
- bool SetAnswer(bool answer_enable, ContentSource src);
-
- // Determines whether the specified packet is RTCP.
- bool DemuxRtcp(const char* data, int len);
-
- private:
- enum State { ST_INIT, ST_SENTOFFER, ST_RECEIVEDOFFER, ST_ACTIVE };
- State state_;
- bool offer_enable_;
+ MSG_RTPPACKET = 22,
+ MSG_RTCPPACKET = 23
};
// BaseChannel contains logic common to voice and video, including
// enable/mute, marshaling calls to a worker thread, and
// connection and media monitors.
-// TODO: Break the dependency on BaseSession. The only thing we need
-// it for is to Create/Destroy TransportChannels, and set codecs, both of which
-// could be done by the calling class.
class BaseChannel
: public talk_base::MessageHandler, public sigslot::has_slots<>,
public MediaChannel::NetworkInterface {
@@ -174,16 +151,16 @@
talk_base::MessageList* removed = NULL);
// NetworkInterface implementation, called by MediaEngine
- virtual int SendPacket(const void *data, size_t len);
- virtual int SendRtcp(const void *data, size_t len);
+ virtual bool SendPacket(talk_base::Buffer* packet);
+ virtual bool SendRtcp(talk_base::Buffer* packet);
virtual int SetOption(SocketType type, talk_base::Socket::Option o, int val);
// From TransportChannel
void OnWritableState(TransportChannel* channel);
void OnChannelRead(TransportChannel* channel, const char *data, size_t len);
- int SendPacket(bool rtcp, const void* data, size_t len);
- void HandlePacket(bool rtcp, const char* data, size_t len);
+ bool SendPacket(bool rtcp, talk_base::Buffer* packet);
+ void HandlePacket(bool rtcp, talk_base::Buffer* packet);
// Setting the send codec based on the remote description.
void OnSessionState(BaseSession* session, BaseSession::State state);
diff --git a/talk/session/phone/channelmanager.cc b/talk/session/phone/channelmanager.cc
index 901a20a..0d9984e 100644
--- a/talk/session/phone/channelmanager.cc
+++ b/talk/session/phone/channelmanager.cc
@@ -237,8 +237,10 @@
audio_out_device_.clear();
}
if (!SetVideoOptions(camera_device_)) {
- // TODO: Consider resetting to the default cam here.
- camera_device_.clear();
+ // Perhaps it's been unplugged, fall back to default device
+ if (!SetVideoOptions("")) {
+ camera_device_.clear();
+ }
}
// Now apply the default video codec that has been set earlier.
if (default_video_encoder_config_.max_codec.id != 0) {
@@ -501,20 +503,8 @@
// If we're running, tell the media engine about it.
if (ret && initialized_) {
-#ifdef OSX
- Device sg_device;
- ret = device_manager_->QtKitToSgDevice(device.name, &sg_device);
- if (ret) {
- device = sg_device;
- } else {
- LOG(LS_ERROR) << "Unable to find SG Component for qtkit device "
- << device.name;
- }
-#endif
- if (ret) {
- VideoOptions options(&device);
- ret = (Send(MSG_SETVIDEOOPTIONS, &options) && options.result);
- }
+ VideoOptions options(&device);
+ ret = (Send(MSG_SETVIDEOOPTIONS, &options) && options.result);
}
// If everything worked, retain the name of the selected camera.
diff --git a/talk/session/phone/devicemanager.cc b/talk/session/phone/devicemanager.cc
index e32ed63..f7f993c 100644
--- a/talk/session/phone/devicemanager.cc
+++ b/talk/session/phone/devicemanager.cc
@@ -43,6 +43,7 @@
#include <CoreAudio/CoreAudio.h>
#include <QuickTime/QuickTime.h>
#elif LINUX
+#include <libudev.h>
#include <unistd.h>
#ifndef USE_TALK_SOUND
#include <alsa/asoundlib.h>
@@ -50,7 +51,9 @@
#include "talk/base/linux.h"
#include "talk/base/fileutils.h"
#include "talk/base/pathutils.h"
+#include "talk/base/physicalsocketserver.h"
#include "talk/base/stream.h"
+#include "talk/session/phone/libudevsymboltable.h"
#include "talk/session/phone/v4llookup.h"
#endif
@@ -67,27 +70,52 @@
// Initialize to empty string.
const std::string DeviceManager::kDefaultDeviceName;
-#if WIN32
+#ifdef WIN32
class DeviceWatcher : public talk_base::Win32Window {
public:
explicit DeviceWatcher(DeviceManager* dm);
bool Start();
void Stop();
+
private:
HDEVNOTIFY Register(REFGUID guid);
void Unregister(HDEVNOTIFY notify);
virtual bool OnMessage(UINT msg, WPARAM wp, LPARAM lp, LRESULT& result);
+
DeviceManager* manager_;
HDEVNOTIFY audio_notify_;
HDEVNOTIFY video_notify_;
};
-#else
-// TODO: Implement this for other platforms.
+#elif defined(LINUX)
+class DeviceWatcher : private talk_base::Dispatcher {
+ public:
+ explicit DeviceWatcher(DeviceManager* dm);
+ bool Start();
+ void Stop();
+
+ private:
+ virtual uint32 GetRequestedEvents();
+ virtual void OnPreEvent(uint32 ff);
+ virtual void OnEvent(uint32 ff, int err);
+ virtual int GetDescriptor();
+ virtual bool IsDescriptorClosed();
+
+ DeviceManager* manager_;
+ LibUDevSymbolTable libudev_;
+ struct udev* udev_;
+ struct udev_monitor* udev_monitor_;
+ bool registered_;
+};
+#define LATE(sym) LATESYM_GET(LibUDevSymbolTable, &libudev_, sym)
+#elif defined(OSX)
class DeviceWatcher {
public:
- explicit DeviceWatcher(DeviceManager* dm) {}
- bool Start() { return true; }
- void Stop() {}
+ explicit DeviceWatcher(DeviceManager* dm);
+ bool Start();
+ void Stop();
+ private:
+ DeviceManager* manager_;
+ void* impl_;
};
#endif
@@ -107,7 +135,9 @@
#elif OSX
static const int kVideoDeviceOpenAttempts = 3;
static const UInt32 kAudioDeviceNameLength = 64;
-// Obj-C function defined in devicemanager-mac.mm
+// Obj-C functions defined in devicemanager-mac.mm
+extern void* CreateDeviceWatcherCallback(DeviceManager* dm);
+extern void ReleaseDeviceWatcherCallback(void* impl);
extern bool GetQTKitVideoDevices(std::vector<Device>* out);
static bool GetAudioDeviceIDs(bool inputs, std::vector<AudioDeviceID>* out);
static bool GetAudioDeviceName(AudioDeviceID id, bool input, std::string* out);
@@ -202,86 +232,6 @@
#endif
}
-#ifdef OSX
-bool DeviceManager::QtKitToSgDevice(const std::string& qtkit_name,
- Device* out) {
- out->name.clear();
-
- ComponentDescription only_vdig;
- memset(&only_vdig, 0, sizeof(only_vdig));
- only_vdig.componentType = videoDigitizerComponentType;
- only_vdig.componentSubType = kAnyComponentSubType;
- only_vdig.componentManufacturer = kAnyComponentManufacturer;
-
- // Enumerate components (drivers).
- Component component = 0;
- while ((component = FindNextComponent(component, &only_vdig)) &&
- out->name.empty()) {
- // Get the name of the component and see if we want to open it.
- Handle name_handle = NewHandle(0);
- GetComponentInfo(component, NULL, name_handle, NULL, NULL);
- Ptr name_ptr = *name_handle;
- std::string comp_name(name_ptr + 1, static_cast<size_t>(*name_ptr));
- DisposeHandle(name_handle);
-
- if (!ShouldDeviceBeIgnored(comp_name)) {
- // Try to open the component.
- // DV Video will fail with err=-9408 (deviceCantMeetRequest)
- // IIDC FireWire Video and USB Video Class Video will fail with err=704
- // if no cameras are present, or there is contention for the camera.
- // We can't tell the scenarios apart, so we will retry a few times if
- // we get a 704 to make sure we detect the cam if one is really there.
- int attempts = 0;
- ComponentInstance vdig;
- OSErr err;
- do {
- err = OpenAComponent(component, &vdig);
- ++attempts;
- } while (!vdig && err == 704 && attempts < kVideoDeviceOpenAttempts);
-
- if (vdig) {
- // We were able to open the component.
- LOG(LS_INFO) << "Opened component \"" << comp_name
- << "\", tries=" << attempts;
-
- // Enumerate cameras on the component.
- // Note, that due to QT strangeness VDGetNumberOfInputs really returns
- // the number of inputs minus one. If no inputs are available -1 is
- // returned.
- short num_inputs; // NOLINT
- VideoDigitizerError err = VDGetNumberOfInputs(vdig, &num_inputs);
- if (err == 0 && num_inputs >= 0) {
- LOG(LS_INFO) << "Found " << num_inputs + 1 << " webcams attached.";
- Str255 pname;
- for (int i = 0; i <= num_inputs; ++i) {
- err = VDGetInputName(vdig, i, pname);
- if (err == 0) {
- // The format for camera ids is <component>:<camera index>.
- char id_buf[256];
- talk_base::sprintfn(id_buf, ARRAY_SIZE(id_buf), "%s:%d",
- comp_name.c_str(), i);
- std::string name(reinterpret_cast<const char*>(pname + 1),
- static_cast<size_t>(*pname)), id(id_buf);
- LOG(LS_INFO) << " Webcam " << i << ": " << name;
- if (name == qtkit_name) {
- out->name = name;
- out->id = id;
- break;
- }
- }
- }
- }
- CloseComponent(vdig);
- } else {
- LOG(LS_INFO) << "Failed to open component \"" << comp_name
- << "\", err=" << err;
- }
- }
- }
- return !out->name.empty();
-}
-#endif
-
bool DeviceManager::GetDefaultVideoCaptureDevice(Device* device) {
bool ret = false;
#if WIN32
@@ -738,6 +688,24 @@
return true;
}
+DeviceWatcher::DeviceWatcher(DeviceManager* manager)
+ : manager_(manager), impl_(NULL) {
+}
+
+bool DeviceWatcher::Start() {
+ if (!impl_) {
+ impl_ = CreateDeviceWatcherCallback(manager_);
+ }
+ return impl_ != NULL;
+}
+
+void DeviceWatcher::Stop() {
+ if (impl_) {
+ ReleaseDeviceWatcherCallback(impl_);
+ impl_ = NULL;
+ }
+}
+
#elif defined(LINUX)
static const std::string kVideoMetaPathK2_4("/proc/video/dev/");
static const std::string kVideoMetaPathK2_6("/sys/class/video4linux/");
@@ -900,6 +868,112 @@
ScanV4L2Devices(devices);
return true;
}
+
+DeviceWatcher::DeviceWatcher(DeviceManager* dm)
+ : manager_(dm), udev_(NULL), udev_monitor_(NULL), registered_(false) {}
+
+bool DeviceWatcher::Start() {
+ // We deliberately return true in the failure paths here because libudev is
+ // not a critical component of a Linux system so it may not be present/usable,
+ // and we don't want to halt DeviceManager initialization in such a case.
+ if (!libudev_.Load()) {
+ LOG(LS_WARNING) << "libudev not present/usable; DeviceWatcher disabled";
+ return true;
+ }
+ udev_ = LATE(udev_new)();
+ if (!udev_) {
+ LOG_ERR(LS_ERROR) << "udev_new()";
+ return true;
+ }
+ // The second argument here is the event source. It can be either "kernel" or
+ // "udev", but "udev" is the only correct choice. Apps listen on udev and the
+ // udev daemon in turn listens on the kernel.
+ udev_monitor_ = LATE(udev_monitor_new_from_netlink)(udev_, "udev");
+ if (!udev_monitor_) {
+ LOG_ERR(LS_ERROR) << "udev_monitor_new_from_netlink()";
+ return true;
+ }
+ // We only listen for changes in the video devices. Audio devices are more or
+ // less unimportant because receiving device change notifications really only
+ // matters for broadcasting updated send/recv capabilities based on whether
+ // there is at least one device available, and almost all computers have at
+ // least one audio device. Also, PulseAudio device notifications don't come
+ // from the udev daemon, they come from the PulseAudio daemon, so we'd only
+ // want to listen for audio device changes from udev if using ALSA. For
+ // simplicity, we don't bother with any audio stuff at all.
+ if (LATE(udev_monitor_filter_add_match_subsystem_devtype)(udev_monitor_,
+ "video4linux",
+ NULL) < 0) {
+ LOG_ERR(LS_ERROR) << "udev_monitor_filter_add_match_subsystem_devtype()";
+ return true;
+ }
+ if (LATE(udev_monitor_enable_receiving)(udev_monitor_) < 0) {
+ LOG_ERR(LS_ERROR) << "udev_monitor_enable_receiving()";
+ return true;
+ }
+ static_cast<talk_base::PhysicalSocketServer*>(
+ talk_base::Thread::Current()->socketserver())->Add(this);
+ registered_ = true;
+ return true;
+}
+
+void DeviceWatcher::Stop() {
+ if (registered_) {
+ static_cast<talk_base::PhysicalSocketServer*>(
+ talk_base::Thread::Current()->socketserver())->Remove(this);
+ registered_ = false;
+ }
+ if (udev_monitor_) {
+ LATE(udev_monitor_unref)(udev_monitor_);
+ udev_monitor_ = NULL;
+ }
+ if (udev_) {
+ LATE(udev_unref)(udev_);
+ udev_ = NULL;
+ }
+ libudev_.Unload();
+}
+
+uint32 DeviceWatcher::GetRequestedEvents() {
+ return talk_base::DE_READ;
+}
+
+void DeviceWatcher::OnPreEvent(uint32 ff) {
+ // Nothing to do.
+}
+
+void DeviceWatcher::OnEvent(uint32 ff, int err) {
+ udev_device* device = LATE(udev_monitor_receive_device)(udev_monitor_);
+ if (!device) {
+ // Probably the socket connection to the udev daemon was terminated (perhaps
+ // the daemon crashed or is being restarted?).
+ LOG_ERR(LS_WARNING) << "udev_monitor_receive_device()";
+ // Stop listening to avoid potential livelock (an fd with EOF in it is
+ // always considered readable).
+ static_cast<talk_base::PhysicalSocketServer*>(
+ talk_base::Thread::Current()->socketserver())->Remove(this);
+ registered_ = false;
+ return;
+ }
+ // Else we read the device successfully.
+
+ // Since we already have our own filesystem-based device enumeration code, we
+ // simply re-enumerate rather than inspecting the device event.
+ LATE(udev_device_unref)(device);
+ manager_->OnDevicesChange();
+}
+
+int DeviceWatcher::GetDescriptor() {
+ return LATE(udev_monitor_get_fd)(udev_monitor_);
+}
+
+bool DeviceWatcher::IsDescriptorClosed() {
+ // If it is closed then we will just get an error in
+ // udev_monitor_receive_device and unregister, so we don't need to check for
+ // it separately.
+ return false;
+}
+
#endif
// TODO: Try to get hold of a copy of Final Cut to understand why we
diff --git a/talk/session/phone/devicemanager.h b/talk/session/phone/devicemanager.h
index 594e9bd..d9438d4 100644
--- a/talk/session/phone/devicemanager.h
+++ b/talk/session/phone/devicemanager.h
@@ -83,9 +83,6 @@
virtual bool GetVideoCaptureDevices(std::vector<Device>* devs);
virtual bool GetDefaultVideoCaptureDevice(Device* device);
-#ifdef OSX
- virtual bool QtKitToSgDevice(const std::string& qtkit_name, Device* out);
-#endif
sigslot::signal0<> SignalDevicesChange;
diff --git a/talk/session/phone/devicemanager_mac.mm b/talk/session/phone/devicemanager_mac.mm
index 1a14e95..3537ed9 100644
--- a/talk/session/phone/devicemanager_mac.mm
+++ b/talk/session/phone/devicemanager_mac.mm
@@ -31,8 +31,48 @@
#include "talk/base/logging.h"
+@interface DeviceWatcherImpl : NSObject {
+@private
+ cricket::DeviceManager* manager_;
+}
+- (id)init:(cricket::DeviceManager*) dm;
+- (void)onDevicesChanged:(NSNotification *)notification;
+@end
+
+@implementation DeviceWatcherImpl
+- (id)init:(cricket::DeviceManager*) dm {
+ if ((self = [super init])) {
+ manager_ = dm;
+ [[NSNotificationCenter defaultCenter] addObserver:self
+ selector:@selector(onDevicesChanged:)
+ name:QTCaptureDeviceWasConnectedNotification
+ object:nil];
+ [[NSNotificationCenter defaultCenter] addObserver:self
+ selector:@selector(onDevicesChanged:)
+ name:QTCaptureDeviceWasDisconnectedNotification
+ object:nil];
+ }
+ return self;
+}
+- (void)dealloc {
+ [[NSNotificationCenter defaultCenter] removeObserver:self];
+ [super dealloc];
+}
+- (void)onDevicesChanged:(NSNotification *)notification {
+ manager_->OnDevicesChange();
+}
+@end
+
namespace cricket {
+void* CreateDeviceWatcherCallback(DeviceManager* dm) {
+ return [[DeviceWatcherImpl alloc] init:dm];
+}
+void ReleaseDeviceWatcherCallback(void* watcher) {
+ DeviceWatcherImpl* watcher_impl = static_cast<DeviceWatcherImpl*>(watcher);
+ [watcher_impl release];
+}
+
bool GetQTKitVideoDevices(std::vector<Device>* devices) {
NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
@@ -44,11 +84,12 @@
QTCaptureDevice* qt_capture_device = [qt_capture_devices objectAtIndex:i];
static const NSString* kFormat = @"localizedDisplayName: \"%@\", "
- "modelUniqueID: \"%@\", isConnected: %d, isOpen: %d, "
+ "modelUniqueID: \"%@\", uniqueID \"%@\", isConnected: %d, isOpen: %d, "
"isInUseByAnotherApplication: %d";
NSString* info = [NSString stringWithFormat:kFormat,
[qt_capture_device localizedDisplayName],
[qt_capture_device modelUniqueID],
+ [qt_capture_device uniqueID],
[qt_capture_device isConnected],
[qt_capture_device isOpen],
[qt_capture_device isInUseByAnotherApplication]];
@@ -57,7 +98,7 @@
std::string name([[qt_capture_device localizedDisplayName]
cStringUsingEncoding:NSUTF8StringEncoding]);
devices->push_back(Device(name,
- [[qt_capture_device modelUniqueID]
+ [[qt_capture_device uniqueID]
cStringUsingEncoding:NSUTF8StringEncoding]));
}
diff --git a/talk/session/phone/filemediaengine.cc b/talk/session/phone/filemediaengine.cc
index 4929933..49d92b6 100644
--- a/talk/session/phone/filemediaengine.cc
+++ b/talk/session/phone/filemediaengine.cc
@@ -25,6 +25,9 @@
#include "talk/session/phone/filemediaengine.h"
+#include <climits>
+
+#include "talk/base/buffer.h"
#include "talk/base/event.h"
#include "talk/base/logging.h"
#include "talk/base/pathutils.h"
@@ -81,12 +84,15 @@
// Called by media channel. Context: media channel thread.
bool SetSend(bool send);
- void OnPacketReceived(const void* data, int len);
+ void OnPacketReceived(talk_base::Buffer* packet);
// Override virtual method of parent MessageHandler. Context: Worker Thread.
virtual void OnMessage(talk_base::Message* pmsg);
private:
+ // Read the next RTP dump packet, whose RTP SSRC is the same as first_ssrc_.
+ // Return true if successful.
+ bool ReadNextPacket(RtpDumpPacket* packet);
// Send a RTP packet to the network. The input parameter data points to the
// start of the RTP packet and len is the packet size. Return true if the sent
// size is equal to len.
@@ -99,8 +105,10 @@
talk_base::scoped_ptr<RtpDumpWriter> rtp_dump_writer_;
// RTP dump packet read from the input stream.
RtpDumpPacket rtp_dump_packet_;
+ uint32 start_send_time_;
bool sending_;
bool first_packet_;
+ uint32 first_ssrc_;
DISALLOW_COPY_AND_ASSIGN(RtpSenderReceiver);
};
@@ -136,13 +144,14 @@
sending_ = send;
if (!was_sending && sending_) {
PostDelayed(0, this); // Wake up the send thread.
+ start_send_time_ = talk_base::Time();
}
return true;
}
-void RtpSenderReceiver::OnPacketReceived(const void* data, int len) {
+void RtpSenderReceiver::OnPacketReceived(talk_base::Buffer* packet) {
if (rtp_dump_writer_.get()) {
- rtp_dump_writer_->WriteRtpPacket(data, len);
+ rtp_dump_writer_->WriteRtpPacket(packet->data(), packet->length());
}
}
@@ -153,32 +162,45 @@
return;
}
- uint32 prev_elapsed_time = 0xFFFFFFFF;
if (!first_packet_) {
- prev_elapsed_time = rtp_dump_packet_.elapsed_time;
+ // Send the previously read packet.
SendRtpPacket(&rtp_dump_packet_.data[0], rtp_dump_packet_.data.size());
- } else {
- first_packet_ = false;
}
- // Read a dump packet and wait for the elapsed time.
- if (talk_base::SR_SUCCESS ==
- rtp_dump_reader_->ReadPacket(&rtp_dump_packet_)) {
- int waiting_time_ms = rtp_dump_packet_.elapsed_time > prev_elapsed_time ?
- rtp_dump_packet_.elapsed_time - prev_elapsed_time : 0;
- PostDelayed(waiting_time_ms, this);
+ if (ReadNextPacket(&rtp_dump_packet_)) {
+ int wait = talk_base::TimeUntil(
+ start_send_time_ + rtp_dump_packet_.elapsed_time);
+ wait = talk_base::_max(0, wait);
+ PostDelayed(wait, this);
} else {
Quit();
}
}
+bool RtpSenderReceiver::ReadNextPacket(RtpDumpPacket* packet) {
+ while (talk_base::SR_SUCCESS == rtp_dump_reader_->ReadPacket(packet)) {
+ uint32 ssrc;
+ if (!packet->GetRtpSsrc(&ssrc)) {
+ return false;
+ }
+ if (first_packet_) {
+ first_packet_ = false;
+ first_ssrc_ = ssrc;
+ }
+ if (ssrc == first_ssrc_) {
+ return true;
+ }
+ }
+ return false;
+}
+
bool RtpSenderReceiver::SendRtpPacket(const void* data, size_t len) {
if (!media_channel_ || !media_channel_->network_interface()) {
return false;
}
- return media_channel_->network_interface()->SendPacket(data, len) ==
- static_cast<int>(len);
+ talk_base::Buffer packet(data, len, kMaxRtpPacketLen);
+ return media_channel_->network_interface()->SendPacket(&packet);
}
///////////////////////////////////////////////////////////////////////////
@@ -200,8 +222,8 @@
return rtp_sender_receiver_->SetSend(flag != SEND_NOTHING);
}
-void FileVoiceChannel::OnPacketReceived(const void* data, int len) {
- rtp_sender_receiver_->OnPacketReceived(data, len);
+void FileVoiceChannel::OnPacketReceived(talk_base::Buffer* packet) {
+ rtp_sender_receiver_->OnPacketReceived(packet);
}
///////////////////////////////////////////////////////////////////////////
@@ -223,8 +245,8 @@
return rtp_sender_receiver_->SetSend(send);
}
-void FileVideoChannel::OnPacketReceived(const void* data, int len) {
- rtp_sender_receiver_->OnPacketReceived(data, len);
+void FileVideoChannel::OnPacketReceived(talk_base::Buffer* packet) {
+ rtp_sender_receiver_->OnPacketReceived(packet);
}
} // namespace cricket
diff --git a/talk/session/phone/filemediaengine.h b/talk/session/phone/filemediaengine.h
index cc6788c..2276772 100644
--- a/talk/session/phone/filemediaengine.h
+++ b/talk/session/phone/filemediaengine.h
@@ -144,8 +144,8 @@
virtual bool GetStats(VoiceMediaInfo* info) { return true; }
// Implement pure virtual methods of MediaChannel.
- virtual void OnPacketReceived(const void* data, int len);
- virtual void OnRtcpReceived(const void* data, int len) {}
+ virtual void OnPacketReceived(talk_base::Buffer* packet);
+ virtual void OnRtcpReceived(talk_base::Buffer* packet) {}
virtual void SetSendSsrc(uint32 id) {} // TODO: change RTP packet?
virtual bool SetRtcpCName(const std::string& cname) { return true; }
virtual bool Mute(bool on) { return false; }
@@ -179,8 +179,8 @@
virtual bool RequestIntraFrame() { return false; }
// Implement pure virtual methods of MediaChannel.
- virtual void OnPacketReceived(const void* data, int len);
- virtual void OnRtcpReceived(const void* data, int len) {}
+ virtual void OnPacketReceived(talk_base::Buffer* packet);
+ virtual void OnRtcpReceived(talk_base::Buffer* packet) {}
virtual void SetSendSsrc(uint32 id) {} // TODO: change RTP packet?
virtual bool SetRtcpCName(const std::string& cname) { return true; }
virtual bool Mute(bool on) { return false; }
diff --git a/talk/session/phone/libudevsymboltable.cc b/talk/session/phone/libudevsymboltable.cc
new file mode 100644
index 0000000..b312306
--- /dev/null
+++ b/talk/session/phone/libudevsymboltable.cc
@@ -0,0 +1,39 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "talk/session/phone/libudevsymboltable.h"
+
+namespace cricket {
+
+LATE_BINDING_SYMBOL_TABLE_DEFINE_BEGIN(LibUDevSymbolTable, "libudev.so.0")
+#define X(sym) \
+ LATE_BINDING_SYMBOL_TABLE_DEFINE_ENTRY(LibUDevSymbolTable, sym)
+LIBUDEV_SYMBOLS_LIST
+#undef X
+LATE_BINDING_SYMBOL_TABLE_DEFINE_END(LibUDevSymbolTable)
+
+} // namespace cricket
diff --git a/talk/session/phone/libudevsymboltable.h b/talk/session/phone/libudevsymboltable.h
new file mode 100644
index 0000000..0dbef6c
--- /dev/null
+++ b/talk/session/phone/libudevsymboltable.h
@@ -0,0 +1,58 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TALK_SESSION_PHONE_LIBUDEVSYMBOLTABLE_H_
+#define TALK_SESSION_PHONE_LIBUDEVSYMBOLTABLE_H_
+
+#include "talk/base/latebindingsymboltable.h"
+
+namespace cricket {
+
+// The libudev symbols we need, as an X-Macro list.
+// This list must contain precisely every libudev function that is used in
+// devicemanager.cc.
+#define LIBUDEV_SYMBOLS_LIST \
+ X(udev_device_unref) \
+ X(udev_monitor_enable_receiving) \
+ X(udev_monitor_filter_add_match_subsystem_devtype) \
+ X(udev_monitor_get_fd) \
+ X(udev_monitor_new_from_netlink) \
+ X(udev_monitor_receive_device) \
+ X(udev_monitor_unref) \
+ X(udev_new) \
+ X(udev_unref)
+
+LATE_BINDING_SYMBOL_TABLE_DECLARE_BEGIN(LibUDevSymbolTable)
+#define X(sym) \
+ LATE_BINDING_SYMBOL_TABLE_DECLARE_ENTRY(LibUDevSymbolTable, sym)
+LIBUDEV_SYMBOLS_LIST
+#undef X
+LATE_BINDING_SYMBOL_TABLE_DECLARE_END(LibUDevSymbolTable)
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_LIBUDEVSYMBOLTABLE_H_
diff --git a/talk/session/phone/mediachannel.h b/talk/session/phone/mediachannel.h
index 01bd8b5..d3951c9 100644
--- a/talk/session/phone/mediachannel.h
+++ b/talk/session/phone/mediachannel.h
@@ -38,12 +38,20 @@
// TODO: re-evaluate this include
#include "talk/session/phone/audiomonitor.h"
+namespace talk_base {
+class Buffer;
+}
+
namespace flute {
- class MagicCamVideoRenderer;
+class MagicCamVideoRenderer;
}
namespace cricket {
+const size_t kMinRtpPacketLen = 12;
+const size_t kMinRtcpPacketLen = 4;
+const size_t kMaxRtpPacketLen = 2048;
+
enum VoiceMediaChannelOptions {
OPT_CONFERENCE = 0x10000, // tune the audio stream for conference mode
OPT_ENERGYLEVEL = 0x20000, // include the energy level in RTP packets, as
@@ -53,6 +61,8 @@
};
enum VideoMediaChannelOptions {
+ OPT_INTERPOLATE = 0x10000 // Increase the output framerate by 2x by
+ // interpolating frames
};
class MediaChannel : public sigslot::has_slots<> {
@@ -60,8 +70,8 @@
class NetworkInterface {
public:
enum SocketType { ST_RTP, ST_RTCP };
- virtual int SendPacket(const void *data, size_t len) = 0;
- virtual int SendRtcp(const void *data, size_t len) = 0;
+ virtual bool SendPacket(talk_base::Buffer* packet) = 0;
+ virtual bool SendRtcp(talk_base::Buffer* packet) = 0;
virtual int SetOption(SocketType type, talk_base::Socket::Option opt,
int option) = 0;
virtual ~NetworkInterface() {}
@@ -77,9 +87,9 @@
}
// Called when a RTP packet is received.
- virtual void OnPacketReceived(const void *data, int len) = 0;
+ virtual void OnPacketReceived(talk_base::Buffer* packet) = 0;
// Called when a RTCP packet is received.
- virtual void OnRtcpReceived(const void *data, int len) = 0;
+ virtual void OnRtcpReceived(talk_base::Buffer* packet) = 0;
// Sets the SSRC to be used for outgoing data.
virtual void SetSendSsrc(uint32 id) = 0;
// Set the CNAME of RTCP
@@ -101,24 +111,78 @@
SEND_MICROPHONE
};
-struct MediaInfo {
- int fraction_lost;
- int cum_lost;
- int ext_max;
- int jitter;
- int RTT;
- int bytesSent;
- int packetsSent;
- int bytesReceived;
- int packetsReceived;
+struct VoiceSenderInfo {
+ uint32 ssrc;
+ int bytes_sent;
+ int packets_sent;
+ int packets_lost;
+ float fraction_lost;
+ int ext_seqnum;
+ int rtt_ms;
+ int jitter_ms;
+ int audio_level;
};
-struct VoiceMediaInfo : MediaInfo {
+struct VoiceReceiverInfo {
+ uint32 ssrc;
+ int bytes_rcvd;
+ int packets_rcvd;
+ int packets_lost;
+ float fraction_lost;
+ int ext_seqnum;
+ int jitter_ms;
+ int audio_level;
};
-struct VideoMediaInfo : MediaInfo {
- int receive_framerate;
- int send_framerate;
+struct VideoSenderInfo {
+ uint32 ssrc;
+ int bytes_sent;
+ int packets_sent;
+ int packets_cached;
+ int packets_lost;
+ float fraction_lost;
+ int firs_rcvd;
+ int nacks_rcvd;
+ int rtt_ms;
+ int frame_width;
+ int frame_height;
+ int framerate_input;
+ int framerate_sent;
+};
+
+struct VideoReceiverInfo {
+ uint32 ssrc;
+ int bytes_rcvd;
+ // vector<int> layer_bytes_rcvd;
+ int packets_rcvd;
+ int packets_lost;
+ int packets_concealed;
+ float fraction_lost;
+ int firs_sent;
+ int nacks_sent;
+ int frame_width;
+ int frame_height;
+ int framerate_rcvd;
+ int framerate_decoded;
+ int framerate_output;
+};
+
+struct VoiceMediaInfo {
+ void Clear() {
+ senders.clear();
+ receivers.clear();
+ }
+ std::vector<VoiceSenderInfo> senders;
+ std::vector<VoiceReceiverInfo> receivers;
+};
+
+struct VideoMediaInfo {
+ void Clear() {
+ senders.clear();
+ receivers.clear();
+ }
+ std::vector<VideoSenderInfo> senders;
+ std::vector<VideoReceiverInfo> receivers;
};
class VoiceMediaChannel : public MediaChannel {
@@ -195,7 +259,7 @@
// nothing is written.
virtual size_t CopyToBuffer(uint8 *buffer, size_t size) const = 0;
- // Converts the I420 data to RGB of a certain type such as BGRA and RGBA.
+ // Converts the I420 data to RGB of a certain type such as ARGB and ABGR.
// Returns the frame's actual size, regardless of whether it was written or
// not (like snprintf). Parameters size and pitch_rgb are in units of bytes.
// If there is insufficient space, nothing is written.
diff --git a/talk/session/phone/mediamonitor.h b/talk/session/phone/mediamonitor.h
index 9eda2aa..6b964aa 100644
--- a/talk/session/phone/mediamonitor.h
+++ b/talk/session/phone/mediamonitor.h
@@ -74,10 +74,8 @@
protected:
// These routines assume the crit_ lock is held by the calling thread.
virtual void GetStats() {
- media_info_.packetsReceived = -1;
- if (!media_channel_->GetStats(&media_info_)) {
- media_info_.packetsReceived = -1;
- }
+ media_info_.Clear();
+ media_channel_->GetStats(&media_info_);
}
virtual void Update() {
MI stats(media_info_);
diff --git a/talk/session/phone/mediasessionclient.cc b/talk/session/phone/mediasessionclient.cc
index f16b531..c862cd5 100644
--- a/talk/session/phone/mediasessionclient.cc
+++ b/talk/session/phone/mediasessionclient.cc
@@ -562,7 +562,7 @@
audio->AddCodec(AudioCodec(0, "PCMU", 8000, 64000, 1, 0));
}
- ParseGingleSsrc(content_elem, QN_GINGLE_VIDEO_SRCID, audio);
+ ParseGingleSsrc(content_elem, QN_GINGLE_AUDIO_SRCID, audio);
if (!ParseGingleEncryption(content_elem, QN_GINGLE_AUDIO_CRYPTO_USAGE,
audio, error)) {
diff --git a/talk/session/phone/rtcpmuxfilter.cc b/talk/session/phone/rtcpmuxfilter.cc
new file mode 100644
index 0000000..8654214
--- /dev/null
+++ b/talk/session/phone/rtcpmuxfilter.cc
@@ -0,0 +1,92 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "talk/session/phone/rtcpmuxfilter.h"
+
+#include "talk/base/logging.h"
+
+namespace cricket {
+
+RtcpMuxFilter::RtcpMuxFilter() : state_(ST_INIT), offer_enable_(false) {
+}
+
+bool RtcpMuxFilter::IsActive() const {
+ // We can receive muxed media prior to the accept, so we have to be able to
+ // deal with that.
+ return (state_ == ST_SENTOFFER || state_ == ST_ACTIVE);
+}
+
+bool RtcpMuxFilter::SetOffer(bool offer_enable, ContentSource source) {
+ bool ret = false;
+ if (state_ == ST_INIT) {
+ offer_enable_ = offer_enable;
+ state_ = (source == CS_LOCAL) ? ST_SENTOFFER : ST_RECEIVEDOFFER;
+ ret = true;
+ } else {
+ LOG(LS_ERROR) << "Invalid state for RTCP mux offer";
+ }
+ return ret;
+}
+
+bool RtcpMuxFilter::SetAnswer(bool answer_enable, ContentSource source) {
+ bool ret = false;
+ if ((state_ == ST_SENTOFFER && source == CS_REMOTE) ||
+ (state_ == ST_RECEIVEDOFFER && source == CS_LOCAL)) {
+ if (offer_enable_) {
+ state_ = (answer_enable) ? ST_ACTIVE : ST_INIT;
+ ret = true;
+ } else {
+ // If the offer didn't specify RTCP mux, the answer shouldn't either.
+ if (!answer_enable) {
+ ret = true;
+ state_ = ST_INIT;
+ } else {
+ LOG(LS_WARNING) << "Invalid parameters in RTCP mux answer";
+ }
+ }
+ } else {
+ LOG(LS_ERROR) << "Invalid state for RTCP mux answer";
+ }
+ return ret;
+}
+
+bool RtcpMuxFilter::DemuxRtcp(const char* data, int len) {
+ // If we're muxing RTP/RTCP, we must inspect each packet delivered and
+ // determine whether it is RTP or RTCP. We do so by checking the packet type,
+ // and assuming RTP if type is 0-63 or 96-127. For additional details, see
+ // http://tools.ietf.org/html/rfc5761.
+ // Note that if we offer RTCP mux, we may receive muxed RTCP before we
+ // receive the answer, so we operate in that state too.
+ if (!IsActive()) {
+ return false;
+ }
+
+ int type = (len >= 2) ? (static_cast<uint8>(data[1]) & 0x7F) : 0;
+ return (type >= 64 && type < 96);
+}
+
+} // namespace cricket
diff --git a/talk/session/phone/rtcpmuxfilter.h b/talk/session/phone/rtcpmuxfilter.h
new file mode 100644
index 0000000..0224e9f
--- /dev/null
+++ b/talk/session/phone/rtcpmuxfilter.h
@@ -0,0 +1,61 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TALK_SESSION_PHONE_RTCPMUXFILTER_H_
+#define TALK_SESSION_PHONE_RTCPMUXFILTER_H_
+
+#include "talk/base/basictypes.h"
+#include "talk/p2p/base/sessiondescription.h"
+
+namespace cricket {
+
+// RTCP Muxer, as defined in RFC 5761 (http://tools.ietf.org/html/rfc5761)
+class RtcpMuxFilter {
+ public:
+ RtcpMuxFilter();
+
+ // Whether the filter is active, i.e. has RTCP mux been properly negotiated.
+ bool IsActive() const;
+
+ // Specifies whether the offer indicates the use of RTCP mux.
+ bool SetOffer(bool offer_enable, ContentSource src);
+
+ // Specifies whether the answer indicates the use of RTCP mux.
+ bool SetAnswer(bool answer_enable, ContentSource src);
+
+ // Determines whether the specified packet is RTCP.
+ bool DemuxRtcp(const char* data, int len);
+
+ private:
+ enum State { ST_INIT, ST_SENTOFFER, ST_RECEIVEDOFFER, ST_ACTIVE };
+ State state_;
+ bool offer_enable_;
+};
+
+} // namespace cricket
+
+#endif // TALK_SESSION_PHONE_RTCPMUXFILTER_H_
diff --git a/talk/session/phone/rtpdump.cc b/talk/session/phone/rtpdump.cc
index bd67cad..deae20f 100644
--- a/talk/session/phone/rtpdump.cc
+++ b/talk/session/phone/rtpdump.cc
@@ -30,6 +30,7 @@
#include <string>
#include "talk/base/bytebuffer.h"
+#include "talk/base/byteorder.h"
#include "talk/base/logging.h"
#include "talk/base/time.h"
@@ -55,13 +56,35 @@
}
// RTP packet format (http://www.networksorcery.com/enp/protocol/rtp.htm).
-static const int kRtpSeqNumOffset = 2;
-static const int kRtpSeqNumAndTimestampSize = 6;
+static const size_t kMinimumRtpHeaderSize = 12;
static const uint32 kDefaultTimeIncrease = 30;
bool RtpDumpPacket::IsValidRtpPacket() const {
- return !is_rtcp &&
- data.size() >= kRtpSeqNumOffset + kRtpSeqNumAndTimestampSize;
+ return !is_rtcp && data.size() >= kMinimumRtpHeaderSize;
+}
+
+bool RtpDumpPacket::GetRtpSeqNum(uint16* seq_num) const {
+ if (!seq_num || !IsValidRtpPacket()) {
+ return false;
+ }
+ *seq_num = talk_base::GetBE16(&data[2]);
+ return true;
+}
+
+bool RtpDumpPacket::GetRtpTimestamp(uint32* ts) const {
+ if (!ts || !IsValidRtpPacket()) {
+ return false;
+ }
+ *ts = talk_base::GetBE32(&data[4]);
+ return true;
+}
+
+bool RtpDumpPacket::GetRtpSsrc(uint32* ssrc) const {
+ if (!ssrc || !IsValidRtpPacket()) {
+ return false;
+ }
+ *ssrc = talk_base::GetBE32(&data[8]);
+ return true;
}
///////////////////////////////////////////////////////////////////////////
@@ -197,12 +220,11 @@
void RtpDumpLoopReader::UpdateStreamStatistics(const RtpDumpPacket& packet) {
// Get the RTP sequence number and timestamp of the dump packet.
uint16 rtp_seq_num = 0;
+ packet.GetRtpSeqNum(&rtp_seq_num);
uint32 rtp_timestamp = 0;
- if (packet.IsValidRtpPacket()) {
- ReadRtpSeqNumAndTimestamp(packet, &rtp_seq_num, &rtp_timestamp);
- }
+ packet.GetRtpTimestamp(&rtp_timestamp);
- // Get the timestamps and sequence number for the first dump packet.
+ // Set the timestamps and sequence number for the first dump packet.
if (0 == packet_count_++) {
first_elapsed_time_ = packet.elapsed_time;
first_rtp_seq_num_ = rtp_seq_num;
@@ -241,8 +263,9 @@
if (packet->IsValidRtpPacket()) {
// Get the old RTP sequence number and timestamp.
uint16 sequence;
+ packet->GetRtpSeqNum(&sequence);
uint32 timestamp;
- ReadRtpSeqNumAndTimestamp(*packet, &sequence, ×tamp);
+ packet->GetRtpTimestamp(×tamp);
// Increase the RTP sequence number and timestamp.
sequence += loop_count_ * rtp_seq_num_increase_;
timestamp += loop_count_ * rtp_timestamp_increase_;
@@ -250,29 +273,27 @@
talk_base::ByteBuffer buffer;
buffer.WriteUInt16(sequence);
buffer.WriteUInt32(timestamp);
- memcpy(&packet->data[0] + kRtpSeqNumOffset, buffer.Data(), buffer.Length());
+ memcpy(&packet->data[2], buffer.Data(), buffer.Length());
}
}
-void RtpDumpLoopReader::ReadRtpSeqNumAndTimestamp(
- const RtpDumpPacket& packet, uint16* sequence, uint32* timestamp) {
- talk_base::ByteBuffer buffer(
- reinterpret_cast<const char*>(&packet.data[0] + kRtpSeqNumOffset),
- kRtpSeqNumAndTimestampSize);
- buffer.ReadUInt16(sequence);
- buffer.ReadUInt32(timestamp);
-}
-
///////////////////////////////////////////////////////////////////////////
// Implementation of RtpDumpWriter.
///////////////////////////////////////////////////////////////////////////
+
+RtpDumpWriter::RtpDumpWriter(talk_base::StreamInterface* stream)
+ : stream_(stream),
+ file_header_written_(false),
+ start_time_ms_(talk_base::Time()) {
+ }
+
uint32 RtpDumpWriter::GetElapsedTime() const {
return talk_base::TimeSince(start_time_ms_);
}
talk_base::StreamResult RtpDumpWriter::WritePacket(
const void* data, size_t data_len, uint32 elapsed, bool rtcp) {
- if (!data || 0 == data_len) return talk_base::SR_ERROR;
+ if (!stream_ || !data || 0 == data_len) return talk_base::SR_ERROR;
talk_base::StreamResult res = talk_base::SR_SUCCESS;
// Write the file header if it has not been written yet.
diff --git a/talk/session/phone/rtpdump.h b/talk/session/phone/rtpdump.h
index 66275e6..f87b922 100644
--- a/talk/session/phone/rtpdump.h
+++ b/talk/session/phone/rtpdump.h
@@ -71,9 +71,12 @@
memcpy(&data[0], d, s);
}
- // Check if the dumped packet is a valid RTP packet with the sequence number
- // and timestamp.
bool IsValidRtpPacket() const;
+ // Get the sequence number, timestampe, and SSRC of the RTP packet. Return
+ // true and set the output parameter if successful.
+ bool GetRtpSeqNum(uint16* seq_num) const;
+ bool GetRtpTimestamp(uint32* ts) const;
+ bool GetRtpSsrc(uint32* ssrc) const;
static const size_t kHeaderLength = 8;
uint32 elapsed_time; // Milliseconds since the start of recording.
@@ -121,10 +124,6 @@
virtual talk_base::StreamResult ReadPacket(RtpDumpPacket* packet);
private:
- // Read the sequence number and timestamp from the RTP dump packet.
- static void ReadRtpSeqNumAndTimestamp(const RtpDumpPacket& packet,
- uint16* seq_num, uint32* timestamp);
-
// During the first loop, update the statistics, including packet count, frame
// count, timestamps, and sequence number, of the input stream.
void UpdateStreamStatistics(const RtpDumpPacket& packet);
@@ -164,11 +163,8 @@
class RtpDumpWriter {
public:
- explicit RtpDumpWriter(talk_base::StreamInterface* stream)
- : stream_(stream),
- file_header_written_(false),
- start_time_ms_(0) {
- }
+ explicit RtpDumpWriter(talk_base::StreamInterface* stream);
+
// Write a RTP or RTCP packet. The parameters data points to the packet and
// data_len is its length.
talk_base::StreamResult WriteRtpPacket(const void* data, size_t data_len) {
diff --git a/talk/session/phone/srtpfilter.cc b/talk/session/phone/srtpfilter.cc
index f8d2dd4..71f1991 100644
--- a/talk/session/phone/srtpfilter.cc
+++ b/talk/session/phone/srtpfilter.cc
@@ -25,8 +25,22 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#undef HAVE_CONFIG_H // talk's config.h conflicts with the one included by the
- // libsrtp headers. Don't use it.
+// talk's config.h, generated from mac_config_dot_h for OSX, conflicts with the
+// one included by the libsrtp headers. Don't use it. Instead, we keep HAVE_SRTP
+// and LOGGING defined in config.h.
+#undef HAVE_CONFIG_H
+
+#ifdef OSX
+// TODO: For the XCode build, we force SRTP (b/2500074)
+#ifndef HAVE_SRTP
+#define HAVE_SRTP 1
+#endif // HAVE_SRTP
+// If LOGGING is not defined, define it to 1 (b/3245816)
+#ifndef LOGGING
+#define LOGGING 1
+#endif // HAVE_SRTP
+#endif
+
#include "talk/session/phone/srtpfilter.h"
#include <algorithm>
@@ -35,11 +49,6 @@
#include "talk/base/base64.h"
#include "talk/base/logging.h"
-// TODO: For the XCode build, we force SRTP (b/2500074)
-#if defined(OSX) && !defined(HAVE_SRTP)
-#define HAVE_SRTP 1
-#endif
-
// Enable this line to turn on SRTP debugging
// #define SRTP_DEBUG
@@ -113,6 +122,7 @@
bool SrtpFilter::ProtectRtp(void* p, int in_len, int max_len, int* out_len) {
if (!IsActive()) {
+ LOG(LS_WARNING) << "Failed to ProtectRtp: SRTP not active";
return false;
}
return send_session_.ProtectRtp(p, in_len, max_len, out_len);
@@ -120,6 +130,7 @@
bool SrtpFilter::ProtectRtcp(void* p, int in_len, int max_len, int* out_len) {
if (!IsActive()) {
+ LOG(LS_WARNING) << "Failed to ProtectRtcp: SRTP not active";
return false;
}
return send_session_.ProtectRtcp(p, in_len, max_len, out_len);
@@ -127,6 +138,7 @@
bool SrtpFilter::UnprotectRtp(void* p, int in_len, int* out_len) {
if (!IsActive()) {
+ LOG(LS_WARNING) << "Failed to UnprotectRtp: SRTP not active";
return false;
}
return recv_session_.UnprotectRtp(p, in_len, out_len);
@@ -134,6 +146,7 @@
bool SrtpFilter::UnprotectRtcp(void* p, int in_len, int* out_len) {
if (!IsActive()) {
+ LOG(LS_WARNING) << "Failed to UnprotectRtcp: SRTP not active";
return false;
}
return recv_session_.UnprotectRtcp(p, in_len, out_len);
@@ -190,6 +203,9 @@
if (ret) {
offer_params_.clear();
state_ = ST_ACTIVE;
+ LOG(LS_INFO) << "SRTP activated with negotiated parameters:"
+ << " send cipher_suite " << send_params.cipher_suite
+ << " recv cipher_suite " << recv_params.cipher_suite;
} else {
LOG(LS_WARNING) << "Failed to apply negotiated SRTP parameters";
}
@@ -199,6 +215,7 @@
bool SrtpFilter::ResetParams() {
offer_params_.clear();
state_ = ST_INIT;
+ LOG(LS_INFO) << "SRTP reset to init state";
return true;
}
@@ -252,11 +269,18 @@
}
bool SrtpSession::ProtectRtp(void* p, int in_len, int max_len, int* out_len) {
- if (!session_)
+ if (!session_) {
+ LOG(LS_WARNING) << "Failed to protect SRTP packet: no SRTP Session";
return false;
+ }
+
int need_len = in_len + rtp_auth_tag_len_; // NOLINT
- if (max_len < need_len)
+ if (max_len < need_len) {
+ LOG(LS_WARNING) << "Failed to protect SRTP packet: The buffer length "
+ << max_len << " is less than the needed " << need_len;
return false;
+ }
+
*out_len = in_len;
int err = srtp_protect(session_, p, out_len);
if (err != err_status_ok) {
@@ -267,11 +291,18 @@
}
bool SrtpSession::ProtectRtcp(void* p, int in_len, int max_len, int* out_len) {
- if (!session_)
+ if (!session_) {
+ LOG(LS_WARNING) << "Failed to protect SRTCP packet: no SRTP Session";
return false;
+ }
+
int need_len = in_len + sizeof(uint32) + rtcp_auth_tag_len_; // NOLINT
- if (max_len < need_len)
+ if (max_len < need_len) {
+ LOG(LS_WARNING) << "Failed to protect SRTCP packet: The buffer length "
+ << max_len << " is less than the needed " << need_len;
return false;
+ }
+
*out_len = in_len;
int err = srtp_protect_rtcp(session_, p, out_len);
if (err != err_status_ok) {
@@ -282,8 +313,11 @@
}
bool SrtpSession::UnprotectRtp(void* p, int in_len, int* out_len) {
- if (!session_)
+ if (!session_) {
+ LOG(LS_WARNING) << "Failed to unprotect SRTP packet: no SRTP Session";
return false;
+ }
+
*out_len = in_len;
int err = srtp_unprotect(session_, p, out_len);
if (err != err_status_ok) {
@@ -294,8 +328,11 @@
}
bool SrtpSession::UnprotectRtcp(void* p, int in_len, int* out_len) {
- if (!session_)
+ if (!session_) {
+ LOG(LS_WARNING) << "Failed to unprotect SRTCP packet: no SRTP Session";
return false;
+ }
+
*out_len = in_len;
int err = srtp_unprotect_rtcp(session_, p, out_len);
if (err != err_status_ok) {
@@ -308,6 +345,8 @@
bool SrtpSession::SetKey(int type, const std::string& cs,
const uint8* key, int len) {
if (session_) {
+ LOG(LS_ERROR) << "Failed to create SRTP session: "
+ << "SRTP session already created";
return false;
}
@@ -325,10 +364,13 @@
crypto_policy_set_aes_cm_128_hmac_sha1_32(&policy.rtp); // rtp is 32,
crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy.rtcp); // rtcp still 80
} else {
+ LOG(LS_WARNING) << "Failed to create SRTP session: unsupported"
+ << " cipher_suite " << cs.c_str();
return false;
}
if (!key || len != SRTP_MASTER_KEY_LEN) {
+ LOG(LS_WARNING) << "Failed to create SRTP session: invalid key";
return false;
}
@@ -376,7 +418,23 @@
}
void SrtpSession::HandleEvent(const srtp_event_data_t* ev) {
- // TODO: Do something about events.
+ switch (ev->event) {
+ case event_ssrc_collision:
+ LOG(LS_INFO) << "SRTP event: SSRC collision";
+ break;
+ case event_key_soft_limit:
+ LOG(LS_INFO) << "SRTP event: reached soft key usage limit";
+ break;
+ case event_key_hard_limit:
+ LOG(LS_INFO) << "SRTP event: reached hard key usage limit";
+ break;
+ case event_packet_index_limit:
+ LOG(LS_INFO) << "SRTP event: reached hard packet limit (2^48 packets)";
+ break;
+ default:
+ LOG(LS_INFO) << "SRTP event: unknown " << ev->event;
+ break;
+ }
}
void SrtpSession::HandleEventThunk(srtp_event_data_t* ev) {
diff --git a/talk/session/phone/testdata/video.rtpdump b/talk/session/phone/testdata/video.rtpdump
index 3b0139b..7be863e 100644
--- a/talk/session/phone/testdata/video.rtpdump
+++ b/talk/session/phone/testdata/video.rtpdump
Binary files differ
diff --git a/talk/session/phone/testdata/voice.rtpdump b/talk/session/phone/testdata/voice.rtpdump
index 5920d1d..8f0ec15 100644
--- a/talk/session/phone/testdata/voice.rtpdump
+++ b/talk/session/phone/testdata/voice.rtpdump
Binary files differ
diff --git a/talk/session/phone/videocommon.h b/talk/session/phone/videocommon.h
index 230b1ff..5354dbe 100644
--- a/talk/session/phone/videocommon.h
+++ b/talk/session/phone/videocommon.h
@@ -85,7 +85,7 @@
FOURCC_YUVS = FOURCC('y', 'u', 'v', 's'), // Alias for YUY2
FOURCC_HDYC = FOURCC('H', 'D', 'Y', 'C'), // Alias for UYVY
FOURCC_2VUY = FOURCC('2', 'v', 'u', 'y'), // Alias for UYVY
- FOURCC_RGB1 = FOURCC('R', 'G', 'B', '1'), // Alias for RGBA
+ FOURCC_RGB1 = FOURCC('R', 'G', 'B', '1'), // Alias for ABGR
FOURCC_RGB2 = FOURCC('R', 'G', 'B', '2'), // Alias for BGRA
FOURCC_BA81 = FOURCC('B', 'A', '8', '1'), // Alias for BGGR
diff --git a/talk/site_scons/talk.py b/talk/site_scons/talk.py
index b9e93ef..757a425 100644
--- a/talk/site_scons/talk.py
+++ b/talk/site_scons/talk.py
@@ -185,7 +185,7 @@
def AddMediaLibs(env, **kwargs):
- lmi_libdir = '$GOOGLE3/third_party/lmi/files/merged/lib/'
+ lmi_libdir = '$GOOGLE3/../googleclient/third_party/lmi/files/lib/'
if env.Bit('windows'):
if env.get('COVERAGE_ENABLED'):
lmi_libdir += 'win32/c_only'
@@ -194,20 +194,11 @@
elif env.Bit('mac'):
lmi_libdir += 'macos'
elif env.Bit('linux'):
- lmi_libdir += 'linux/x86'
-
- ipp_libdir = '$GOOGLE3/third_party/Intel_ipp/%s/ia32/lib'
- if env.Bit('windows'):
- ipp_libdir %= 'v_5_2_windows'
- elif env.Bit('mac'):
- ipp_libdir %= 'v_5_3_mac_os_x'
- elif env.Bit('linux'):
- ipp_libdir %= 'v_5_2_linux'
+ lmi_libdir += 'linux/x86'
AddToDict(kwargs, 'libdirs', [
'$MAIN_DIR/third_party/gips/Libraries/',
- ipp_libdir,
lmi_libdir,
])
@@ -220,7 +211,7 @@
elif env.Bit('mac'):
gips_lib = 'VoiceEngine_mac_universal_gcc'
elif env.Bit('linux'):
- gips_lib = 'VoiceEngine_Linux_external_gcc'
+ gips_lib = 'VoiceEngine_Linux_external_gcc'
AddToDict(kwargs, 'libs', [
@@ -253,14 +244,6 @@
'LmiUtils',
'LmiVideoCommon',
'LmiXml',
- 'ippsmerged',
- 'ippsemerged',
- 'ippvcmerged',
- 'ippvcemerged',
- 'ippimerged',
- 'ippiemerged',
- 'ippsrmerged',
- 'ippsremerged',
])
if env.Bit('windows'):
@@ -268,32 +251,21 @@
'dsound',
'd3d9',
'gdi32',
- 'ippcorel',
- 'ippscmerged',
- 'ippscemerged',
'strmiids',
])
- else:
- AddToDict(kwargs, 'libs', [
- 'ippcore',
- 'ippacmerged',
- 'ippacemerged',
- 'ippccmerged',
- 'ippccemerged',
- 'ippchmerged',
- 'ippchemerged',
- 'ippcvmerged',
- 'ippcvemerged',
- 'ippdcmerged',
- 'ippdcemerged',
- 'ippjmerged',
- 'ippjemerged',
- 'ippmmerged',
- 'ippmemerged',
- 'ipprmerged',
- 'ippremerged',
- ])
+ if env.Bit('mac'):
+ AddToDict(kwargs, 'FRAMEWORKS', [
+ 'AudioToolbox',
+ 'AudioUnit',
+ 'Cocoa',
+ 'CoreAudio',
+ 'CoreFoundation',
+ 'IOKit',
+ 'QTKit',
+ 'QuickTime',
+ 'QuartzCore',
+ ])
return kwargs
@@ -387,10 +359,9 @@
# only build 32 bit. For 32 bit debian installer a 32 bit host is required.
# ChromeOS (linux) ebuild don't support 64 bit and requires 32 bit build only
# for now.
-# TODO: Detect ChromeOS chroot board for ChromeOS x64 build.
def Allow64BitCompile(env):
- return (env.Bit('linux') and env.Bit('platform_arch_64bit') and
- not env.Bit('linux_chromeos'))
+ return (env.Bit('linux') and env.Bit('platform_arch_64bit')
+ )
def MergeSettingsFromLibraryDependencies(env, params):
if params.has_key('libs'):
@@ -465,9 +436,13 @@
'libs' : 'LIBS',
'FRAMEWORKS' : 'FRAMEWORKS',
}
- prepends = {
- 'ccflags' : 'CCFLAGS',
- }
+ prepends = {}
+ if env.Bit('windows'):
+ # MSVC compile flags have precedence at the beginning ...
+ prepends['ccflags'] = 'CCFLAGS'
+ else:
+ # ... while GCC compile flags have precedence at the end
+ appends['ccflags'] = 'CCFLAGS'
if GetEntry(params, 'prepend_includedirs'):
prepends['includedirs'] = 'CPPPATH'
else:
diff --git a/talk/third_party/libudev/libudev.h b/talk/third_party/libudev/libudev.h
new file mode 100644
index 0000000..5bc42df
--- /dev/null
+++ b/talk/third_party/libudev/libudev.h
@@ -0,0 +1,175 @@
+/*
+ * libudev - interface to udev device information
+ *
+ * Copyright (C) 2008-2010 Kay Sievers <kay.sievers@vrfy.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ */
+
+#ifndef _LIBUDEV_H_
+#define _LIBUDEV_H_
+
+#include <stdarg.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * udev - library context
+ *
+ * reads the udev config and system environment
+ * allows custom logging
+ */
+struct udev;
+struct udev *udev_ref(struct udev *udev);
+void udev_unref(struct udev *udev);
+struct udev *udev_new(void);
+void udev_set_log_fn(struct udev *udev,
+ void (*log_fn)(struct udev *udev,
+ int priority, const char *file, int line, const char *fn,
+ const char *format, va_list args));
+int udev_get_log_priority(struct udev *udev);
+void udev_set_log_priority(struct udev *udev, int priority);
+const char *udev_get_sys_path(struct udev *udev);
+const char *udev_get_dev_path(struct udev *udev);
+void *udev_get_userdata(struct udev *udev);
+void udev_set_userdata(struct udev *udev, void *userdata);
+
+/*
+ * udev_list
+ *
+ * access to libudev generated lists
+ */
+struct udev_list_entry;
+struct udev_list_entry *udev_list_entry_get_next(struct udev_list_entry *list_entry);
+struct udev_list_entry *udev_list_entry_get_by_name(struct udev_list_entry *list_entry, const char *name);
+const char *udev_list_entry_get_name(struct udev_list_entry *list_entry);
+const char *udev_list_entry_get_value(struct udev_list_entry *list_entry);
+/**
+ * udev_list_entry_foreach:
+ * @list_entry: entry to store the current position
+ * @first_entry: first entry to start with
+ *
+ * Helper to iterate over all entries of a list.
+ */
+#define udev_list_entry_foreach(list_entry, first_entry) \
+ for (list_entry = first_entry; \
+ list_entry != NULL; \
+ list_entry = udev_list_entry_get_next(list_entry))
+
+/*
+ * udev_device
+ *
+ * access to sysfs/kernel devices
+ */
+struct udev_device;
+struct udev_device *udev_device_ref(struct udev_device *udev_device);
+void udev_device_unref(struct udev_device *udev_device);
+struct udev *udev_device_get_udev(struct udev_device *udev_device);
+struct udev_device *udev_device_new_from_syspath(struct udev *udev, const char *syspath);
+struct udev_device *udev_device_new_from_devnum(struct udev *udev, char type, dev_t devnum);
+struct udev_device *udev_device_new_from_subsystem_sysname(struct udev *udev, const char *subsystem, const char *sysname);
+struct udev_device *udev_device_new_from_environment(struct udev *udev);
+/* udev_device_get_parent_*() does not take a reference on the returned device, it is automatically unref'd with the parent */
+struct udev_device *udev_device_get_parent(struct udev_device *udev_device);
+struct udev_device *udev_device_get_parent_with_subsystem_devtype(struct udev_device *udev_device,
+ const char *subsystem, const char *devtype);
+/* retrieve device properties */
+const char *udev_device_get_devpath(struct udev_device *udev_device);
+const char *udev_device_get_subsystem(struct udev_device *udev_device);
+const char *udev_device_get_devtype(struct udev_device *udev_device);
+const char *udev_device_get_syspath(struct udev_device *udev_device);
+const char *udev_device_get_sysname(struct udev_device *udev_device);
+const char *udev_device_get_sysnum(struct udev_device *udev_device);
+const char *udev_device_get_devnode(struct udev_device *udev_device);
+struct udev_list_entry *udev_device_get_devlinks_list_entry(struct udev_device *udev_device);
+struct udev_list_entry *udev_device_get_properties_list_entry(struct udev_device *udev_device);
+struct udev_list_entry *udev_device_get_tags_list_entry(struct udev_device *udev_device);
+const char *udev_device_get_property_value(struct udev_device *udev_device, const char *key);
+const char *udev_device_get_driver(struct udev_device *udev_device);
+dev_t udev_device_get_devnum(struct udev_device *udev_device);
+const char *udev_device_get_action(struct udev_device *udev_device);
+unsigned long long int udev_device_get_seqnum(struct udev_device *udev_device);
+const char *udev_device_get_sysattr_value(struct udev_device *udev_device, const char *sysattr);
+
+/*
+ * udev_monitor
+ *
+ * access to kernel uevents and udev events
+ */
+struct udev_monitor;
+struct udev_monitor *udev_monitor_ref(struct udev_monitor *udev_monitor);
+void udev_monitor_unref(struct udev_monitor *udev_monitor);
+struct udev *udev_monitor_get_udev(struct udev_monitor *udev_monitor);
+/* kernel and udev generated events over netlink */
+struct udev_monitor *udev_monitor_new_from_netlink(struct udev *udev, const char *name);
+/* custom socket (use netlink and filters instead) */
+struct udev_monitor *udev_monitor_new_from_socket(struct udev *udev, const char *socket_path);
+/* bind socket */
+int udev_monitor_enable_receiving(struct udev_monitor *udev_monitor);
+int udev_monitor_set_receive_buffer_size(struct udev_monitor *udev_monitor, int size);
+int udev_monitor_get_fd(struct udev_monitor *udev_monitor);
+struct udev_device *udev_monitor_receive_device(struct udev_monitor *udev_monitor);
+/* in-kernel socket filters to select messages that get delivered to a listener */
+int udev_monitor_filter_add_match_subsystem_devtype(struct udev_monitor *udev_monitor,
+ const char *subsystem, const char *devtype);
+int udev_monitor_filter_add_match_tag(struct udev_monitor *udev_monitor, const char *tag);
+int udev_monitor_filter_update(struct udev_monitor *udev_monitor);
+int udev_monitor_filter_remove(struct udev_monitor *udev_monitor);
+
+/*
+ * udev_enumerate
+ *
+ * search sysfs for specific devices and provide a sorted list
+ */
+struct udev_enumerate;
+struct udev_enumerate *udev_enumerate_ref(struct udev_enumerate *udev_enumerate);
+void udev_enumerate_unref(struct udev_enumerate *udev_enumerate);
+struct udev *udev_enumerate_get_udev(struct udev_enumerate *udev_enumerate);
+struct udev_enumerate *udev_enumerate_new(struct udev *udev);
+/* device properties filter */
+int udev_enumerate_add_match_subsystem(struct udev_enumerate *udev_enumerate, const char *subsystem);
+int udev_enumerate_add_nomatch_subsystem(struct udev_enumerate *udev_enumerate, const char *subsystem);
+int udev_enumerate_add_match_sysattr(struct udev_enumerate *udev_enumerate, const char *sysattr, const char *value);
+int udev_enumerate_add_nomatch_sysattr(struct udev_enumerate *udev_enumerate, const char *sysattr, const char *value);
+int udev_enumerate_add_match_property(struct udev_enumerate *udev_enumerate, const char *property, const char *value);
+int udev_enumerate_add_match_sysname(struct udev_enumerate *udev_enumerate, const char *sysname);
+int udev_enumerate_add_match_tag(struct udev_enumerate *udev_enumerate, const char *tag);
+int udev_enumerate_add_syspath(struct udev_enumerate *udev_enumerate, const char *syspath);
+/* run enumeration with active filters */
+int udev_enumerate_scan_devices(struct udev_enumerate *udev_enumerate);
+int udev_enumerate_scan_subsystems(struct udev_enumerate *udev_enumerate);
+/* return device list */
+struct udev_list_entry *udev_enumerate_get_list_entry(struct udev_enumerate *udev_enumerate);
+
+/*
+ * udev_queue
+ *
+ * access to the currently running udev events
+ */
+struct udev_queue;
+struct udev_queue *udev_queue_ref(struct udev_queue *udev_queue);
+void udev_queue_unref(struct udev_queue *udev_queue);
+struct udev *udev_queue_get_udev(struct udev_queue *udev_queue);
+struct udev_queue *udev_queue_new(struct udev *udev);
+unsigned long long int udev_queue_get_kernel_seqnum(struct udev_queue *udev_queue);
+unsigned long long int udev_queue_get_udev_seqnum(struct udev_queue *udev_queue);
+int udev_queue_get_udev_is_active(struct udev_queue *udev_queue);
+int udev_queue_get_queue_is_empty(struct udev_queue *udev_queue);
+int udev_queue_get_seqnum_is_finished(struct udev_queue *udev_queue, unsigned long long int seqnum);
+int udev_queue_get_seqnum_sequence_is_finished(struct udev_queue *udev_queue,
+ unsigned long long int start, unsigned long long int end);
+struct udev_list_entry *udev_queue_get_queued_list_entry(struct udev_queue *udev_queue);
+struct udev_list_entry *udev_queue_get_failed_list_entry(struct udev_queue *udev_queue);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif
