Adds support for receiving IPv4 and IPv6 multicast groups

Adds parsing of IGMP and MLD queries.
Sends IGMPv2 and MLDv1 reports on a schedule that is updated based on received IGMP/MLD queries.
Sends unsolicited IGMP and MLD reports on network-up events and on add-membership socket option.
Adds 2 function pointers to the network interface struct that handle adding and removing  multicast MAC addresses.
Adds pxSocket->u.xUDP.xMulticastTTL that can be used for both IPv4 and IPv6
Adds pxSocket->u.xUDP.xMulticastAddress that can be used for both IPv4 and IPv6
Adds socket option defines to add/drop membership as well as change the transmit TTL of multicasts.
Makes all 3 multicast socket options (add/drop/ttl) work with both IPv4 and IPv6
Adds a ucMaximumHops field to NetworkBufferDescriptor_t and assigns it to the proper TTL/HopLimit value based on what packet is being sent.
Adds a NetworkInterface_t * to the socket struct to keep track of which network interface(s) should receive multicasts.
Adds exceptions so that we don't send multicast reports for 224.0.0.1, ff02::1, as well as anything with IPv6 multicast scope of 0 or 1
Adds defines for MLD packets like the Multicast Listener Query and Report
Generates an MLD report for the solicited-node multicast addresses corresponding to all unicast IPv6 addresses
Sends IGMPv2 Leave Group messages whenever the last socket subscribed to a group drops that membership.

Adds ipconfigPERIODIC_MULTICAST_REPORT_INTERVAL for debug purposes when there is no IGMP/MLD querier (+3 squashed commit)

Improves the SAME70 driver to handle adding/removing multicast MAC addresses
Adds a Multicast ToDo list to help keep me on track.

Author: Emil Popov

source/FreeRTOS_DNS_Networking.c

@@ -84,6 +84,11 @@
              * going to be '0' i.e. success. Thus, return value is discarded */
             ( void ) FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_SNDTIMEO, &( uxWriteTimeOut_ticks ), sizeof( TickType_t ) );
             ( void ) FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_RCVTIMEO, &( uxReadTimeOut_ticks ), sizeof( TickType_t ) );
+            #if ( ipconfigSUPPORT_IP_MULTICAST != 0 )
+                /* Since this socket may be used for LLMNR or mDNS, set the multicast TTL to 1. */
+                uint8_t ucMulticastTTL = 1;
+                ( void ) FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_IP_MULTICAST_TTL, &( ucMulticastTTL ), sizeof( ucMulticastTTL ) );
+            #endif
         }
 
         return xSocket;

source/FreeRTOS_DNS_Parser.c

@@ -936,6 +936,26 @@
                     }
 
                     xUDPPacket_IPv6->xUDPHeader.usLength = FreeRTOS_htons( ( uint16_t ) lNetLength + ipSIZE_OF_UDP_HEADER );
+
+                    if( xUDPPacket_IPv6->xUDPHeader.usDestinationPort == FreeRTOS_ntohs( ipMDNS_PORT ) )
+                    {
+                        /* RFC6762, section 11 */
+                        xUDPPacket_IPv6->xIPHeader.ucHopLimit = 255U;
+                    }
+                    else if( xUDPPacket_IPv6->xUDPHeader.usDestinationPort == FreeRTOS_ntohs( ipLLMNR_PORT ) )
+                    {
+                        /* LLMNR: RFC4795 section 2.5 recommends UDP requests and responses use TTL of 255 */
+
+                        /* Theoretically, LLMNR replies can go "off-link" and create a DDoS scenario. That should be preventable
+                         * by settings our rely's TTL/HopLimit to 1. Please note that in certain situations ( I think unicast
+                         * responses), Wireshark flags some LLMNR packets that have TTL of 1 as too low. */
+                        xUDPPacket_IPv6->xIPHeader.ucHopLimit = 1U;
+                    }
+                    else
+                    {
+                        xUDPPacket_IPv6->xIPHeader.ucHopLimit = ipconfigUDP_TIME_TO_LIVE;
+                    }
+
                     vFlip_16( pxUDPHeader->usSourcePort, pxUDPHeader->usDestinationPort );
                     uxDataLength = ( size_t ) lNetLength + ipSIZE_OF_IPv6_HEADER + ipSIZE_OF_UDP_HEADER + ipSIZE_OF_ETH_HEADER;
                 }
@@ -951,8 +971,18 @@
                 /* HT:endian: should not be translated, copying from packet to packet */
                 if( pxIPHeader->ulDestinationIPAddress == ipMDNS_IP_ADDRESS )
                 {
+                    /* RFC6762, section 11 */
                     pxIPHeader->ucTimeToLive = ipMDNS_TIME_TO_LIVE;
                 }
