Iox #32 Mac OS fully supported

iceoryx_posh/include/iceoryx_posh/iceoryx_posh_types.hpp

@@ -28,11 +28,26 @@ namespace popo
 class SenderPort;
 class ReceiverPort;
 } // namespace popo
+namespace posix
+{
+class UnixDomainSocket;
+class MessageQueue;
+} // namespace posix
 
 using SenderPortType = iox::popo::SenderPort;
 using ReceiverPortType = iox::popo::ReceiverPort;
 
 constexpr char MQ_ROUDI_NAME[] = "/roudi";
+/// @brief The socket is created in the current path if no absolute path is given hence
+///      we need an absolut path so that every application knows where our sockets can
+///      be found.
+#if defined(__APPLE__)
+constexpr char MQ_ROOT_PATH[] = "/tmp";
+using CommunicationType = iox::posix::UnixDomainSocket;
+#else
+constexpr char MQ_ROOT_PATH[] = "";
+using CommunicationType = iox::posix::MessageQueue;
+#endif
 
 /// shared memmory segment for the iceoryx managment data
 constexpr char SHM_NAME[] = "/iceoryx_mgmt";

iceoryx_posh/include/iceoryx_posh/internal/runtime/message_queue_interface.hpp

@@ -17,6 +17,7 @@
 #include "iceoryx_posh/iceoryx_posh_types.hpp"
 #include "iceoryx_posh/internal/runtime/message_queue_message.hpp"
 #include "iceoryx_utils/internal/posix_wrapper/message_queue.hpp"
+#include "iceoryx_utils/internal/posix_wrapper/unix_domain_socket.hpp"
 #include "iceoryx_utils/internal/units/duration.hpp"
 #include "iceoryx_utils/platform/fcntl.hpp"
 #include "iceoryx_utils/platform/mqueue.hpp"
@@ -227,7 +228,7 @@ class MqBase
     long m_maxMessageSize{0};
     long m_maxMessages{0};
     iox::posix::IpcChannelSide m_channelSide{posix::IpcChannelSide::CLIENT};
-    iox::posix::MessageQueue m_mq;
+    CommunicationType m_mq;
 };
 
 /// @brief Class for handling a message queue via mq_open and mq_close.

iceoryx_posh/source/runtime/message_queue_interface.cpp

@@ -160,10 +160,13 @@ bool MqBase::openMessageQueue(const posix::IpcChannelSide channelSide) noexcept
     m_mq.destroy();
 
     m_channelSide = channelSide;
-    posix::MessageQueue::create(
-        m_interfaceName, posix::IpcChannelMode::BLOCKING, m_channelSide, m_maxMessageSize, m_maxMessages)
+    CommunicationType::create(std::string(MQ_ROOT_PATH) + m_interfaceName,
+                              posix::IpcChannelMode::BLOCKING,
+                              m_channelSide,
+                              m_maxMessageSize,
+                              m_maxMessages)
         .on_success(
-            [this](cxx::expected<posix::MessageQueue, posix::IpcChannelError>& mq) { this->m_mq = std::move(*mq); });
+            [this](cxx::expected<CommunicationType, posix::IpcChannelError>& mq) { this->m_mq = std::move(*mq); });
 
     return m_mq.isInitialized();
 }
