Line data    Source code

       1             : /*
       2             :  *
       3             :  *    Copyright (c) 2022 Project CHIP Authors
       4             :  *
       5             :  *    Licensed under the Apache License, Version 2.0 (the "License");
       6             :  *    you may not use this file except in compliance with the License.
       7             :  *    You may obtain a copy of the License at
       8             :  *
       9             :  *        http://www.apache.org/licenses/LICENSE-2.0
      10             :  *
      11             :  *    Unless required by applicable law or agreed to in writing, software
      12             :  *    distributed under the License is distributed on an "AS IS" BASIS,
      13             :  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      14             :  *    See the License for the specific language governing permissions and
      15             :  *    limitations under the License.
      16             :  */
      17             : 
      18             : #pragma once
      19             : 
      20             : #include <cstdint>
      21             : 
      22             : #include <lib/dnssd/minimal_mdns/core/QName.h>
      23             : #include <lib/support/CHIPMemString.h>
      24             : #include <lib/support/CHIPPlatformMemory.h>
      25             : #include <lib/support/ScopedBuffer.h>
      26             : 
      27             : namespace mdns {
      28             : namespace Minimal {
      29             : 
      30             : /// Contructs a FullQName from a SerializedNameIterator
      31             : ///
      32             : /// Generally a conversion from an iterator to a `const char *[]`
      33             : /// using heap for underlying storage of the data.
      34             : class HeapQName
      35             : {
      36             : public:
      37             :     HeapQName() {}
      38           0 :     HeapQName(SerializedQNameIterator name)
      39           0 :     {
      40             :         // Storage is:
      41             :         //    - separate pointers into mElementPointers
      42             :         //    - allocated pointers inside that
      43           0 :         mElementCount = 0;
      44             : 
      45           0 :         SerializedQNameIterator it = name;
      46           0 :         while (it.Next())
      47             :         {
      48             :             // Count all elements
      49           0 :             mElementCount++;
      50             :         }
      51             : 
      52           0 :         if (!it.IsValid())
      53             :         {
      54           0 :             return;
      55             :         }
      56             : 
      57           0 :         mElementPointers.Alloc(mElementCount);
      58           0 :         if (!mElementPointers)
      59             :         {
      60           0 :             return;
      61             :         }
      62             :         // ensure all set to null since we may need to free
      63           0 :         for (size_t i = 0; i < mElementCount; i++)
      64             :         {
      65           0 :             mElementPointers[i] = nullptr;
      66             :         }
      67             : 
      68           0 :         it         = name;
      69           0 :         size_t idx = 0;
      70           0 :         while (it.Next())
      71             :         {
      72           0 :             mElementPointers[idx] = chip::Platform::MemoryAllocString(it.Value(), strlen(it.Value()));
      73           0 :             if (!mElementPointers[idx])
      74             :             {
      75           0 :                 return;
      76             :             }
      77           0 :             idx++;
      78             :         }
      79           0 :         mIsOk = true;
      80             :     }
      81             : 
      82           0 :     HeapQName(const HeapQName & other) { *this = other; }
      83             : 
      84           0 :     HeapQName & operator=(const HeapQName & other)
      85             :     {
      86           0 :         Free();
      87             : 
      88           0 :         if (!other)
      89             :         {
      90           0 :             return *this; // No point in copying the other value
      91             :         }
      92             : 
      93           0 :         mElementCount = other.mElementCount;
      94           0 :         mElementPointers.Alloc(other.mElementCount);
      95           0 :         if (!mElementPointers)
      96             :         {
      97           0 :             return *this;
      98             :         }
      99             : 
     100           0 :         for (size_t i = 0; i < mElementCount; i++)
     101             :         {
     102           0 :             mElementPointers[i] = nullptr;
     103             :         }
     104             : 
     105           0 :         for (size_t i = 0; i < mElementCount; i++)
     106             :         {
     107           0 :             const char * other_data = other.mElementPointers[i];
     108           0 :             mElementPointers[i]     = chip::Platform::MemoryAllocString(other_data, strlen(other_data));
     109           0 :             if (!mElementPointers[i])
     110             :             {
     111           0 :                 return *this;
     112             :             }
     113             :         }
     114           0 :         mIsOk = true;
     115           0 :         return *this;
     116             :     }
     117             : 
     118           0 :     ~HeapQName() { Free(); }
     119             : 
     120           0 :     bool IsOk() const { return mIsOk; }
     121             : 
     122           0 :     operator bool() const { return IsOk(); }
     123           0 :     bool operator!() const { return !IsOk(); }
     124             : 
     125             :     /// Returns the contained FullQName.
     126             :     ///
     127             :     /// VALIDITY: since this references data inside `this` it is only valid
     128             :     ///           as long as `this` is valid.
     129           0 :     FullQName Content() const
     130             :     {
     131           0 :         FullQName result;
     132             : 
     133           0 :         result.names     = mElementPointers.Get();
     134           0 :         result.nameCount = mElementCount;
     135             : 
     136           0 :         return result;
     137             :     }
     138             : 
     139             : private:
     140           0 :     void Free()
     141             :     {
     142           0 :         if (!mElementPointers)
     143             :         {
     144           0 :             return;
     145             :         }
     146             : 
     147           0 :         for (size_t i = 0; i < mElementCount; i++)
     148             :         {
     149           0 :             if (mElementPointers[i] != nullptr)
     150             :             {
     151           0 :                 chip::Platform::MemoryFree(mElementPointers[i]);
     152           0 :                 mElementPointers[i] = nullptr;
     153             :             }
     154             :         }
     155           0 :         mElementPointers.Free();
     156           0 :         mElementCount = 0;
     157           0 :         mIsOk         = false;
     158             :     }
     159             : 
     160             :     bool mIsOk           = false;
     161             :     size_t mElementCount = 0;
     162             :     chip::Platform::ScopedMemoryBuffer<char *> mElementPointers;
     163             : };
     164             : 
     165             : } // namespace Minimal
     166             : } // namespace mdns