Ip4Icmp.c

Go to the documentation of this file.

 
#include "Ip4Impl.h"
 
IP4_ICMP_CLASS
  mIcmpClass[] = {
  { ICMP_ECHO_REPLY,        ICMP_QUERY_MESSAGE   },
  { 1,                      ICMP_INVALID_MESSAGE },
  { 2,                      ICMP_INVALID_MESSAGE },
  { ICMP_DEST_UNREACHABLE,  ICMP_ERROR_MESSAGE   },
  { ICMP_SOURCE_QUENCH,     ICMP_ERROR_MESSAGE   },
  { ICMP_REDIRECT,          ICMP_ERROR_MESSAGE   },
  { 6,                      ICMP_INVALID_MESSAGE },
  { 7,                      ICMP_INVALID_MESSAGE },
  { ICMP_ECHO_REQUEST,      ICMP_QUERY_MESSAGE   },
  { 9,                      ICMP_INVALID_MESSAGE },
  { 10,                     ICMP_INVALID_MESSAGE },
  { ICMP_TIME_EXCEEDED,     ICMP_ERROR_MESSAGE   },
  { ICMP_PARAMETER_PROBLEM, ICMP_ERROR_MESSAGE   },
  { ICMP_TIMESTAMP,         ICMP_QUERY_MESSAGE   },
  { 14,                     ICMP_INVALID_MESSAGE },
  { ICMP_INFO_REQUEST,      ICMP_QUERY_MESSAGE   },
  { ICMP_INFO_REPLY,        ICMP_QUERY_MESSAGE   },
};
 
EFI_IP4_ICMP_TYPE
  mIp4SupportedIcmp[23] = {
  { ICMP_ECHO_REPLY,        ICMP_DEFAULT_CODE         },
 
  { ICMP_DEST_UNREACHABLE,  ICMP_NET_UNREACHABLE      },
  { ICMP_DEST_UNREACHABLE,  ICMP_HOST_UNREACHABLE     },
  { ICMP_DEST_UNREACHABLE,  ICMP_PROTO_UNREACHABLE    },
  { ICMP_DEST_UNREACHABLE,  ICMP_PORT_UNREACHABLE     },
  { ICMP_DEST_UNREACHABLE,  ICMP_FRAGMENT_FAILED      },
  { ICMP_DEST_UNREACHABLE,  ICMP_SOURCEROUTE_FAILED   },
  { ICMP_DEST_UNREACHABLE,  ICMP_NET_UNKNOWN          },
  { ICMP_DEST_UNREACHABLE,  ICMP_HOST_UNKNOWN         },
  { ICMP_DEST_UNREACHABLE,  ICMP_SOURCE_ISOLATED      },
  { ICMP_DEST_UNREACHABLE,  ICMP_NET_PROHIBITED       },
  { ICMP_DEST_UNREACHABLE,  ICMP_HOST_PROHIBITED      },
  { ICMP_DEST_UNREACHABLE,  ICMP_NET_UNREACHABLE_TOS  },
  { ICMP_DEST_UNREACHABLE,  ICMP_HOST_UNREACHABLE_TOS },
 
  { ICMP_SOURCE_QUENCH,     ICMP_DEFAULT_CODE         },
 
  { ICMP_REDIRECT,          ICMP_NET_REDIRECT         },
  { ICMP_REDIRECT,          ICMP_HOST_REDIRECT        },
  { ICMP_REDIRECT,          ICMP_NET_TOS_REDIRECT     },
  { ICMP_REDIRECT,          ICMP_HOST_TOS_REDIRECT    },
 
  { ICMP_ECHO_REQUEST,      ICMP_DEFAULT_CODE         },
 
  { ICMP_TIME_EXCEEDED,     ICMP_TIMEOUT_IN_TRANSIT   },
  { ICMP_TIME_EXCEEDED,     ICMP_TIMEOUT_REASSEMBLE   },
 
  { ICMP_PARAMETER_PROBLEM, ICMP_DEFAULT_CODE         },
};
 
