1 /* 2 * File: pep-gprs.c 3 * 4 * GPRS over Phonet pipe end point socket 5 * 6 * Copyright (C) 2008 Nokia Corporation. 7 * 8 * Author: Rémi Denis-Courmont 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public License 12 * version 2 as published by the Free Software Foundation. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 22 * 02110-1301 USA 23 */ 24 25 #include <linux/kernel.h> 26 #include <linux/netdevice.h> 27 #include <linux/if_ether.h> 28 #include <linux/if_arp.h> 29 #include <net/sock.h> 30 31 #include <linux/if_phonet.h> 32 #include <net/tcp_states.h> 33 #include <net/phonet/gprs.h> 34 35 #define GPRS_DEFAULT_MTU 1400 36 37 struct gprs_dev { 38 struct sock *sk; 39 void (*old_state_change)(struct sock *); 40 void (*old_data_ready)(struct sock *); 41 void (*old_write_space)(struct sock *); 42 43 struct net_device *dev; 44 }; 45 46 static __be16 gprs_type_trans(struct sk_buff *skb) 47 { 48 const u8 *pvfc; 49 u8 buf; 50 51 pvfc = skb_header_pointer(skb, 0, 1, &buf); 52 if (!pvfc) 53 return htons(0); 54 /* Look at IP version field */ 55 switch (*pvfc >> 4) { 56 case 4: 57 return htons(ETH_P_IP); 58 case 6: 59 return htons(ETH_P_IPV6); 60 } 61 return htons(0); 62 } 63 64 static void gprs_writeable(struct gprs_dev *gp) 65 { 66 struct net_device *dev = gp->dev; 67 68 if (pep_writeable(gp->sk)) 69 netif_wake_queue(dev); 70 } 71 72 /* 73 * Socket callbacks 74 */ 75 76 static void gprs_state_change(struct sock *sk) 77 { 78 struct gprs_dev *gp = sk->sk_user_data; 79 80 if (sk->sk_state == TCP_CLOSE_WAIT) { 81 struct net_device *dev = gp->dev; 82 83 netif_stop_queue(dev); 84 netif_carrier_off(dev); 85 } 86 } 87 88 static int gprs_recv(struct gprs_dev *gp, struct sk_buff *skb) 89 { 90 struct net_device *dev = gp->dev; 91 int err = 0; 92 __be16 protocol = gprs_type_trans(skb); 93 94 if (!protocol) { 95 err = -EINVAL; 96 goto drop; 97 } 98 99 if (skb_headroom(skb) & 3) { 100 struct sk_buff *rskb, *fs; 101 int flen = 0; 102 103 /* Phonet Pipe data header may be misaligned (3 bytes), 104 * so wrap the IP packet as a single fragment of an head-less 105 * socket buffer. The network stack will pull what it needs, 106 * but at least, the whole IP payload is not memcpy'd. */ 107 rskb = netdev_alloc_skb(dev, 0); 108 if (!rskb) { 109 err = -ENOBUFS; 110 goto drop; 111 } 112 skb_shinfo(rskb)->frag_list = skb; 113 rskb->len += skb->len; 114 rskb->data_len += rskb->len; 115 rskb->truesize += rskb->len; 116 117 /* Avoid nested fragments */ 118 skb_walk_frags(skb, fs) 119 flen += fs->len; 120 skb->next = skb_shinfo(skb)->frag_list; 121 skb_frag_list_init(skb); 122 skb->len -= flen; 123 skb->data_len -= flen; 124 skb->truesize -= flen; 125 126 skb = rskb; 127 } 128 129 skb->protocol = protocol; 130 skb_reset_mac_header(skb); 131 skb->dev = dev; 132 133 if (likely(dev->flags & IFF_UP)) { 134 dev->stats.rx_packets++; 135 dev->stats.rx_bytes += skb->len; 136 netif_rx(skb); 137 skb = NULL; 138 } else 139 err = -ENODEV; 140 141 drop: 142 if (skb) { 143 dev_kfree_skb(skb); 144 dev->stats.rx_dropped++; 145 } 146 return err; 147 } 148 149 static void gprs_data_ready(struct sock *sk) 150 { 151 struct gprs_dev *gp = sk->sk_user_data; 152 struct sk_buff *skb; 153 154 while ((skb = pep_read(sk)) != NULL) { 155 skb_orphan(skb); 156 gprs_recv(gp, skb); 157 } 158 } 159 160 static void gprs_write_space(struct sock *sk) 161 { 162 struct gprs_dev *gp = sk->sk_user_data; 163 164 if (netif_running(gp->dev)) 165 gprs_writeable(gp); 166 } 167 168 /* 169 * Network device callbacks 170 */ 171 172 static int gprs_open(struct net_device *dev) 173 { 174 struct gprs_dev *gp = netdev_priv(dev); 175 176 gprs_writeable(gp); 177 return 0; 178 } 179 180 static int gprs_close(struct net_device *dev) 181 { 182 netif_stop_queue(dev); 183 return 0; 184 } 185 186 static netdev_tx_t gprs_xmit(struct sk_buff *skb, struct net_device *dev) 187 { 188 struct gprs_dev *gp = netdev_priv(dev); 189 struct sock *sk = gp->sk; 190 int len, err; 191 192 switch (skb->protocol) { 193 case htons(ETH_P_IP): 194 case htons(ETH_P_IPV6): 195 break; 196 default: 197 dev_kfree_skb(skb); 198 return NETDEV_TX_OK; 199 } 200 201 skb_orphan(skb); 202 skb_set_owner_w(skb, sk); 203 len = skb->len; 204 err = pep_write(sk, skb); 205 if (err) { 206 net_dbg_ratelimited("%s: TX error (%d)\n", dev->name, err); 207 dev->stats.tx_aborted_errors++; 208 dev->stats.tx_errors++; 209 } else { 210 dev->stats.tx_packets++; 211 dev->stats.tx_bytes += len; 212 } 213 214 netif_stop_queue(dev); 215 if (pep_writeable(sk)) 216 netif_wake_queue(dev); 217 return NETDEV_TX_OK; 218 } 219 220 static const struct net_device_ops gprs_netdev_ops = { 221 .ndo_open = gprs_open, 222 .ndo_stop = gprs_close, 223 .ndo_start_xmit = gprs_xmit, 224 }; 225 226 static void gprs_setup(struct net_device *dev) 227 { 228 dev->features = NETIF_F_FRAGLIST; 229 dev->type = ARPHRD_PHONET_PIPE; 230 dev->flags = IFF_POINTOPOINT | IFF_NOARP; 231 dev->mtu = GPRS_DEFAULT_MTU; 232 dev->min_mtu = 576; 233 dev->max_mtu = (PHONET_MAX_MTU - 11); 234 dev->hard_header_len = 0; 235 dev->addr_len = 0; 236 dev->tx_queue_len = 10; 237 238 dev->netdev_ops = &gprs_netdev_ops; 239 dev->needs_free_netdev = true; 240 } 241 242 /* 243 * External interface 244 */ 245 246 /* 247 * Attach a GPRS interface to a datagram socket. 248 * Returns the interface index on success, negative error code on error. 249 */ 250 int gprs_attach(struct sock *sk) 251 { 252 static const char ifname[] = "gprs%d"; 253 struct gprs_dev *gp; 254 struct net_device *dev; 255 int err; 256 257 if (unlikely(sk->sk_type == SOCK_STREAM)) 258 return -EINVAL; /* need packet boundaries */ 259 260 /* Create net device */ 261 dev = alloc_netdev(sizeof(*gp), ifname, NET_NAME_UNKNOWN, gprs_setup); 262 if (!dev) 263 return -ENOMEM; 264 gp = netdev_priv(dev); 265 gp->sk = sk; 266 gp->dev = dev; 267 268 netif_stop_queue(dev); 269 err = register_netdev(dev); 270 if (err) { 271 free_netdev(dev); 272 return err; 273 } 274 275 lock_sock(sk); 276 if (unlikely(sk->sk_user_data)) { 277 err = -EBUSY; 278 goto out_rel; 279 } 280 if (unlikely((1 << sk->sk_state & (TCPF_CLOSE|TCPF_LISTEN)) || 281 sock_flag(sk, SOCK_DEAD))) { 282 err = -EINVAL; 283 goto out_rel; 284 } 285 sk->sk_user_data = gp; 286 gp->old_state_change = sk->sk_state_change; 287 gp->old_data_ready = sk->sk_data_ready; 288 gp->old_write_space = sk->sk_write_space; 289 sk->sk_state_change = gprs_state_change; 290 sk->sk_data_ready = gprs_data_ready; 291 sk->sk_write_space = gprs_write_space; 292 release_sock(sk); 293 sock_hold(sk); 294 295 printk(KERN_DEBUG"%s: attached\n", dev->name); 296 return dev->ifindex; 297 298 out_rel: 299 release_sock(sk); 300 unregister_netdev(dev); 301 return err; 302 } 303 304 void gprs_detach(struct sock *sk) 305 { 306 struct gprs_dev *gp = sk->sk_user_data; 307 struct net_device *dev = gp->dev; 308 309 lock_sock(sk); 310 sk->sk_user_data = NULL; 311 sk->sk_state_change = gp->old_state_change; 312 sk->sk_data_ready = gp->old_data_ready; 313 sk->sk_write_space = gp->old_write_space; 314 release_sock(sk); 315 316 printk(KERN_DEBUG"%s: detached\n", dev->name); 317 unregister_netdev(dev); 318 sock_put(sk); 319 } 320