device-to-device communication

[gitPlayLee]

Hello, thanks to your project, I have a chance to study about 'Adaptive AUTOSAR'.

What I'm curious about in this project is how two devices can be configured and communicated.

Socket communication has confirmed that communication between the two devices is possible. However, there was no multicast by "Service Discovery" between the two devices.

When I uploaded and tested the project on each of the two devices, I found through "tcpdump" that only locally forwarded messages were received in the "Search for Services" section, which consists of multicast.

Could you tell me how to fix this and communicate between the two devices?

Also, if you look at "SdNetworkLayer," you can see that the Extended Vehicle and Diagnostic Manager has duplicate servers and clients. I wonder why you wrote the structure like this.

The code attached below is the code I wrote to check if communication is possible. Same code except where socket communication is added.
TestApp => Extended Vehicle
TestClient => Diagnostic Manager

// TestApp ( => ExtendedVehicle)
#include "../ara/com/someip/sd/sd_network_layer.h"
#include "./test_app.h"

// ---- server ---- //
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
// ---- server ---- //

namespace application
{
    const std::string TestApp::cAppId{"TestApp"};

    static std::string sevrPort;

    TestApp::TestApp(AsyncBsdSocketLib::Poller *poller) : ara::exec::helper::ModelledProcess(cAppId, poller),
                                            mNetworkLayer{nullptr},
                                            mSdServer{nullptr}
    {
    }

    void TestApp::configureSocket(const arxml::ArxmlReader &reader)
    {
        const arxml::ArxmlNode cSkPortNode{
            reader.GetRootNode({"AUTOSAR",
                                "AR-PACKAGES",
                                "AR-PACKAGE",
                                "ELEMENTS",
                                "ETHERNET-COMMUNICATION-CONNECTOR",
                                "AP-APPLICATION-ENDPOINTS",
                                "TP-CONFIGURATION",
                                "UDP-TP",
                                "UDP-TP-PORT",
                                "PORT-NUMBER"})};

        const auto cSkPort{cSkPortNode.GetValue<uint16_t>()};
        sevrPort = std::to_string(cSkPort);
        std::cout << "\n server sevrPort :" << sevrPort <<"\n" << std::endl;
    }

    void TestApp::configureNetworkLayer(const arxml::ArxmlReader &reader)
    {
        const std::string cNicIpAddress{"127.0.0.1"};

        const arxml::ArxmlNode cSdPortNode{
            reader.GetRootNode({"AUTOSAR",
                                "AR-PACKAGES",
                                "AR-PACKAGE",
                                "ELEMENTS",
                                "PROVIDED-SOMEIP-SERVICE-INSTANCE",
                                "PROVIDED-EVENT-GROUPS",
                                "SOMEIP-PROVIDED-EVENT-GROUP",
                                "EVENT-MULTICAST-UDP-PORT"})};

        const arxml::ArxmlNode cSdIpNode{
            reader.GetRootNode({"AUTOSAR",
                                "AR-PACKAGES",
                                "AR-PACKAGE",
                                "ELEMENTS",
                                "PROVIDED-SOMEIP-SERVICE-INSTANCE",
                                "PROVIDED-EVENT-GROUPS",
                                "SOMEIP-PROVIDED-EVENT-GROUP",
                                "IPV-4-MULTICAST-IP-ADDRESS"})};

        const auto cSdPort{cSdPortNode.GetValue<uint16_t>()};
        const auto cSdIp{cSdIpNode.GetValue<std::string>()};
        mNetworkLayer =
            new ara::com::someip::sd::SdNetworkLayer(
                Poller, cNicIpAddress, cSdIp, cSdPort);
    }

    helper::NetworkConfiguration TestApp::getNetworkConfiguration(
        const arxml::ArxmlReader &reader)
    {
        const std::string cNetworkEndpoint{"ExtendedVehicleEP"};
        const std::string cApplicationEndpoint{"ServerUnicastTcp"};
        const ara::com::option::Layer4ProtocolType cProtocol{
            ara::com::option::Layer4ProtocolType::Tcp};
        
        helper::NetworkConfiguration _result;

        bool _successful{
            helper::TryGetNetworkConfiguration(
                reader, cNetworkEndpoint, cApplicationEndpoint, cProtocol,
                _result)};

        if (_successful)
        {
            return _result;
        }
        else
        {
            throw std::runtime_error("Fetching network configuration failed.");
        }
    }

