net/phonet/pep-gprs.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * File: pep-gprs.c
0004  *
0005  * GPRS over Phonet pipe end point socket
0006  *
0007  * Copyright (C) 2008 Nokia Corporation.
0008  *
0009  * Author: Rémi Denis-Courmont
0010  */
0011
0012 #include <linux/kernel.h>
0013 #include <linux/netdevice.h>
0014 #include <linux/if_ether.h>
0015 #include <linux/if_arp.h>
0016 #include <net/sock.h>
0017
0018 #include <linux/if_phonet.h>
0019 #include <net/tcp_states.h>
0020 #include <net/phonet/gprs.h>
0021
0022 #define GPRS_DEFAULT_MTU 1400
0023
0024 struct gprs_dev {
0025     struct sock     *sk;
0026     void            (*old_state_change)(struct sock *);
0027     void            (*old_data_ready)(struct sock *);
0028     void            (*old_write_space)(struct sock *);
0029
0030     struct net_device   *dev;
0031 };
0032
0033 static __be16 gprs_type_trans(struct sk_buff *skb)
0034 {
0035     const u8 *pvfc;
0036     u8 buf;
0037
0038     pvfc = skb_header_pointer(skb, 0, 1, &buf);
0039     if (!pvfc)
0040         return htons(0);
0041     /* Look at IP version field */
0042     switch (*pvfc >> 4) {
0043     case 4:
0044         return htons(ETH_P_IP);
0045     case 6:
0046         return htons(ETH_P_IPV6);
0047     }
0048     return htons(0);
0049 }
0050
0051 static void gprs_writeable(struct gprs_dev *gp)
0052 {
0053     struct net_device *dev = gp->dev;
0054
0055     if (pep_writeable(gp->sk))
0056         netif_wake_queue(dev);
0057 }
0058
0059 /*
0060  * Socket callbacks
0061  */
0062
0063 static void gprs_state_change(struct sock *sk)
0064 {
0065     struct gprs_dev *gp = sk->sk_user_data;
0066
0067     if (sk->sk_state == TCP_CLOSE_WAIT) {
0068         struct net_device *dev = gp->dev;
0069
0070         netif_stop_queue(dev);
0071         netif_carrier_off(dev);
0072     }
0073 }
0074
0075 static int gprs_recv(struct gprs_dev *gp, struct sk_buff *skb)
0076 {
0077     struct net_device *dev = gp->dev;
0078     int err = 0;
0079     __be16 protocol = gprs_type_trans(skb);
0080
0081     if (!protocol) {
0082         err = -EINVAL;
0083         goto drop;
0084     }
0085
0086     if (skb_headroom(skb) & 3) {
0087         struct sk_buff *rskb, *fs;
0088         int flen = 0;
0089
0090         /* Phonet Pipe data header may be misaligned (3 bytes),
0091          * so wrap the IP packet as a single fragment of an head-less
0092          * socket buffer. The network stack will pull what it needs,
0093          * but at least, the whole IP payload is not memcpy'd. */
0094         rskb = netdev_alloc_skb(dev, 0);
0095         if (!rskb) {
0096             err = -ENOBUFS;
0097             goto drop;
0098         }
0099         skb_shinfo(rskb)->frag_list = skb;
0100         rskb->len += skb->len;
0101         rskb->data_len += rskb->len;
0102         rskb->truesize += rskb->len;
0103
0104         /* Avoid nested fragments */
0105         skb_walk_frags(skb, fs)
0106             flen += fs->len;
0107         skb->next = skb_shinfo(skb)->frag_list;
0108         skb_frag_list_init(skb);
0109         skb->len -= flen;
0110         skb->data_len -= flen;
0111         skb->truesize -= flen;
0112
0113         skb = rskb;
0114     }
0115
0116     skb->protocol = protocol;
0117     skb_reset_mac_header(skb);
0118     skb->dev = dev;
0119
0120     if (likely(dev->flags & IFF_UP)) {
0121         dev->stats.rx_packets++;
0122         dev->stats.rx_bytes += skb->len;
0123         netif_rx(skb);
0124         skb = NULL;
0125     } else
0126         err = -ENODEV;
0127
0128 drop:
0129     if (skb) {
0130         dev_kfree_skb(skb);
0131         dev->stats.rx_dropped++;
0132     }
0133     return err;
0134 }
0135
0136 static void gprs_data_ready(struct sock *sk)
0137 {
0138     struct gprs_dev *gp = sk->sk_user_data;
0139     struct sk_buff *skb;
0140
0141     while ((skb = pep_read(sk)) != NULL) {
0142         skb_orphan(skb);
0143         gprs_recv(gp, skb);
0144     }
0145 }
0146
0147 static void gprs_write_space(struct sock *sk)
0148 {
0149     struct gprs_dev *gp = sk->sk_user_data;
0150
0151     if (netif_running(gp->dev))
0152         gprs_writeable(gp);
0153 }
0154
0155 /*
0156  * Network device callbacks
0157  */
0158
0159 static int gprs_open(struct net_device *dev)
0160 {
0161     struct gprs_dev *gp = netdev_priv(dev);
0162
0163     gprs_writeable(gp);
0164     return 0;
0165 }
0166
0167 static int gprs_close(struct net_device *dev)
0168 {
0169     netif_stop_queue(dev);
0170     return 0;
0171 }
0172
0173 static netdev_tx_t gprs_xmit(struct sk_buff *skb, struct net_device *dev)
0174 {
0175     struct gprs_dev *gp = netdev_priv(dev);
0176     struct sock *sk = gp->sk;
0177     int len, err;
0178
0179     switch (skb->protocol) {
0180     case  htons(ETH_P_IP):
0181     case  htons(ETH_P_IPV6):
0182         break;
0183     default:
0184         dev_kfree_skb(skb);
0185         return NETDEV_TX_OK;
0186     }
0187
0188     skb_orphan(skb);
0189     skb_set_owner_w(skb, sk);
0190     len = skb->len;
0191     err = pep_write(sk, skb);
0192     if (err) {
0193         net_dbg_ratelimited("%s: TX error (%d)\n", dev->name, err);
0194         dev->stats.tx_aborted_errors++;
0195         dev->stats.tx_errors++;
0196     } else {
0197         dev->stats.tx_packets++;
0198         dev->stats.tx_bytes += len;
0199     }
0200
0201     netif_stop_queue(dev);
0202     if (pep_writeable(sk))
0203         netif_wake_queue(dev);
0204     return NETDEV_TX_OK;
0205 }
0206
0207 static const struct net_device_ops gprs_netdev_ops = {
0208     .ndo_open   = gprs_open,
0209     .ndo_stop   = gprs_close,
0210     .ndo_start_xmit = gprs_xmit,
0211 };
0212
0213 static void gprs_setup(struct net_device *dev)
0214 {
0215     dev->features       = NETIF_F_FRAGLIST;
0216     dev->type       = ARPHRD_PHONET_PIPE;
0217     dev->flags      = IFF_POINTOPOINT | IFF_NOARP;
0218     dev->mtu        = GPRS_DEFAULT_MTU;
0219     dev->min_mtu        = 576;
0220     dev->max_mtu        = (PHONET_MAX_MTU - 11);
0221     dev->hard_header_len    = 0;
0222     dev->addr_len       = 0;
0223     dev->tx_queue_len   = 10;
0224
0225     dev->netdev_ops     = &gprs_netdev_ops;
0226     dev->needs_free_netdev  = true;
0227 }
0228
0229 /*
0230  * External interface
0231  */
0232
0233 /*
0234  * Attach a GPRS interface to a datagram socket.
0235  * Returns the interface index on success, negative error code on error.
0236  */
0237 int gprs_attach(struct sock *sk)
0238 {
0239     static const char ifname[] = "gprs%d";
0240     struct gprs_dev *gp;
0241     struct net_device *dev;
0242     int err;
0243
0244     if (unlikely(sk->sk_type == SOCK_STREAM))
0245         return -EINVAL; /* need packet boundaries */
0246
0247     /* Create net device */
0248     dev = alloc_netdev(sizeof(*gp), ifname, NET_NAME_UNKNOWN, gprs_setup);
0249     if (!dev)
0250         return -ENOMEM;
0251     gp = netdev_priv(dev);
0252     gp->sk = sk;
0253     gp->dev = dev;
0254
0255     netif_stop_queue(dev);
0256     err = register_netdev(dev);
0257     if (err) {
0258         free_netdev(dev);
0259         return err;
0260     }
0261
0262     lock_sock(sk);
0263     if (unlikely(sk->sk_user_data)) {
0264         err = -EBUSY;
0265         goto out_rel;
0266     }
0267     if (unlikely((1 << sk->sk_state & (TCPF_CLOSE|TCPF_LISTEN)) ||
0268             sock_flag(sk, SOCK_DEAD))) {
0269         err = -EINVAL;
0270         goto out_rel;
0271     }
0272     sk->sk_user_data    = gp;
0273     gp->old_state_change    = sk->sk_state_change;
0274     gp->old_data_ready  = sk->sk_data_ready;
0275     gp->old_write_space = sk->sk_write_space;
0276     sk->sk_state_change = gprs_state_change;
0277     sk->sk_data_ready   = gprs_data_ready;
0278     sk->sk_write_space  = gprs_write_space;
0279     release_sock(sk);
0280     sock_hold(sk);
0281
0282     printk(KERN_DEBUG"%s: attached\n", dev->name);
0283     return dev->ifindex;
0284
0285 out_rel:
0286     release_sock(sk);
0287     unregister_netdev(dev);
0288     return err;
0289 }
0290
0291 void gprs_detach(struct sock *sk)
0292 {
0293     struct gprs_dev *gp = sk->sk_user_data;
0294     struct net_device *dev = gp->dev;
0295
0296     lock_sock(sk);
0297     sk->sk_user_data    = NULL;
0298     sk->sk_state_change = gp->old_state_change;
0299     sk->sk_data_ready   = gp->old_data_ready;
0300     sk->sk_write_space  = gp->old_write_space;
0301     release_sock(sk);
0302
0303     printk(KERN_DEBUG"%s: detached\n", dev->name);
0304     unregister_netdev(dev);
0305     sock_put(sk);
0306 }