diff --git a/libuavcan/include/uavcan/internal/transport/transfer_buffer.hpp b/libuavcan/include/uavcan/internal/transport/transfer_buffer.hpp
index 6373089133..2d2ba36a1b 100644
--- a/libuavcan/include/uavcan/internal/transport/transfer_buffer.hpp
+++ b/libuavcan/include/uavcan/internal/transport/transfer_buffer.hpp
@@ -94,7 +94,8 @@ public:
  * reset() call releases all memory blocks.
  * Supports unordered write operations - from higher to lower offsets
  */
-class DynamicTransferBuffer : public TransferBufferManagerEntry, public LinkedListNode<DynamicTransferBuffer>
+class DynamicTransferBufferManagerEntry : public TransferBufferManagerEntry,
+                                          public LinkedListNode<DynamicTransferBufferManagerEntry>
 {
     struct Block : LinkedListNode<Block>
     {
@@ -118,23 +119,23 @@ class DynamicTransferBuffer : public TransferBufferManagerEntry, public LinkedLi
     void resetImpl();
 
 public:
-    DynamicTransferBuffer(IAllocator& allocator, unsigned int max_size)
+    DynamicTransferBufferManagerEntry(IAllocator& allocator, unsigned int max_size)
     : allocator_(allocator)
     , max_write_pos_(0)
     , max_size_(max_size)
     {
         StaticAssert<(Block::SIZE > 8)>::check();
         IsDynamicallyAllocatable<Block>::check();
-        IsDynamicallyAllocatable<DynamicTransferBuffer>::check();
+        IsDynamicallyAllocatable<DynamicTransferBufferManagerEntry>::check();
     }
 
-    ~DynamicTransferBuffer()
+    ~DynamicTransferBufferManagerEntry()
     {
         resetImpl();
     }
 
-    static DynamicTransferBuffer* instantiate(IAllocator& allocator, unsigned int max_size);
-    static void destroy(DynamicTransferBuffer*& obj, IAllocator& allocator);
+    static DynamicTransferBufferManagerEntry* instantiate(IAllocator& allocator, unsigned int max_size);
+    static void destroy(DynamicTransferBufferManagerEntry*& obj, IAllocator& allocator);
 
     int read(unsigned int offset, uint8_t* data, unsigned int len) const;
     int write(unsigned int offset, const uint8_t* data, unsigned int len);
@@ -299,7 +300,7 @@ class TransferBufferManager : public ITransferBufferManager, Noncopyable
     typedef StaticTransferBufferManagerEntry<MAX_BUF_SIZE> StaticBufferType;
 
     StaticBufferType static_buffers_[NUM_STATIC_BUFS];
-    LinkedListRoot<DynamicTransferBuffer> dynamic_buffers_;
+    LinkedListRoot<DynamicTransferBufferManagerEntry> dynamic_buffers_;
     IAllocator& allocator_;
 
     StaticBufferType* findFirstStatic(const TransferBufferManagerKey& key)
@@ -312,9 +313,9 @@ class TransferBufferManager : public ITransferBufferManager, Noncopyable
         return NULL;
     }
 
-    DynamicTransferBuffer* findFirstDynamic(const TransferBufferManagerKey& key)
+    DynamicTransferBufferManagerEntry* findFirstDynamic(const TransferBufferManagerKey& key)
     {
-        DynamicTransferBuffer* dyn = dynamic_buffers_.get();
+        DynamicTransferBufferManagerEntry* dyn = dynamic_buffers_.get();
         while (dyn)
         {
             assert(!dyn->isEmpty());
@@ -332,7 +333,7 @@ class TransferBufferManager : public ITransferBufferManager, Noncopyable
             StaticBufferType* const sb = findFirstStatic(TransferBufferManagerKey());
             if (sb == NULL)
                 break;
-            DynamicTransferBuffer* dyn = dynamic_buffers_.get();
+            DynamicTransferBufferManagerEntry* dyn = dynamic_buffers_.get();
             assert(dyn);
             assert(!dyn->isEmpty());
             if (sb->migrateFrom(dyn))
@@ -341,7 +342,7 @@ class TransferBufferManager : public ITransferBufferManager, Noncopyable
                 UAVCAN_TRACE("TransferBufferManager", "Storage optimization: Migrated %s",
                              dyn->getKey().toString().c_str());
                 dynamic_buffers_.remove(dyn);
-                DynamicTransferBuffer::destroy(dyn, allocator_);
+                DynamicTransferBufferManagerEntry::destroy(dyn, allocator_);
             }
             else
             {
@@ -367,12 +368,12 @@ public:
 
     ~TransferBufferManager()
     {
-        DynamicTransferBuffer* dyn = dynamic_buffers_.get();
+        DynamicTransferBufferManagerEntry* dyn = dynamic_buffers_.get();
         while (dyn)
         {
-            DynamicTransferBuffer* const next = dyn->getNextListNode();
+            DynamicTransferBufferManagerEntry* const next = dyn->getNextListNode();
             dynamic_buffers_.remove(dyn);
-            DynamicTransferBuffer::destroy(dyn, allocator_);
+            DynamicTransferBufferManagerEntry::destroy(dyn, allocator_);
             dyn = next;
         }
     }
@@ -402,7 +403,7 @@ public:
         TransferBufferManagerEntry* tbme = findFirstStatic(TransferBufferManagerKey());
         if (tbme == NULL)
         {
-            DynamicTransferBuffer* dyn = DynamicTransferBuffer::instantiate(allocator_, MAX_BUF_SIZE);
+            DynamicTransferBufferManagerEntry* dyn = DynamicTransferBufferManagerEntry::instantiate(allocator_, MAX_BUF_SIZE);
             tbme = dyn;
             if (dyn == NULL)
                 return NULL;     // Epic fail.
@@ -437,12 +438,12 @@ public:
             return;
         }
 
-        DynamicTransferBuffer* dyn = findFirstDynamic(key);
+        DynamicTransferBufferManagerEntry* dyn = findFirstDynamic(key);
         if (dyn)
         {
             UAVCAN_TRACE("TransferBufferManager", "Dynamic buffer deleted, %s", key.toString().c_str());
             dynamic_buffers_.remove(dyn);
-            DynamicTransferBuffer::destroy(dyn, allocator_);
+            DynamicTransferBufferManagerEntry::destroy(dyn, allocator_);
         }
     }
 
diff --git a/libuavcan/src/transport/transfer_buffer.cpp b/libuavcan/src/transport/transfer_buffer.cpp
index b534ed8a9b..0f3970dc4b 100644
--- a/libuavcan/src/transport/transfer_buffer.cpp
+++ b/libuavcan/src/transport/transfer_buffer.cpp
@@ -23,7 +23,7 @@ std::string TransferBufferManagerKey::toString() const
 /*
  * DynamicTransferBuffer::Block
  */
-DynamicTransferBuffer::Block* DynamicTransferBuffer::Block::instantiate(IAllocator& allocator)
+DynamicTransferBufferManagerEntry::Block* DynamicTransferBufferManagerEntry::Block::instantiate(IAllocator& allocator)
 {
     void* const praw = allocator.allocate(sizeof(Block));
     if (praw == NULL)
@@ -31,7 +31,7 @@ DynamicTransferBuffer::Block* DynamicTransferBuffer::Block::instantiate(IAllocat
     return new (praw) Block;
 }
 
-void DynamicTransferBuffer::Block::destroy(Block*& obj, IAllocator& allocator)
+void DynamicTransferBufferManagerEntry::Block::destroy(Block*& obj, IAllocator& allocator)
 {
     if (obj != NULL)
     {
@@ -41,7 +41,7 @@ void DynamicTransferBuffer::Block::destroy(Block*& obj, IAllocator& allocator)
     }
 }
 
-void DynamicTransferBuffer::Block::read(uint8_t*& outptr, unsigned int target_offset,
+void DynamicTransferBufferManagerEntry::Block::read(uint8_t*& outptr, unsigned int target_offset,
                                         unsigned int& total_offset, unsigned int& left_to_read)
 {
     assert(outptr);
@@ -55,7 +55,7 @@ void DynamicTransferBuffer::Block::read(uint8_t*& outptr, unsigned int target_of
     }
 }
 
-void DynamicTransferBuffer::Block::write(const uint8_t*& inptr, unsigned int target_offset,
+void DynamicTransferBufferManagerEntry::Block::write(const uint8_t*& inptr, unsigned int target_offset,
                                          unsigned int& total_offset, unsigned int& left_to_write)
 {
     assert(inptr);
@@ -72,25 +72,25 @@ void DynamicTransferBuffer::Block::write(const uint8_t*& inptr, unsigned int tar
 /*
  * DynamicTransferBuffer
  */
-DynamicTransferBuffer* DynamicTransferBuffer::instantiate(IAllocator& allocator, unsigned int max_size)
+DynamicTransferBufferManagerEntry* DynamicTransferBufferManagerEntry::instantiate(IAllocator& allocator, unsigned int max_size)
 {
-    void* const praw = allocator.allocate(sizeof(DynamicTransferBuffer));
+    void* const praw = allocator.allocate(sizeof(DynamicTransferBufferManagerEntry));
     if (praw == NULL)
         return NULL;
-    return new (praw) DynamicTransferBuffer(allocator, max_size);
+    return new (praw) DynamicTransferBufferManagerEntry(allocator, max_size);
 }
 
-void DynamicTransferBuffer::destroy(DynamicTransferBuffer*& obj, IAllocator& allocator)
+void DynamicTransferBufferManagerEntry::destroy(DynamicTransferBufferManagerEntry*& obj, IAllocator& allocator)
 {
     if (obj != NULL)
     {
-        obj->~DynamicTransferBuffer();
+        obj->~DynamicTransferBufferManagerEntry();
         allocator.deallocate(obj);
         obj = NULL;
     }
 }
 
-void DynamicTransferBuffer::resetImpl()
+void DynamicTransferBufferManagerEntry::resetImpl()
 {
     max_write_pos_ = 0;
     Block* p = blocks_.get();
@@ -103,7 +103,7 @@ void DynamicTransferBuffer::resetImpl()
     }
 }
 
-int DynamicTransferBuffer::read(unsigned int offset, uint8_t* data, unsigned int len) const
+int DynamicTransferBufferManagerEntry::read(unsigned int offset, uint8_t* data, unsigned int len) const
 {
     if (!data)
     {
@@ -132,7 +132,7 @@ int DynamicTransferBuffer::read(unsigned int offset, uint8_t* data, unsigned int
     return len;
 }
 
-int DynamicTransferBuffer::write(unsigned int offset, const uint8_t* data, unsigned int len)
+int DynamicTransferBufferManagerEntry::write(unsigned int offset, const uint8_t* data, unsigned int len)
 {
     if (!data)
     {
diff --git a/libuavcan/test/transport/transfer_buffer.cpp b/libuavcan/test/transport/transfer_buffer.cpp
index b74a040051..d546423cb2 100644
--- a/libuavcan/test/transport/transfer_buffer.cpp
+++ b/libuavcan/test/transport/transfer_buffer.cpp
@@ -128,9 +128,9 @@ TEST(StaticTransferBuffer, Basic)
 }
 
 
-TEST(DynamicTransferBuffer, Basic)
+TEST(DynamicTransferBufferManagerEntry, Basic)
 {
-    using uavcan::DynamicTransferBuffer;
+    using uavcan::DynamicTransferBufferManagerEntry;
 
     static const int MAX_SIZE = TEST_BUFFER_SIZE;
     static const int POOL_BLOCKS = 8;
@@ -138,7 +138,7 @@ TEST(DynamicTransferBuffer, Basic)
     uavcan::PoolManager<2> poolmgr;
     poolmgr.addPool(&pool);
 
-    DynamicTransferBuffer buf(poolmgr, MAX_SIZE);
+    DynamicTransferBufferManagerEntry buf(poolmgr, MAX_SIZE);
 
     uint8_t local_buffer[TEST_BUFFER_SIZE * 2];
     const uint8_t* const test_data_ptr = reinterpret_cast<const uint8_t*>(TEST_DATA.c_str());
@@ -190,7 +190,7 @@ TEST(DynamicTransferBuffer, Basic)
 
     // Destroying the object; memory should be released
     ASSERT_LT(0, pool.getNumUsedBlocks());
-    buf.~DynamicTransferBuffer();
+    buf.~DynamicTransferBufferManagerEntry();
     ASSERT_EQ(0, pool.getNumUsedBlocks());
 }