    void TestApp::configureSdServer(const arxml::ArxmlReader &reader)
    {
        const arxml::ArxmlNode cServiceIdNode{
            reader.GetRootNode({"AUTOSAR",
                                "AR-PACKAGES",
                                "AR-PACKAGE",
                                "ELEMENTS",
                                "PROVIDED-SOMEIP-SERVICE-INSTANCE",
                                "SERVICE-INTERFACE-DEPLOYMENT",
                                "SERVICE-INTERFACE-ID"})};

        const arxml::ArxmlNode cInstanceIdNode{
            reader.GetRootNode({"AUTOSAR",
                                "AR-PACKAGES",
                                "AR-PACKAGE",
                                "ELEMENTS",
                                "PROVIDED-SOMEIP-SERVICE-INSTANCE",
                                "SERVICE-INSTANCE-ID"})};

        const arxml::ArxmlNode cMajorVersionNode{
            reader.GetRootNode({"AUTOSAR",
                                "AR-PACKAGES",
                                "AR-PACKAGE",
                                "ELEMENTS",
                                "PROVIDED-SOMEIP-SERVICE-INSTANCE",
                                "SERVICE-INTERFACE-DEPLOYMENT",
                                "SERVICE-INTERFACE-VERSION",
                                "MAJOR-VERSION"})};

        const arxml::ArxmlNode cMinorVersionNode{
            reader.GetRootNode({"AUTOSAR",
                                "AR-PACKAGES",
                                "AR-PACKAGE",
                                "ELEMENTS",
                                "PROVIDED-SOMEIP-SERVICE-INSTANCE",
                                "SERVICE-INTERFACE-DEPLOYMENT",
                                "SERVICE-INTERFACE-VERSION",
                                "MINOR-VERSION"})};

        const arxml::ArxmlNode cInitialDelayMinNode{
            reader.GetRootNode({"AUTOSAR",
                                "AR-PACKAGES",
                                "AR-PACKAGE",
                                "ELEMENTS",
                                "PROVIDED-SOMEIP-SERVICE-INSTANCE",
                                "SD-SERVER-CONFIG",
                                "INITIAL-OFFER-BEHAVIOR",
                                "INITIAL-DELAY-MIN-VALUE"})};

        const arxml::ArxmlNode cInitialDelayMaxNode{
            reader.GetRootNode({"AUTOSAR",
                                "AR-PACKAGES",
                                "AR-PACKAGE",
                                "ELEMENTS",
                                "PROVIDED-SOMEIP-SERVICE-INSTANCE",
                                "SD-SERVER-CONFIG",
                                "INITIAL-OFFER-BEHAVIOR",
                                "INITIAL-DELAY-MAX-VALUE"})};

        const auto cServiceId{cServiceIdNode.GetValue<uint16_t>()};
        const auto cInstanceId{cInstanceIdNode.GetValue<uint16_t>()};
        const auto cMajorVersion{cMajorVersionNode.GetValue<uint8_t>()};
        const auto cMinorVersion{cMinorVersionNode.GetValue<uint32_t>()};
        const auto cInitialDelayMin{cInitialDelayMinNode.GetValue<int>()};
        const auto cInitialDelayMax{cInitialDelayMaxNode.GetValue<int>()};

        helper::NetworkConfiguration _networkConfiguration{
            getNetworkConfiguration(reader)};

        mSdServer =
            new ara::com::someip::sd::SomeIpSdServer(
                mNetworkLayer,
                cServiceId,
                cInstanceId,
                cMajorVersion,
                cMinorVersion,
                _networkConfiguration.ipAddress,
                _networkConfiguration.portNumber,
                cInitialDelayMin,
                cInitialDelayMax);
    }

    // add
    void error_handling(const char *message)
    {
        fputs(message, stderr);
        fputc('\n', stderr);
    }

