ARP Packet Parser

_arp.ads

with HAL; use HAL;

package ARP is

   type Packet
      (HLEN, PLEN : Natural)
   is record
      HTYPE : UInt16;
      PTYPE : UInt16;
      OPER  : UInt16;
      SHA   : UInt8_Array (1 .. HLEN);
      SPA   : UInt8_Array (1 .. PLEN);
      THA   : UInt8_Array (1 .. HLEN);
      TPA   : UInt8_Array (1 .. PLEN);
   end record;

   function Parse
      (Data : UInt8_Array)
      return Packet;

end ARP;

arp.adb

with Ada.Unchecked_Conversion;
with System;

package body ARP is

   function Parse
      (Data : UInt8_Array)
      return Packet
   is
      type Header is record
         HTYPE : UInt16;         --  Hardware type
         PTYPE : UInt16;         --  Protocol type
         HLEN  : UInt8;          --  Hardware address length
         PLEN  : UInt8;          --  Protocol address length
         OPER  : UInt16;         --  Operation
      end record
         with Size => 64,
              Bit_Order => System.High_Order_First,
              Scalar_Storage_Order => System.High_Order_First;
      for Header use record
         HTYPE at 0 range 0 .. 15;
         PTYPE at 2 range 0 .. 15;
         HLEN  at 4 range 0 .. 7;
         PLEN  at 5 range 0 .. 7;
         OPER  at 6 range 0 .. 15;
      end record;

      Header_Length : constant Natural := Header'Size / 8;
      subtype Header_Bytes is UInt8_Array (1 .. Header_Length);
      function To_Header is new Ada.Unchecked_Conversion (Header_Bytes, Header);

      First : Natural := Data'First;
      Last  : Natural := First + Header_Length - 1;
      H : constant Header := To_Header (Data (First .. Last));

      function Next
         (Len : UInt8)
         return UInt8_Array
      is
      begin
         First := Last + 1;
         Last := First + Natural (Len) - 1;
         return Data (First .. Last);
      end Next;
   begin
      return Packet'
         (HLEN    => Natural (H.HLEN),
          PLEN    => Natural (H.PLEN),
          HTYPE   => H.HTYPE,
          PTYPE   => H.PTYPE,
          OPER    => H.OPER,
          SHA     => Next (H.HLEN),
          SPA     => Next (H.PLEN),
          THA     => Next (H.HLEN),
          TPA     => Next (H.PLEN));
   end Parse;

end ARP;