Ip4Option.c

Go to the documentation of this file.

 
#include "Ip4Impl.h"
 
BOOLEAN
Ip4OptionIsValid (
  IN UINT8    *Option,
  IN UINT32   OptionLen,
  IN BOOLEAN  Rcvd
  )
{
  UINT32  Cur;
  UINT32  Len;
  UINT32  Point;
 
  Cur = 0;
 
  while (Cur < OptionLen) {
    switch (Option[Cur]) {
      case IP4_OPTION_NOP:
        Cur++;
        break;
 
      case IP4_OPTION_EOP:
        Cur = OptionLen;
        break;
 
      case IP4_OPTION_LSRR:
      case IP4_OPTION_SSRR:
      case IP4_OPTION_RR:
        Len   = Option[Cur + 1];
        Point = Option[Cur + 2];
 
        //
        // SRR/RR options are formatted as |Type|Len|Point|Ip1|Ip2|...
        //
        if ((OptionLen - Cur < Len) || (Len < 3) || ((Len - 3) % 4 != 0)) {
          return FALSE;
        }
 
        if ((Point > Len + 1) || (Point % 4 != 0)) {
          return FALSE;
        }
 
        //
        // The Point must point pass the last entry if the packet is received
        // by us. It must point to 4 if the packet is to be sent by us for
        // source route option.
        //
        if ((Option[Cur] != IP4_OPTION_RR) &&
            ((Rcvd && (Point != Len + 1)) || (!Rcvd && (Point != 4))))
        {
          return FALSE;
        }
 
        Cur += Len;
        break;
 
      default:
        Len = Option[Cur + 1];
 
        if ((OptionLen - Cur < Len) || (Len < 2)) {
          return FALSE;
        }
 
        Cur = Cur + Len;
        break;
    }
  }
 
  return TRUE;
}
 
EFI_STATUS
Ip4CopyOption (
  IN     UINT8    *Option,
  IN     UINT32   OptionLen,
  IN     BOOLEAN  FirstFragment,
  IN OUT UINT8    *Buf            OPTIONAL,
  IN OUT UINT32   *BufLen
  )
{
  UINT8   OptBuf[40];
  UINT32  Cur;
  UINT32  Next;
  UINT8   Type;
  UINT32  Len;
 
  ASSERT ((BufLen != NULL) && (OptionLen <= 40));
 
  Cur  = 0;
  Next = 0;
 
  while (Cur < OptionLen) {
    Type = Option[Cur];
    Len  = Option[Cur + 1];
 
    if (Type == IP4_OPTION_NOP) {
      //
      // Keep the padding, in case that the sender wants to align
      // the option, say, to 4 bytes
      //
      OptBuf[Next] = IP4_OPTION_NOP;
      Next++;
      Cur++;
    } else if (Type == IP4_OPTION_EOP) {
      //
      // Don't append the EOP to avoid including only a EOP option
      //
      break;
    } else {
      //
      // don't copy options that is only valid for the first fragment
      //
      if (FirstFragment || ((Type & IP4_OPTION_COPY_MASK) != 0)) {
        CopyMem (OptBuf + Next, Option + Cur, Len);
        Next += Len;
      }
 
      Cur += Len;
    }
  }
 
  //
  // Don't append an EOP only option.
  //
  if (Next == 0) {
    *BufLen = 0;
    return EFI_SUCCESS;
  }
 
  //
  // Append an EOP if the end of option doesn't coincide with the
  // end of the IP header, that is, isn't aligned to 4 bytes..
  //
  if ((Next % 4) != 0) {
    OptBuf[Next] = IP4_OPTION_EOP;
    Next++;
  }
 
  //
  // Head length is in the unit of 4 bytes. Now, Len is the
  // actual option length to appear in the IP header.
  //
  Len = ((Next + 3) &~0x03);
 
  //
  // If the buffer is too small, set the BufLen then return
  //
  if ((Buf == NULL) || (*BufLen < Len)) {
    *BufLen = Len;
    return EFI_BUFFER_TOO_SMALL;
  }
 
  //
  // Copy the option to the Buf, zero the buffer first to pad
  // the options with NOP to align to 4 bytes.
  //
  ZeroMem (Buf, Len);
  CopyMem (Buf, OptBuf, Next);
  *BufLen = Len;
  return EFI_SUCCESS;
}