ans.c

COPE the first practical network coding scheme which is developped on click

#ifdef IANS_BASE_VLAN_TAGGING
    /* check to see if this is a qtag packet */
    Frame_is_tagged = bd_ans_IsQtagPacket(bps, iANSdata, rxd, peth_vlan_header);
        
    /* get the tag */
    tag = bd_ans_GetVlanId(bps, iANSdata, rxd, peth_vlan_header);
    
    switch (iANSdata->tag_mode)
    {
    case IANS_BD_TAGGING_NONE:
	/* the rules are as follows for this situation:
	 * vlan tagged - drop
	 * priority tagged - strip, and send w/o OOB
	 * untagged - receive and send w/o OOB
	 *
	 * because we are required to send attributed packets,
	 * we will fill out just the last attribute and sent up
	 * if we accept the packet.  No untagged or vlan attribute
	 */
	DEBUGLOG("bd_ans_Receive: Tagging mode NONE\n");
	if (Frame_is_tagged) {
	    if (tag) {
		DEBUGLOG("bd_ans_Receive: Invalid VLAN packet\n");
		return BD_ANS_FAILURE;
	    }
	    /* priority tagged */
	    if (iANSdata->vlan_offload_support == BD_ANS_FALSE)
		bd_ans_os_StripQtagSW(os_frame_data);
	}
	break;
            
    case IANS_BD_TAGGING_802_3AC:
	/* here we have the following rules:
	 * VLAN-tagged: strip, report vlan id in tlv
	 * Priority-tagged: drop
	 * Untagged: receive with untagged tlv.
	 *
	 *  The Untagged rule is there for 802.3ad requirements.
	 *  The 802.3ad spec allows for sending protocol packets
	 *  to and from the switch that ANS must be able to
	 *  receive.
	 */
	DEBUGLOG("bd_ans_Receive: Tagging mode 802.3ac\n");
	if (!tag) {
	    DEBUGLOG("bd_ans_Receive: Invalid VLAN packet\n");
	    return BD_ANS_FAILURE;
	}
	if (tlvlist_length == 0)
	    if (bd_ans_os_AllocateTLV(os_frame_data, os_tlv) == 
		BD_ANS_FAILURE) {
		DEBUGLOG("bd_ans_Receive: Failed to allocated TLV\n");
		return BD_ANS_FAILURE;
	    }
	if (Frame_is_tagged) {
	    /* VLAN_ID TLV */
	    tlvlist_length += bd_ans_os_AttributeFill(IANS_ATTR_VLAN_ID, 
		*os_tlv, 
		tlvlist_length,
		(void *)&tag);
	    if (iANSdata->vlan_offload_support == BD_ANS_FALSE)
		bd_ans_os_StripQtagSW(os_frame_data);
	} else {
	    /* Send along, but untagged */
	    /* Untagged TLV */
	    tlvlist_length += 
		bd_ans_os_AttributeFill(IANS_ATTR_TAGGING_UNTAGGED, 
		    *os_tlv, 
		    tlvlist_length,
		    NULL);
	}
	break;
    default:
	DEBUGLOG("bd_ans_Receive: Invalid tagging mode\n");
	return BD_ANS_FAILURE;        
    }
#endif
    /* allocate space for the last attribute TLV */
    if (tlvlist_length == 0) {
        if (bd_ans_os_AllocateTLV(os_frame_data, os_tlv) ==
	    BD_ANS_FAILURE) {
	    DEBUGLOG("bd_ans_Receive: failed to allocated TLV\n");
            return BD_ANS_FAILURE;                 
	}
    }       

    /* Last Attribute TLV */
    tlvlist_length += bd_ans_os_AttributeFill(IANS_ATTR_LAST_ATTR, 
	*os_tlv, 
	tlvlist_length,
	NULL);
    *tlv_list_length = tlvlist_length;
    return BD_ANS_SUCCESS;
}
                             