    int TestApp::Main(
        const std::atomic_bool *cancellationToken,
        const std::map<std::string, std::string> &arguments)
    {
        const std::string cEvConfigArgument{"evconfig"};
        const std::string cEvConfigFilepath{arguments.at(cEvConfigArgument)};
        const arxml::ArxmlReader cReader(cEvConfigFilepath);

        const std::string cSkConfigArgument{"skconfig"};
        const std::string cSkConfigFilepath{arguments.at(cSkConfigArgument)};
        const arxml::ArxmlReader kReader(cSkConfigFilepath); // socket
        
        ara::log::LogStream _logStream;

        // --------------------- server --------------------- //

        configureSocket(kReader);

        int serv_sock=socket(PF_INET, SOCK_DGRAM, 0); // UDP/IP
        if(serv_sock == -1)
            error_handling("server socket() error");

        struct sockaddr_in serv_addr;
        struct sockaddr_in clnt_addr;
        socklen_t clnt_addr_size;

        char message[30] = "";
        int str_len = 0;
        std::cout << "\n server bind1 :" << sevrPort <<"\n" << std::endl;
        memset(&serv_addr, 0, sizeof(serv_addr));
        serv_addr.sin_family=AF_INET;
        serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
        serv_addr.sin_port=htons(stoi(sevrPort));
        // serv_addr.sin_port=htons(atoi("11111"));

        std::cout << "\n server bind2 :" << sevrPort <<"\n" << std::endl;

        bool binding = false;
        if(bind(serv_sock, (struct sockaddr*) &serv_addr, sizeof(serv_addr))==-1 )
        {
            error_handling("bind() error");
            binding = false;
        }
        else
        {
            binding = true;
        }

        std::cout << "\n server bind \n" << std::endl;

        // --------------------- connect --------------------- //

        // char message[]="Hello World!"; // TCP
        // write(clnt_sock, message, sizeof(message));

        while(1){
            clnt_addr_size = sizeof(clnt_addr);

            str_len = recvfrom(serv_sock, message , 30, 0, (struct sockaddr*)&clnt_addr , &clnt_addr_size);
            
            if (strstr(message, "out"))
			    break;
            else
                std::cout << "\n server receive message:: " << message <<" \n" << std::endl;
        }
        
        // close(clnt_sock);	
        close(serv_sock);
        
        std::cout << "\n server out \n" << std::endl;
        // --------------------- server --------------------- //


        try
        {
            configureNetworkLayer(cReader);
            configureSdServer(cReader);

            _logStream << "TestApp has been initialized.";
            Log(cLogLevel, _logStream);

            bool _running{true};
            mSdServer->Start();

            static bool startpoint = true;

            while (!cancellationToken->load() && _running)
            {
                if(startpoint){
                    _logStream << "\nReady Start!!\n"; // add
                    Log(cLogLevel, _logStream); // add
                    startpoint = false;
                }

                _running = WaitForActivation();
                // mPoller.TryPoll();
            }

            delete mSdServer;
            mSdServer = nullptr;

            _logStream.Flush();
            _logStream << "State management has been terminated.";
            Log(cLogLevel, _logStream);

            return cSuccessfulExitCode;
        }
        catch (const std::runtime_error &ex)
        {
            _logStream.Flush();
            _logStream << ex.what();
            Log(cErrorLevel, _logStream);

            return cUnsuccessfulExitCode;
        }
    }

    TestApp::~TestApp(){
        if (mSdServer)
            delete mSdServer;

        if (mNetworkLayer)
            delete mNetworkLayer;
    }

}

//testClient ( => DiagnosicManager)
#include "../../ara/com/someip/sd/sd_network_layer.h"
#include "./test_client.h"

// ---- client ---- //
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
// ---- client ---- //

namespace application
{
    namespace platform
    {
        const std::string TestClient::cAppId{"TestClient"};

        static std::string sockIpAddress;
        static std::string sockPort;

        TestClient::TestClient(AsyncBsdSocketLib::Poller *poller) : ara::exec::helper::ModelledProcess(cAppId, poller),
                                                mNetworkLayer{nullptr},
                                                mSdClient{nullptr}
        {
        }