EFI_STATUS
Ip4ProcessIcmpRedirect (
  IN IP4_SERVICE          *IpSb,
  IN IP4_HEAD             *Head,
  IN NET_BUF              *Packet,
  IN IP4_ICMP_ERROR_HEAD  *Icmp
  )
{
  LIST_ENTRY             *Entry;
  IP4_PROTOCOL           *Ip4Instance;
  IP4_ROUTE_CACHE_ENTRY  *CacheEntry;
  IP4_INTERFACE          *IpIf;
  IP4_ADDR               Gateway;
  IP4_ADDR               Src;
  IP4_ADDR               Dst;
 
  //
  // Find the interface whose IP address is the source of the
  // orgianl IP packet.
  //
  IpIf    = Ip4FindInterface (IpSb, NTOHL (Icmp->IpHead.Src));
  Gateway = NTOHL (Icmp->Fourth);
 
  //
  // discard the packet if the new gateway address it specifies
  // is not on the same connected net through which the Redirect
  // arrived. (RFC1122 3.2.2.2).
  //
  if ((IpIf == NULL) || !IP4_NET_EQUAL (Gateway, IpIf->Ip, IpIf->SubnetMask)) {
    NetbufFree (Packet);
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Update each IP child's route cache on the interface.
  //
  NET_LIST_FOR_EACH (Entry, &IpIf->IpInstances) {
    Ip4Instance = NET_LIST_USER_STRUCT (Entry, IP4_PROTOCOL, AddrLink);
 
    if (Ip4Instance->RouteTable == NULL) {
      continue;
    }
 
    Dst        = NTOHL (Icmp->IpHead.Dst);
    Src        = NTOHL (Icmp->IpHead.Src);
    CacheEntry = Ip4FindRouteCache (Ip4Instance->RouteTable, Dst, Src);
 
    //
    // Only update the route cache's gateway if the source of the
    // Redirect is the current first-hop gateway
    //
    if ((CacheEntry != NULL) && (NTOHL (Head->Src) == CacheEntry->NextHop)) {
      CacheEntry->NextHop = Gateway;
    }
  }
 
  NetbufFree (Packet);
  return EFI_SUCCESS;
}
 
EFI_STATUS
Ip4ProcessIcmpError (
  IN IP4_SERVICE  *IpSb,
  IN IP4_HEAD     *Head,
  IN NET_BUF      *Packet
  )
{
  IP4_ICMP_ERROR_HEAD  Icmp;
 
  if (Packet->TotalSize < sizeof (Icmp)) {
    NetbufFree (Packet);
    return EFI_INVALID_PARAMETER;
  }
 
  NetbufCopy (Packet, 0, sizeof (Icmp), (UINT8 *)&Icmp);
 
  //
  // If it is an ICMP redirect error, update the route cache
  // as RFC1122. Otherwise, demultiplex it to IP instances.
  //
  if (Icmp.Head.Type == ICMP_REDIRECT) {
    return Ip4ProcessIcmpRedirect (IpSb, Head, Packet, &Icmp);
  }
 
  IP4_GET_CLIP_INFO (Packet)->Status = EFI_ICMP_ERROR;
  return Ip4Demultiplex (IpSb, Head, Packet, NULL, 0);
}
 
EFI_STATUS
Ip4IcmpReplyEcho (
  IN IP4_SERVICE  *IpSb,
  IN IP4_HEAD     *Head,
  IN NET_BUF      *Packet
  )
{
  IP4_ICMP_QUERY_HEAD  *Icmp;
  NET_BUF              *Data;
  EFI_STATUS           Status;
  IP4_HEAD             ReplyHead;
 
  //
  // make a copy the packet, it is really a bad idea to
  // send the MNP's buffer back to MNP.
  //
  Data = NetbufDuplicate (Packet, NULL, IP4_MAX_HEADLEN);
 
  if (Data == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto ON_EXIT;
  }
 
  //
  // Change the ICMP type to echo reply, exchange the source
  // and destination, then send it. The source is updated to
  // use specific destination. See RFC1122. SRR/RR option
  // update is omitted.
  //
  Icmp = (IP4_ICMP_QUERY_HEAD *)NetbufGetByte (Data, 0, NULL);
  ASSERT (Icmp != NULL);
  Icmp->Head.Type     = ICMP_ECHO_REPLY;
  Icmp->Head.Checksum = 0;
  Icmp->Head.Checksum = (UINT16)(~NetblockChecksum ((UINT8 *)Icmp, Data->TotalSize));
 
  ReplyHead.Tos      = 0;
  ReplyHead.Fragment = 0;
  ReplyHead.Ttl      = 64;
  ReplyHead.Protocol = EFI_IP_PROTO_ICMP;
  ReplyHead.Src      = 0;
 
  //
  // Ip4Output will select a source for us
  //
  ReplyHead.Dst = Head->Src;
 
  Status = Ip4Output (
             IpSb,
             NULL,
             Data,
             &ReplyHead,
             NULL,
             0,
             IP4_ALLZERO_ADDRESS,
             Ip4SysPacketSent,
             NULL
             );
  if (EFI_ERROR (Status)) {
    NetbufFree (Data);
  }
 
ON_EXIT:
  NetbufFree (Packet);
  return Status;
}
 
EFI_STATUS
Ip4ProcessIcmpQuery (
  IN IP4_SERVICE  *IpSb,
  IN IP4_HEAD     *Head,
  IN NET_BUF      *Packet
  )
{
  IP4_ICMP_QUERY_HEAD  Icmp;
 
  if (Packet->TotalSize < sizeof (Icmp)) {
    NetbufFree (Packet);
    return EFI_INVALID_PARAMETER;
  }
 
  NetbufCopy (Packet, 0, sizeof (Icmp), (UINT8 *)&Icmp);
 
  if (Icmp.Head.Type == ICMP_ECHO_REQUEST) {
    return Ip4IcmpReplyEcho (IpSb, Head, Packet);
  }
 
  return Ip4Demultiplex (IpSb, Head, Packet, NULL, 0);
}
 
EFI_STATUS
Ip4IcmpHandle (
  IN IP4_SERVICE  *IpSb,
  IN IP4_HEAD     *Head,
  IN NET_BUF      *Packet
  )
{
  IP4_ICMP_HEAD  Icmp;
  UINT16         Checksum;
 
  if (Packet->TotalSize < sizeof (Icmp)) {
    goto DROP;
  }
 
  NetbufCopy (Packet, 0, sizeof (Icmp), (UINT8 *)&Icmp);
 
  if (Icmp.Type > ICMP_TYPE_MAX) {
    goto DROP;
  }
 
  Checksum = (UINT16)(~NetbufChecksum (Packet));
  if ((Icmp.Checksum != 0) && (Checksum != 0)) {
    goto DROP;
  }
 
  if (mIcmpClass[Icmp.Type].IcmpClass == ICMP_ERROR_MESSAGE) {
    return Ip4ProcessIcmpError (IpSb, Head, Packet);
  } else if (mIcmpClass[Icmp.Type].IcmpClass == ICMP_QUERY_MESSAGE) {
    return Ip4ProcessIcmpQuery (IpSb, Head, Packet);
  }
 
DROP:
  NetbufFree (Packet);
  return EFI_INVALID_PARAMETER;
}