@@ -190,7 +193,7 @@ bool MqBase::hasClosableMessageQueue() const noexcept
 
 void MqBase::cleanupOutdatedMessageQueue(const std::string& name) noexcept
 {
-    if (posix::MessageQueue::unlinkIfExists(name).get_value_or(false))
+    if (posix::MessageQueue::unlinkIfExists(std::string(MQ_ROOT_PATH) + name).get_value_or(false))
     {
         LogWarn() << "MQ still there, doing an unlink of " << name;
     }
@@ -238,6 +241,7 @@ MqRuntimeInterface::MqRuntimeInterface(const std::string& roudiName,
 
     int64_t transmissionTimestamp{0};
     auto regState = RegState::WAIT_FOR_ROUDI;
+    // regState = RegState::SEND_REGISTER_REQUEST;
     while (!timer.hasExpiredComparedToCreationTime() && regState != RegState::FINISHED)
     {
         if (!m_RoudiMqInterface.isInitialized() || !m_RoudiMqInterface.mqMapsToFile())

iceoryx_posh/test/integrationtests/test_mq_interface_startup_race.cpp

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "iceoryx_posh/iceoryx_posh_types.hpp"
 #include "test.hpp"
 
 #include "iceoryx_posh/internal/runtime/message_queue_interface.hpp"
@@ -33,12 +34,14 @@ using iox::runtime::MqMessage;
 using iox::runtime::MqMessageType;
 using iox::runtime::MqRuntimeInterface;
 
-using MQueue = iox::posix::MessageQueue;
-
-constexpr char MqRouDiName[] = "/roudi";
-constexpr char MqAppName[] = "/racer";
 
+#if defined(__APPLE__)
+constexpr char DeleteRouDiMessageQueue[] = "rm /tmp/roudi";
+#else
 constexpr char DeleteRouDiMessageQueue[] = "rm /dev/mqueue/roudi";
+#endif
+
+constexpr char MqAppName[] = "/racer";
 
 class StringToMessage : public MqBase
 {
@@ -50,7 +53,7 @@ class CMqInterfaceStartupRace_test : public Test
 {
   public:
     CMqInterfaceStartupRace_test()
-        : m_appQueue{MQueue::create()}
+        : m_appQueue{CommunicationType::create()}
     {
     }
 
@@ -93,7 +96,8 @@ class CMqInterfaceStartupRace_test : public Test
 
         if (m_appQueue.has_error())
         {
-            m_appQueue = MQueue::create(MqAppName, IpcChannelMode::BLOCKING, IpcChannelSide::CLIENT);
+            m_appQueue = CommunicationType::create(
+                std::string(MQ_ROOT_PATH) + MqAppName, IpcChannelMode::BLOCKING, IpcChannelSide::CLIENT);
         }
         ASSERT_THAT(m_appQueue.has_error(), false);
 
@@ -102,12 +106,13 @@ class CMqInterfaceStartupRace_test : public Test
 
     /// @note smart_lock in combination with optional is currently not really usable
     std::mutex m_roudiQueueMutex;
-    MQueue::result_t m_roudiQueue{
-        MQueue::create(MqRouDiName, IpcChannelMode::BLOCKING, IpcChannelSide::SERVER)};
+    CommunicationType::result_t m_roudiQueue{CommunicationType::create(
+        std::string(MQ_ROOT_PATH) + MQ_ROUDI_NAME, IpcChannelMode::BLOCKING, IpcChannelSide::SERVER)};
     std::mutex m_appQueueMutex;
-    MQueue::result_t m_appQueue;
+    CommunicationType::result_t m_appQueue;
 };
 
+#if !defined(__APPLE__)
 TEST_F(CMqInterfaceStartupRace_test, ObsoleteRouDiMq)
 {
     /// @note this test checks if the application handles the situation when the roudi mqueue was not properly cleaned
@@ -127,7 +132,8 @@ TEST_F(CMqInterfaceStartupRace_test, ObsoleteRouDiMq)
 
         // simulate the restart of RouDi with the mqueue cleanup
         system(DeleteRouDiMessageQueue);
-        auto m_roudiQueue2 = MQueue::create(MqRouDiName, IpcChannelMode::BLOCKING, IpcChannelSide::SERVER);
+        auto m_roudiQueue2 = CommunicationType::create(
+            std::string(MQ_ROOT_PATH) + MQ_ROUDI_NAME, IpcChannelMode::BLOCKING, IpcChannelSide::SERVER);
 
         // check if the app retries to register at RouDi
         request = m_roudiQueue2->timedReceive(15_s);
@@ -143,7 +149,7 @@ TEST_F(CMqInterfaceStartupRace_test, ObsoleteRouDiMq)
         }
     });
 
-    MqRuntimeInterface dut(MqRouDiName, MqAppName, 35_s);
+    MqRuntimeInterface dut(MQ_ROUDI_NAME, MqAppName, 35_s);
 
     shutdown = true;
     roudi.join();
@@ -169,7 +175,8 @@ TEST_F(CMqInterfaceStartupRace_test, ObsoleteRouDiMqWithFullMq)
 
         // simulate the restart of RouDi with the mqueue cleanup
         system(DeleteRouDiMessageQueue);
-        auto newRoudi = MQueue::create(MqRouDiName, IpcChannelMode::BLOCKING, IpcChannelSide::SERVER);
+        auto newRoudi = CommunicationType::create(
+            std::string(MQ_ROOT_PATH) + MQ_ROUDI_NAME, IpcChannelMode::BLOCKING, IpcChannelSide::SERVER);
 
         // check if the app retries to register at RouDi
         auto request = newRoudi->timedReceive(15_s);
@@ -192,11 +199,12 @@ TEST_F(CMqInterfaceStartupRace_test, ObsoleteRouDiMqWithFullMq)
         }
     });
 
-    MqRuntimeInterface dut(MqRouDiName, MqAppName, 35_s);
+    MqRuntimeInterface dut(MQ_ROUDI_NAME, MqAppName, 35_s);
 
     shutdown = true;
     roudi.join();
 }