/* bd_ans_Transmit()
**
**  This function is called when the driver has been configured to be
**  run in attributed mode (meaning we are receiving TLVs along with
**  the frame from ANS).  It will perform the necessary operations 
**  according to what TLVs it finds.  Note that it does NOT remove the
**  TLV list from the frame, it is up to the OS routines to do that 
**  if it is needed.  
**
**  Arguments:  BOARD_PRIVATE_STRUCT *bps - a pointer to the adapters hw 
**                                          specific data structure.
**              HW_RX_DESCRIPTOR *rxd - pointer to hw dependent rx struct
**              FRAME_DATA *frame - pointer to an ethernet frame
**              OS_DATA *os_data - pointer to OS dependent frame data
**
**  Returns:    BD_ANS_STATUS -  SUCCESS if command was processed 
**                               successfully, FAILURE otherwise.
*/                                                                     
BD_ANS_STATUS bd_ans_Transmit(BOARD_PRIVATE_STRUCT *bps,
    iANSsupport_t *iANSdata,
    pPer_Frame_Attribute_Header pTLV,
    HW_TX_DESCRIPTOR *txd,
    OS_DATA **frame_ptr,
    UINT16 *vlanid)
{
    OS_DATA *frame = *frame_ptr;

    *vlanid = INVALID_VLAN_ID;

#ifdef IANS_BASE_VLAN_TAGGING
    /* if we are not in tagging mode, we have nothing to do */
    if ( iANSdata->tag_mode == IANS_BD_TAGGING_NONE ) {
        return BD_ANS_SUCCESS;
    }
#ifdef VLAN_DEBUG_NO_ANS
    /* we don't have an ANS module above us inserting the TLVs,
     * so we will just skip traversing the list and insert the
     * qtag
     */
    /* we will hardcode vlanid 2 here */
    *vlanid = 2;
    if (iANSdata->vlan_offload_support == BD_ANS_TRUE) {
	if (bd_ans_hw_InsertQtagHW(bps, txd, vlanid) == BD_ANS_FAILURE) {
	    DEBUGLOG("bd_ans_Transmit: failed to insert qtag hw\n");
	    return BD_ANS_FAILURE;
	}
    } else {
	DEBUGLOG("bd_ans_Transmit: no vlan offload support\n");
	if (bd_ans_os_InsertQtagSW(bps, frame_ptr, vlanid) == BD_ANS_FAILURE) {
	    DEBUGLOG("bd_ans_Transmit: failed to insert qtag sw\n");
	    return BD_ANS_FAILURE;
	}
    }
    DEBUGLOG("bd_ans_Transmit: inserted vlan id 2\n");
    return BD_ANS_SUCCESS;
#endif
	
    /* traverse the list of TLVs until we get to the Last TLV. */
    while (pTLV->AttributeID != IANS_ATTR_LAST_ATTR) { 
        switch( pTLV->AttributeID ) {
	case IANS_ATTR_VLAN_ID:
	    *vlanid = (UINT16) bd_ans_ExtractValue(pTLV);
	    break;
	default:
	    break;
        } /* switch AttributeID */
        
        pTLV = GET_NEXT_TLV(pTLV);
        
    }
    if (*vlanid != INVALID_VLAN_ID) {
	/* we can insert the qtag here.  Doing this here instead of
	 * within the while loop insures that the TLV list is no longer
	 * needed, and we can recycle that extra memory (if needed)
	 */
        if (iANSdata->vlan_offload_support == BD_ANS_FALSE) {
	    if (bd_ans_os_InsertQtagSW(bps, frame_ptr, vlanid) == BD_ANS_FAILURE)
		return BD_ANS_FAILURE;               
        } else {
	    if (bd_ans_hw_InsertQtagHW(bps, txd, vlanid) == BD_ANS_FAILURE) 
		return BD_ANS_FAILURE;
        }
    }
#endif
    /* not implemented yet */
    return (BD_ANS_SUCCESS);
}

#ifdef IANS_BASE_VLAN_TAGGING

/* bd_ans_IsQtagPacket()
**
**  This function will determine whether or not a given packet has a
**  Qtag in it.
**
**  Arguments:  BOARD_PRIVATE_STRUCT *bps - pointer to the driver's private
**                                          data structure
**              iANSsupport_t *iANSdata   - pointer to the required ANS
**                                          support structure.
**              HW_RX_DESCRIPTOR *rxd     - pointer to hw specific rx frame
**                                          descriptor
**              eth_vlan_header_t *header - pointer to the head of the actual
**                                          frame data.
**
**  Returns:    BD_ANS_BOOLEAN      BD_ANS_TRUE if it is a qtag packet
**                                  BD_ANS_FALSE if it is not.
*/
BD_ANS_BOOLEAN
bd_ans_IsQtagPacket(BOARD_PRIVATE_STRUCT *bps,
    iANSsupport_t *iANSdata, 
    HW_RX_DESCRIPTOR *rxd,
    peth_vlan_header_t header)
{
    /* if this support flag is set, then the driver has already stripped
     * the packet and will have a proprietary means of indicating that it
     * found a qtag packet.  If so, call the hw module routine to check it 
     */
    DEBUGLOG1("bd_ans_IsQtagPacket: offload=%d\n", iANSdata->vlan_offload_support);

    if (iANSdata->vlan_offload_support) {
        return (bd_ans_hw_IsQtagPacket(bps, rxd));
    }
    /* print the packet for debugging */
    DEBUGLOG1("bd_ans_IsQtagPacket: type is 0x%x\n",
	ntohs(header->Qtag.EtherType));
    return (ntohs(header->Qtag.EtherType) == QTAG_TYPE);
}                                                 