+                else if( pxUDPHeader->usDestinationPort == FreeRTOS_ntohs( ipLLMNR_PORT ) )
+                {
+                    /* LLMNR: RFC4795 section 2.5 recommends UDP requests and responses use TTL of 255 */
+
+                    /* Theoretically, LLMNR replies can go "off-link" and create a DDoS scenario. That should be preventable
+                     * by settings our rely's TTL/HopLimit to 1. Please note that in certain situations ( I think unicast
+                     * responses), Wireshark flags some LLMNR packets that have TTL of 1 as too low. */
+                    pxIPHeader->ucTimeToLive = 1;
+                }
                 else
                 {
                     pxIPHeader->ulDestinationIPAddress = pxIPHeader->ulSourceIPAddress;

source/FreeRTOS_IP.c

@@ -59,6 +59,9 @@
 #include "FreeRTOS_DNS.h"
 #include "FreeRTOS_Routing.h"
 #include "FreeRTOS_ND.h"
+#if ( ipconfigSUPPORT_IP_MULTICAST != 0 )
+    #include "FreeRTOS_IGMP.h"
+#endif
 
 /** @brief Time delay between repeated attempts to initialise the network hardware. */
 #ifndef ipINITIALISATION_RETRY_DELAY
@@ -467,6 +470,20 @@ static void prvProcessIPEventsAndTimers( void )
             /* xQueueReceive() returned because of a normal time-out. */
             break;
 
+            #if ( ipconfigSUPPORT_IP_MULTICAST != 0 )
+                case eSocketOptAddMembership:
+                case eSocketOptDropMembership:
+                   {
+                       MulticastAction_t * pxMCA = ( MulticastAction_t * ) xReceivedEvent.pvData;
+                       vModifyMulticastMembership( pxMCA, xReceivedEvent.eEventType );
+                       break;
+                   }
+
+                case eMulticastTimerEvent:
+                    vIPMulticast_HandleTimerEvent();
+                    break;
+            #endif /* ( ipconfigSUPPORT_IP_MULTICAST != 0) */
+
         default:
             /* Should not get here. */
             break;
@@ -526,6 +543,11 @@ static void prvIPTask_Initialise( void )
     }
     #endif /* ( ( ipconfigUSE_DNS_CACHE != 0 ) && ( ipconfigUSE_DNS != 0 ) ) */
 
+    /* Init the list that will hold scheduled IGMP reports. */
+    #if ( ipconfigSUPPORT_IP_MULTICAST != 0 )
+        ( void ) vIPMulticast_Init();
+    #endif
+
     /* Initialisation is complete and events can now be processed. */
     xIPTaskInitialised = pdTRUE;
 }