+#endif
 
 TEST_F(CMqInterfaceStartupRace_test, ObsoleteRegAck)
 {
@@ -231,7 +239,7 @@ TEST_F(CMqInterfaceStartupRace_test, ObsoleteRegAck)
         }
     });
 
-    MqRuntimeInterface dut(MqRouDiName, MqAppName, 35_s);
+    MqRuntimeInterface dut(MQ_ROUDI_NAME, MqAppName, 35_s);
 
     shutdown = true;
     roudi.join();

iceoryx_posh/test/integrationtests/test_shm_sigbus_handler.cpp

@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.#include "test.hpp"
 
+#if !defined(__APPLE__)
+
 #include "iceoryx_posh/iceoryx_posh_config.hpp"
 #include "iceoryx_posh/internal/roudi/memory/mempool_collection_memory_block.hpp"
 #include "iceoryx_posh/mepoo/mepoo_config.hpp"
@@ -52,3 +54,5 @@ TEST(ShmCreatorDeathTest, AllocatingTooMuchMemoryLeadsToExitWithSIGBUS)
     goodShmProvider.create();
 }
 } // namespace
+
+#endif

iceoryx_posh/test/mocks/chunk_mock.hpp

@@ -32,10 +32,18 @@ class ChunkMock
     {
 #if defined(QNX) || defined(QNX__) || defined(__QNX__)
         m_rawMemory = static_cast<uint8_t*>(memalign(Alignment, Size));
+        m_unalignedMemory = m_rawMemory;
+#elif defined(__APPLE__)
+        uint64_t memOffset = reinterpret_cast<uint64_t>(malloc(Size + Alignment));
+        m_unalignedMemory = reinterpret_cast<uint8_t*>(memOffset);
+        memOffset += memOffset % Alignment;
+        m_rawMemory = reinterpret_cast<uint8_t*>(memOffset);
 #elif defined(_WIN32)
         m_rawMemory = static_cast<uint8_t*>(_aligned_malloc(Alignment, Size));
+        m_unalignedMemory = m_rawMemory;
 #else
         m_rawMemory = static_cast<uint8_t*>(aligned_alloc(Alignment, Size));
+        m_unalignedMemory = m_rawMemory;
 #endif
         assert(m_rawMemory != nullptr && "Could not get aligned memory");
 
@@ -50,9 +58,10 @@ class ChunkMock
         {
             m_chunkHeader->~ChunkHeader();
         }
-        if (m_rawMemory != nullptr)
+        if (m_unalignedMemory != nullptr)
         {
-            free(m_rawMemory);
+            free(m_unalignedMemory);
+            m_unalignedMemory = nullptr;
             m_rawMemory = nullptr;
         }
     }
@@ -78,6 +87,7 @@ class ChunkMock
     uint8_t* m_rawMemory{nullptr};
     iox::mepoo::ChunkHeader* m_chunkHeader = nullptr;
     Topic* m_topic = nullptr;
+    void* m_unalignedMemory{nullptr};
 };
 
 #endif // IOX_POSH_MOCKS_CHUNK_MOCK_HPP

iceoryx_posh/test/mocks/roudi_memory_provider_mock.hpp

@@ -42,6 +42,11 @@ class MemoryProviderTestImpl : public iox::roudi::MemoryProvider
 
 #if defined(QNX) || defined(QNX__) || defined(__QNX__)
         dummyMemory = static_cast<uint8_t*>(memalign(alignment, size));
+#elif defined(__APPLE__)
+        uint64_t memOffset = reinterpret_cast<uint64_t>(malloc(size + alignment));
+        dummyMemory = reinterpret_cast<uint8_t*>(memOffset);
+        memOffset += memOffset % alignment;
+        return iox::cxx::success<void*>(reinterpret_cast<void*>(memOffset));
 #else
         dummyMemory = static_cast<uint8_t*>(aligned_alloc(alignment, size));
 #endif

iceoryx_utils/CMakeLists.txt

@@ -138,7 +138,6 @@ add_library(iceoryx_utils
     source/log/logstream.cpp
     source/log/ac3log_shim/simplelogger.cpp
     source/posix_wrapper/access_control.cpp
-    source/posix_wrapper/argv_inspection.cpp
     source/posix_wrapper/mutex.cpp
     source/posix_wrapper/semaphore.cpp
     source/posix_wrapper/timer.cpp

iceoryx_utils/include/iceoryx_utils/internal/posix_wrapper/argv_inspection.hpp

@@ -44,7 +44,7 @@ class ArgvInspector
 
   private:
     cxx::optional<std::string> m_cmdline;
-};
+} m
 } // namespace posix
 } // namespace iox
 

