/****************************************************************************** * * Name: skcsum.c * Project: GEnesis, PCI Gigabit Ethernet Adapter * Version: $Revision: 1.10 $ * Date: $Date: 2002/04/11 10:02:04 $ * Purpose: Store/verify Internet checksum in send/receive packets. * ******************************************************************************/ /****************************************************************************** * * (C)Copyright 1998-2001 SysKonnect GmbH. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * The information in this file is provided "AS IS" without warranty. * ******************************************************************************/ /****************************************************************************** * * History: * * $Log: skcsum.c,v $ * Revision 1.10 2002/04/11 10:02:04 rwahl * Fix in SkCsGetSendInfo(): * - function did not return ProtocolFlags in every case. * - pseudo header csum calculated wrong for big endian. * * Revision 1.9 2001/06/13 07:42:08 gklug * fix: NetNumber was wrong in CLEAR_STAT event * add: check for good NetNumber in Clear STAT * * Revision 1.8 2001/02/06 11:15:36 rassmann * Supporting two nets on dual-port adapters. * * Revision 1.7 2000/06/29 13:17:05 rassmann * Corrected reception of a packet with UDP checksum == 0 (which means there * is no UDP checksum). * * Revision 1.6 2000/02/21 12:35:10 cgoos * Fixed license header comment. * * Revision 1.5 2000/02/21 11:05:19 cgoos * Merged changes back to common source. * Fixed rx path for BIG ENDIAN architecture. * * Revision 1.1 1999/07/26 15:28:12 mkarl * added return SKCS_STATUS_IP_CSUM_ERROR_UDP and * SKCS_STATUS_IP_CSUM_ERROR_TCP to pass the NidsTester * changed from common source to windows specific source * therefore restarting with v1.0 * * Revision 1.3 1999/05/10 08:39:33 mkarl * prevent overflows in SKCS_HTON16 * fixed a bug in pseudo header checksum calculation * added some comments * * Revision 1.2 1998/10/22 11:53:28 swolf * Now using SK_DBG_MSG. * * Revision 1.1 1998/09/01 15:35:41 swolf * initial revision * * 13-May-1998 sw Created. * ******************************************************************************/ #include <config.h> #ifdef CONFIG_SK98 #ifdef SK_USE_CSUM /* Check if CSUM is to be used. */ #ifndef lint static const char SysKonnectFileId[] = "@(#)" "$Id: skcsum.c,v 1.10 2002/04/11 10:02:04 rwahl Exp $" " (C) SysKonnect."; #endif /* !lint */ /****************************************************************************** * * Description: * * This is the "GEnesis" common module "CSUM". * * This module contains the code necessary to calculate, store, and verify the * Internet Checksum of IP, TCP, and UDP frames. * * "GEnesis" is an abbreviation of "Gigabit Ethernet Network System in Silicon" * and is the code name of this SysKonnect project. * * Compilation Options: * * SK_USE_CSUM - Define if CSUM is to be used. Otherwise, CSUM will be an * empty module. * * SKCS_OVERWRITE_PROTO - Define to overwrite the default protocol id * definitions. In this case, all SKCS_PROTO_xxx definitions must be made * external. * * SKCS_OVERWRITE_STATUS - Define to overwrite the default return status * definitions. In this case, all SKCS_STATUS_xxx definitions must be made * external. * * Include File Hierarchy: * * "h/skdrv1st.h" * "h/skcsum.h" * "h/sktypes.h" * "h/skqueue.h" * "h/skdrv2nd.h" * ******************************************************************************/ #include "h/skdrv1st.h" #include "h/skcsum.h" #include "h/skdrv2nd.h" /* defines ********************************************************************/ /* The size of an Ethernet MAC header. */ #define SKCS_ETHERNET_MAC_HEADER_SIZE (6+6+2) /* The size of the used topology's MAC header. */ #define SKCS_MAC_HEADER_SIZE SKCS_ETHERNET_MAC_HEADER_SIZE /* The size of the IP header without any option fields. */ #define SKCS_IP_HEADER_SIZE 20 /* * Field offsets within the IP header. */ /* "Internet Header Version" and "Length". */ #define SKCS_OFS_IP_HEADER_VERSION_AND_LENGTH 0 /* "Total Length". */ #define SKCS_OFS_IP_TOTAL_LENGTH 2 /* "Flags" "Fragment Offset". */ #define SKCS_OFS_IP_FLAGS_AND_FRAGMENT_OFFSET 6 /* "Next Level Protocol" identifier. */ #define SKCS_OFS_IP_NEXT_LEVEL_PROTOCOL 9 /* Source IP address. */ #define SKCS_OFS_IP_SOURCE_ADDRESS 12 /* Destination IP address. */ #define SKCS_OFS_IP_DESTINATION_ADDRESS 16 /* * Field offsets within the UDP header. */ /* UDP checksum. */ #define SKCS_OFS_UDP_CHECKSUM 6 /* IP "Next Level Protocol" identifiers (see RFC 790). */ #define SKCS_PROTO_ID_TCP 6 /* Transport Control Protocol */ #define SKCS_PROTO_ID_UDP 17 /* User Datagram Protocol */ /* IP "Don't Fragment" bit. */ #define SKCS_IP_DONT_FRAGMENT SKCS_HTON16(0x4000) /* Add a byte offset to a pointer. */ #define SKCS_IDX(pPtr, Ofs) ((void *) ((char *) (pPtr) + (Ofs))) /* * Macros that convert host to network representation and vice versa, i.e. * little/big endian conversion on little endian machines only. */ #ifdef SK_LITTLE_ENDIAN #define SKCS_HTON16(Val16) (((unsigned) (Val16) >> 8) | (((Val16) & 0xFF) << 8)) #endif /* SK_LITTLE_ENDIAN */ #ifdef SK_BIG_ENDIAN #define SKCS_HTON16(Val16) (Val16) #endif /* SK_BIG_ENDIAN */ #define SKCS_NTOH16(Val16) SKCS_HTON16(Val16) /* typedefs *******************************************************************/ /* function prototypes ********************************************************/ /****************************************************************************** * * SkCsGetSendInfo - get checksum information for a send packet * * Description: * Get all checksum information necessary to send a TCP or UDP packet. The * function checks the IP header passed to it. If the high-level protocol * is either TCP or UDP the pseudo header checksum is calculated and * returned. * * The function returns the total length of the IP header (including any * IP option fields), which is the same as the start offset of the IP data * which in turn is the start offset of the TCP or UDP header. * * The function also returns the TCP or UDP pseudo header checksum, which * should be used as the start value for the hardware checksum calculation. * (Note that any actual pseudo header checksum can never calculate to * zero.) * * Note: * There is a bug in the ASIC which may lead to wrong checksums. * * Arguments: * pAc - A pointer to the adapter context struct. * * pIpHeader - Pointer to IP header. Must be at least the IP header *not* * including any option fields, i.e. at least 20 bytes. * * Note: This pointer will be used to address 8-, 16-, and 32-bit * variables with the respective alignment offsets relative to the pointer. * Thus, the pointer should point to a 32-bit aligned address. If the * target system cannot address 32-bit variables on non 32-bit aligned * addresses, then the pointer *must* point to a 32-bit aligned address. * * pPacketInfo - A pointer to the packet information structure for this * packet. Before calling this SkCsGetSendInfo(), the following field must * be initialized: * * ProtocolFlags - Initialize with any combination of * SKCS_PROTO_XXX bit flags. SkCsGetSendInfo() will only work on * the protocols specified here. Any protocol(s) not specified * here will be ignored. * * Note: Only one checksum can be calculated in hardware. Thus, if * SKCS_PROTO_IP is specified in the 'ProtocolFlags', * SkCsGetSendInfo() must calculate the IP header checksum in * software. It might be a better idea to have the calling * protocol stack calculate the IP header checksum. * * Returns: N/A * On return, the following fields in 'pPacketInfo' may or may not have * been filled with information, depending on the protocol(s) found in the * packet: * * ProtocolFlags - Returns the SKCS_PROTO_XXX bit flags of the protocol(s) * that were both requested by the caller and actually found in the packet. * Protocol(s) not specified by the caller and/or not found in the packet * will have their respective SKCS_PROTO_XXX bit flags reset. * * Note: For IP fragments, TCP and UDP packet information is ignored. * * IpHeaderLength - The total length in bytes of the complete IP header * including any option fields is returned here. This is the start offset * of the IP data, i.e. the TCP or UDP header if present. * * IpHeaderChecksum - If IP has been specified in the 'ProtocolFlags', the * 16-bit Internet Checksum of the IP header is returned here. This value * is to be stored into the packet's 'IP Header Checksum' field. * * PseudoHeaderChecksum - If this is a TCP or UDP packet and if TCP or UDP * has been specified in the 'ProtocolFlags', the 16-bit Internet Checksum * of the TCP or UDP pseudo header is returned here. */ #if 0 void SkCsGetSendInfo( SK_AC *pAc, /* Adapter context struct. */ void *pIpHeader, /* IP header. */ SKCS_PACKET_INFO *pPacketInfo, /* Packet information struct. */ int NetNumber) /* Net number */ { /* Internet Header Version found in IP header. */ unsigned InternetHeaderVersion; /* Length of the IP header as found in IP header. */ unsigned IpHeaderLength; /* Bit field specifiying the desired/found protocols. */ unsigned ProtocolFlags; /* Next level protocol identifier found in IP header. */ unsigned NextLevelProtocol; /* Length of IP data portion. */ unsigned IpDataLength; /* TCP/UDP pseudo header checksum. */ unsigned long PseudoHeaderChecksum; /* Pointer to next level protocol statistics structure. */ SKCS_PROTO_STATS *NextLevelProtoStats; /* Temporary variable. */ unsigned Tmp; Tmp = *(SK_U8 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_HEADER_VERSION_AND_LENGTH); /* Get the Internet Header Version (IHV). */ /* Note: The IHV is stored in the upper four bits. */ InternetHeaderVersion = Tmp >> 4; /* Check the Internet Header Version. */ /* Note: We currently only support IP version 4. */ if (InternetHeaderVersion != 4) { /* IPv4? */ SK_DBG_MSG(pAc, SK_DBGMOD_CSUM, SK_DBGCAT_ERR | SK_DBGCAT_TX, ("Tx: Unknown Internet Header Version %u.\n", InternetHeaderVersion)); pPacketInfo->ProtocolFlags = 0; pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_IP].TxUnableCts++; return; } /* Get the IP header length (IHL). */ /* * Note: The IHL is stored in the lower four bits as the number of * 4-byte words. */ IpHeaderLength = (Tmp & 0xf) * 4; pPacketInfo->IpHeaderLength = IpHeaderLength; /* Check the IP header length. */ /* 04-Aug-1998 sw - Really check the IHL? Necessary? */ if (IpHeaderLength < 5*4) { SK_DBG_MSG(pAc, SK_DBGMOD_CSUM, SK_DBGCAT_ERR | SK_DBGCAT_TX, ("Tx: Invalid IP Header Length %u.\n", IpHeaderLength)); pPacketInfo->ProtocolFlags = 0; pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_IP].TxUnableCts++; return; } /* This is an IPv4 frame with a header of valid length. */ pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_IP].TxOkCts++; /* Check if we should calculate the IP header checksum. */ ProtocolFlags = pPacketInfo->ProtocolFlags; if (ProtocolFlags & SKCS_PROTO_IP) { pPacketInfo->IpHeaderChecksum = SkCsCalculateChecksum(pIpHeader, IpHeaderLength); } /* Get the next level protocol identifier. */ NextLevelProtocol = *(SK_U8 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_NEXT_LEVEL_PROTOCOL); /* * Check if this is a TCP or UDP frame and if we should calculate the * TCP/UDP pseudo header checksum. * * Also clear all protocol bit flags of protocols not present in the * frame. */ if ((ProtocolFlags & SKCS_PROTO_TCP) != 0 && NextLevelProtocol == SKCS_PROTO_ID_TCP) { /* TCP/IP frame. */ ProtocolFlags &= SKCS_PROTO_TCP | SKCS_PROTO_IP; NextLevelProtoStats = &pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_TCP]; } else if ((ProtocolFlags & SKCS_PROTO_UDP) != 0 && NextLevelProtocol == SKCS_PROTO_ID_UDP) { /* UDP/IP frame. */ ProtocolFlags &= SKCS_PROTO_UDP | SKCS_PROTO_IP; NextLevelProtoStats = &pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_UDP]; } else { /* * Either not a TCP or UDP frame and/or TCP/UDP processing not * specified. */ pPacketInfo->ProtocolFlags = ProtocolFlags & SKCS_PROTO_IP; return; } /* Check if this is an IP fragment. */ /* * Note: An IP fragment has a non-zero "Fragment Offset" field and/or * the "More Fragments" bit set. Thus, if both the "Fragment Offset" * and the "More Fragments" are zero, it is *not* a fragment. We can * easily check both at the same time since they are in the same 16-bit * word. */ if ((*(SK_U16 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_FLAGS_AND_FRAGMENT_OFFSET) & ~SKCS_IP_DONT_FRAGMENT) != 0) { /* IP fragment; ignore all other protocols. */ pPacketInfo->ProtocolFlags = ProtocolFlags & SKCS_PROTO_IP; NextLevelProtoStats->TxUnableCts++; return; } /* * Calculate the TCP/UDP pseudo header checksum. */ /* Get total length of IP header and data. */ IpDataLength = *(SK_U16 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_TOTAL_LENGTH); /* Get length of IP data portion. */ IpDataLength = SKCS_NTOH16(IpDataLength) - IpHeaderLength; /* Calculate the sum of all pseudo header fields (16-bit). */ PseudoHeaderChecksum = (unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_SOURCE_ADDRESS + 0) + (unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_SOURCE_ADDRESS + 2) + (unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_DESTINATION_ADDRESS + 0) + (unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_DESTINATION_ADDRESS + 2) + (unsigned long) SKCS_HTON16(NextLevelProtocol) + (unsigned long) SKCS_HTON16(IpDataLength); /* Add-in any carries. */ SKCS_OC_ADD(PseudoHeaderChecksum, PseudoHeaderChecksum, 0); /* Add-in any new carry. */ SKCS_OC_ADD(pPacketInfo->PseudoHeaderChecksum, PseudoHeaderChecksum, 0); pPacketInfo->ProtocolFlags = ProtocolFlags; NextLevelProtoStats->TxOkCts++; /* Success. */ } /* SkCsGetSendInfo */ /****************************************************************************** * * SkCsGetReceiveInfo - verify checksum information for a received packet * * Description: * Verify a received frame's checksum. The function returns a status code * reflecting the result of the verification. * * Note: * Before calling this function you have to verify that the frame is * not padded and Checksum1 and Checksum2 are bigger than 1. * * Arguments: * pAc - Pointer to adapter context struct. * * pIpHeader - Pointer to IP header. Must be at least the length in bytes * of the received IP header including any option fields. For UDP packets, * 8 additional bytes are needed to access the UDP checksum. * * Note: The actual length of the IP header is stored in the lower four * bits of the first octet of the IP header as the number of 4-byte words, * so it must be multiplied by four to get the length in bytes. Thus, the * maximum IP header length is 15 * 4 = 60 bytes. * * Checksum1 - The first 16-bit Internet Checksum calculated by the * hardware starting at the offset returned by SkCsSetReceiveFlags(). * * Checksum2 - The second 16-bit Internet Checksum calculated by the * hardware starting at the offset returned by SkCsSetReceiveFlags(). * * Returns: * SKCS_STATUS_UNKNOWN_IP_VERSION - Not an IP v4 frame. * SKCS_STATUS_IP_CSUM_ERROR - IP checksum error. * SKCS_STATUS_IP_CSUM_ERROR_TCP - IP checksum error in TCP frame. * SKCS_STATUS_IP_CSUM_ERROR_UDP - IP checksum error in UDP frame * SKCS_STATUS_IP_FRAGMENT - IP fragment (IP checksum ok). * SKCS_STATUS_IP_CSUM_OK - IP checksum ok (not a TCP or UDP frame). * SKCS_STATUS_TCP_CSUM_ERROR - TCP checksum error (IP checksum ok). * SKCS_STATUS_UDP_CSUM_ERROR - UDP checksum error (IP checksum ok). * SKCS_STATUS_TCP_CSUM_OK - IP and TCP checksum ok. * SKCS_STATUS_UDP_CSUM_OK - IP and UDP checksum ok. * SKCS_STATUS_IP_CSUM_OK_NO_UDP - IP checksum OK and no UDP checksum. * * Note: If SKCS_OVERWRITE_STATUS is defined, the SKCS_STATUS_XXX values * returned here can be defined in some header file by the module using CSUM. * In this way, the calling module can assign return values for its own needs, * e.g. by assigning bit flags to the individual protocols. */ SKCS_STATUS SkCsGetReceiveInfo( SK_AC *pAc, /* Adapter context struct. */ void *pIpHeader, /* IP header. */ unsigned Checksum1, /* Hardware checksum 1. */ unsigned Checksum2, /* Hardware checksum 2. */ int NetNumber) /* Net number */ { /* Internet Header Version found in IP header. */ unsigned InternetHeaderVersion; /* Length of the IP header as found in IP header. */ unsigned IpHeaderLength; /* Length of IP data portion. */ unsigned IpDataLength; /* IP header checksum. */ unsigned IpHeaderChecksum; /* IP header options checksum, if any. */ unsigned IpOptionsChecksum; /* IP data checksum, i.e. TCP/UDP checksum. */ unsigned IpDataChecksum; /* Next level protocol identifier found in IP header. */ unsigned NextLevelProtocol; /* The checksum of the "next level protocol", i.e. TCP or UDP. */ unsigned long NextLevelProtocolChecksum; /* Pointer to next level protocol statistics structure. */ SKCS_PROTO_STATS *NextLevelProtoStats; /* Temporary variable. */ unsigned Tmp; Tmp = *(SK_U8 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_HEADER_VERSION_AND_LENGTH); /* Get the Internet Header Version (IHV). */ /* Note: The IHV is stored in the upper four bits. */ InternetHeaderVersion = Tmp >> 4; /* Check the Internet Header Version. */ /* Note: We currently only support IP version 4. */ if (InternetHeaderVersion != 4) { /* IPv4? */ SK_DBG_MSG(pAc, SK_DBGMOD_CSUM, SK_DBGCAT_ERR | SK_DBGCAT_RX, ("Rx: Unknown Internet Header Version %u.\n", InternetHeaderVersion)); pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_IP].RxUnableCts++; return (SKCS_STATUS_UNKNOWN_IP_VERSION); } /* Get the IP header length (IHL). */ /* * Note: The IHL is stored in the lower four bits as the number of * 4-byte words. */ IpHeaderLength = (Tmp & 0xf) * 4; /* Check the IP header length. */ /* 04-Aug-1998 sw - Really check the IHL? Necessary? */ if (IpHeaderLength < 5*4) { SK_DBG_MSG(pAc, SK_DBGMOD_CSUM, SK_DBGCAT_ERR | SK_DBGCAT_RX, ("Rx: Invalid IP Header Length %u.\n", IpHeaderLength)); pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_IP].RxErrCts++; return (SKCS_STATUS_IP_CSUM_ERROR); } /* This is an IPv4 frame with a header of valid length. */ /* Get the IP header and data checksum. */ IpDataChecksum = Checksum2; /* * The IP header checksum is calculated as follows: * * IpHeaderChecksum = Checksum1 - Checksum2 */ SKCS_OC_SUB(IpHeaderChecksum, Checksum1, Checksum2); /* Check if any IP header options. */ if (IpHeaderLength > SKCS_IP_HEADER_SIZE) { /* Get the IP options checksum. */ IpOptionsChecksum = SkCsCalculateChecksum( SKCS_IDX(pIpHeader, SKCS_IP_HEADER_SIZE), IpHeaderLength - SKCS_IP_HEADER_SIZE); /* Adjust the IP header and IP data checksums. */ SKCS_OC_ADD(IpHeaderChecksum, IpHeaderChecksum, IpOptionsChecksum); SKCS_OC_SUB(IpDataChecksum, IpDataChecksum, IpOptionsChecksum); } /* * Check if the IP header checksum is ok. * * NOTE: We must check the IP header checksum even if the caller just wants * us to check upper-layer checksums, because we cannot do any further * processing of the packet without a valid IP checksum. */ /* Get the next level protocol identifier. */ NextLevelProtocol = *(SK_U8 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_NEXT_LEVEL_PROTOCOL); if (IpHeaderChecksum != 0xFFFF) { pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_IP].RxErrCts++; /* the NDIS tester wants to know the upper level protocol too */ if (NextLevelProtocol == SKCS_PROTO_ID_TCP) { return(SKCS_STATUS_IP_CSUM_ERROR_TCP); } else if (NextLevelProtocol == SKCS_PROTO_ID_UDP) { return(SKCS_STATUS_IP_CSUM_ERROR_UDP); } return (SKCS_STATUS_IP_CSUM_ERROR); } /* * Check if this is a TCP or UDP frame and if we should calculate the * TCP/UDP pseudo header checksum. * * Also clear all protocol bit flags of protocols not present in the * frame. */ if ((pAc->Csum.ReceiveFlags[NetNumber] & SKCS_PROTO_TCP) != 0 && NextLevelProtocol == SKCS_PROTO_ID_TCP) { /* TCP/IP frame. */ NextLevelProtoStats = &pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_TCP]; } else if ((pAc->Csum.ReceiveFlags[NetNumber] & SKCS_PROTO_UDP) != 0 && NextLevelProtocol == SKCS_PROTO_ID_UDP) { /* UDP/IP frame. */ NextLevelProtoStats = &pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_UDP]; } else { /* * Either not a TCP or UDP frame and/or TCP/UDP processing not * specified. */ return (SKCS_STATUS_IP_CSUM_OK); } /* Check if this is an IP fragment. */ /* * Note: An IP fragment has a non-zero "Fragment Offset" field and/or * the "More Fragments" bit set. Thus, if both the "Fragment Offset" * and the "More Fragments" are zero, it is *not* a fragment. We can * easily check both at the same time since they are in the same 16-bit * word. */ if ((*(SK_U16 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_FLAGS_AND_FRAGMENT_OFFSET) & ~SKCS_IP_DONT_FRAGMENT) != 0) { /* IP fragment; ignore all other protocols. */ NextLevelProtoStats->RxUnableCts++; return (SKCS_STATUS_IP_FRAGMENT); } /* * 08-May-2000 ra * * From RFC 768 (UDP) * If the computed checksum is zero, it is transmitted as all ones (the * equivalent in one's complement arithmetic). An all zero transmitted * checksum value means that the transmitter generated no checksum (for * debugging or for higher level protocols that don't care). */ if (NextLevelProtocol == SKCS_PROTO_ID_UDP && *(SK_U16*)SKCS_IDX(pIpHeader, IpHeaderLength + 6) == 0x0000) { NextLevelProtoStats->RxOkCts++; return (SKCS_STATUS_IP_CSUM_OK_NO_UDP); } /* * Calculate the TCP/UDP checksum. */ /* Get total length of IP header and data. */ IpDataLength = *(SK_U16 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_TOTAL_LENGTH); /* Get length of IP data portion. */ IpDataLength = SKCS_NTOH16(IpDataLength) - IpHeaderLength; NextLevelProtocolChecksum = /* Calculate the pseudo header checksum. */ (unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_SOURCE_ADDRESS + 0) + (unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_SOURCE_ADDRESS + 2) + (unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_DESTINATION_ADDRESS + 0) + (unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_DESTINATION_ADDRESS + 2) + (unsigned long) SKCS_HTON16(NextLevelProtocol) + (unsigned long) SKCS_HTON16(IpDataLength) + /* Add the TCP/UDP header checksum. */ (unsigned long) IpDataChecksum; /* Add-in any carries. */ SKCS_OC_ADD(NextLevelProtocolChecksum, NextLevelProtocolChecksum, 0); /* Add-in any new carry. */ SKCS_OC_ADD(NextLevelProtocolChecksum, NextLevelProtocolChecksum, 0); /* Check if the TCP/UDP checksum is ok. */ if ((unsigned) NextLevelProtocolChecksum == 0xFFFF) { /* TCP/UDP checksum ok. */ NextLevelProtoStats->RxOkCts++; return (NextLevelProtocol == SKCS_PROTO_ID_TCP ? SKCS_STATUS_TCP_CSUM_OK : SKCS_STATUS_UDP_CSUM_OK); } /* TCP/UDP checksum error. */ NextLevelProtoStats->RxErrCts++; return (NextLevelProtocol == SKCS_PROTO_ID_TCP ? SKCS_STATUS_TCP_CSUM_ERROR : SKCS_STATUS_UDP_CSUM_ERROR); } /* SkCsGetReceiveInfo */ #endif /****************************************************************************** * * SkCsSetReceiveFlags - set checksum receive flags * * Description: * Use this function to set the various receive flags. According to the * protocol flags set by the caller, the start offsets within received * packets of the two hardware checksums are returned. These offsets must * be stored in all receive descriptors. * * Arguments: * pAc - Pointer to adapter context struct. * * ReceiveFlags - Any combination of SK_PROTO_XXX flags of the protocols * for which the caller wants checksum information on received frames. * * pChecksum1Offset - The start offset of the first receive descriptor * hardware checksum to be calculated for received frames is returned * here. * * pChecksum2Offset - The start offset of the second receive descriptor * hardware checksum to be calculated for received frames is returned * here. * * Returns: N/A * Returns the two hardware checksum start offsets. */ void SkCsSetReceiveFlags( SK_AC *pAc, /* Adapter context struct. */ unsigned ReceiveFlags, /* New receive flags. */ unsigned *pChecksum1Offset, /* Offset for hardware checksum 1. */ unsigned *pChecksum2Offset, /* Offset for hardware checksum 2. */ int NetNumber) { /* Save the receive flags. */ pAc->Csum.ReceiveFlags[NetNumber] = ReceiveFlags; /* First checksum start offset is the IP header. */ *pChecksum1Offset = SKCS_MAC_HEADER_SIZE; /* * Second checksum start offset is the IP data. Note that this may vary * if there are any IP header options in the actual packet. */ *pChecksum2Offset = SKCS_MAC_HEADER_SIZE + SKCS_IP_HEADER_SIZE; } /* SkCsSetReceiveFlags */ #ifndef SkCsCalculateChecksum /****************************************************************************** * * SkCsCalculateChecksum - calculate checksum for specified data * * Description: * Calculate and return the 16-bit Internet Checksum for the specified * data. * * Arguments: * pData - Pointer to data for which the checksum shall be calculated. * Note: The pointer should be aligned on a 16-bit boundary. * * Length - Length in bytes of data to checksum. * * Returns: * The 16-bit Internet Checksum for the specified data. * * Note: The checksum is calculated in the machine's natural byte order, * i.e. little vs. big endian. Thus, the resulting checksum is different * for the same input data on little and big endian machines. * * However, when written back to the network packet, the byte order is * always in correct network order. */ unsigned SkCsCalculateChecksum( void *pData, /* Data to checksum. */ unsigned Length) /* Length of data. */ { SK_U16 *pU16; /* Pointer to the data as 16-bit words. */ unsigned long Checksum; /* Checksum; must be at least 32 bits. */ /* Sum up all 16-bit words. */ pU16 = (SK_U16 *) pData; for (Checksum = 0; Length > 1; Length -= 2) { Checksum += *pU16++; } /* If this is an odd number of bytes, add-in the last byte. */ if (Length > 0) { #ifdef SK_BIG_ENDIAN /* Add the last byte as the high byte. */ Checksum += ((unsigned) *(SK_U8 *) pU16) << 8; #else /* !SK_BIG_ENDIAN */ /* Add the last byte as the low byte. */ Checksum += *(SK_U8 *) pU16; #endif /* !SK_BIG_ENDIAN */ } /* Add-in any carries. */ SKCS_OC_ADD(Checksum, Checksum, 0); /* Add-in any new carry. */ SKCS_OC_ADD(Checksum, Checksum, 0); /* Note: All bits beyond the 16-bit limit are now zero. */ return ((unsigned) Checksum); } /* SkCsCalculateChecksum */ #endif /* SkCsCalculateChecksum */ /****************************************************************************** * * SkCsEvent - the CSUM event dispatcher * * Description: * This is the event handler for the CSUM module. * * Arguments: * pAc - Pointer to adapter context. * * Ioc - I/O context. * * Event - Event id. * * Param - Event dependent parameter. * * Returns: * The 16-bit Internet Checksum for the specified data. * * Note: The checksum is calculated in the machine's natural byte order, * i.e. little vs. big endian. Thus, the resulting checksum is different * for the same input data on little and big endian machines. * * However, when written back to the network packet, the byte order is * always in correct network order. */ int SkCsEvent( SK_AC *pAc, /* Pointer to adapter context. */ SK_IOC Ioc, /* I/O context. */ SK_U32 Event, /* Event id. */ SK_EVPARA Param) /* Event dependent parameter. */ { int ProtoIndex; int NetNumber; switch (Event) { /* * Clear protocol statistics. * * Param - Protocol index, or -1 for all protocols. * - Net number. */ case SK_CSUM_EVENT_CLEAR_PROTO_STATS: ProtoIndex = (int)Param.Para32[1]; NetNumber = (int)Param.Para32[0]; if (ProtoIndex < 0) { /* Clear for all protocols. */ if (NetNumber >= 0) { memset(&pAc->Csum.ProtoStats[NetNumber][0], 0, sizeof(pAc->Csum.ProtoStats[NetNumber])); } } else { /* Clear for individual protocol. */ memset(&pAc->Csum.ProtoStats[NetNumber][ProtoIndex], 0, sizeof(pAc->Csum.ProtoStats[NetNumber][ProtoIndex])); } break; default: break; } return (0); /* Success. */ } /* SkCsEvent */ #endif /* SK_USE_CSUM */ #endif /* CONFIG_SK98 */