@@ -631,8 +653,76 @@ TaskHandle_t FreeRTOS_GetIPTaskHandle( void )
  */
 void vIPNetworkUpCalls( struct xNetworkEndPoint * pxEndPoint )
 {
+    #if ( ipconfigSUPPORT_IP_MULTICAST != 0 )
+        MCastReportData_t * pxMRD;
+        IPv6_Type_t xAddressType;
+        MACAddress_t xMACAddress;
+    #endif /* ( ipconfigSUPPORT_IP_MULTICAST != 0 ) */
+
     pxEndPoint->bits.bEndPointUp = pdTRUE_UNSIGNED;
 
+    #if ( ipconfigSUPPORT_IP_MULTICAST != 0 )
+        if( pxEndPoint->bits.bIPv6 == pdTRUE_UNSIGNED )
+        {
+            /* Now that the network is up, pxEndPoint->ipv6_settings should hold the actual address of this
+             * end-point. For unicast addresses, generate the solicited-node multicast address that corresponds
+             * to the address and generate an MLD report for it.
+             * ToDo: Figure out what the proper place is to remove multicast addresses that are no longer valid. For
+             * example when a DHCPv6 lease expires. */
+            xAddressType = xIPv6_GetIPType( &( pxEndPoint->ipv6_settings.xIPAddress ) );
+
+            if( ( xAddressType == eIPv6_LinkLocal ) || ( xAddressType == eIPv6_SiteLocal ) || ( xAddressType == eIPv6_Global ) )
+            {
+                if( NULL != ( pxMRD = ( MCastReportData_t * ) pvPortMalloc( sizeof( MCastReportData_t ) ) ) )
+                {
+                    listSET_LIST_ITEM_OWNER( &( pxMRD->xListItem ), ( void * ) pxMRD );
+                    pxMRD->pxInterface = pxEndPoint->pxNetworkInterface;
+                    pxMRD->xMCastGroupAddress.xIs_IPv6 = pdTRUE_UNSIGNED;
+
+                    /* Generate the solicited-node multicast address in the form of
+                     * ff02::1:ffnn:nnnn, where nn:nnnn are the last 3 bytes of the IPv6 address. */
+                    pxMRD->xMCastGroupAddress.xIPAddress.xIP_IPv6.ucBytes[ 0 ] = 0xFFU;
+                    pxMRD->xMCastGroupAddress.xIPAddress.xIP_IPv6.ucBytes[ 1 ] = 0x02U;
+                    ( void ) memset( &pxMRD->xMCastGroupAddress.xIPAddress.xIP_IPv6.ucBytes[ 2 ], 0x00, 9 );
+                    pxMRD->xMCastGroupAddress.xIPAddress.xIP_IPv6.ucBytes[ 11 ] = 0x01U;
+                    pxMRD->xMCastGroupAddress.xIPAddress.xIP_IPv6.ucBytes[ 12 ] = 0xFFU;
+                    ( void ) memcpy( &pxMRD->xMCastGroupAddress.xIPAddress.xIP_IPv6.ucBytes[ 13 ], &pxEndPoint->ipv6_settings.xIPAddress.ucBytes[ 13 ], 3 );
+
+                    if( pdTRUE != xAddMulticastReportToList( pxMRD ) )
+                    {
+                        vPortFree( pxMRD );
+                        pxMRD = NULL;
+                    }
+                    else
+                    {
+                        /* The report was consumed, therefore it was added to the list. Tell the network
+                         * driver to begin receiving the associated MAC address */
+                        if( pxEndPoint->pxNetworkInterface && ( pxEndPoint->pxNetworkInterface->pfAddMulticastMAC != NULL ) )
+                        {
+                            xMACAddress.ucBytes[ 0 ] = 0x33;
+                            xMACAddress.ucBytes[ 1 ] = 0x33;
+                            xMACAddress.ucBytes[ 2 ] = 0xFF;
+                            xMACAddress.ucBytes[ 3 ] = pxEndPoint->ipv6_settings.xIPAddress.ucBytes[ 13 ];
+                            xMACAddress.ucBytes[ 4 ] = pxEndPoint->ipv6_settings.xIPAddress.ucBytes[ 14 ];
+                            xMACAddress.ucBytes[ 5 ] = pxEndPoint->ipv6_settings.xIPAddress.ucBytes[ 15 ];
+                            pxEndPoint->pxNetworkInterface->pfAddMulticastMAC( xMACAddress.ucBytes );
+                        }
+                    }
+                }
+            }
+        } /* if( pxEndPoint->bits.bIPv6 == pdTRUE_UNSIGNED ) */
+
+        /* Reschedule all multicast reports associated with this end-point.
+         * /* Note: countdown is in increments of ipIGMP_TIMER_PERIOD_MS. It's a good idea to spread out all reports a little.
+         * 200 to 500ms ( xMaxCountdown of 2 - 5 ) should be a good happy medium. If the network we just connected to has a IGMP/MLD querier,
+         * they will soon ask us for reports anyways, so sending these unsolicited reports is not required. It simply enhances the user
+         * experience by shortening the time it takes before we begin receiving the multicasts that we care for. */
+        /* _EP_: vRescheduleAllMulticastReports() is NOT declared in header files because I don't want to expose it to the user */
+        extern void vRescheduleAllMulticastReports( NetworkInterface_t * pxInterface,
+                                                    BaseType_t xMaxCountdown );
+        vRescheduleAllMulticastReports( pxEndPoint->pxNetworkInterface, 5 );
+    #endif /* ( ipconfigSUPPORT_IP_MULTICAST != 0 ) */
+
     #if ( ipconfigUSE_NETWORK_EVENT_HOOK == 1 )
     #if ( ipconfigIPv4_BACKWARD_COMPATIBLE == 1 )
         {
@@ -1310,6 +1400,7 @@ void FreeRTOS_SetEndPointConfiguration( const uint32_t * pulIPAddress,
                 pxNetworkBuffer->pucEthernetBuffer[ ipSOCKET_OPTIONS_OFFSET ] = FREERTOS_SO_UDPCKSUM_OUT;
                 pxNetworkBuffer->xIPAddress.ulIP_IPv4 = ulIPAddress;
                 pxNetworkBuffer->usPort = ipPACKET_CONTAINS_ICMP_DATA;
+                pxNetworkBuffer->ucMaximumHops = ipconfigICMP_TIME_TO_LIVE;
                 /* xDataLength is the size of the total packet, including the Ethernet header. */
                 pxNetworkBuffer->xDataLength = uxTotalLength;
 
@@ -1976,6 +2067,13 @@ static eFrameProcessingResult_t prvProcessIPPacket( const IPPacket_t * pxIPPacke
                             break;
                     #endif /* ( ipconfigUSE_IPv6 != 0 ) */
 
+                    #if ( ipconfigSUPPORT_IP_MULTICAST != 0 )
+                        case ipPROTOCOL_IGMP:
+                            /* The IP packet contained an IGMP frame.  */
+                            eReturn = eProcessIGMPPacket( pxNetworkBuffer );
+                            break;
+                    #endif /* ( ipconfigSUPPORT_IP_MULTICAST != 0 ) */
+
                     case ipPROTOCOL_UDP:
                         /* The IP packet contained a UDP frame. */