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

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

Version: ~ [ linux-5.8-rc5 ] ~ [ linux-5.7.8 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.51 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.132 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.188 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.230 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.230 ] ~ [ 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.85 ] ~ [ 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-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
  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 

~ [ 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