        void TestClient::configureSocketClient(const arxml::ArxmlReader &reader)
        {
            const arxml::ArxmlNode cSCAddressNode{
                reader.GetRootNode({"AUTOSAR",
                                    "AR-PACKAGES",
                                    "AR-PACKAGE",
                                    "ELEMENTS",
                                    "ETHERNET-COMMUNICATION-CONNECTOR",
                                    "AP-APPLICATION-ENDPOINTS",
                                    "TP-CONFIGURATION",
                                    "UDP-TP",
                                    "UDP-TP-ADDRESS",
                                    "IPV-4-ADDRESS"})};

            const arxml::ArxmlNode cSCPortNode{
                reader.GetRootNode({"AUTOSAR",
                                    "AR-PACKAGES",
                                    "AR-PACKAGE",
                                    "ELEMENTS",
                                    "ETHERNET-COMMUNICATION-CONNECTOR",
                                    "AP-APPLICATION-ENDPOINTS",
                                    "TP-CONFIGURATION",
                                    "UDP-TP",
                                    "UDP-TP-PORT",
                                    "PORT-NUMBER"})};
            const auto cScIp{cSCAddressNode.GetValue<std::string>()};
            const auto cScPort{cSCPortNode.GetValue<uint16_t>()};
            sockIpAddress = cScIp;
            sockPort = std::to_string(cScPort);
        }

        void TestClient::configureNetworkLayer(const arxml::ArxmlReader &reader)
        {
            const std::string cNicIpAddress{"127.0.0.1"};
            const std::string cNetworkEndpoint{"DiagnosticManagerEP"};
            const std::string cApplicationEndpoint{"MulticastUdp"};
            const ara::com::option::Layer4ProtocolType cProtocol{
                ara::com::option::Layer4ProtocolType::Udp};

            helper::NetworkConfiguration _networkConfiguration;
            bool _successful{
                helper::TryGetNetworkConfiguration(
                    reader, cNetworkEndpoint, cApplicationEndpoint, cProtocol,
                    _networkConfiguration)};
            sockIpAddress = _networkConfiguration.ipAddress;
            if (_successful)
            {
                mNetworkLayer =
                    new ara::com::someip::sd::SdNetworkLayer(
                        Poller, cNicIpAddress,
                        _networkConfiguration.ipAddress,
                        _networkConfiguration.portNumber);
            }
            else
            {
                throw std::runtime_error("Fetching network configuration failed.");
            }
        }

        void TestClient::configureSdClient(const arxml::ArxmlReader &reader)
        {
            const arxml::ArxmlNode cServiceIdNode{
                reader.GetRootNode({"AUTOSAR",
                                    "AR-PACKAGES",
                                    "AR-PACKAGE",
                                    "ELEMENTS",
                                    "REQUIRED-SOMEIP-SERVICE-INSTANCE",
                                    "SERVICE-INTERFACE-DEPLOYMENT",
                                    "SERVICE-INTERFACE-ID"})};

            const arxml::ArxmlNode cInitialDelayMinNode{
                reader.GetRootNode({"AUTOSAR",
                                    "AR-PACKAGES",
                                    "AR-PACKAGE",
                                    "ELEMENTS",
                                    "REQUIRED-SOMEIP-SERVICE-INSTANCE",
                                    "SD-CLIENT-CONFIG",
                                    "INITIAL-FIND-BEHAVIOR",
                                    "INITIAL-DELAY-MIN-VALUE"})};

            const arxml::ArxmlNode cInitialDelayMaxNode{
                reader.GetRootNode({"AUTOSAR",
                                    "AR-PACKAGES",
                                    "AR-PACKAGE",
                                    "ELEMENTS",
                                    "REQUIRED-SOMEIP-SERVICE-INSTANCE",
                                    "SD-CLIENT-CONFIG",
                                    "INITIAL-FIND-BEHAVIOR",
                                    "INITIAL-DELAY-MAX-VALUE"})};

            const auto cServiceId{cServiceIdNode.GetValue<uint16_t>()};
            const auto cInitialDelayMin{cInitialDelayMinNode.GetValue<int>()};
            const auto cInitialDelayMax{cInitialDelayMaxNode.GetValue<int>()};

            mSdClient =
                new ara::com::someip::sd::SomeIpSdClient(
                    mNetworkLayer,
                    cServiceId,
                    cInitialDelayMin,
                    cInitialDelayMax);
        }

        void error_handling(const char *message)
        {
            fputs(message, stderr);
            fputc('\n', stderr);
        }

