Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * llc_input.c - Minimal input path for LLC |
| 3 | * |
| 4 | * Copyright (c) 1997 by Procom Technology, Inc. |
| 5 | * 2001-2003 by Arnaldo Carvalho de Melo <acme@conectiva.com.br> |
| 6 | * |
| 7 | * This program can be redistributed or modified under the terms of the |
| 8 | * GNU General Public License as published by the Free Software Foundation. |
| 9 | * This program is distributed without any warranty or implied warranty |
| 10 | * of merchantability or fitness for a particular purpose. |
| 11 | * |
| 12 | * See the GNU General Public License for more details. |
| 13 | */ |
| 14 | #include <linux/netdevice.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 15 | #include <linux/slab.h> |
Eric W. Biederman | e730c15 | 2007-09-17 11:53:39 -0700 | [diff] [blame] | 16 | #include <net/net_namespace.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | #include <net/llc.h> |
| 18 | #include <net/llc_pdu.h> |
| 19 | #include <net/llc_sap.h> |
| 20 | |
| 21 | #if 0 |
| 22 | #define dprintk(args...) printk(KERN_DEBUG args) |
| 23 | #else |
| 24 | #define dprintk(args...) |
| 25 | #endif |
| 26 | |
| 27 | /* |
| 28 | * Packet handler for the station, registerable because in the minimal |
| 29 | * LLC core that is taking shape only the very minimal subset of LLC that |
| 30 | * is needed for things like IPX, Appletalk, etc will stay, with all the |
| 31 | * rest in the llc1 and llc2 modules. |
| 32 | */ |
| 33 | static void (*llc_station_handler)(struct sk_buff *skb); |
| 34 | |
| 35 | /* |
| 36 | * Packet handlers for LLC_DEST_SAP and LLC_DEST_CONN. |
| 37 | */ |
| 38 | static void (*llc_type_handlers[2])(struct llc_sap *sap, |
| 39 | struct sk_buff *skb); |
| 40 | |
| 41 | void llc_add_pack(int type, void (*handler)(struct llc_sap *sap, |
| 42 | struct sk_buff *skb)) |
| 43 | { |
| 44 | if (type == LLC_DEST_SAP || type == LLC_DEST_CONN) |
| 45 | llc_type_handlers[type - 1] = handler; |
| 46 | } |
| 47 | |
| 48 | void llc_remove_pack(int type) |
| 49 | { |
| 50 | if (type == LLC_DEST_SAP || type == LLC_DEST_CONN) |
| 51 | llc_type_handlers[type - 1] = NULL; |
| 52 | } |
| 53 | |
| 54 | void llc_set_station_handler(void (*handler)(struct sk_buff *skb)) |
| 55 | { |
| 56 | llc_station_handler = handler; |
| 57 | } |
| 58 | |
| 59 | /** |
| 60 | * llc_pdu_type - returns which LLC component must handle for PDU |
| 61 | * @skb: input skb |
| 62 | * |
| 63 | * This function returns which LLC component must handle this PDU. |
| 64 | */ |
| 65 | static __inline__ int llc_pdu_type(struct sk_buff *skb) |
| 66 | { |
| 67 | int type = LLC_DEST_CONN; /* I-PDU or S-PDU type */ |
| 68 | struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb); |
| 69 | |
| 70 | if ((pdu->ctrl_1 & LLC_PDU_TYPE_MASK) != LLC_PDU_TYPE_U) |
| 71 | goto out; |
| 72 | switch (LLC_U_PDU_CMD(pdu)) { |
| 73 | case LLC_1_PDU_CMD_XID: |
| 74 | case LLC_1_PDU_CMD_UI: |
| 75 | case LLC_1_PDU_CMD_TEST: |
| 76 | type = LLC_DEST_SAP; |
| 77 | break; |
| 78 | case LLC_2_PDU_CMD_SABME: |
| 79 | case LLC_2_PDU_CMD_DISC: |
| 80 | case LLC_2_PDU_RSP_UA: |
| 81 | case LLC_2_PDU_RSP_DM: |
| 82 | case LLC_2_PDU_RSP_FRMR: |
| 83 | break; |
| 84 | default: |
| 85 | type = LLC_DEST_INVALID; |
| 86 | break; |
| 87 | } |
| 88 | out: |
| 89 | return type; |
| 90 | } |
| 91 | |
| 92 | /** |
| 93 | * llc_fixup_skb - initializes skb pointers |
| 94 | * @skb: This argument points to incoming skb |
| 95 | * |
| 96 | * Initializes internal skb pointer to start of network layer by deriving |
| 97 | * length of LLC header; finds length of LLC control field in LLC header |
| 98 | * by looking at the two lowest-order bits of the first control field |
| 99 | * byte; field is either 3 or 4 bytes long. |
| 100 | */ |
| 101 | static inline int llc_fixup_skb(struct sk_buff *skb) |
| 102 | { |
| 103 | u8 llc_len = 2; |
Jochen Friedrich | 096f0eb | 2005-09-22 04:48:46 -0300 | [diff] [blame] | 104 | struct llc_pdu_un *pdu; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 105 | |
Arnaldo Carvalho de Melo | af426d3 | 2005-09-22 03:59:22 -0300 | [diff] [blame] | 106 | if (unlikely(!pskb_may_pull(skb, sizeof(*pdu)))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 107 | return 0; |
| 108 | |
Jochen Friedrich | 096f0eb | 2005-09-22 04:48:46 -0300 | [diff] [blame] | 109 | pdu = (struct llc_pdu_un *)skb->data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 110 | if ((pdu->ctrl_1 & LLC_PDU_TYPE_MASK) == LLC_PDU_TYPE_U) |
| 111 | llc_len = 1; |
| 112 | llc_len += 2; |
Jochen Friedrich | 096f0eb | 2005-09-22 04:48:46 -0300 | [diff] [blame] | 113 | |
| 114 | if (unlikely(!pskb_may_pull(skb, llc_len))) |
| 115 | return 0; |
| 116 | |
Arnaldo Carvalho de Melo | b0e380b | 2007-04-10 21:21:55 -0700 | [diff] [blame] | 117 | skb->transport_header += llc_len; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 118 | skb_pull(skb, llc_len); |
| 119 | if (skb->protocol == htons(ETH_P_802_2)) { |
Al Viro | 3fbd418 | 2006-11-08 00:26:05 -0800 | [diff] [blame] | 120 | __be16 pdulen = eth_hdr(skb)->h_proto; |
Joonwoo Park | 27785d8 | 2008-03-28 16:27:33 -0700 | [diff] [blame] | 121 | s32 data_size = ntohs(pdulen) - llc_len; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 122 | |
Joonwoo Park | 27785d8 | 2008-03-28 16:27:33 -0700 | [diff] [blame] | 123 | if (data_size < 0 || |
| 124 | ((skb_tail_pointer(skb) - |
| 125 | (u8 *)pdu) - llc_len) < data_size) |
| 126 | return 0; |
David S. Miller | 5185db0 | 2006-04-19 15:37:13 -0700 | [diff] [blame] | 127 | if (unlikely(pskb_trim_rcsum(skb, data_size))) |
| 128 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 129 | } |
| 130 | return 1; |
| 131 | } |
| 132 | |
| 133 | /** |
| 134 | * llc_rcv - 802.2 entry point from net lower layers |
| 135 | * @skb: received pdu |
| 136 | * @dev: device that receive pdu |
| 137 | * @pt: packet type |
| 138 | * |
| 139 | * When the system receives a 802.2 frame this function is called. It |
| 140 | * checks SAP and connection of received pdu and passes frame to |
| 141 | * llc_{station,sap,conn}_rcv for sending to proper state machine. If |
| 142 | * the frame is related to a busy connection (a connection is sending |
| 143 | * data now), it queues this frame in the connection's backlog. |
| 144 | */ |
| 145 | int llc_rcv(struct sk_buff *skb, struct net_device *dev, |
David S. Miller | f2ccd8f | 2005-08-09 19:34:12 -0700 | [diff] [blame] | 146 | struct packet_type *pt, struct net_device *orig_dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 147 | { |
| 148 | struct llc_sap *sap; |
| 149 | struct llc_pdu_sn *pdu; |
| 150 | int dest; |
Stephen Hemminger | 23dbe79 | 2006-05-25 15:09:37 -0700 | [diff] [blame] | 151 | int (*rcv)(struct sk_buff *, struct net_device *, |
| 152 | struct packet_type *, struct net_device *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 153 | |
YOSHIFUJI Hideaki | 721499e | 2008-07-19 22:34:43 -0700 | [diff] [blame] | 154 | if (!net_eq(dev_net(dev), &init_net)) |
Eric W. Biederman | e730c15 | 2007-09-17 11:53:39 -0700 | [diff] [blame] | 155 | goto drop; |
| 156 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 157 | /* |
| 158 | * When the interface is in promisc. mode, drop all the crap that it |
| 159 | * receives, do not try to analyse it. |
| 160 | */ |
| 161 | if (unlikely(skb->pkt_type == PACKET_OTHERHOST)) { |
Harvey Harrison | 0dc4787 | 2008-03-05 20:47:47 -0800 | [diff] [blame] | 162 | dprintk("%s: PACKET_OTHERHOST\n", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 163 | goto drop; |
| 164 | } |
| 165 | skb = skb_share_check(skb, GFP_ATOMIC); |
| 166 | if (unlikely(!skb)) |
| 167 | goto out; |
| 168 | if (unlikely(!llc_fixup_skb(skb))) |
| 169 | goto drop; |
| 170 | pdu = llc_pdu_sn_hdr(skb); |
| 171 | if (unlikely(!pdu->dsap)) /* NULL DSAP, refer to station */ |
| 172 | goto handle_station; |
| 173 | sap = llc_sap_find(pdu->dsap); |
| 174 | if (unlikely(!sap)) {/* unknown SAP */ |
Harvey Harrison | 0dc4787 | 2008-03-05 20:47:47 -0800 | [diff] [blame] | 175 | dprintk("%s: llc_sap_find(%02X) failed!\n", __func__, |
YOSHIFUJI Hideaki | d57b186 | 2007-02-09 23:25:01 +0900 | [diff] [blame] | 176 | pdu->dsap); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 177 | goto drop; |
| 178 | } |
| 179 | /* |
| 180 | * First the upper layer protocols that don't need the full |
| 181 | * LLC functionality |
| 182 | */ |
Stephen Hemminger | 23dbe79 | 2006-05-25 15:09:37 -0700 | [diff] [blame] | 183 | rcv = rcu_dereference(sap->rcv_func); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 184 | dest = llc_pdu_type(skb); |
Changli Gao | 696ea47 | 2011-02-22 01:55:18 +0000 | [diff] [blame^] | 185 | if (unlikely(!dest || !llc_type_handlers[dest - 1])) { |
| 186 | if (rcv) |
| 187 | rcv(skb, dev, pt, orig_dev); |
| 188 | else |
| 189 | kfree_skb(skb); |
| 190 | } else { |
| 191 | if (rcv) { |
| 192 | struct sk_buff *cskb = skb_clone(skb, GFP_ATOMIC); |
| 193 | if (cskb) |
| 194 | rcv(cskb, dev, pt, orig_dev); |
| 195 | } |
| 196 | llc_type_handlers[dest - 1](sap, skb); |
| 197 | } |
Arnaldo Carvalho de Melo | 6e2144b | 2005-09-22 04:43:05 -0300 | [diff] [blame] | 198 | llc_sap_put(sap); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 199 | out: |
| 200 | return 0; |
| 201 | drop: |
| 202 | kfree_skb(skb); |
| 203 | goto out; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 204 | handle_station: |
| 205 | if (!llc_station_handler) |
| 206 | goto drop; |
| 207 | llc_station_handler(skb); |
| 208 | goto out; |
| 209 | } |
| 210 | |
| 211 | EXPORT_SYMBOL(llc_add_pack); |
| 212 | EXPORT_SYMBOL(llc_remove_pack); |
| 213 | EXPORT_SYMBOL(llc_set_station_handler); |