开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
skcsum.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：28k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

skcsum.c：源码内容
  1. /******************************************************************************
  2.  *
  3.  * Name: skcsum.c
  4.  * Project: GEnesis, PCI Gigabit Ethernet Adapter
  5.  * Version: $Revision: 1.8 $
  6.  * Date: $Date: 2001/02/06 11:15:36 $
  7.  * Purpose: Store/verify Internet checksum in send/receive packets.
  8.  *
  9.  ******************************************************************************/
  11. /******************************************************************************
  12.  *
  13.  * (C)Copyright 1998-2001 SysKonnect GmbH.
  14.  *
  15.  * This program is free software; you can redistribute it and/or modify
  16.  * it under the terms of the GNU General Public License as published by
  17.  * the Free Software Foundation; either version 2 of the License, or
  18.  * (at your option) any later version.
  19.  *
  20.  * The information in this file is provided "AS IS" without warranty.
  21.  *
  22.  ******************************************************************************/
  24. /******************************************************************************
  25.  *
  26.  * History:
  27.  *
  28.  * $Log: skcsum.c,v $
  29.  * Revision 1.8  2001/02/06 11:15:36  rassmann
  30.  * Supporting two nets on dual-port adapters.
  31.  *
  32.  * Revision 1.7  2000/06/29 13:17:05  rassmann
  33.  * Corrected reception of a packet with UDP checksum == 0 (which means there
  34.  * is no UDP checksum).
  35.  *
  36.  * Revision 1.6  2000/02/21 12:35:10  cgoos
  37.  * Fixed license header comment.
  38.  *
  39.  * Revision 1.5  2000/02/21 11:05:19  cgoos
  40.  * Merged changes back to common source.
  41.  * Fixed rx path for BIG ENDIAN architecture.
  42.  *
  43.  * Revision 1.1  1999/07/26 15:28:12  mkarl
  44.  * added return SKCS_STATUS_IP_CSUM_ERROR_UDP and
  45.  * SKCS_STATUS_IP_CSUM_ERROR_TCP to pass the NidsTester
  46.  * changed from common source to windows specific source
  47.  * therefore restarting with v1.0
  48.  *
  49.  * Revision 1.3  1999/05/10 08:39:33  mkarl
  50.  * prevent overflows in SKCS_HTON16
  51.  * fixed a bug in pseudo header checksum calculation
  52.  * added some comments
  53.  *
  54.  * Revision 1.2  1998/10/22 11:53:28  swolf
  55.  * Now using SK_DBG_MSG.
  56.  *
  57.  * Revision 1.1  1998/09/01 15:35:41  swolf
  58.  * initial revision
  59.  *
  60.  * 13-May-1998 sw Created.
  61.  *
  62.  ******************************************************************************/
  64. #ifdef SK_USE_CSUM /* Check if CSUM is to be used. */
  66. #ifndef lint
  67. static const char SysKonnectFileId[] = "@(#)"
  68. "$Id: skcsum.c,v 1.8 2001/02/06 11:15:36 rassmann Exp $"
  69. " (C) SysKonnect.";
  70. #endif /* !lint */
  72. /******************************************************************************
  73.  *
  74.  * Description:
  75.  *
  76.  * This is the "GEnesis" common module "CSUM".
  77.  *
  78.  * This module contains the code necessary to calculate, store, and verify the
  79.  * Internet Checksum of IP, TCP, and UDP frames.
  80.  *
  81.  * "GEnesis" is an abbreviation of "Gigabit Ethernet Network System in Silicon"
  82.  * and is the code name of this SysKonnect project.
  83.  *
  84.  * Compilation Options:
  85.  *
  86.  * SK_USE_CSUM - Define if CSUM is to be used. Otherwise, CSUM will be an
  87.  * empty module.
  88.  *
  89.  * SKCS_OVERWRITE_PROTO - Define to overwrite the default protocol id
  90.  * definitions. In this case, all SKCS_PROTO_xxx definitions must be made
  91.  * external.
  92.  *
  93.  * SKCS_OVERWRITE_STATUS - Define to overwrite the default return status
  94.  * definitions. In this case, all SKCS_STATUS_xxx definitions must be made
  95.  * external.
  96.  *
  97.  * Include File Hierarchy:
  98.  *
  99.  * "h/skdrv1st.h"
  100.  * "h/skcsum.h"
  101.  *  "h/sktypes.h"
  102.  *  "h/skqueue.h"
  103.  * "h/skdrv2nd.h"
  104.  *
  105.  ******************************************************************************/
  107. #include "h/skdrv1st.h"
  108. #include "h/skcsum.h"
  109. #include "h/skdrv2nd.h"
  111. /* defines ********************************************************************/
  113. /* The size of an Ethernet MAC header. */
  114. #define SKCS_ETHERNET_MAC_HEADER_SIZE (6+6+2)
  116. /* The size of the used topology's MAC header. */
  117. #define SKCS_MAC_HEADER_SIZE SKCS_ETHERNET_MAC_HEADER_SIZE
  119. /* The size of the IP header without any option fields. */
  120. #define SKCS_IP_HEADER_SIZE 20
  122. /*
  123.  * Field offsets within the IP header.
  124.  */
  126. /* "Internet Header Version" and "Length". */
  127. #define SKCS_OFS_IP_HEADER_VERSION_AND_LENGTH 0
  129. /* "Total Length". */
  130. #define SKCS_OFS_IP_TOTAL_LENGTH 2
  132. /* "Flags" "Fragment Offset". */
  133. #define SKCS_OFS_IP_FLAGS_AND_FRAGMENT_OFFSET 6
  135. /* "Next Level Protocol" identifier. */
  136. #define SKCS_OFS_IP_NEXT_LEVEL_PROTOCOL 9
  138. /* Source IP address. */
  139. #define SKCS_OFS_IP_SOURCE_ADDRESS 12
  141. /* Destination IP address. */
  142. #define SKCS_OFS_IP_DESTINATION_ADDRESS 16
  145. /*
  146.  * Field offsets within the UDP header.
  147.  */
  149. /* UDP checksum. */
  150. #define SKCS_OFS_UDP_CHECKSUM 6
  152. /* IP "Next Level Protocol" identifiers (see RFC 790). */
  153. #define SKCS_PROTO_ID_TCP 6 /* Transport Control Protocol */
  154. #define SKCS_PROTO_ID_UDP 17 /* User Datagram Protocol */
  156. /* IP "Don't Fragment" bit. */
  157. #define SKCS_IP_DONT_FRAGMENT SKCS_HTON16(0x4000)
  159. /* Add a byte offset to a pointer. */
  160. #define SKCS_IDX(pPtr, Ofs) ((void *) ((char *) (pPtr) + (Ofs)))
  162. /*
  163.  * Macros that convert host to network representation and vice versa, i.e.
  164.  * little/big endian conversion on little endian machines only.
  165.  */
  166. #ifdef SK_LITTLE_ENDIAN
  167. #define SKCS_HTON16(Val16) (((unsigned) (Val16) >> 8) | (((Val16) & 0xFF) << 8))
  168. #endif /* SK_LITTLE_ENDIAN */
  169. #ifdef SK_BIG_ENDIAN
  170. #define SKCS_HTON16(Val16) (Val16)
  171. #endif /* SK_BIG_ENDIAN */
  172. #define SKCS_NTOH16(Val16) SKCS_HTON16(Val16)
  174. /* typedefs *******************************************************************/
  176. /* function prototypes ********************************************************/
  178. /******************************************************************************
  179.  *
  180.  * SkCsGetSendInfo - get checksum information for a send packet
  181.  *
  182.  * Description:
  183.  * Get all checksum information necessary to send a TCP or UDP packet. The
  184.  * function checks the IP header passed to it. If the high-level protocol
  185.  * is either TCP or UDP the pseudo header checksum is calculated and
  186.  * returned.
  187.  *
  188.  * The function returns the total length of the IP header (including any
  189.  * IP option fields), which is the same as the start offset of the IP data
  190.  * which in turn is the start offset of the TCP or UDP header.
  191.  *
  192.  * The function also returns the TCP or UDP pseudo header checksum, which
  193.  * should be used as the start value for the hardware checksum calculation.
  194.  * (Note that any actual pseudo header checksum can never calculate to
  195.  * zero.)
  196.  *
  197.  * Note:
  198.  * There is a bug in the ASIC whic may lead to wrong checksums.
  199.  *
  200.  * Arguments:
  201.  * pAc - A pointer to the adapter context struct.
  202.  *
  203.  * pIpHeader - Pointer to IP header. Must be at least the IP header *not*
  204.  * including any option fields, i.e. at least 20 bytes.
  205.  *
  206.  * Note: This pointer will be used to address 8-, 16-, and 32-bit
  207.  * variables with the respective alignment offsets relative to the pointer.
  208.  * Thus, the pointer should point to a 32-bit aligned address. If the
  209.  * target system cannot address 32-bit variables on non 32-bit aligned
  210.  * addresses, then the pointer *must* point to a 32-bit aligned address.
  211.  *
  212.  * pPacketInfo - A pointer to the packet information structure for this
  213.  * packet. Before calling this SkCsGetSendInfo(), the following field must
  214.  * be initialized:
  215.  *
  216.  * ProtocolFlags - Initialize with any combination of
  217.  * SKCS_PROTO_XXX bit flags. SkCsGetSendInfo() will only work on
  218.  * the protocols specified here. Any protocol(s) not specified
  219.  * here will be ignored.
  220.  *
  221.  * Note: Only one checksum can be calculated in hardware. Thus, if
  222.  * SKCS_PROTO_IP is specified in the 'ProtocolFlags',
  223.  * SkCsGetSendInfo() must calculate the IP header checksum in
  224.  * software. It might be a better idea to have the calling
  225.  * protocol stack calculate the IP header checksum.
  226.  *
  227.  * Returns: N/A
  228.  * On return, the following fields in 'pPacketInfo' may or may not have
  229.  * been filled with information, depending on the protocol(s) found in the
  230.  * packet:
  231.  *
  232.  * ProtocolFlags - Returns the SKCS_PROTO_XXX bit flags of the protocol(s)
  233.  * that were both requested by the caller and actually found in the packet.
  234.  * Protocol(s) not specified by the caller and/or not found in the packet
  235.  * will have their respective SKCS_PROTO_XXX bit flags reset.
  236.  *
  237.  * Note: For IP fragments, TCP and UDP packet information is ignored.
  238.  *
  239.  * IpHeaderLength - The total length in bytes of the complete IP header
  240.  * including any option fields is returned here. This is the start offset
  241.  * of the IP data, i.e. the TCP or UDP header if present.
  242.  *
  243.  * IpHeaderChecksum - If IP has been specified in the 'ProtocolFlags', the
  244.  * 16-bit Internet Checksum of the IP header is returned here. This value
  245.  * is to be stored into the packet's 'IP Header Checksum' field.
  246.  *
  247.  * PseudoHeaderChecksum - If this is a TCP or UDP packet and if TCP or UDP
  248.  * has been specified in the 'ProtocolFlags', the 16-bit Internet Checksum
  249.  * of the TCP or UDP pseudo header is returned here.
  250.  */
  251. void SkCsGetSendInfo(
  252. SK_AC *pAc, /* Adapter context struct. */
  253. void *pIpHeader, /* IP header. */
  254. SKCS_PACKET_INFO *pPacketInfo, /* Packet information struct. */
  255. int NetNumber) /* Net number */
  256. {
  257. /* Internet Header Version found in IP header. */
  258. unsigned InternetHeaderVersion;
  260. /* Length of the IP header as found in IP header. */
  261. unsigned IpHeaderLength;
  263. /* Bit field specifiying the desired/found protocols. */
  264. unsigned ProtocolFlags;
  266. /* Next level protocol identifier found in IP header. */
  267. unsigned NextLevelProtocol;
  269. /* Length of IP data portion. */
  270. unsigned IpDataLength;
  272. /* TCP/UDP pseudo header checksum. */
  273. unsigned long PseudoHeaderChecksum;
  275. /* Pointer to next level protocol statistics structure. */
  276. SKCS_PROTO_STATS *NextLevelProtoStats;
  278. /* Temporary variable. */
  279. unsigned Tmp;
  281. Tmp = *(SK_U8 *)
  282. SKCS_IDX(pIpHeader, SKCS_OFS_IP_HEADER_VERSION_AND_LENGTH);
  284. /* Get the Internet Header Version (IHV). */
  285. /* Note: The IHV is stored in the upper four bits. */
  287. InternetHeaderVersion = Tmp >> 4;
  289. /* Check the Internet Header Version. */
  290. /* Note: We currently only support IP version 4. */
  292. if (InternetHeaderVersion != 4) { /* IPv4? */
  293. SK_DBG_MSG(pAc, SK_DBGMOD_CSUM, SK_DBGCAT_ERR | SK_DBGCAT_TX,
  294. ("Tx: Unknown Internet Header Version %u.n",
  295. InternetHeaderVersion));
  296. pPacketInfo->ProtocolFlags = 0;
  297. pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_IP].TxUnableCts++;
  298. return;
  299. }
  301. /* Get the IP header length (IHL). */
  302. /*
  303.  * Note: The IHL is stored in the lower four bits as the number of
  304.  * 4-byte words.
  305.  */
  307. IpHeaderLength = (Tmp & 0xf) * 4;
  308. pPacketInfo->IpHeaderLength = IpHeaderLength;
  310. /* Check the IP header length. */
  312. /* 04-Aug-1998 sw - Really check the IHL? Necessary? */
  314. if (IpHeaderLength < 5*4) {
  315. SK_DBG_MSG(pAc, SK_DBGMOD_CSUM, SK_DBGCAT_ERR | SK_DBGCAT_TX,
  316. ("Tx: Invalid IP Header Length %u.n", IpHeaderLength));
  317. pPacketInfo->ProtocolFlags = 0;
  318. pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_IP].TxUnableCts++;
  319. return;
  320. }
  322. /* This is an IPv4 frame with a header of valid length. */
  324. pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_IP].TxOkCts++;
  326. /* Check if we should calculate the IP header checksum. */
  328. ProtocolFlags = pPacketInfo->ProtocolFlags;
  330. if (ProtocolFlags & SKCS_PROTO_IP) {
  331. pPacketInfo->IpHeaderChecksum =
  332. SkCsCalculateChecksum(pIpHeader, IpHeaderLength);
  333. }
  335. /* Get the next level protocol identifier. */
  337. NextLevelProtocol =
  338. *(SK_U8 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_NEXT_LEVEL_PROTOCOL);
  340. /*
  341.  * Check if this is a TCP or UDP frame and if we should calculate the
  342.  * TCP/UDP pseudo header checksum.
  343.  *
  344.  * Also clear all protocol bit flags of protocols not present in the
  345.  * frame.
  346.  */
  348. if ((ProtocolFlags & SKCS_PROTO_TCP) != 0 &&
  349. NextLevelProtocol == SKCS_PROTO_ID_TCP) {
  350. /* TCP/IP frame. */
  351. ProtocolFlags &= SKCS_PROTO_TCP | SKCS_PROTO_IP;
  352. NextLevelProtoStats =
  353. &pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_TCP];
  354. }
  355. else if ((ProtocolFlags & SKCS_PROTO_UDP) != 0 &&
  356. NextLevelProtocol == SKCS_PROTO_ID_UDP) {
  357. /* UDP/IP frame. */
  358. ProtocolFlags &= SKCS_PROTO_UDP | SKCS_PROTO_IP;
  359. NextLevelProtoStats =
  360. &pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_UDP];
  361. }
  362. else {
  363. /*
  364.  * Either not a TCP or UDP frame and/or TCP/UDP processing not
  365.  * specified.
  366.  */
  367. pPacketInfo->ProtocolFlags = ProtocolFlags & SKCS_PROTO_IP;
  368. return;
  369. }
  371. /* Check if this is an IP fragment. */
  373. /*
  374.  * Note: An IP fragment has a non-zero "Fragment Offset" field and/or
  375.  * the "More Fragments" bit set. Thus, if both the "Fragment Offset"
  376.  * and the "More Fragments" are zero, it is *not* a fragment. We can
  377.  * easily check both at the same time since they are in the same 16-bit
  378.  * word.
  379.  */
  381. if ((*(SK_U16 *)
  382. SKCS_IDX(pIpHeader, SKCS_OFS_IP_FLAGS_AND_FRAGMENT_OFFSET) &
  383. ~SKCS_IP_DONT_FRAGMENT) != 0) {
  384. /* IP fragment; ignore all other protocols. */
  385. pPacketInfo->ProtocolFlags = ProtocolFlags & SKCS_PROTO_IP;
  386. NextLevelProtoStats->TxUnableCts++;
  387. return;
  388. }
  390. /*
  391.  * Calculate the TCP/UDP pseudo header checksum.
  392.  */
  394. /* Get total length of IP header and data. */
  396. IpDataLength =
  397. *(SK_U16 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_TOTAL_LENGTH);
  399. /* Get length of IP data portion. */
  401. IpDataLength = SKCS_NTOH16(IpDataLength) - IpHeaderLength;
  403. /* Calculate the sum of all pseudo header fields (16-bit). */
  405. PseudoHeaderChecksum =
  406. (unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader,
  407. SKCS_OFS_IP_SOURCE_ADDRESS + 0) +
  408. (unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader,
  409. SKCS_OFS_IP_SOURCE_ADDRESS + 2) +
  410. (unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader,
  411. SKCS_OFS_IP_DESTINATION_ADDRESS + 0) +
  412. (unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader,
  413. SKCS_OFS_IP_DESTINATION_ADDRESS + 2) +
  414. (unsigned long) (NextLevelProtocol << 8) +
  415. (unsigned long) SKCS_HTON16(IpDataLength);
  417. /* Add-in any carries. */
  419. SKCS_OC_ADD(PseudoHeaderChecksum, PseudoHeaderChecksum, 0);
  421. /* Add-in any new carry. */
  423. SKCS_OC_ADD(pPacketInfo->PseudoHeaderChecksum, PseudoHeaderChecksum, 0);
  425. NextLevelProtoStats->TxOkCts++; /* Success. */
  426. } /* SkCsGetSendInfo */
  429. /******************************************************************************
  430.  *
  431.  * SkCsGetReceiveInfo - verify checksum information for a received packet
  432.  *
  433.  * Description:
  434.  * Verify a received frame's checksum. The function returns a status code
  435.  * reflecting the result of the verification.
  436.  *
  437.  * Note:
  438.  * Before calling this function you have to verify that the frame is
  439.  * not padded and Checksum1 and Checksum2 are bigger than 1.
  440.  *
  441.  * Arguments:
  442.  * pAc - Pointer to adapter context struct.
  443.  *
  444.  * pIpHeader - Pointer to IP header. Must be at least the length in bytes
  445.  * of the received IP header including any option fields. For UDP packets,
  446.  * 8 additional bytes are needed to access the UDP checksum.
  447.  *
  448.  * Note: The actual length of the IP header is stored in the lower four
  449.  * bits of the first octet of the IP header as the number of 4-byte words,
  450.  * so it must be multiplied by four to get the length in bytes. Thus, the
  451.  * maximum IP header length is 15 * 4 = 60 bytes.
  452.  *
  453.  * Checksum1 - The first 16-bit Internet Checksum calculated by the
  454.  * hardware starting at the offset returned by SkCsSetReceiveFlags().
  455.  *
  456.  * Checksum2 - The second 16-bit Internet Checksum calculated by the
  457.  * hardware starting at the offset returned by SkCsSetReceiveFlags().
  458.  *
  459.  * Returns:
  460.  * SKCS_STATUS_UNKNOWN_IP_VERSION - Not an IP v4 frame.
  461.  * SKCS_STATUS_IP_CSUM_ERROR - IP checksum error.
  462.  * SKCS_STATUS_IP_CSUM_ERROR_TCP - IP checksum error in TCP frame.
  463.  * SKCS_STATUS_IP_CSUM_ERROR_UDP - IP checksum error in UDP frame
  464.  * SKCS_STATUS_IP_FRAGMENT - IP fragment (IP checksum ok).
  465.  * SKCS_STATUS_IP_CSUM_OK - IP checksum ok (not a TCP or UDP frame).
  466.  * SKCS_STATUS_TCP_CSUM_ERROR - TCP checksum error (IP checksum ok).
  467.  * SKCS_STATUS_UDP_CSUM_ERROR - UDP checksum error (IP checksum ok).
  468.  * SKCS_STATUS_TCP_CSUM_OK - IP and TCP checksum ok.
  469.  * SKCS_STATUS_UDP_CSUM_OK - IP and UDP checksum ok.
  470.  * SKCS_STATUS_IP_CSUM_OK_NO_UDP - IP checksum OK and no UDP checksum.
  471.  *
  472.  * Note: If SKCS_OVERWRITE_STATUS is defined, the SKCS_STATUS_XXX values
  473.  * returned here can be defined in some header file by the module using CSUM.
  474.  * In this way, the calling module can assign return values for its own needs,
  475.  * e.g. by assigning bit flags to the individual protocols.
  476.  */
  477. SKCS_STATUS SkCsGetReceiveInfo(
  478. SK_AC *pAc, /* Adapter context struct. */
  479. void *pIpHeader, /* IP header. */
  480. unsigned Checksum1, /* Hardware checksum 1. */
  481. unsigned Checksum2, /* Hardware checksum 2. */
  482. int NetNumber) /* Net number */
  483. {
  484. /* Internet Header Version found in IP header. */
  485. unsigned InternetHeaderVersion;
  487. /* Length of the IP header as found in IP header. */
  488. unsigned IpHeaderLength;
  490. /* Length of IP data portion. */
  491. unsigned IpDataLength;
  493. /* IP header checksum. */
  494. unsigned IpHeaderChecksum;
  496. /* IP header options checksum, if any. */
  497. unsigned IpOptionsChecksum;
  499. /* IP data checksum, i.e. TCP/UDP checksum. */
  500. unsigned IpDataChecksum;
  502. /* Next level protocol identifier found in IP header. */
  503. unsigned NextLevelProtocol;
  505. /* The checksum of the "next level protocol", i.e. TCP or UDP. */
  506. unsigned long NextLevelProtocolChecksum;
  508. /* Pointer to next level protocol statistics structure. */
  509. SKCS_PROTO_STATS *NextLevelProtoStats;
  511. /* Temporary variable. */
  512. unsigned Tmp;
  514. Tmp = *(SK_U8 *)
  515. SKCS_IDX(pIpHeader, SKCS_OFS_IP_HEADER_VERSION_AND_LENGTH);
  517. /* Get the Internet Header Version (IHV). */
  518. /* Note: The IHV is stored in the upper four bits. */
  520. InternetHeaderVersion = Tmp >> 4;
  522. /* Check the Internet Header Version. */
  523. /* Note: We currently only support IP version 4. */
  525. if (InternetHeaderVersion != 4) { /* IPv4? */
  526. SK_DBG_MSG(pAc, SK_DBGMOD_CSUM, SK_DBGCAT_ERR | SK_DBGCAT_RX,
  527. ("Rx: Unknown Internet Header Version %u.n",
  528. InternetHeaderVersion));
  529. pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_IP].RxUnableCts++;
  530. return (SKCS_STATUS_UNKNOWN_IP_VERSION);
  531. }
  533. /* Get the IP header length (IHL). */
  534. /*
  535.  * Note: The IHL is stored in the lower four bits as the number of
  536.  * 4-byte words.
  537.  */
  539. IpHeaderLength = (Tmp & 0xf) * 4;
  541. /* Check the IP header length. */
  543. /* 04-Aug-1998 sw - Really check the IHL? Necessary? */
  545. if (IpHeaderLength < 5*4) {
  546. SK_DBG_MSG(pAc, SK_DBGMOD_CSUM, SK_DBGCAT_ERR | SK_DBGCAT_RX,
  547. ("Rx: Invalid IP Header Length %u.n", IpHeaderLength));
  548. pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_IP].RxErrCts++;
  549. return (SKCS_STATUS_IP_CSUM_ERROR);
  550. }
  552. /* This is an IPv4 frame with a header of valid length. */
  554. /* Get the IP header and data checksum. */
  556. IpDataChecksum = Checksum2;
  558. /*
  559.  * The IP header checksum is calculated as follows:
  560.  *
  561.  * IpHeaderChecksum = Checksum1 - Checksum2
  562.  */
  564. SKCS_OC_SUB(IpHeaderChecksum, Checksum1, Checksum2);
  566. /* Check if any IP header options. */
  568. if (IpHeaderLength > SKCS_IP_HEADER_SIZE) {
  570. /* Get the IP options checksum. */
  572. IpOptionsChecksum = SkCsCalculateChecksum(
  573. SKCS_IDX(pIpHeader, SKCS_IP_HEADER_SIZE),
  574. IpHeaderLength - SKCS_IP_HEADER_SIZE);
  576. /* Adjust the IP header and IP data checksums. */
  578. SKCS_OC_ADD(IpHeaderChecksum, IpHeaderChecksum, IpOptionsChecksum);
  580. SKCS_OC_SUB(IpDataChecksum, IpDataChecksum, IpOptionsChecksum);
  581. }
  583. /*
  584.  * Check if the IP header checksum is ok.
  585.  *
  586.  * NOTE: We must check the IP header checksum even if the caller just wants
  587.  * us to check upper-layer checksums, because we cannot do any further
  588.  * processing of the packet without a valid IP checksum.
  589.  */
  591. /* Get the next level protocol identifier. */
  593. NextLevelProtocol = *(SK_U8 *)
  594. SKCS_IDX(pIpHeader, SKCS_OFS_IP_NEXT_LEVEL_PROTOCOL);
  596. if (IpHeaderChecksum != 0xFFFF) {
  597. pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_IP].RxErrCts++;
  598. /* the NDIS tester wants to know the upper level protocol too */
  599. if (NextLevelProtocol == SKCS_PROTO_ID_TCP) {
  600. return(SKCS_STATUS_IP_CSUM_ERROR_TCP);
  601. }
  602. else if (NextLevelProtocol == SKCS_PROTO_ID_UDP) {
  603. return(SKCS_STATUS_IP_CSUM_ERROR_UDP);
  604. }
  605. return (SKCS_STATUS_IP_CSUM_ERROR);
  606. }
  608. /*
  609.  * Check if this is a TCP or UDP frame and if we should calculate the
  610.  * TCP/UDP pseudo header checksum.
  611.  *
  612.  * Also clear all protocol bit flags of protocols not present in the
  613.  * frame.
  614.  */
  616. if ((pAc->Csum.ReceiveFlags[NetNumber] & SKCS_PROTO_TCP) != 0 &&
  617. NextLevelProtocol == SKCS_PROTO_ID_TCP) {
  618. /* TCP/IP frame. */
  619. NextLevelProtoStats =
  620. &pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_TCP];
  621. }
  622. else if ((pAc->Csum.ReceiveFlags[NetNumber] & SKCS_PROTO_UDP) != 0 &&
  623. NextLevelProtocol == SKCS_PROTO_ID_UDP) {
  624. /* UDP/IP frame. */
  625. NextLevelProtoStats =
  626. &pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_UDP];
  627. }
  628. else {
  629. /*
  630.  * Either not a TCP or UDP frame and/or TCP/UDP processing not
  631.  * specified.
  632.  */
  633. return (SKCS_STATUS_IP_CSUM_OK);
  634. }
  636. /* Check if this is an IP fragment. */
  638. /*
  639.  * Note: An IP fragment has a non-zero "Fragment Offset" field and/or
  640.  * the "More Fragments" bit set. Thus, if both the "Fragment Offset"
  641.  * and the "More Fragments" are zero, it is *not* a fragment. We can
  642.  * easily check both at the same time since they are in the same 16-bit
  643.  * word.
  644.  */
  646. if ((*(SK_U16 *)
  647. SKCS_IDX(pIpHeader, SKCS_OFS_IP_FLAGS_AND_FRAGMENT_OFFSET) &
  648. ~SKCS_IP_DONT_FRAGMENT) != 0) {
  649. /* IP fragment; ignore all other protocols. */
  650. NextLevelProtoStats->RxUnableCts++;
  651. return (SKCS_STATUS_IP_FRAGMENT);
  652. }
  654. /*
  655.  * 08-May-2000 ra
  656.  *
  657.  * From RFC 768 (UDP)
  658.  * If the computed checksum is zero, it is transmitted as all ones (the
  659.  * equivalent in one's complement arithmetic).  An all zero transmitted
  660.  * checksum value means that the transmitter generated no checksum (for
  661.  * debugging or for higher level protocols that don't care).
  662.  */
  664. if (NextLevelProtocol == SKCS_PROTO_ID_UDP &&
  665. *(SK_U16*)SKCS_IDX(pIpHeader, IpHeaderLength + 6) == 0x0000) {
  667. NextLevelProtoStats->RxOkCts++;
  669. return (SKCS_STATUS_IP_CSUM_OK_NO_UDP);
  670. }
  672. /*
  673.  * Calculate the TCP/UDP checksum.
  674.  */
  676. /* Get total length of IP header and data. */
  678. IpDataLength =
  679. *(SK_U16 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_TOTAL_LENGTH);
  681. /* Get length of IP data portion. */
  683. IpDataLength = SKCS_NTOH16(IpDataLength) - IpHeaderLength;
  685. NextLevelProtocolChecksum =
  687. /* Calculate the pseudo header checksum. */
  689. (unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader,
  690. SKCS_OFS_IP_SOURCE_ADDRESS + 0) +
  691. (unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader,
  692. SKCS_OFS_IP_SOURCE_ADDRESS + 2) +
  693. (unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader,
  694. SKCS_OFS_IP_DESTINATION_ADDRESS + 0) +
  695. (unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader,
  696. SKCS_OFS_IP_DESTINATION_ADDRESS + 2) +
  697. (unsigned long) SKCS_HTON16(NextLevelProtocol) +
  698. (unsigned long) SKCS_HTON16(IpDataLength) +
  700. /* Add the TCP/UDP header checksum. */
  702. (unsigned long) IpDataChecksum;
  704. /* Add-in any carries. */
  706. SKCS_OC_ADD(NextLevelProtocolChecksum, NextLevelProtocolChecksum, 0);
  708. /* Add-in any new carry. */
  710. SKCS_OC_ADD(NextLevelProtocolChecksum, NextLevelProtocolChecksum, 0);
  712. /* Check if the TCP/UDP checksum is ok. */
  714. if ((unsigned) NextLevelProtocolChecksum == 0xFFFF) {
  716. /* TCP/UDP checksum ok. */
  718. NextLevelProtoStats->RxOkCts++;
  720. return (NextLevelProtocol == SKCS_PROTO_ID_TCP ?
  721. SKCS_STATUS_TCP_CSUM_OK : SKCS_STATUS_UDP_CSUM_OK);
  722. }
  724. /* TCP/UDP checksum error. */
  726. NextLevelProtoStats->RxErrCts++;
  728. return (NextLevelProtocol == SKCS_PROTO_ID_TCP ?
  729. SKCS_STATUS_TCP_CSUM_ERROR : SKCS_STATUS_UDP_CSUM_ERROR);
  730. } /* SkCsGetReceiveInfo */
  733. /******************************************************************************
  734.  *
  735.  * SkCsSetReceiveFlags - set checksum receive flags
  736.  *
  737.  * Description:
  738.  * Use this function to set the various receive flags. According to the
  739.  * protocol flags set by the caller, the start offsets within received
  740.  * packets of the two hardware checksums are returned. These offsets must
  741.  * be stored in all receive descriptors.
  742.  *
  743.  * Arguments:
  744.  * pAc - Pointer to adapter context struct.
  745.  *
  746.  * ReceiveFlags - Any combination of SK_PROTO_XXX flags of the protocols
  747.  * for which the caller wants checksum information on received frames.
  748.  *
  749.  * pChecksum1Offset - The start offset of the first receive descriptor
  750.  * hardware checksum to be calculated for received frames is returned
  751.  * here.
  752.  *
  753.  * pChecksum2Offset - The start offset of the second receive descriptor
  754.  * hardware checksum to be calculated for received frames is returned
  755.  * here.
  756.  *
  757.  * Returns: N/A
  758.  * Returns the two hardware checksum start offsets.
  759.  */
  760. void SkCsSetReceiveFlags(
  761. SK_AC *pAc, /* Adapter context struct. */
  762. unsigned ReceiveFlags, /* New receive flags. */
  763. unsigned *pChecksum1Offset, /* Offset for hardware checksum 1. */
  764. unsigned *pChecksum2Offset, /* Offset for hardware checksum 2. */
  765. int NetNumber)
  766. {
  767. /* Save the receive flags. */
  769. pAc->Csum.ReceiveFlags[NetNumber] = ReceiveFlags;
  771. /* First checksum start offset is the IP header. */
  772. *pChecksum1Offset = SKCS_MAC_HEADER_SIZE;
  774. /*
  775.  * Second checksum start offset is the IP data. Note that this may vary
  776.  * if there are any IP header options in the actual packet.
  777.  */
  778. *pChecksum2Offset = SKCS_MAC_HEADER_SIZE + SKCS_IP_HEADER_SIZE;
  779. } /* SkCsSetReceiveFlags */
  781. #ifndef SkCsCalculateChecksum
  783. /******************************************************************************
  784.  *
  785.  * SkCsCalculateChecksum - calculate checksum for specified data
  786.  *
  787.  * Description:
  788.  * Calculate and return the 16-bit Internet Checksum for the specified
  789.  * data.
  790.  *
  791.  * Arguments:
  792.  * pData - Pointer to data for which the checksum shall be calculated.
  793.  * Note: The pointer should be aligned on a 16-bit boundary.
  794.  *
  795.  * Length - Length in bytes of data to checksum.
  796.  *
  797.  * Returns:
  798.  * The 16-bit Internet Checksum for the specified data.
  799.  *
  800.  * Note: The checksum is calculated in the machine's natural byte order,
  801.  * i.e. little vs. big endian. Thus, the resulting checksum is different
  802.  * for the same input data on little and big endian machines.
  803.  *
  804.  * However, when written back to the network packet, the byte order is
  805.  * always in correct network order.
  806.  */
  807. unsigned SkCsCalculateChecksum(
  808. void *pData, /* Data to checksum. */
  809. unsigned Length) /* Length of data. */
  810. {
  811. SK_U16 *pU16; /* Pointer to the data as 16-bit words. */
  812. unsigned long Checksum; /* Checksum; must be at least 32 bits. */
  814. /* Sum up all 16-bit words. */
  816. pU16 = (SK_U16 *) pData;
  817. for (Checksum = 0; Length > 1; Length -= 2) {
  818. Checksum += *pU16++;
  819. }
  821. /* If this is an odd number of bytes, add-in the last byte. */
  823. if (Length > 0) {
  824. #ifdef SK_BIG_ENDIAN
  825. /* Add the last byte as the high byte. */
  826. Checksum += ((unsigned) *(SK_U8 *) pU16) << 8;
  827. #else /* !SK_BIG_ENDIAN */
  828. /* Add the last byte as the low byte. */
  829. Checksum += *(SK_U8 *) pU16;
  830. #endif /* !SK_BIG_ENDIAN */
  831. }
  833. /* Add-in any carries. */
  835. SKCS_OC_ADD(Checksum, Checksum, 0);
  837. /* Add-in any new carry. */
  839. SKCS_OC_ADD(Checksum, Checksum, 0);
  841. /* Note: All bits beyond the 16-bit limit are now zero. */
  843. return ((unsigned) Checksum);
  844. } /* SkCsCalculateChecksum */
  846. #endif /* SkCsCalculateChecksum */
  848. /******************************************************************************
  849.  *
  850.  * SkCsEvent - the CSUM event dispatcher
  851.  *
  852.  * Description:
  853.  * This is the event handler for the CSUM module.
  854.  *
  855.  * Arguments:
  856.  * pAc - Pointer to adapter context.
  857.  *
  858.  * Ioc - I/O context.
  859.  *
  860.  * Event -  Event id.
  861.  *
  862.  * Param - Event dependent parameter.
  863.  *
  864.  * Returns:
  865.  * The 16-bit Internet Checksum for the specified data.
  866.  *
  867.  * Note: The checksum is calculated in the machine's natural byte order,
  868.  * i.e. little vs. big endian. Thus, the resulting checksum is different
  869.  * for the same input data on little and big endian machines.
  870.  *
  871.  * However, when written back to the network packet, the byte order is
  872.  * always in correct network order.
  873.  */
  874. int SkCsEvent(
  875. SK_AC *pAc, /* Pointer to adapter context. */
  876. SK_IOC Ioc, /* I/O context. */
  877. SK_U32 Event, /* Event id. */
  878. SK_EVPARA Param) /* Event dependent parameter. */
  879. {
  880. int ProtoIndex;
  881. int NetNumber;
  883. switch (Event) {
  884. /*
  885.  * Clear protocol statistics.
  886.  *
  887.  * Param - Protocol index, or -1 for all protocols.
  888.  *  - Net number.
  889.  */
  890. case SK_CSUM_EVENT_CLEAR_PROTO_STATS:
  892. ProtoIndex = (int)Param.Para32[0];
  893. NetNumber = (int)Param.Para32[1];
  894. if (ProtoIndex < 0) { /* Clear for all protocols. */
  895. memset(&pAc->Csum.ProtoStats[NetNumber][0], 0,
  896. sizeof(pAc->Csum.ProtoStats[NetNumber]));
  897. }
  898. else { /* Clear for individual protocol. */
  899. memset(&pAc->Csum.ProtoStats[NetNumber][ProtoIndex], 0,
  900. sizeof(pAc->Csum.ProtoStats[NetNumber][ProtoIndex]));
  901. }
  902. break;
  903. default:
  904. break;
  905. }
  906. return (0); /* Success. */
  907. } /* SkCsEvent */
  909. #endif /* SK_USE_CSUM */