~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/phonet/pep-gprs.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.10 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.83 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.153 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.200 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.200 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.76 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp