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

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

Linux/Unix编程

开发平台：

Unix_Linux

rfc1201.c：源码内容
  1. /*
  2.  * Linux ARCnet driver - RFC1201 (standard) packet encapsulation
  3.  * 
  4.  * Written 1994-1999 by Avery Pennarun.
  5.  * Derived from skeleton.c by Donald Becker.
  6.  *
  7.  * Special thanks to Contemporary Controls, Inc. (www.ccontrols.com)
  8.  *  for sponsoring the further development of this driver.
  9.  *
  10.  * **********************
  11.  *
  12.  * The original copyright of skeleton.c was as follows:
  13.  *
  14.  * skeleton.c Written 1993 by Donald Becker.
  15.  * Copyright 1993 United States Government as represented by the
  16.  * Director, National Security Agency.  This software may only be used
  17.  * and distributed according to the terms of the GNU General Public License as
  18.  * modified by SRC, incorporated herein by reference.
  19.  *
  20.  * **********************
  21.  *
  22.  * For more details, see drivers/net/arcnet.c
  23.  *
  24.  * **********************
  25.  */
  26. #include <linux/module.h>
  27. #include <linux/init.h>
  28. #include <linux/if_arp.h>
  29. #include <linux/netdevice.h>
  30. #include <linux/skbuff.h>
  31. #include <linux/arcdevice.h>
  33. #define VERSION "arcnet: RFC1201 "standard" (`a') encapsulation support loaded.n"
  36. static unsigned short type_trans(struct sk_buff *skb, struct net_device *dev);
  37. static void rx(struct net_device *dev, int bufnum,
  38.        struct archdr *pkthdr, int length);
  39. static int build_header(struct sk_buff *skb, unsigned short type,
  40. uint8_t daddr);
  41. static int prepare_tx(struct net_device *dev, struct archdr *pkt, int length,
  42.       int bufnum);
  43. static int continue_tx(struct net_device *dev, int bufnum);
  45. struct ArcProto rfc1201_proto =
  46. {
  47. 'a',
  48. 1500, /* could be more, but some receivers can't handle it... */
  49. rx,
  50. build_header,
  51. prepare_tx,
  52. continue_tx
  53. };
  56. void __init arcnet_rfc1201_init(void)
  57. {
  58. arc_proto_map[ARC_P_IP]
  59.     = arc_proto_map[ARC_P_ARP]
  60.     = arc_proto_map[ARC_P_RARP]
  61.     = arc_proto_map[ARC_P_IPX]
  62.     = arc_proto_map[ARC_P_NOVELL_EC]
  63.     = &rfc1201_proto;
  65. /* if someone else already owns the broadcast, we won't take it */
  66. if (arc_bcast_proto == arc_proto_default)
  67. arc_bcast_proto = &rfc1201_proto;
  68. }
  71. #ifdef MODULE
  73. MODULE_LICENSE("GPL");
  75. int __init init_module(void)
  76. {
  77. printk(VERSION);
  78. arcnet_rfc1201_init();
  79. return 0;
  80. }
  82. void cleanup_module(void)
  83. {
  84. arcnet_unregister_proto(&rfc1201_proto);
  85. }
  87. #endif /* MODULE */
  90. /*
  91.  * Determine a packet's protocol ID.
  92.  * 
  93.  * With ARCnet we have to convert everything to Ethernet-style stuff.
  94.  */
  95. static unsigned short type_trans(struct sk_buff *skb, struct net_device *dev)
  96. {
  97. struct archdr *pkt = (struct archdr *) skb->data;
  98. struct arc_rfc1201 *soft = &pkt->soft.rfc1201;
  99. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  100. int hdr_size = ARC_HDR_SIZE + RFC1201_HDR_SIZE;
  102. /* Pull off the arcnet header. */
  103. skb->mac.raw = skb->data;
  104. skb_pull(skb, hdr_size);
  106. if (pkt->hard.dest == 0)
  107. skb->pkt_type = PACKET_BROADCAST;
  108. else if (dev->flags & IFF_PROMISC) {
  109. /* if we're not sending to ourselves :) */
  110. if (pkt->hard.dest != dev->dev_addr[0])
  111. skb->pkt_type = PACKET_OTHERHOST;
  112. }
  113. /* now return the protocol number */
  114. switch (soft->proto) {
  115. case ARC_P_IP:
  116. return htons(ETH_P_IP);
  117. case ARC_P_ARP:
  118. return htons(ETH_P_ARP);
  119. case ARC_P_RARP:
  120. return htons(ETH_P_RARP);
  122. case ARC_P_IPX:
  123. case ARC_P_NOVELL_EC:
  124. return htons(ETH_P_802_3);
  125. default:
  126. lp->stats.rx_errors++;
  127. lp->stats.rx_crc_errors++;
  128. return 0;
  129. }
  131. return htons(ETH_P_IP);
  132. }
  135. /* packet receiver */
  136. static void rx(struct net_device *dev, int bufnum,
  137.        struct archdr *pkthdr, int length)
  138. {
  139. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  140. struct sk_buff *skb;
  141. struct archdr *pkt = pkthdr;
  142. struct arc_rfc1201 *soft = &pkthdr->soft.rfc1201;
  143. int saddr = pkt->hard.source, ofs;
  144. struct Incoming *in = &lp->rfc1201.incoming[saddr];
  146. BUGMSG(D_DURING, "it's an RFC1201 packet (length=%d)n", length);
  148. if (length >= MinTU)
  149. ofs = 512 - length;
  150. else
  151. ofs = 256 - length;
  153. if (soft->split_flag == 0xFF) { /* Exception Packet */
  154. if (length >= 4 + RFC1201_HDR_SIZE)
  155. BUGMSG(D_DURING, "compensating for exception packetn");
  156. else {
  157. BUGMSG(D_EXTRA, "short RFC1201 exception packet from %02Xh",
  158.        saddr);
  159. return;
  160. }
  162. /* skip over 4-byte junkola */
  163. length -= 4;
  164. ofs += 4;
  165. lp->hw.copy_from_card(dev, bufnum, 512 - length,
  166.       soft, sizeof(pkt->soft));
  167. }
  168. if (!soft->split_flag) { /* not split */
  169. BUGMSG(D_RX, "incoming is not split (splitflag=%d)n",
  170.        soft->split_flag);
  172. if (in->skb) { /* already assembling one! */
  173. BUGMSG(D_EXTRA, "aborting assembly (seq=%d) for unsplit packet (splitflag=%d, seq=%d)n",
  174.  in->sequence, soft->split_flag, soft->sequence);
  175. lp->rfc1201.aborted_seq = soft->sequence;
  176. dev_kfree_skb_irq(in->skb);
  177. lp->stats.rx_errors++;
  178. lp->stats.rx_missed_errors++;
  179. in->skb = NULL;
  180. }
  181. in->sequence = soft->sequence;
  183. skb = alloc_skb(length + ARC_HDR_SIZE, GFP_ATOMIC);
  184. if (skb == NULL) {
  185. BUGMSG(D_NORMAL, "Memory squeeze, dropping packet.n");
  186. lp->stats.rx_dropped++;
  187. return;
  188. }
  189. skb_put(skb, length + ARC_HDR_SIZE);
  190. skb->dev = dev;
  192. pkt = (struct archdr *) skb->data;
  193. soft = &pkt->soft.rfc1201;
  195. /* up to sizeof(pkt->soft) has already been copied from the card */
  196. memcpy(pkt, pkthdr, sizeof(struct archdr));
  197. if (length > sizeof(pkt->soft))
  198. lp->hw.copy_from_card(dev, bufnum, ofs + sizeof(pkt->soft),
  199.        pkt->soft.raw + sizeof(pkt->soft),
  200.       length - sizeof(pkt->soft));
  202. /*
  203.  * ARP packets have problems when sent from some DOS systems: the
  204.  * source address is always 0!  So we take the hardware source addr
  205.  * (which is impossible to fumble) and insert it ourselves.
  206.  */
  207. if (soft->proto == ARC_P_ARP) {
  208. struct arphdr *arp = (struct arphdr *) soft->payload;
  210. /* make sure addresses are the right length */
  211. if (arp->ar_hln == 1 && arp->ar_pln == 4) {
  212. uint8_t *cptr = (uint8_t *) arp + sizeof(struct arphdr);
  214. if (!*cptr) { /* is saddr = 00? */
  215. BUGMSG(D_EXTRA,
  216.        "ARP source address was 00h, set to %02Xh.n",
  217.        saddr);
  218. lp->stats.rx_crc_errors++;
  219. *cptr = saddr;
  220. } else {
  221. BUGMSG(D_DURING, "ARP source address (%Xh) is fine.n",
  222.        *cptr);
  223. }
  224. } else {
  225. BUGMSG(D_NORMAL, "funny-shaped ARP packet. (%Xh, %Xh)n",
  226.        arp->ar_hln, arp->ar_pln);
  227. lp->stats.rx_errors++;
  228. lp->stats.rx_crc_errors++;
  229. }
  230. }
  231. BUGLVL(D_SKB) arcnet_dump_skb(dev, skb, "rx");
  233. skb->protocol = type_trans(skb, dev);
  234. netif_rx(skb);
  235. dev->last_rx = jiffies;
  236. } else { /* split packet */
  237. /*
  238.  * NOTE: MSDOS ARP packet correction should only need to apply to
  239.  * unsplit packets, since ARP packets are so short.
  240.  *
  241.  * My interpretation of the RFC1201 document is that if a packet is
  242.  * received out of order, the entire assembly process should be
  243.  * aborted.
  244.  *
  245.  * The RFC also mentions "it is possible for successfully received
  246.  * packets to be retransmitted." As of 0.40 all previously received
  247.  * packets are allowed, not just the most recent one.
  248.  *
  249.  * We allow multiple assembly processes, one for each ARCnet card
  250.  * possible on the network.  Seems rather like a waste of memory,
  251.  * but there's no other way to be reliable.
  252.  */
  254. BUGMSG(D_RX, "packet is split (splitflag=%d, seq=%d)n",
  255.        soft->split_flag, in->sequence);
  257. if (in->skb && in->sequence != soft->sequence) {
  258. BUGMSG(D_EXTRA, "wrong seq number (saddr=%d, expected=%d, seq=%d, splitflag=%d)n",
  259.        saddr, in->sequence, soft->sequence,
  260.        soft->split_flag);
  261. dev_kfree_skb_irq(in->skb);
  262. in->skb = NULL;
  263. lp->stats.rx_errors++;
  264. lp->stats.rx_missed_errors++;
  265. in->lastpacket = in->numpackets = 0;
  266. }
  267. if (soft->split_flag & 1) { /* first packet in split */
  268. BUGMSG(D_RX, "brand new splitpacket (splitflag=%d)n",
  269.        soft->split_flag);
  270. if (in->skb) { /* already assembling one! */
  271. BUGMSG(D_EXTRA, "aborting previous (seq=%d) assembly "
  272.        "(splitflag=%d, seq=%d)n",
  273.        in->sequence, soft->split_flag,
  274.        soft->sequence);
  275. lp->stats.rx_errors++;
  276. lp->stats.rx_missed_errors++;
  277. dev_kfree_skb_irq(in->skb);
  278. }
  279. in->sequence = soft->sequence;
  280. in->numpackets = ((unsigned) soft->split_flag >> 1) + 2;
  281. in->lastpacket = 1;
  283. if (in->numpackets > 16) {
  284. BUGMSG(D_EXTRA, "incoming packet more than 16 segments; dropping. (splitflag=%d)n",
  285.        soft->split_flag);
  286. lp->rfc1201.aborted_seq = soft->sequence;
  287. lp->stats.rx_errors++;
  288. lp->stats.rx_length_errors++;
  289. return;
  290. }
  291. in->skb = skb = alloc_skb(508 * in->numpackets + ARC_HDR_SIZE,
  292.   GFP_ATOMIC);
  293. if (skb == NULL) {
  294. BUGMSG(D_NORMAL, "(split) memory squeeze, dropping packet.n");
  295. lp->rfc1201.aborted_seq = soft->sequence;
  296. lp->stats.rx_dropped++;
  297. return;
  298. }
  299. skb->dev = dev;
  300. pkt = (struct archdr *) skb->data;
  301. soft = &pkt->soft.rfc1201;
  303. memcpy(pkt, pkthdr, ARC_HDR_SIZE + RFC1201_HDR_SIZE);
  304. skb_put(skb, ARC_HDR_SIZE + RFC1201_HDR_SIZE);
  306. soft->split_flag = 0; /* end result won't be split */
  307. } else { /* not first packet */
  308. int packetnum = ((unsigned) soft->split_flag >> 1) + 1;
  310. /*
  311.  * if we're not assembling, there's no point trying to
  312.  * continue.
  313.  */
  314. if (!in->skb) {
  315. if (lp->rfc1201.aborted_seq != soft->sequence) {
  316. BUGMSG(D_EXTRA, "can't continue split without starting "
  317.        "first! (splitflag=%d, seq=%d, aborted=%d)n",
  318. soft->split_flag, soft->sequence,
  319.        lp->rfc1201.aborted_seq);
  320. lp->stats.rx_errors++;
  321. lp->stats.rx_missed_errors++;
  322. }
  323. return;
  324. }
  325. in->lastpacket++;
  326. if (packetnum != in->lastpacket) { /* not the right flag! */
  327. /* harmless duplicate? ignore. */
  328. if (packetnum <= in->lastpacket - 1) {
  329. BUGMSG(D_EXTRA, "duplicate splitpacket ignored! (splitflag=%d)n",
  330.        soft->split_flag);
  331. lp->stats.rx_errors++;
  332. lp->stats.rx_frame_errors++;
  333. return;
  334. }
  335. /* "bad" duplicate, kill reassembly */
  336. BUGMSG(D_EXTRA, "out-of-order splitpacket, reassembly "
  337.        "(seq=%d) aborted (splitflag=%d, seq=%d)n",
  338.        in->sequence, soft->split_flag, soft->sequence);
  339. lp->rfc1201.aborted_seq = soft->sequence;
  340. dev_kfree_skb_irq(in->skb);
  341. in->skb = NULL;
  342. lp->stats.rx_errors++;
  343. lp->stats.rx_missed_errors++;
  344. in->lastpacket = in->numpackets = 0;
  345. return;
  346. }
  347. pkt = (struct archdr *) in->skb->data;
  348. soft = &pkt->soft.rfc1201;
  349. }
  351. skb = in->skb;
  353. lp->hw.copy_from_card(dev, bufnum, ofs + RFC1201_HDR_SIZE,
  354.       skb->data + skb->len,
  355.       length - RFC1201_HDR_SIZE);
  356. skb_put(skb, length - RFC1201_HDR_SIZE);
  358. /* are we done? */
  359. if (in->lastpacket == in->numpackets) {
  360. in->skb = NULL;
  361. in->lastpacket = in->numpackets = 0;
  363.     BUGMSG(D_SKB_SIZE, "skb: received %d bytes from %02X (unsplit)n",
  364.      skb->len, pkt->hard.source);
  365.     BUGMSG(D_SKB_SIZE, "skb: received %d bytes from %02X (split)n",
  366.      skb->len, pkt->hard.source);
  367. BUGLVL(D_SKB) arcnet_dump_skb(dev, skb, "rx");
  369. skb->protocol = type_trans(skb, dev);
  370. netif_rx(skb);
  371. dev->last_rx = jiffies;
  372. }
  373. }
  374. }
  377. /* Create the ARCnet hard/soft headers for RFC1201. */
  378. static int build_header(struct sk_buff *skb, unsigned short type,
  379. uint8_t daddr)
  380. {
  381. struct net_device *dev = skb->dev;
  382. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  383. int hdr_size = ARC_HDR_SIZE + RFC1201_HDR_SIZE;
  384. struct archdr *pkt = (struct archdr *) skb_push(skb, hdr_size);
  385. struct arc_rfc1201 *soft = &pkt->soft.rfc1201;
  387. /* set the protocol ID according to RFC1201 */
  388. switch (type) {
  389. case ETH_P_IP:
  390. soft->proto = ARC_P_IP;
  391. break;
  392. case ETH_P_ARP:
  393. soft->proto = ARC_P_ARP;
  394. break;
  395. case ETH_P_RARP:
  396. soft->proto = ARC_P_RARP;
  397. break;
  398. case ETH_P_IPX:
  399. case ETH_P_802_3:
  400. case ETH_P_802_2:
  401. soft->proto = ARC_P_IPX;
  402. break;
  403. case ETH_P_ATALK:
  404. soft->proto = ARC_P_ATALK;
  405. break;
  406. default:
  407. BUGMSG(D_NORMAL, "RFC1201: I don't understand protocol %d (%Xh)n",
  408.        type, type);
  409. lp->stats.tx_errors++;
  410. lp->stats.tx_aborted_errors++;
  411. return 0;
  412. }
  414. /*
  415.  * Set the source hardware address.
  416.  *
  417.  * This is pretty pointless for most purposes, but it can help in
  418.  * debugging.  ARCnet does not allow us to change the source address in
  419.  * the actual packet sent)
  420.  */
  421. pkt->hard.source = *dev->dev_addr;
  423. soft->sequence = htons(lp->rfc1201.sequence++);
  424. soft->split_flag = 0; /* split packets are done elsewhere */
  426. /* see linux/net/ethernet/eth.c to see where I got the following */
  428. if (dev->flags & (IFF_LOOPBACK | IFF_NOARP)) {
  429. /* 
  430.  * FIXME: fill in the last byte of the dest ipaddr here to better
  431.  * comply with RFC1051 in "noarp" mode.  For now, always broadcasting
  432.  * will probably at least get packets sent out :)
  433.  */
  434. pkt->hard.dest = 0;
  435. return hdr_size;
  436. }
  437. /* otherwise, drop in the dest address */
  438. pkt->hard.dest = daddr;
  439. return hdr_size;
  440. }
  443. static void load_pkt(struct net_device *dev, struct arc_hardware *hard,
  444.      struct arc_rfc1201 *soft, int softlen, int bufnum)
  445. {
  446. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  447. int ofs;
  449. /* assume length <= XMTU: someone should have handled that by now. */
  451. if (softlen > MinTU) {
  452. hard->offset[0] = 0;
  453. hard->offset[1] = ofs = 512 - softlen;
  454. } else if (softlen > MTU) { /* exception packet - add an extra header */
  455. struct arc_rfc1201 excsoft;
  457. excsoft.proto = soft->proto;
  458. excsoft.split_flag = 0xff;
  459. excsoft.sequence = 0xffff;
  461. hard->offset[0] = 0;
  462. ofs = 512 - softlen;
  463. hard->offset[1] = ofs - RFC1201_HDR_SIZE;
  464. lp->hw.copy_to_card(dev, bufnum, ofs - RFC1201_HDR_SIZE,
  465.     &excsoft, RFC1201_HDR_SIZE);
  466. } else
  467. hard->offset[0] = ofs = 256 - softlen;
  469. lp->hw.copy_to_card(dev, bufnum, 0, hard, ARC_HDR_SIZE);
  470. lp->hw.copy_to_card(dev, bufnum, ofs, soft, softlen);
  472. lp->lastload_dest = hard->dest;
  473. }
  476. static int prepare_tx(struct net_device *dev, struct archdr *pkt, int length,
  477.       int bufnum)
  478. {
  479. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  480. const int maxsegsize = XMTU - RFC1201_HDR_SIZE;
  481. struct Outgoing *out;
  484. BUGMSG(D_DURING, "prepare_tx: txbufs=%d/%d/%dn",
  485.        lp->next_tx, lp->cur_tx, bufnum);
  487. length -= ARC_HDR_SIZE; /* hard header is not included in packet length */
  488. pkt->soft.rfc1201.split_flag = 0;
  490. /* need to do a split packet? */
  491. if (length > XMTU) {
  492. out = &lp->outgoing;
  494. out->length = length - RFC1201_HDR_SIZE;
  495. out->dataleft = lp->outgoing.length;
  496. out->numsegs = (out->dataleft + maxsegsize - 1) / maxsegsize;
  497. out->segnum = 0;
  499. BUGMSG(D_DURING, "rfc1201 prep_tx: ready for %d-segment split "
  500.        "(%d bytes, seq=%d)n", out->numsegs, out->length,
  501.        pkt->soft.rfc1201.sequence);
  503. return 0; /* not done */
  504. }
  505. /* just load the packet into the buffers and send it off */
  506. load_pkt(dev, &pkt->hard, &pkt->soft.rfc1201, length, bufnum);
  508. return 1; /* done */
  509. }
  512. static int continue_tx(struct net_device *dev, int bufnum)
  513. {
  514. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  515. struct Outgoing *out = &lp->outgoing;
  516. struct arc_hardware *hard = &out->pkt->hard;
  517. struct arc_rfc1201 *soft = &out->pkt->soft.rfc1201, *newsoft;
  518. int maxsegsize = XMTU - RFC1201_HDR_SIZE;
  519. int seglen;
  521. BUGMSG(D_DURING,
  522.   "rfc1201 continue_tx: loading segment %d(+1) of %d (seq=%d)n",
  523.        out->segnum, out->numsegs, soft->sequence);
  525. /* the "new" soft header comes right before the data chunk */
  526. newsoft = (struct arc_rfc1201 *)
  527.     (out->pkt->soft.raw + out->length - out->dataleft);
  529. if (!out->segnum) /* first packet; newsoft == soft */
  530. newsoft->split_flag = ((out->numsegs - 2) << 1) | 1;
  531. else {
  532. newsoft->split_flag = out->segnum << 1;
  533. newsoft->proto = soft->proto;
  534. newsoft->sequence = soft->sequence;
  535. }
  537. seglen = maxsegsize;
  538. if (seglen > out->dataleft)
  539. seglen = out->dataleft;
  540. out->dataleft -= seglen;
  542. load_pkt(dev, hard, newsoft, seglen + RFC1201_HDR_SIZE, bufnum);
  544. out->segnum++;
  545. if (out->segnum >= out->numsegs)
  546. return 1;
  547. else
  548. return 0;
  549. }