iceoryx_utils/include/iceoryx_utils/internal/posix_wrapper/ipc_channel.hpp

@@ -36,6 +36,7 @@ enum class IpcChannelError : uint8_t
     OUT_OF_MEMORY,
     INVALID_FILE_DESCRIPTOR,
     I_O_ERROR,
+    CONNECTION_RESET_BY_PEER,
     UNDEFINED
 };
 

iceoryx_utils/include/iceoryx_utils/internal/posix_wrapper/unix_domain_socket.hpp

@@ -32,9 +32,13 @@ namespace posix
 class UnixDomainSocket : public DesignPattern::Creation<UnixDomainSocket, IpcChannelError>
 {
   public:
-    static constexpr size_t MAX_MESSAGE_SIZE = 4096u;
+    /// @brief Max message size is on linux = 4096 and on mac os = 2048. To have
+    ///  the same behavior on every platform we use 2048.
+    static constexpr size_t MAX_MESSAGE_SIZE = 2048u;
     static constexpr size_t SHORTEST_VALID_NAME = 2u;
-    static constexpr size_t LONGEST_VALID_NAME = 100u;
+    /// @brief The name has to contain the full path besides the name and has to
+    ///      be therefore much longer then the message queue pendant.
+    static constexpr size_t LONGEST_VALID_NAME = 1024u;
     static constexpr int32_t ERROR_CODE = -1;
     static constexpr int32_t INVALID_FD = -1;
 
@@ -64,22 +68,22 @@ class UnixDomainSocket : public DesignPattern::Creation<UnixDomainSocket, IpcCha
     /// @brief send a message using std::string.
     /// @param msg to send
     /// @return IpcChannelError if error occured
-    cxx::expected<IpcChannelError> send(const std::string& msg) noexcept;
+    cxx::expected<IpcChannelError> send(const std::string& msg) const noexcept;
 
     /// @brief try to send a message for a given timeout duration using std::string
     /// @param msg to send
     /// @param timout for the send operation
     /// @return IpcChannelError if error occured
-    cxx::expected<IpcChannelError> timedSend(const std::string& msg, const units::Duration& timeout) noexcept;
+    cxx::expected<IpcChannelError> timedSend(const std::string& msg, const units::Duration& timeout) const noexcept;
 
     /// @brief receive message using std::string.
     /// @return received message. In case of an error, IpcChannelError is returned and msg is empty.
-    cxx::expected<std::string, IpcChannelError> receive() noexcept;
+    cxx::expected<std::string, IpcChannelError> receive() const noexcept;
 
     /// @brief try to receive message for a given timeout duration using std::string.
     /// @param timout for the receive operation
     /// @return received message. In case of an error, IpcChannelError is returned and msg is empty.
-    cxx::expected<std::string, IpcChannelError> timedReceive(const units::Duration& timeout) noexcept;
+    cxx::expected<std::string, IpcChannelError> timedReceive(const units::Duration& timeout) const noexcept;
 
     /// @brief checks whether the unix domain socket is outdated
     /// @return true if the unix domain socket is outdated, false otherwise, IpcChannelError if error occured
@@ -105,7 +109,9 @@ class UnixDomainSocket : public DesignPattern::Creation<UnixDomainSocket, IpcCha
 
     /// @brief create an IpcChannelError from the provides error code
     /// @return IpcChannelError if error occured
-    cxx::error<IpcChannelError> createErrorFromErrnum(const int32_t errnum) noexcept;
+    cxx::error<IpcChannelError> createErrorFromErrnum(const int32_t errnum) const noexcept;
+
+    static bool isNameValid(const std::string& name) noexcept;
 
   private:
     std::string m_name;

iceoryx_utils/platform/mac/include/iceoryx_utils/platform/grp.hpp

@@ -27,7 +27,7 @@
 // with the correct argument types and just forward all arguments
 inline int getgrouplist(const char* user, gid_t group, gid_t* groups, int* ngroups)
 {
-    return getgrouplist(user, group, groups, ngroups);
+    return getgrouplist(user, static_cast<int>(group), reinterpret_cast<int*>(groups), ngroups);
 }
 
 #endif // IOX_UTILS_MAC_PLATFORM_GRP_HPP

iceoryx_utils/platform/mac/source/semaphore.cpp

@@ -236,6 +236,11 @@ int iox_sem_unlink(const char* name)
 
 iox_sem_t* iox_sem_open_impl(const char* name, int oflag, ...)
 {
+    if (strlen(name) == 0)
+    {
+        return reinterpret_cast<iox_sem_t*>(SEM_FAILED);
+    }
+
     iox_sem_t* sem = new iox_sem_t;
 
     if (oflag & (O_CREAT | O_EXCL))