net/phonet/pep-gprs.c

   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 <remi.denis-courmont@nokia.com>
   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 *, int);
  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 (likely(skb_headroom(skb) & 3)) {
 100                 struct sk_buff *rskb, *fs;
 101                 int flen = 0;
 102
 103                 /* Phonet Pipe data header is 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                 for (fs = skb_shinfo(skb)->frag_list; fs; fs = fs->next)
 119                         flen += fs->len;
 120                 skb->next = skb_shinfo(skb)->frag_list;
 121                 skb_shinfo(skb)->frag_list = NULL;
 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, int len)
 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 int 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 0;
 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                 LIMIT_NETDEBUG(KERN_WARNING"%s: TX error (%d)\n",
 207                                 dev->name, err);
 208                 dev->stats.tx_aborted_errors++;
 209                 dev->stats.tx_errors++;
 210         } else {
 211                 dev->stats.tx_packets++;
 212                 dev->stats.tx_bytes += len;
 213         }
 214
 215         if (!pep_writeable(sk))
 216                 netif_stop_queue(dev);
 217         return 0;
 218 }
 219
 220 static int gprs_set_mtu(struct net_device *dev, int new_mtu)
 221 {
 222         if ((new_mtu < 576) || (new_mtu > (PHONET_MAX_MTU - 11)))
 223                 return -EINVAL;
 224
 225         dev->mtu = new_mtu;
 226         return 0;
 227 }
 228
 229 static const struct net_device_ops gprs_netdev_ops = {
 230         .ndo_open       = gprs_open,
 231         .ndo_stop       = gprs_close,
 232         .ndo_start_xmit = gprs_xmit,
 233         .ndo_change_mtu = gprs_set_mtu,
 234 };
 235
 236 static void gprs_setup(struct net_device *dev)
 237 {
 238         dev->features           = NETIF_F_FRAGLIST;
 239         dev->type               = ARPHRD_PHONET_PIPE;
 240         dev->flags              = IFF_POINTOPOINT | IFF_NOARP;
 241         dev->mtu                = GPRS_DEFAULT_MTU;
 242         dev->hard_header_len    = 0;
 243         dev->addr_len           = 0;
 244         dev->tx_queue_len       = 10;
 245
 246         dev->netdev_ops         = &gprs_netdev_ops;
 247         dev->destructor         = free_netdev;
 248 }
 249
 250 /*
 251  * External interface
 252  */
 253
 254 /*
 255  * Attach a GPRS interface to a datagram socket.
 256  * Returns the interface index on success, negative error code on error.
 257  */
 258 int gprs_attach(struct sock *sk)
 259 {
 260         static const char ifname[] = "gprs%d";
 261         struct gprs_dev *gp;
 262         struct net_device *dev;
 263         int err;
 264
 265         if (unlikely(sk->sk_type == SOCK_STREAM))
 266                 return -EINVAL; /* need packet boundaries */
 267
 268         /* Create net device */
 269         dev = alloc_netdev(sizeof(*gp), ifname, gprs_setup);
 270         if (!dev)
 271                 return -ENOMEM;
 272         gp = netdev_priv(dev);
 273         gp->sk = sk;
 274         gp->dev = dev;
 275
 276         netif_stop_queue(dev);
 277         err = register_netdev(dev);
 278         if (err) {
 279                 free_netdev(dev);
 280                 return err;
 281         }
 282
 283         lock_sock(sk);
 284         if (unlikely(sk->sk_user_data)) {
 285                 err = -EBUSY;
 286                 goto out_rel;
 287         }
 288         if (unlikely((1 << sk->sk_state & (TCPF_CLOSE|TCPF_LISTEN)) ||
 289                         sock_flag(sk, SOCK_DEAD))) {
 290                 err = -EINVAL;
 291                 goto out_rel;
 292         }
 293         sk->sk_user_data        = gp;
 294         gp->old_state_change    = sk->sk_state_change;
 295         gp->old_data_ready      = sk->sk_data_ready;
 296         gp->old_write_space     = sk->sk_write_space;
 297         sk->sk_state_change     = gprs_state_change;
 298         sk->sk_data_ready       = gprs_data_ready;
 299         sk->sk_write_space      = gprs_write_space;
 300         release_sock(sk);
 301         sock_hold(sk);
 302
 303         printk(KERN_DEBUG"%s: attached\n", dev->name);
 304         return dev->ifindex;
 305
 306 out_rel:
 307         release_sock(sk);
 308         unregister_netdev(dev);
 309         return err;
 310 }
 311
 312 void gprs_detach(struct sock *sk)
 313 {
 314         struct gprs_dev *gp = sk->sk_user_data;
 315         struct net_device *dev = gp->dev;
 316
 317         lock_sock(sk);
 318         sk->sk_user_data        = NULL;
 319         sk->sk_state_change     = gp->old_state_change;
 320         sk->sk_data_ready       = gp->old_data_ready;
 321         sk->sk_write_space      = gp->old_write_space;
 322         release_sock(sk);
 323
 324         printk(KERN_DEBUG"%s: detached\n", dev->name);
 325         unregister_netdev(dev);
 326         sock_put(sk);
 327 }