/* bd_ans_GetVlanId()
**
**  This function will call the hw proprietary function to get the
**  vlan id if the driver supports vlan offloading, otherwise, it
**  will get the IEEE vlan id from the packet.
**
**
**  Arguments:  BOARD_PRIVATE_STRUCT *bps - pointer to the driver's private
**                                          data structure.
**              iANSsupport_t *iANSdata   - pointer to the ans required
**                                          support structure.
**              HW_RX_DESCRIPTOR *rxd     - pointer to the hw specific
**                                          rx frame descriptor
**              eth_vlan_header_t *header - pointer to the actual frame data
**
**  Returns:    UINT16      - the IEEE vlan id.
*/
UINT16
bd_ans_GetVlanId(BOARD_PRIVATE_STRUCT *bps,
    iANSsupport_t *iANSdata, 
    HW_RX_DESCRIPTOR *rxd,
    peth_vlan_header_t header)    
{
    if (iANSdata->vlan_offload_support) {
        return (bd_ans_hw_GetVlanId(bps, rxd));
    }
    return (ntohs(header->Qtag.VLAN_ID) & VLAN_ID_MASK);
}                     
#endif


/* bd_ans_AttributeFill()
**
**  This routine will fill out a TLV based on a given attribute ID
**
**  Arguments:   iANS_Attribute_ID attr_id - id which identifies which 
**                                           TLV this is.
**               void *pTLV                - pointer to where the TLV should
**                                           be copied.
**               void *data                - optional data to be added to the
**                                           TLV (the V part)
**
** Returns:      UINT32                    - the length of the new TLV
*/
UINT32
bd_ans_AttributeFill(iANS_Attribute_ID attr_id, 
    void *pTLV, 
    void *data)
{
#ifdef IANS_BASE_VLAN_TAGGING
    VLAN_ID_Per_Frame_Info *vlan_pfi;
    Untagged_Attribute *untagged;
#endif
    Last_Attribute *last;    
    int tlv_length = 0;

    DEBUGLOG("bd_ans_AttributeFill: enter\n");
    
    switch(attr_id)
    {
#ifdef IANS_BASE_VLAN_TAGGING
    case IANS_ATTR_VLAN_ID:
	DEBUGLOG("bd_ans_AttributeFill: filling vlan id attr\n");
	tlv_length = sizeof(VLAN_ID_Per_Frame_Info);
	vlan_pfi = (VLAN_ID_Per_Frame_Info *)pTLV;
	vlan_pfi->AttrHeader.AttributeID = IANS_ATTR_VLAN_ID;
	vlan_pfi->AttrHeader.AttributeLength = 
            tlv_length - sizeof(Per_Frame_Attribute_Header);
	vlan_pfi->VLanID = *((UINT16 *)data);
	break;
            
    case IANS_ATTR_TAGGING_UNTAGGED: 
	DEBUGLOG("bd_ans_AttributeFill: filling untagged attr\n");
	tlv_length = sizeof(Untagged_Attribute);
	untagged = (Untagged_Attribute *)pTLV;
	untagged->AttrHeader.AttributeID = IANS_ATTR_TAGGING_UNTAGGED;
	untagged->AttrHeader.AttributeLength = 
            tlv_length - sizeof(Per_Frame_Attribute_Header);
	break;
#endif            
    case IANS_ATTR_LAST_ATTR:
	DEBUGLOG("bd_ans_AttributeFill: filling last attr\n");
	tlv_length = sizeof(Last_Attribute);
	last = (Last_Attribute *)pTLV;
	last->LastHeader.AttributeID = IANS_ATTR_LAST_ATTR; 
	last->LastHeader.AttributeLength = 0;   
	break;
    }
    return tlv_length;
}    




/* bd_ans_ExtractValue()
**
**  This function will extract the value from a TLV
**  I assume that the value will be at most 32 bits.
**  I should probably rename this to be extract dword value or
**  something that makes that clear.
**
**  Arguments:  Per_Frame_Attribute_Header *pTLV - pointer to the TLV
**
**  Returns:    UINT32 - dword value from the TLV.  Smaller values 
**                       should be cast correctly by the caller.
*/
UINT32
bd_ans_ExtractValue(Per_Frame_Attribute_Header *pTLV)
{
    UINT32 ret_val;
    UCHAR *p;
    p = (UCHAR *) &(pTLV->AttributeLength);
    p += sizeof(pTLV->AttributeLength);
    ret_val = *((UINT32 *)p);
    return (ret_val); 
}