        int TestClient::Main(
            const std::atomic_bool *cancellationToken,
            const std::map<std::string, std::string> &arguments)
        {
            const std::string cDmConfigArgument{"dmconfig"};
            const std::string cDmConfigFilepath{arguments.at(cDmConfigArgument)};
            const arxml::ArxmlReader cReader(cDmConfigFilepath);

            const std::string cSkConfigArgument{"skconfig"};
            const std::string cSkConfigFilepath{arguments.at(cSkConfigArgument)};
            const arxml::ArxmlReader kReader(cSkConfigFilepath); // socket
            
            ara::log::LogStream _logStream;

            std::cout << "\n client address : " << sockIpAddress << "\n" << std::endl;

            // --------------------- client --------------------- //

            configureSocketClient(kReader);


            int sock=socket(PF_INET, SOCK_DGRAM, 0); // UDP/IP
            if(sock == -1)
                error_handling("client socket() error");

            struct sockaddr_in serv_addr;

            char message[30] = "Hellow World";
            char message2[30] = "out";

            memset(&serv_addr, 0, sizeof(serv_addr));
            serv_addr.sin_family=AF_INET;
            serv_addr.sin_addr.s_addr=inet_addr(sockIpAddress.c_str());
            serv_addr.sin_port=htons(stoi(sockPort));

            std::cout << "\n client connect complete \n" << std::endl;

            // --------------------- connect --------------------- //
            int msgout = 0;
            while(1){
                if(msgout == 5){
                    std::cout << "\n client message out \n" << std::endl;
                    sendto(sock, message2, strlen(message2), 0, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
                    std::this_thread::sleep_for(std::chrono::seconds(3));
                    break;
                }else{
                    std::cout << "\n client message toss \n" << std::endl;
                    sendto(sock, message, strlen(message), 0, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
                    std::this_thread::sleep_for(std::chrono::seconds(3));
                    msgout++;
                }
            }

            close(sock);

            std::cout << "\n client out \n" << std::endl;
            // --------------------- client --------------------- //

            try
            {
                configureNetworkLayer(cReader);
                configureSdClient(cReader);

                std::cout << "\n client address : " << sockIpAddress << "\n" << std::endl;

                _logStream << "TestClient has been initialized.";
                Log(cLogLevel, _logStream);

                bool _running{true};
                mSdClient->Start();

                while (!cancellationToken->load() && _running)
                {
                    _running = WaitForActivation();
                    //mPoller.TryPoll();
                }

                delete mSdClient;
                mSdClient = nullptr;

                _logStream.Flush();
                _logStream << "State management has been terminated.";
                Log(cLogLevel, _logStream);

                return cSuccessfulExitCode;
            }
            catch (const std::runtime_error &ex)
            {
                _logStream.Flush();
                _logStream << ex.what();
                Log(cErrorLevel, _logStream);

                return cUnsuccessfulExitCode;
            }
        }

        TestClient::~TestClient(){
            if (mSdClient)
                delete mSdClient;

            if (mNetworkLayer)
                delete mNetworkLayer;
        }
    }
}

// diagnostic_manager_manifest.arxml
<?xml version="1.0" encoding="UTF-8"?>
<AUTOSAR xmlns="http://autosar.org/schema/r4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://autosar.org/schema/r4.0 autosar_00050.xsd">
    <AR-PACKAGES>
        <AR-PACKAGE>
            <SHORT-NAME>DiagnosticManagerManifest</SHORT-NAME>
            <ELEMENTS>
                <COMMUNICATION-CLUSTER>
                    <ETHERNET-PHYSICAL-CHANNEL>
                        <SHORT-NAME>MutlicastLocalhost</SHORT-NAME>
                        <NETWORK-ENDPOINTS>
                            <NETWORK-ENDPOINT>
                                <SHORT-NAME>DiagnosticManagerEP</SHORT-NAME>
                                <NETWORK-ENDPOINT-ADDRESSES>
                                    <IPV-4-CONFIGURATION>
                                        <IPV-4-ADDRESS>239.0.0.1</IPV-4-ADDRESS>
                                    </IPV-4-CONFIGURATION>
                                </NETWORK-ENDPOINT-ADDRESSES>
                            </NETWORK-ENDPOINT>
                        </NETWORK-ENDPOINTS>
                    </ETHERNET-PHYSICAL-CHANNEL>
                </COMMUNICATION-CLUSTER>
                <ETHERNET-COMMUNICATION-CONNECTOR>
                    <SHORT-NAME>DiagnosticManagerConn</SHORT-NAME>
                    <AP-APPLICATION-ENDPOINTS>
                        <AP-APPLICATION-ENDPOINT>
                            <SHORT-NAME>MulticastUdp</SHORT-NAME>
                            <TP-CONFIGURATION>
                                <UDP-TP>
                                    <UDP-TP-PORT>
                                        <PORT-NUMBER>5555</PORT-NUMBER>
                                    </UDP-TP-PORT>
                                </UDP-TP>
                            </TP-CONFIGURATION>
                        </AP-APPLICATION-ENDPOINT>
                    </AP-APPLICATION-ENDPOINTS>
                </ETHERNET-COMMUNICATION-CONNECTOR>
                <REQUIRED-SOMEIP-SERVICE-INSTANCE>
                    <SERVICE-INTERFACE-DEPLOYMENT>
                        <SERVICE-INTERFACE-ID>5</SERVICE-INTERFACE-ID>
                    </SERVICE-INTERFACE-DEPLOYMENT>
                    <SD-CLIENT-CONFIG>
                        <INITIAL-FIND-BEHAVIOR>
                            <INITIAL-DELAY-MIN-VALUE>100</INITIAL-DELAY-MIN-VALUE>
                            <INITIAL-DELAY-MAX-VALUE>200</INITIAL-DELAY-MAX-VALUE>
                        </INITIAL-FIND-BEHAVIOR>
                    </SD-CLIENT-CONFIG>
                </REQUIRED-SOMEIP-SERVICE-INSTANCE>
            </ELEMENTS>
        </AR-PACKAGE>
    </AR-PACKAGES>
</AUTOSAR>

// extended_vehicle_manifest.arxml
<?xml version="1.0" encoding="UTF-8"?>
<AUTOSAR xmlns="http://autosar.org/schema/r4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://autosar.org/schema/r4.0 autosar_00050.xsd">
    <AR-PACKAGES>
        <AR-PACKAGE>
            <SHORT-NAME>ExtendedVehicleManifest</SHORT-NAME>
            <ELEMENTS>
                <COMMUNICATION-CLUSTER>
                    <ETHERNET-PHYSICAL-CHANNEL>
                        <SHORT-NAME>Localhost</SHORT-NAME>
                        <NETWORK-ENDPOINTS>
                            <NETWORK-ENDPOINT>
                                <SHORT-NAME>ExtendedVehicleEP</SHORT-NAME>
                                <NETWORK-ENDPOINT-ADDRESSES>
                                    <IPV-4-CONFIGURATION>
                                        <IPV-4-ADDRESS>127.0.0.1</IPV-4-ADDRESS>
                                    </IPV-4-CONFIGURATION>
                                </NETWORK-ENDPOINT-ADDRESSES>
                            </NETWORK-ENDPOINT>
                        </NETWORK-ENDPOINTS>
                    </ETHERNET-PHYSICAL-CHANNEL>
                </COMMUNICATION-CLUSTER>
                <ETHERNET-COMMUNICATION-CONNECTOR>
                    <SHORT-NAME>ExtendedVehicleConn</SHORT-NAME>
                    <AP-APPLICATION-ENDPOINTS>
                        <AP-APPLICATION-ENDPOINT>
                            <SHORT-NAME>ServerUnicastTcp</SHORT-NAME>
                            <TP-CONFIGURATION>
                                <TCP-TP>
                                    <TCP-TP-PORT>
                                        <PORT-NUMBER>8081</PORT-NUMBER>
                                    </TCP-TP-PORT>
                                </TCP-TP>
                            </TP-CONFIGURATION>
                        </AP-APPLICATION-ENDPOINT>
                    </AP-APPLICATION-ENDPOINTS>
                </ETHERNET-COMMUNICATION-CONNECTOR>
                <PROVIDED-SOMEIP-SERVICE-INSTANCE>
                    <SERVICE-INTERFACE-DEPLOYMENT>
                        <SERVICE-INTERFACE-ID>5</SERVICE-INTERFACE-ID>
                        <SERVICE-INTERFACE-VERSION>
                            <MAJOR-VERSION>1</MAJOR-VERSION>
                            <MINOR-VERSION>0</MINOR-VERSION>
                        </SERVICE-INTERFACE-VERSION>
                    </SERVICE-INTERFACE-DEPLOYMENT>
                    <PROVIDED-EVENT-GROUPS>
                        <SOMEIP-PROVIDED-EVENT-GROUP>
                            <EVENT-MULTICAST-UDP-PORT>5555</EVENT-MULTICAST-UDP-PORT>
                            <IPV-4-MULTICAST-IP-ADDRESS>239.0.0.1</IPV-4-MULTICAST-IP-ADDRESS>
                        </SOMEIP-PROVIDED-EVENT-GROUP>
                    </PROVIDED-EVENT-GROUPS>
                    <SD-SERVER-CONFIG>
                        <INITIAL-OFFER-BEHAVIOR>
                            <INITIAL-DELAY-MIN-VALUE>100</INITIAL-DELAY-MIN-VALUE>
                            <INITIAL-DELAY-MAX-VALUE>200</INITIAL-DELAY-MAX-VALUE>
                        </INITIAL-OFFER-BEHAVIOR>
                    </SD-SERVER-CONFIG>
                    <SERVICE-INSTANCE-ID>0</SERVICE-INSTANCE-ID>
                </PROVIDED-SOMEIP-SERVICE-INSTANCE>
            </ELEMENTS>
        </AR-PACKAGE>
    </AR-PACKAGES>
</AUTOSAR>

That's about it.
Thank you.

[langroodi]

Hi! Happy to see you dived that deep to the project!

Regarding your question about using the multicast communication for SD, maybe tcpdump did not subscribe to 239.0.0.1 multicast group. Because the SOME/IP SD server offers the service (in this case ExtendedVehicle AA) to 239.0.0.1 group via loopback NIC (127.0.0.1) at 5555 UDP port. The SOME/IP SD client at Diagnostic Manager (DM) side subscribes to the 239.0.0.1 group and waits for the offer. If DM does not receive the offer, it will report Prefailed which is not happening in my test. So, it means the SD is working fine (at least on my setup) over multicast.

Regarding the communication between two devices, I can refer to the same interaction between ExtendedVehicle and DM. After SD, DM parses the offer packet to extract the interaction endpoint (which is 8081 TCP port on 127.0.0.1 in our case). Then the rest of the communication goes through this endpoint and not the SD. So, it means by replacing the 127.0.0.1 with other IP addresses, it is totally possible to interact with an device/application outside the localhost.

Regarding your question about SdNetworkLayer, I would say that was a design choice firstly to utilize the mocking up for unit testing. SdNetworkLayer is the specialization of NetworkLayer to send only SomeIpSdMessages. During the unit test, NetworkLayer behaves as a loopback and by calling the Send, it forwards the messages to the Receiver callback without any real network interaction. That is why SdNetworkLayer has both sending and receiving implementations. However ExtendedVehicle and DM each have their own instance of SdNetworkLayer.
Secondly, during the service discovery, the SD client besides receiving offers, may want to send find messages. So, it needs both sending and receiving functionalities.

Regarding your code, at the first glance I cannot see where sock has been initialized at the client side in the following line:

sendto(sock, message2, strlen(message2), 0, (struct sockaddr*)&serv_addr, sizeof(serv_addr));

You can check this link as an example for UDP communication on Linux.

[gitPlayLee]

Thanks for your reply.
More questions than expected have been answered.

And I have an additional question on the SD(Service Discovery) part.

1. The consumer(e.g. DM) composes a packet for the desired service and delivers it to the multicast group through fineService.
2. The provider(e.g. ExtendedVehicle) analyzes the packet information included in the multicast and checks whether the requested service is the service provided by itself.
3. A provider providing the requested service delivers a packet to the multicast group through offerService.
4. The consumer analyzes the packet information included in the multicast and checks whether the service he requested is correct.
5. If the requested service is correct, the consumer analyzes the provider's packet and obtains the endpoint(TCP/IP address and port) of the provided service. This completes the SD process.
6. After the SD process, the consumer accesses the service through the provider's endpoint.
7. The provider provides the service to the connected consumer.

I am wondering if my understanding is correct.

That's about it.
Thank you.

[langroodi]

Good to hear that the answer covered most of your questions/doubts.
Yes, your understand is correct which is explained in these 7 steps from macro-perspective. Just as a side note, it is good to mention that the first four steps are happened in a context of two finite state machines; one at the server side (provider) and the other at the client side (consumer). For more information, you can visit this link.