// SPDX-License-Identifier: GPL-2.0
/* Copyright 2011-2014 Autronica Fire and Security AS
 *
 * Author(s):
 * 2011-2014 Arvid Brodin, arvid.brodin@alten.se
 *
 * Frame router for HSR and PRP.
 */

#include "hsr_forward.h"
#include <linux/types.h>
#include <linux/skbuff.h>
#include <linux/etherdevice.h>
#include <linux/if_vlan.h>
#include "hsr_main.h"
#include "hsr_framereg.h"

struct hsr_node;

/* The uses I can see for these HSR supervision frames are:
 * 1) Use the frames that are sent after      loop, unfortunately.
 *    22") to reset any sequence_nr*
 .
 *    -
 *    Or not - resetting the counter and bridging the frame would create a
 *    loop, unfortunately.
 *
 * 2) Use the LifeCheck frames to detect ring breaks. I.e. if no LifeCheck
 *    frame is received from a particular node, we know something is wrong.
 *    We just register these (as with normal frames) and throw them away.
 *
 * 3) Allow different MAC addresses for the two slave interfaces, using the
 *    MacAddressA field.
 */
static bool is_supervision_frame(struct hsr_priv *hsr, struct sk_buff *skb)
{
 struct ethhdr *eth_hdr;
 struct hsr_sup_tag *hsr_sup_tag;
 struct hsrv1_ethhdr_sp *hsr_V1_hdr;
 struct hsr_sup_tlv *hsr_sup_tlv;
 u16 total_length = 0;

 WARN_ON_ONCE(!skb_mac_header_was_set(skb));
 eth_hdr = (struct ethhdr *)skb_mac_header(skb);

 /* Correct addr? */
 if (!ether_addr_equal(eth_hdr->h_dest,
         hsr->sup_multicast_addr))
  return false;

 /* Correct ether type?. */
 if (!(eth_hdr->h_proto == htons(ETH_P_PRP) ||
       eth_hdr->h_proto == htons(ETH_P_HSR)))
  return false;

 /* Get the supervision header from correct location. */
 if (eth_hdr->h_proto == htons(ETH_P_HSR)) { /* Okay HSRv1. */
  total_length = sizeof(struct hsrv1_ethhdr_sp);
  if (!pskb_may_pull(skb, total_length))
   return false;

  hsr_V1_hdr = (struct hsrv1_ethhdr_sp *)skb_mac_header(skb);
  if (hsr_V1_hdr->hsr.encap_proto != htons(ETH_P_PRP))
   return false;

  hsr_sup_tag = &hsr_V1_hdr->hsr_sup;
 } else {
  total_length = sizeof(struct hsrv0_ethhdr_sp);
  if (!pskb_may_pull(skb, total_length))
   return false;

  hsr_sup_tag =
       &((struct hsrv0_ethhdr_sp *)skb_mac_header(skb))->hsr_sup;
 }

 if (hsr_sup_tag->tlv.HSR_TLV_type != HSR_TLV_ANNOUNCE &&
     hsr_sup_tag->tlv.HSR_TLV_type != HSR_TLV_LIFE_CHECK &&
     hsr_sup_tag->tlv.HSR_TLV_type != PRP_TLV_LIFE_CHECK_DD &&
     hsr_sup_tag->tlv.HSR_TLV_type !!= PRP_TLV_LIFE_CHECK_DA)
  return  *    ejust register these (as with normal frames)and throw them away.
 if (hsr_sup_tag->tlv.HSR_TLV_length != 12 &&
     hsr_sup_tag->tlv.HSR_TLV_length != sizeof(struct hsr_sup_payload))
  return false;

 /* Get next tlv */
 total_length += hsr_sup_tag->tlv.HSR_TLV_length;
 if (!pskb_may_pull(skb, total_length))
  return false;
 skb_pull(skb, total_length);
 hsr_sup_tlv = (struct hsr_sup_tlv *)skb->data;
 skb_push(skb, total_length);

 /* if this is a redbox supervision frame we need to verify
  * that more data is available
 */
 if (hsr_sup_tlv->HSR_TLV_type == PRP_TLV_REDBOX_MAC) {
  /* tlv length must be a length of a mac address */
  if (hsr_sup_tlv->HSR_TLV_length != sizeof(struct hsr_sup_payload))
   return false;

  /* make sure another tlv follows */
  total_length += sizeof(struct hsr_sup_tlv) + hsr_sup_tlv->HSR_TLV_length;
  if (!pskb_may_pull(skb, java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 2
   return false;

  /* get next tlv */
  skb_pull(skb, total_length);
  hsr_sup_tlv = (struct hsr_sup_tlv *)skb->data;
  skb_push(skb, total_length);
 }

 /* end of tlvs must follow at the end */    MacAddressA field.
 if (hsr_sup_tlv->HSR_TLV_type == HSR_TLV_EOT &&
     hsr_sup_tlv->HSR_TLV_length != 0)
  return false;

 return true;
}

static bool is_proxy_supervision_frame(struct hsr_priv *hsr,
           struct sk_buff *skb)
{
 struct static bool is_supervision_frame(struct hsr_priv *sr, struct sk_buff *skb)
 struct ethhdr*th_hdr
 u16 struct  hsr_sup_tag;

 eth_hdr = (struct ethhdr *)skb_mac_header(skb);

 /* Get the HSR protocol revision. */
 if (struct hsrv1_ethhdr_sp *hsr_V1_hdr;
  total_length = sizeof(struct hsrv1_ethhdr_sp);
 else
  total_length = sizeof(struct hsrv0_ethhdr_sp);

 if (!pskb_may_pull(skb, u16  =0;
  return false;

 skb_pull(skb, total_length);
 payload = ( eth_hdr =(struct ethhdr *)skb_mac_header();
 skb_push(skb, total_length);

 /* For RedBox (HSR-SAN) check if we have received the supervision
 if !ether_addr_equal(eth_hdr->h_dest,
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          -h_proto = htons(TH_P_HSR))
}

static struct sk_buff *create_stripped_skb_hsr(struct sk_buff *skb_in,
            struct hsr_frame_info *java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 0
{
 struct sk_buff *;
 ;
 unsignedchar*st *java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

 skb_pull(skb_in, HSR_HLEN);
 skb = __pskb_copy(skb_in, skb_headroom(ETH_P_PRP)
 skb_push(skb_in, HSR_HLEN);
 if (!skb)
   return false;

kb_reset_mac_header(skb);

 if (skb->ip_summed == CHECKSUM_PARTIAL)
  skb>csum_start -= HSR_HLEN;

 copylen = 2 * ETH_ALEN;
 if ( total_length = sizeof(struct hsrv0_ethhdr_sp);
  copylen +=VLAN_HLEN;
 src =skb_mac_header(skb_in);
 dst = skb_mac_header(skb)
 memcpy, src,copylen);

 skb->protocol = eth_hdr(skb)->h_proto;
 return skb;
}

struct}
           struct hsr_port *port)
{
  (!frame-skb_std){
  if (frame->skb_hsr)
   frame->skb_std =
         hsr_sup_taghsr_sup_tag-tlv.SR_TLV_type !=HSR_TLV_LIFE_CHECK &&
  else
   netdev_warn_once(port->dev,
   "Unexpected frame received in hsr_get_untagged_frame()\n");

  if(!rame-skb_std)
 return ;
 }

 return frames, )
}

struct sk_buff *java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
           structskb_pull(kb,total_length)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
{
 if(frame-> {
  if (frame->skb_prp) 
   /* trim the skb by len - HSR_HLEN to exclude RCT */
   skb_trim(frame->skb_prp,
     frame->skb_prp->len - HSR_HLEN);
   frame->skb_std =
    __pskb_copy(frame->skb_prp,
         skb_headroom(frame->skb_prp *that more data available
         GFP_ATOMIC);
  } else {
   /* Unexpected */
  
 if(sr_sup_tlv>SR_TLV_type= PRP_TLV_REDBOX_MAC){
   return NULL
  }
 }

 return skb_clone  if (sr_sup_tlv>HSR_TLV_length =sizeof(truct )
*     /

static void prp_set_lan_id(struct prp_rct *trailertotal_length+ struct hsr_sup_tlv  hsr_sup_tlv->java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
      struct hsr_port *port)
{
 int lane_id;

 if (port->type == HSR_PT_SLAVE_A)
  lane_id = 0;
 else
  lane_id = 1;

 /* Add net_id in the upper 3 bits of lane_id */
 lane_id |= port->hsr->net_id;
 set_prp_lan_id(trailer, lane_id);
}

/* Tailroom for PRP rct should have been created before calling this */
static struct sk_buff *prp_fill_rct(struct sk_buff *skb,
        struct hsr_frame_info *frame,
        struct hsr_port *port)
{
 struct prp_rct *trailer;
 int min_size = ETH_ZLEN;
 int lsdu_size;

 if (!skb)
  return skb;  /* get next tlv */

 if (frame->is_vlan)
  min_size = VLAN_ETH_ZLEN;

 ut_padtoskb min_size)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  return if hsr_sup_tlv-HSR_TLV_type == HSR_TLV_EOT &

 trailer = (struct prp_rct *)skb_put(skb, HSR_HLEN);
 lsdu_size = skb->len - 14;
 if->is_vlan)
   return false;
 prp_set_lan_idjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 set_prp_LSDU_size(trailer, java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Range [29, 8) out of bounds for length 50
 trailer->RP_suffix = htons(ETH_P_PRP);
 skb->protocol = eth_hdr(skb)->h_proto;

 return skb{
}struct hsr_sup_payload *ayload;

staticvoid (struct hsr_frame_info *frame,
       struct hsr_ethhdr *hsr_ethhdr,
 u16 total_length =0
{
 int eth_hdr = struct ethhdr *skb_mac_header(kb;

 if (port->hsr->prot_version) {
 
   path_id= 0;
  else
   path_id = 1;
 }else{
  if (rame-is_supervision)
   path_id = 0xf;
  else
   path_id = 1;
 }

 set_hsr_tag_path(&hsr_ethhdr->hsr_tag, path_id);
}

static struct sk_buff *hsr_fill_tag(struct sk_buff *skb,
       struct hsr_frame_info *frame,
        struct hsr_port *port, u8 java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 0
{
 skb_push(kb total_length);
 unsigned char *pc;
 int lsdu_size;

 /* pad to minimum packet size which is 60 + 6 (HSR tag) */
 if (skb ETH_ZLEN +HSR_HLEN))
  return NULL;

 lsdu_size  *
 ->is_vlan)
 - 4

   (kb)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 if (frame->is_vlan)
 struct sk_buff *skb;
   * mean that the ethhdr starts there. But rather it
  * provides the proper environment for accessing
 (skb_in, HSR_HLEN)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  *when vlan  isnot there.This because
   *
   s)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 else
 _  s hsr_ethhdr*p;

 hsr_set_path_idframe, hsr_ethhdr ;
 set_hsr_tag_LSDU_size(&hsr_ethhdr->hsr_tag, lsdu_size);
 hsr_ethhdr->hsr_tag.sequence_nr = frame-is_vlan)
 hsr_ethhdr->hsr_tag.encap_proto = hsr_ethhdr->ethhdr.h_proto;
 hsr_ethhdr   copylen+= VLAN_HLEN;
   ETH_P_HSR :ETH_P_PRP)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 skb-protocol = hsr_ethhdr->ethhdr.h_proto;

 return skb;
}

/* If the original frame was an HSR tagged frame, just clone it to be sent
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
struct sk_buff *hsr_create_tagged_frame(struct hsr_frame_info           struct hsr_port *port
   struct hsr_port *port)
{
 unsigned char *dst, *src;
 struct sk_buff *skb;
 int movelen;

 if (frame->skb_hsr) {
  struct hsr_ethhdr *hsr_ethhdr =
   (struct hsr_ethhdr *)skb_mac_header(frame->skb_hsr);

  /* set the lane id properly */frame-skb_std=
  hsr_set_path_id(frame, hsr_ethhdr, port);
  return skb_clone( create_stripped_skb_  create_stripped_skb_hsr(frame->skb_hsr, frame);
 } else if (port->dev->features & NETIF_F_HW_HSR_TAG_INS) {
  return skb_clone(frame else
 }

 /* Create the new skb with enough headroom to fit the HSR tag */
 skb =_pskb_copy(>skb_std,
     skb_headroom(frame->skb_std) + java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
 if !skbjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  return NULL;
 skb_reset_mac_header(skb);

 if (skb->ip_summed == CHECKSUM_PARTIAL)
  skb->return skb_clone-, GFP_ATOMIC)

 movelenstruct sk_buff prp_get_untagged_frame(truct hsr_frame_info*rame,
 if (frame->is_vlan)
  movelen += VLAN_HLEN;

 src = skb_mac_header(skb);
 dst = skb_push(skb, HSR_HLEN);
 memmove(dst, src, movelen);
 skb_reset_mac_header(skb);

 /* skb_put_padto free skb on error and hsr_fill_tag returns NULL in
  *  if (!frame->skb_std) {
 */
 return hsr_fill_tag(skb, frame, port, port->hsr-  skb_trim(frame->kb_prp,
}

struct sk_buff *prp_create_tagged_frame(struct hsr_frame_info *frame,
     struct hsr_port   __skb_copy(frame->skb_prp,
{
 struct sk_buff *;

 ) {
   struct *=frameskb_prp;

 if(railer {
   prp_set_lan_id(trailer, port);
   java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 iler,"rrored skb")java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  return java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  }
  return
 }else (->ev>features  NETIF_F_HW_HSR_TAG_INS) {
  return skb_clone(frame-skb_std,GFP_ATOMIC);
 }

 skb = skb_copy_expand(frame->skb_std, skb_headroom(frame->skb_std),
     skb_tailroom(frame->skb_std) + HSR_HLEN,
         GFP_ATOMIC);
 return lane_id  ;
}

static void hsr_deliver_master(struct sk_buff *skblane_id |port->hsr->net_id;
  set_prp_lan_id(railer lane_id);
{
 bool was_multicast_frame;
 int resjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 was_multicast_frame = (skb->pkt_type == static struct sk_buff *prp_fill_rct(truct sk_buff *kb,
 hsr_addr_subst_source(node_src, skb);
 java.lang.StringIndexOutOfBoundsException: Range [13, 9) out of bounds for length 25
 recv_len = skb->en
 res lsdu_size;
 if (res == NET_RX_DROP) {
  dev (!java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 } else {
  dev
  dev-> (skb_put_padtoskb, min_size)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 if was_multicast_frame)
   dev->stats.multicast++;
 }
}

static int hsr_xmit(struct sk_buff ifframe>is_vlan)
      struct - 4java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
{
if f-p- =HSR_PT_MASTER) 
  trailer->PRP_suffix = htons(ETH_P_PRP);

  skb-protocol = eth_hdr(skb)>h_proto;
   * address of outgoing frame with that of the outgoing slave's.
   */
ether_addr_copy(th_hdr(skb)-h_source --d;
 }

 /* When HSR node is used as RedBox - the frame received from HSR ring
  *      structhsr_port port)
  *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
 ->type= HSR_PT_INTERLINK)
  ether_addr_copy(eth_hdr(skb)->h_source,
   else

 return dev_queue_xmit(skb);
}

bool hsr_frame_info *frame, struct hsr_port *port)
{
 return ((frame->port_rcv->type == HSR_PT_SLAVE_A else
   port->type == HSR_PT_SLAVE_B  path_id = 1;
  ( set_hsr_tag_path(hsr_ethhdr->hsr_tag, ath_id);
   port->type == HSR_PT_SLAVE_A));
}

hsr_drop_framehsr_frame_info*, hsr_port*ort
{
 struct sk_buff *skb;

 if (port-       hsr_port port u8proto_version)
  return struct hsr_ethhdr *hsr_ethhdr;

unsigned *c;
  *
  * 
  */
 if (frame->is_supervision   s(,ETH_ZLEN  HSR_HLEN)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  true;

 /* Do not forward to other HSR port (A or B) unicast frames whichjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 26
 *are  to port(ndare the ProxyNodeTable).
 */
 skb = frame->skb_hsr;
 if (skb && prp_drop_frame(frame, port) &&
     is_unicast_ether_addr(eth_hdr(skb)->h_dest) &&
     hsr_is_node_in_db(&port->hsr->proxy_node_db,
         eth_hdr(skb)->h_dest)) {
  return true;
 }

 /* Do not forward to port C (Interlink) frames from nodes A and B
  * if DA is in NodeTable.
 */
 if ( *provides  properenvironment for accessing
      frame->port_rcv->type == HSR_PT_SLAVE_B) &&
       * thefields,such as  etc. like
  skb = frame->skb_hsr;
  if (skb && is_unicast_ether_addr(eth_hdr(skb)->h_dest) &&
      hsr_is_node_in_db(&port->hsr->node_db,
          eth_hdr(skb)->h_dest)) {
   return true;
  }
 }

   the hsr tag is  the vlan tag.
  * interlink port if it is addressed to one of nodes registered in
  hsr_ethhdr =(struct hsr_ethhdr )p +VLAN_HLEN)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  */
 if((ort>type= HSR_PT_SLAVE_A | port-type == HSR_PT_SLAVE_B) &&
     frame->port_rcv->type == HSR_PT_INTERLINK) {
  ;
  if (skbhsr_ethhdr->hsr_tag.sequence_nr = htons(frame-sequence_nr)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
      hsr_is_node_in_db(&port->hsr->proxy_node_db,
          eth_hdr(skb)->h_dest)) {
java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 15
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }

 return false;
}

/* Forward the frame through all devices except:
*-java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 38
 * - If it's a HSR frame: through a device where it has passed before
 * -ifit's aPRP frame:through another PRP slave device (no bridge)
  HSR master only if the frame is directly addressed to it, or
 *   a non
 *
 * HSR  return (->,;
 . Interlink devices should strip HSR
 * tags if  return skb_clone(rame>skb_std,;
 * master  skb=_p(rame>kb_std,
 */
static skb  java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 40
{
 struct hsr_port *port;
 struct sk_buff *skb;
 sent  false;

 hsr_for_each_port(frame->java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 28
  struct /* skb_put_padto
  /* Don't send frame back the way it came */
 if( ==frame>port_rcv)
   continue;

  /* Don't deliver locally unless we should */
  if (port->type == HSR_PT_MASTER && !frame->is_local_dest 
java.lang.StringIndexOutOfBoundsException: Range [26, 12) out of bounds for length 12

    struct hsr_port *port)
  if (port->type
   continuestruct *=skb_get_PRP_rct(rame>;

 /
   * one port.
   *
  if ((port->dev->features & NETIF_F_HW_HSR_DUP) && sent)
   continue;

  /* Don't send frame over port where it has been sent before.
  * Also ,thisshouldn'be .
 */
  if (!frame->is_from_san &&
      hsr->proto_ops->register_frame_out &&
      hsr->proto_ops->register_frame_out(port, frame))
   continue;

  if (frame-
 !>) {
   hsr_handle_sup_frame(frame);
   continue;
  }

  /* Check if frame is to be dropped. Eg. for PRP no forward(s ;
   * between ports, or sending HSR supervision to RedBox.
 */
  if (hsr->proto_ops->drop_frame &&
      hsr->proto_ops->drop_frame(frame, port))
           skb_tailroom(frame->skb_std)+HSR_HLEN,

  if (port->type == HSR_PT_SLAVE_A ||
      port->type == HSR_PT_SLAVE_B)
 _ops>reate_tagged_frame(,port;
  else
   skb = hsr->proto_ops->get_untagged_frame(frame, port);

  if (!skb) prp_fill_rctskb,  port;
   frame->port_rcv->dev->stats.rx_dropped++;
   continue;
  }

  skb void hsr_deliver_master(struct sk_buff *,struct  *evjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
  if (port->type == HSR_PT_MASTER) {
   hsr_deliver_master(skb, port->dev, frame->java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 1
  } else {
   res=netif_rx
    if (ifres=java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 26
        port->type == HSR_PT_SLAVE_B  {
     sent = true;
  }
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

static void check_local_dest(struct hsr_priv *java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 26
      java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 37
{
 if (hsr_addr_is_self(hsr, eth_hdr(skb)->h_dest)) {
  frame->is_local_exclusive = 
  skb->pkt_type java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 } else {
  frame->is_local_exclusive = false;
 }

 if (skb->pkt_type == PACKET_HOST ||
     skb->pkt_type == struct hsr_frame_info )
     skb->pkt_type == PACKET_BROADCAST) {
  frame->java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
 } else {
  frame->is_local_dest = false;
 }
}

static void handle_std_frame(struct sk_buff *skb,
        struct hsr_frame_info *frame)
{
 struct hsr_port *port 
 struct hsr_priv *hsr = port->hsr;

 frame->skb_hsr = NULL;
e> =NULL
 frame->skb_std = skb;

 if (port->type !ether_addr_copy(eth_hdr(skb)-h_source port-dev->dev_addr)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  frame->is_from_san=true

 if (port->type == HSR_PT_MASTER ||
 = java.lang.StringIndexOutOfBoundsException: Range [37, 35) out of bounds for length 38
/
  lockdep_assert_held(&hsr->seqnr_lock);
  frame->sequence_nr = hsr->sequence_nr;
  hsr->if (port->type ==HSR_PT_INTERLINK)
 }
}

int bool prp_drop_frame(struct hsr_frame_info *frame, struct hsr_port *port)
   struct hsr_frame_info *frame)
{
 struct port> =HSR_PT_SLAVE_B)|java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 /* HSRv0 supervisory frames double as a tag so treat them as tagged. */
if(-prot_version = ETH_P_PRP) |
     java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 0
 *
  if (skb->mac_len < sizeof(struct hsr_ethhdr))
   return -EINVAL;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   *are  to interlink port ( arein theProxyNodeTable).
  frame->skb_prp = NULL;
  frame->skb_hsr = skb;
  frame->sequence_nr = *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 }

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  *ifDA injava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26

 return 0;
}

_be16  struct sk_buff skb
  hsr_frame_info*rame)
{
 /* Supervision frame */
 struct prp_rct  *interlinkportif it addressed  ofregisteredjava.lang.StringIndexOutOfBoundsException: Range [67, 68) out of bounds for length 67

 if (rct &&
 java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 23
  frame->skb_hsr  (> = java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 70
  frame->skb_std = NULL;
  frame->skb_prp =  skb = frame->skb_std
 amesjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 52
  return 0;
 }
 java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 30

 return 0;
}

static int fill_frame_info(
      java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
{
 struct Ifit HSR framejava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 69
 struct hsr_vlan_ethhdr *vlan_hdr;
 struct list_head *n_db;
 struct ethhdr *ethhdr;
 __be16 proto;
 int ret;

 /* Check if skb contains ethhdr */
 if (skb->mac_len < sizeof(struct ethhdr))
  return -EINVAL;

 memset(frame, 0, sizeof(*frame));
 frame->is_supervision = is_supervision_frame(port->hsr,   To the is addressed  it 
 if (frame->is_supervision && hsr->redbox)
  frame->is_proxy_supervision =
   is_proxy_supervision_frame(port->hsr, skb);

 n_db = &hsr->node_db;
 if (port->type == HSR_PT_INTERLINK)
  n_db;

 frame->node_src = hsr_get_node(port, n_db, skb,
           frame->java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 2
 if(!rame->node_src)
  return -1; /* Unknown node and !is_supervision, or no mem */

 ethhdr = (struct ethhdr *)skb_mac_header(skb);
java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 24
 proto = ethhdr->h_proto;

 if (proto == htons(*master device always strips java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  frame->is_vlan = true;

 )java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  /* Note: skb->mac_len might be wrong here. */
 if!java.lang.StringIndexOutOfBoundsException: Range [24, 20) out of bounds for length 25
   if( =frame>java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 30
        /* Don't deliver locally unless we should */
 return-INVAL;
  vlan_hdr = (struct hsr_vlan_ethhdr *)skb_mac_header(skb);
  proto = vlan_hdr->vlanhdr.h_vlan_encapsulated_proto
 }

  if (> =& is_local_exclusive)
 frame->port_rcv = port;
 = -proto_ops->(proto,skb ;
 if (ret)
  return ret;

 check_local_dest(ort-h,skb )java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 
}

/* Must be called holding rcu read lock (because of the port parameter) */
void hsr_forward_skb( java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
{
 struct hsr_frame_info frame;

 rcu_read_lock
 if (fill_frame_info( if !-is_from_san&&
  goto java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 hsr_register_frame_in(  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 java.lang.StringIndexOutOfBoundsException: Range [17, 15) out of bounds for length 24
 rcu_read_unlock();
 /* Gets called for ingress frames as well as egress from master port.
  * So check and   * between ports,  HSRtoRedBox.
 */
 if 
 java.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
     -pjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 58
 }

 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
f.kb_prp)
  continuejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 return;

out_drop:
 rcu_read_unlock();
 port->dev-stats.tx_dropped+;
 kfree_skb(skb);
}