?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Clean up unused variables.
[vde.git] / ipn / af_ipn.c
blobe15a533129d2f1de357cffb86805a055e69dbf0c
1 /*
2 * Main inter process networking (virtual distributed ethernet) module
3 * (part of the View-OS project: wiki.virtualsquare.org)
4 *
5 * Copyright (C) 2007 Renzo Davoli (renzo@cs.unibo.it)
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * Due to this file being licensed under the GPL there is controversy over
13 * whether this permits you to write a module that #includes this file
14 * without placing your module under the GPL. Please consult a lawyer for
15 * advice before doing this.
16 *
17 * WARNING: THIS CODE IS ALREADY EXPERIMENTAL
18 *
19 */
20
21 #include <linux/init.h>
22 #include <linux/module.h>
23 #include <linux/socket.h>
24 #include <linux/namei.h>
25 #include <linux/poll.h>
26 #include <linux/un.h>
27 #include <linux/list.h>
28 #include <linux/mount.h>
29 #include <linux/version.h>
30 #include <net/sock.h>
31 /*
32 #include <net/af_ipn.h>
33 */
34 #include "af_ipn.h"
35 #include "ipn_netdev.h"
36 #include "ipn_msgbuf.h"
37 #include "ipn_chrdev.h"
38
39 MODULE_LICENSE("GPL");
40 MODULE_AUTHOR("VIEW-OS TEAM");
41 MODULE_DESCRIPTION("IPN Kernel Module");
42
43 #define IPN_MAX_PROTO 4
44 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30)
45 #define IPN_PRE2630
46 #endif
47 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)
48 #define IPN_PRE2632
49 #endif
50 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33)
51 #define IPN_PRE2633
52 #endif
53 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37)
54 #define IPN_PRE2637
55 #endif
56 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39)
57 #define IPN_PRE2639
58 #endif
59 #if LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0)
60 #define IPN_PRE310
61 #endif
62 #if LINUX_VERSION_CODE < KERNEL_VERSION(3,9,0)
63 #define IPN_PRE390
64 #endif
65
66 /*extension of RCV_SHUTDOWN defined in include/net/sock.h
67 * when the bit is set recv fails */
68 /* NO_OOB: do not send OOB */
69 #define RCV_SHUTDOWN_NO_OOB 4
70 /* EXTENDED MASK including OOB */
71 #define SHUTDOWN_XMASK (SHUTDOWN_MASK | RCV_SHUTDOWN_NO_OOB)
72 /* if XRCV_SHUTDOWN is all set recv fails */
73 #define XRCV_SHUTDOWN (RCV_SHUTDOWN | RCV_SHUTDOWN_NO_OOB)
74
75 /* Global MUTEX: this is locked to add/delete/modify networks
76 * this is *not* locked just to send/receive msgs */
77 #ifdef IPN_PRE2637
78 static DECLARE_MUTEX(ipn_glob_mutex);
79 #else
80 static DEFINE_SEMAPHORE(ipn_glob_mutex);
81 #endif
82 /* Network table and hash */
83 struct hlist_head ipn_network_table[IPN_HASH_SIZE + 1];
84 /* slab(s) for fast data structure allocation */
85 static struct kmem_cache *ipn_network_cache;
86 static struct kmem_cache *ipn_node_cache;
87 static struct kmem_cache *ipn_msgitem_cache;
88
89 /* Protocol 1: HUB/Broadcast default protocol. Function Prototypes */
90 static int ipn_bcast_newport(struct ipn_node *newport);
91 static int ipn_bcast_handlemsg(struct ipn_node *from,
92 struct msgpool_item *msgitem);
93
94 /* default protocol IPN_BROADCAST (0) */
95 static struct ipn_protocol ipn_bcast = {
96 .refcnt=0,
97 .ipn_p_newport=ipn_bcast_newport,
98 .ipn_p_handlemsg=ipn_bcast_handlemsg};
99 /* Protocol table */
100 static struct ipn_protocol *ipn_protocol_table[IPN_MAX_PROTO]={&ipn_bcast};
101
102 /* Socket call function prototypes */
103 static int ipn_release(struct socket *);
104 static int ipn_bind(struct socket *, struct sockaddr *, int);
105 static int ipn_connect(struct socket *, struct sockaddr *,
106 int addr_len, int flags);
107 static int ipn_getname(struct socket *, struct sockaddr *, int *, int);
108 static unsigned int ipn_poll(struct file *, struct socket *, poll_table *);
109 static int ipn_ioctl(struct socket *, unsigned int, unsigned long);
110 static int ipn_shutdown(struct socket *, int);
111 static int ipn_sendmsg(struct kiocb *, struct socket *,
112 struct msghdr *, size_t);
113 static int ipn_recvmsg(struct kiocb *, struct socket *,
114 struct msghdr *, size_t, int);
115 #ifndef IPN_PRE2632
116 static int ipn_setsockopt(struct socket *sock, int level, int optname,
117 char __user *optval, unsigned int optlen);
118 #else
119 static int ipn_setsockopt(struct socket *sock, int level, int optname,
120 char __user *optval, int optlen);
121 #endif
122 static int ipn_getsockopt(struct socket *sock, int level, int optname,
123 char __user *optval, int __user *optlen);
124
125 /* Network table Management
126 * inode->ipn_network hash table
127 * protected by ipn_glob_mutex */
128 static inline void ipn_insert_network(struct hlist_head *list, struct ipn_network *ipnn)
129 {
130 hlist_add_head(&ipnn->hnode, list);
131 }
132
133 static inline void ipn_remove_network(struct ipn_network *ipnn)
134 {
135 hlist_del(&ipnn->hnode);
136 }
137
138 static struct ipn_network *ipn_find_network_byinode(struct inode *i)
139 {
140 struct ipn_network *ipnn;
141 #ifdef PRE390
142 struct hlist_node *node;
143
144 hlist_for_each_entry(ipnn, node,
145 &ipn_network_table[i->i_ino & (IPN_HASH_SIZE - 1)], hnode)
146 #else
147 hlist_for_each_entry(ipnn,
148 &ipn_network_table[i->i_ino & (IPN_HASH_SIZE - 1)], hnode)
149 #endif
150 {
151 struct dentry *dentry = ipnn->dentry;
152
153 if(dentry && dentry->d_inode == i)
154 return ipnn;
155 }
156 return NULL;
157 }
158
159 struct ipn_network *ipn_find_network_byfun(
160 int (*fun)(struct ipn_network *,void *),void *funarg)
161 {
162 struct ipn_network *ipnn;
163 int ipn_table_scan;
164
165 for (ipn_table_scan=0;ipn_table_scan<IPN_HASH_SIZE;ipn_table_scan++) {
166 #ifdef PRE390
167 struct hlist_node *node;
168 hlist_for_each_entry(ipnn, node, &ipn_network_table[ipn_table_scan], hnode)
169 #else
170 hlist_for_each_entry(ipnn, &ipn_network_table[ipn_table_scan], hnode)
171 #endif
172
173 {
174 if(fun(ipnn,funarg))
175 return ipnn;
176 }
177 }
178 return NULL;
179 }
180
181 /* msgpool management
182 * msgpool_item are ipn_network dependent (each net has its own MTU)
183 * for each message sent there is one msgpool_item and many struct msgitem
184 * one for each receipient.
185 * msgitem are connected to the node's msgqueue or oobmsgqueue.
186 * when a message is delivered to a process the msgitem is deleted and
187 * the count of the msgpool_item is decreased.
188 * msgpool_item elements gets deleted automatically when count is 0*/
189
190 struct msgitem {
191 struct list_head list;
192 struct msgpool_item *msg;
193 };
194
195 /* alloc a fresh msgpool item. count is set to 1.
196 * the typical use is
197 * ipn_msgpool_alloc
198 * for each receipient
199 * enqueue messages to the process (using msgitem), ipn_msgpool_hold
200 * ipn_msgpool_put
201 * The message can be delivered concurrently. init count to 1 guarantees
202 * that it survives at least until is has been enqueued to all
203 * receivers */
204 /* msgpool_cache == NULL when the ipn network is using the flexible allocation,
205 * i.e. the msgpool item gets allocated by kmalloc instead of using slab */
206 static inline struct msgpool_item *_ipn_msgpool_alloc(struct ipn_network *ipnn, int len)
207 {
208 struct msgpool_item *new;
209 if ((new=ipnn->msgpool_cache?
210 kmem_cache_alloc(ipnn->msgpool_cache,GFP_KERNEL):
211 kmalloc(sizeof(struct msgpool_item)+len,GFP_KERNEL)) != NULL) {
212 atomic_set(&new->count,1);
213 atomic_inc(&ipnn->msgpool_nelem);
214 }
215 return new;
216 }
217
218 /* ipn_msgpool_alloc returns null when leaky, lossless and no space is left
219 * for new msgpool items. When !leaky, it can allocate more msgpooli items,
220 * this temporary overassignment blocks new messages to be delivered until
221 * there is space for a msgpool item to be allocated */
222 struct msgpool_item *ipn_msgpool_alloc(struct ipn_network *ipnn,int leaky,int len)
223 {
224 if (leaky && (ipnn->flags & IPN_FLAG_LOSSLESS) &&
225 atomic_read(&ipnn->msgpool_nelem) < ipnn->msgpool_size)
226 return NULL;
227 else
228 return _ipn_msgpool_alloc(ipnn,len);
229 }
230
231 /* If the service il LOSSLESS, this msgpool call waits for an
232 * available msgpool item */
233 static inline struct msgpool_item *ipn_msgpool_alloc_locking(struct ipn_network *ipnn,int len)
234 {
235 if (ipnn->flags & IPN_FLAG_LOSSLESS) {
236 while (atomic_read(&ipnn->msgpool_nelem) >= ipnn->msgpool_size) {
237 if (wait_event_interruptible_exclusive(ipnn->send_wait,
238 atomic_read(&ipnn->msgpool_nelem) < ipnn->msgpool_size))
239 return NULL;
240 }
241 }
242 return _ipn_msgpool_alloc(ipnn,len);
243 }
244
245 /* register one more user for this msgpool item (i.e. count++) */
246 static inline void ipn_msgpool_hold(struct msgpool_item *msg)
247 {
248 atomic_inc(&msg->count);
249 }
250
251 /* decrease count and delete msgpool_item if count == 0 */
252 void ipn_msgpool_put(struct msgpool_item *old,
253 struct ipn_network *ipnn)
254 {
255 if (atomic_dec_and_test(&old->count)) {
256 if (ipnn->msgpool_cache)
257 kmem_cache_free(ipnn->msgpool_cache,old);
258 else
259 kfree(old);
260 atomic_dec(&ipnn->msgpool_nelem);
261 if (ipnn->flags & IPN_FLAG_LOSSLESS) /* this could be done anyway */
262 wake_up_interruptible(&ipnn->send_wait);
263 }
264 }
265
266 /* socket calls */
267 static const struct proto_ops ipn_ops = {
268 .family = PF_IPN,
269 .owner = THIS_MODULE,
270 .release = ipn_release,
271 .bind = ipn_bind,
272 .connect = ipn_connect,
273 .socketpair = sock_no_socketpair,
274 .accept = sock_no_accept,
275 .getname = ipn_getname,
276 .poll = ipn_poll,
277 .ioctl = ipn_ioctl,
278 .listen = sock_no_listen,
279 .shutdown = ipn_shutdown,
280 .setsockopt = ipn_setsockopt,
281 .getsockopt = ipn_getsockopt,
282 .sendmsg = ipn_sendmsg,
283 .recvmsg = ipn_recvmsg,
284 .mmap = sock_no_mmap,
285 .sendpage = sock_no_sendpage,
286 };
287
288 static struct proto ipn_proto = {
289 .name = "IPN",
290 .owner = THIS_MODULE,
291 .obj_size = sizeof(struct ipn_sock),
292 };
293
294 /* create a new ipn_node */
295 struct ipn_node *ipn_node_create(struct net *net)
296 {
297 struct ipn_node *ipn_node;
298 ipn_node=kmem_cache_alloc(ipn_node_cache,GFP_KERNEL);
299 if (ipn_node!=NULL) {
300 INIT_LIST_HEAD(&ipn_node->nodelist);
301 ipn_node->protocol=0; /* BROADCAST, caller must set a proper value */
302 ipn_node->flags=IPN_NODEFLAG_INUSE;
303 ipn_node->shutdown=RCV_SHUTDOWN_NO_OOB;
304 ipn_node->descr[0]=0;
305 ipn_node->portno=IPN_PORTNO_ANY;
306 ipn_node->net=net;
307 ipn_node->netdev=NULL;
308 ipn_node->chrdev=0;
309 ipn_node->proto_private=NULL;
310 ipn_node->totmsgcount=0;
311 ipn_node->oobmsgcount=0;
312 spin_lock_init(&ipn_node->msglock);
313 INIT_LIST_HEAD(&ipn_node->msgqueue);
314 INIT_LIST_HEAD(&ipn_node->oobmsgqueue);
315 ipn_node->ipn=NULL;
316 init_waitqueue_head(&ipn_node->read_wait);
317 ipn_node->pbp=NULL;
318 }
319 return ipn_node;
320 }
321
322 /* create a socket
323 * ipn_node is a separate structure, pointed by ipn_sock -> node
324 * when a node is "persistent", ipn_node survives while ipn_sock gets released*/
325 #ifdef IPN_PRE2633
326 static int ipn_create(struct net *net,struct socket *sock, int protocol)
327 #else
328 static int ipn_create(struct net *net,struct socket *sock,
329 int protocol, int kern)
330 #endif
331 {
332 struct ipn_sock *ipn_sk;
333
334 if (net != &init_net)
335 return -EAFNOSUPPORT;
336
337 if (sock->type != SOCK_RAW)
338 return -EPROTOTYPE;
339 if (protocol > 0)
340 protocol=protocol-1;
341 else
342 protocol=IPN_BROADCAST-1;
343 if (protocol < 0 || protocol >= IPN_MAX_PROTO ||
344 ipn_protocol_table[protocol] == NULL)
345 return -EPROTONOSUPPORT;
346 ipn_sk = (struct ipn_sock *) sk_alloc(net, PF_IPN, GFP_KERNEL, &ipn_proto);
347
348 if (!ipn_sk)
349 return -ENOMEM;
350 if ((ipn_sk->node=ipn_node_create(net))==NULL) {
351 sock_put((struct sock *) ipn_sk);
352 return -ENOMEM;
353 }
354 ipn_sk->node->protocol=protocol;
355 sock_init_data(sock,(struct sock *) ipn_sk);
356 sock->state = SS_UNCONNECTED;
357 sock->ops = &ipn_ops;
358 sock->sk=(struct sock *)ipn_sk;
359 return 0;
360 }
361
362 /* update # of readers and # of writers counters for an ipn network.
363 * This function sends oob messages to nodes requesting the service */
364 /* LOCKING ipnn_mutex is locked */
365 static void ipn_net_update_counters(struct ipn_network *ipnn,
366 int chg_readers, int chg_writers) {
367 ipnn->numreaders += chg_readers;
368 ipnn->numwriters += chg_writers;
369 if (ipnn->mtu >= sizeof(struct numnode_oob))
370 {
371 struct msgpool_item *ipn_msg=_ipn_msgpool_alloc(ipnn,sizeof(struct numnode_oob));
372 if (ipn_msg) {
373 struct numnode_oob *oob_msg=(struct numnode_oob *)(ipn_msg->data);
374 struct ipn_node *ipn_node;
375 ipn_msg->len=sizeof(struct numnode_oob);
376 oob_msg->level=IPN_ANY;
377 oob_msg->tag=IPN_OOB_NUMNODE_TAG;
378 oob_msg->numreaders=ipnn->numreaders;
379 oob_msg->numwriters=ipnn->numwriters;
380 list_for_each_entry(ipn_node, &ipnn->connectqueue, nodelist) {
381 if (ipn_node->flags & IPN_NODEFLAG_OOB_NUMNODES)
382 ipn_proto_oobsendmsg(ipn_node,ipn_msg);
383 }
384 ipn_msgpool_put(ipn_msg,ipnn);
385 }
386 }
387 }
388
389 /* flush pending messages (for close and shutdown RCV) */
390 /* LOCKING: ipnn_mutex is locked */
391 static void ipn_flush_recvqueue(struct ipn_node *ipn_node)
392 {
393 struct ipn_network *ipnn=ipn_node->ipn;
394 spin_lock(&ipn_node->msglock);
395 while (!list_empty(&ipn_node->msgqueue)) {
396 struct msgitem *msgitem=
397 list_first_entry(&ipn_node->msgqueue, struct msgitem, list);
398 list_del(&msgitem->list);
399 ipn_node->totmsgcount--;
400 ipn_msgpool_put(msgitem->msg,ipnn);
401 kmem_cache_free(ipn_msgitem_cache,msgitem);
402 }
403 spin_unlock(&ipn_node->msglock);
404 }
405
406 /* flush pending oob messages (for socket close) */
407 /* LOCKING: ipnn_mutex is locked */
408 static void ipn_flush_oobrecvqueue(struct ipn_node *ipn_node)
409 {
410 struct ipn_network *ipnn=ipn_node->ipn;
411 spin_lock(&ipn_node->msglock);
412 while (!list_empty(&ipn_node->oobmsgqueue)) {
413 struct msgitem *msgitem=
414 list_first_entry(&ipn_node->oobmsgqueue, struct msgitem, list);
415 list_del(&msgitem->list);
416 ipn_node->totmsgcount--;
417 ipn_node->oobmsgcount--;
418 ipn_msgpool_put(msgitem->msg,ipnn);
419 kmem_cache_free(ipn_msgitem_cache,msgitem);
420 }
421 spin_unlock(&ipn_node->msglock);
422 }
423
424 /* Terminate node. The node is "logically" terminated. */
425 /* LOCKING: ipn_glob_lock must be locked here */
426 static int ipn_terminate_node(struct ipn_node *ipn_node)
427 {
428 struct ipn_network *ipnn=ipn_node->ipn;
429 if (ipnn) {
430 if (down_interruptible(&ipnn->ipnn_mutex))
431 return -ERESTARTSYS;
432 if (ipn_node->portno >= 0) {
433 ipn_protocol_table[ipnn->protocol]->ipn_p_predelport(ipn_node);
434 ipnn->connport[ipn_node->portno]=NULL;
435 }
436 list_del(&ipn_node->nodelist);
437 ipn_flush_recvqueue(ipn_node);
438 ipn_flush_oobrecvqueue(ipn_node);
439 if (ipn_node->portno >= 0)
440 ipn_protocol_table[ipnn->protocol]->ipn_p_delport(ipn_node);
441 ipn_node->ipn=NULL;
442 ipn_net_update_counters(ipnn,
443 (ipn_node->shutdown & RCV_SHUTDOWN)?0:-1,
444 (ipn_node->shutdown & SEND_SHUTDOWN)?0:-1);
445 ipn_node->shutdown = SHUTDOWN_XMASK;
446 up(&ipnn->ipnn_mutex);
447 if (ipn_node->netdev)
448 ipn_netdev_close(ipn_node);
449 /* No more network elements */
450 ipnn->refcnt--;
451 if (ipnn->refcnt == 0 && !ipn_is_persistent_chrdev(ipnn))
452 {
453 if (ipnn->chrdev)
454 ipn_deregister_chrdev(ipnn);
455 ipn_protocol_table[ipnn->protocol]->ipn_p_delnet(ipnn);
456 ipn_remove_network(ipnn);
457 ipn_protocol_table[ipnn->protocol]->refcnt--;
458 if (ipnn->dentry) {
459 dput(ipnn->dentry);
460 mntput(ipnn->mnt);
461 }
462 if (ipnn->msgpool_cache)
463 ipn_msgbuf_put(ipnn->msgpool_cache);
464 if (ipnn->connport)
465 kfree(ipnn->connport);
466 kmem_cache_free(ipn_network_cache, ipnn);
467 module_put(THIS_MODULE);
468 }
469 }
470 if (ipn_node->pbp) {
471 kfree(ipn_node->pbp);
472 ipn_node->pbp=NULL;
473 }
474 return 0;
475 }
476
477 /* release of an ipn_node */
478 int ipn_node_release(struct ipn_node *ipn_node)
479 {
480 int rv;
481 if (down_interruptible(&ipn_glob_mutex))
482 return -ERESTARTSYS;
483 if (ipn_node->flags & IPN_NODEFLAG_PERSIST) {
484 ipn_node->flags &= ~IPN_NODEFLAG_INUSE;
485 rv=0;
486 up(&ipn_glob_mutex);
487 } else {
488 rv=ipn_terminate_node(ipn_node);
489 up(&ipn_glob_mutex);
490 if (rv==0) {
491 ipn_netdevsync();
492 kmem_cache_free(ipn_node_cache,ipn_node);
493 }
494 }
495 return rv;
496 }
497
498 /* release of an ipn socket */
499 static int ipn_release (struct socket *sock)
500 {
501 struct ipn_sock *ipn_sk=(struct ipn_sock *)sock->sk;
502 struct ipn_node *ipn_node=ipn_sk->node;
503 int rv=ipn_node_release(ipn_node);
504 if (rv == 0)
505 sock_put((struct sock *) ipn_sk);
506 return rv;
507 }
508
509 /* _set persist, change the persistence of a node,
510 * when persistence gets cleared and the node is no longer used
511 * the node is terminated and freed.
512 * ipn_glob_mutex must be locked */
513 static int _ipn_setpersist(struct ipn_node *ipn_node, int persist)
514 {
515 int rv=0;
516 if (persist)
517 ipn_node->flags |= IPN_NODEFLAG_PERSIST;
518 else {
519 ipn_node->flags &= ~IPN_NODEFLAG_PERSIST;
520 if (!(ipn_node->flags & IPN_NODEFLAG_INUSE)) {
521 rv=ipn_terminate_node(ipn_node);
522 if (rv==0)
523 kmem_cache_free(ipn_node_cache,ipn_node);
524 }
525 }
526 return rv;
527 }
528
529 /* ipn_setpersist
530 * lock ipn_glob_mutex and call __ipn_setpersist above */
531 static int ipn_setpersist(struct ipn_node *ipn_node, int persist)
532 {
533 int rv=0;
534 if (ipn_node->netdev == NULL)
535 return -ENODEV;
536 if (down_interruptible(&ipn_glob_mutex))
537 return -ERESTARTSYS;
538 rv=_ipn_setpersist(ipn_node,persist);
539 up(&ipn_glob_mutex);
540 return rv;
541 }
542
543 /* several network parameters can be set by setsockopt prior to bind */
544 /* struct pre_bind_parms is a temporary stucture connected to ipn_node->pbp
545 * to keep the parameter values. */
546 struct pre_bind_parms {
547 unsigned short maxports;
548 unsigned short flags;
549 unsigned short msgpoolsize;
550 unsigned short mtu;
551 unsigned short mode;
552 };
553
554 /* STD_PARMS: BITS_PER_LONG nodes, no flags, BITS_PER_BYTE pending msgs,
555 * Ethernet + VLAN MTU*/
556 #define STD_BIND_PARMS {BITS_PER_LONG, 0, BITS_PER_BYTE, 1514, 0777};
557
558 static int ipn_mkname(struct sockaddr_un * sunaddr, int len)
559 {
560 if (len <= sizeof(short) || len > sizeof(*sunaddr))
561 return -EINVAL;
562 if (!sunaddr || sunaddr->sun_family != AF_IPN)
563 return -EINVAL;
564 /*
565 * This may look like an off by one error but it is a bit more
566 * subtle. 108 is the longest valid AF_IPN path for a binding.
567 * sun_path[108] doesnt as such exist. However in kernel space
568 * we are guaranteed that it is a valid memory location in our
569 * kernel address buffer.
570 */
571 ((char *)sunaddr)[len]=0;
572 len = strlen(sunaddr->sun_path)+1+sizeof(short);
573 return len;
574 }
575
576 static int ipn_node_bind(struct ipn_node *ipn_node, struct ipn_network *ipnn)
577 {
578 if (ipnn == NULL)
579 return -ENOENT;
580 if (ipn_node->ipn != NULL)
581 return -EISCONN;
582 ipnn->refcnt++;
583 list_add_tail(&ipn_node->nodelist,&ipnn->unconnectqueue);
584 ipn_node->ipn=ipnn;
585 ipn_node->flags |= IPN_NODEFLAG_BOUND;
586 return 0;
587 }
588
589 /* IPN BIND */
590 #ifndef IPN_PRE310
591 static int ipn_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
592 {
593 struct sockaddr_un *sunaddr=(struct sockaddr_un *)uaddr;
594 struct ipn_node *ipn_node=((struct ipn_sock *)sock->sk)->node;
595 struct path path;
596 struct ipn_network *ipnn;
597 struct dentry * dentry = NULL;
598 int err;
599 struct pre_bind_parms parms=STD_BIND_PARMS;
600
601 //printk("IPN bind\n");
602
603 if (down_interruptible(&ipn_glob_mutex))
604 return -ERESTARTSYS;
605 if (sock->state != SS_UNCONNECTED ||
606 ipn_node->ipn != NULL) {
607 err= -EISCONN;
608 goto out;
609 }
610
611 if (ipn_node->protocol >= 0 &&
612 (ipn_node->protocol >= IPN_MAX_PROTO ||
613 ipn_protocol_table[ipn_node->protocol] == NULL)) {
614 err= -EPROTONOSUPPORT;
615 goto out;
616 }
617
618 addr_len = ipn_mkname(sunaddr, addr_len);
619 if (addr_len < 0) {
620 err=addr_len;
621 goto out;
622 }
623
624 /* check if there is already an ipn-network socket with that name */
625 err = kern_path(sunaddr->sun_path, LOOKUP_FOLLOW, &path);
626 if (err) { /* it does not exist, NEW IPN socket! */
627 unsigned int mode;
628 /* Do I have the permission to create a file? */
629 dentry = kern_path_create(AT_FDCWD, sunaddr->sun_path, &path, 0);
630 err = PTR_ERR(dentry);
631 if (IS_ERR(dentry))
632 goto out_mknod_unlock;
633 /*
634 * All right, let's create it.
635 */
636 if (ipn_node->pbp)
637 mode = ipn_node->pbp->mode;
638 else
639 mode = SOCK_INODE(sock)->i_mode;
640 mode = S_IFSOCK | (mode & ~current_umask());
641 err = mnt_want_write(path.mnt);
642 if (err)
643 goto out_mknod_dput;
644 if (!err) {
645 #ifdef APPARMOR
646 err = vfs_mknod(path.dentry->d_inode, dentry, path.mnt, mode, 0);
647 #else
648 err = vfs_mknod(path.dentry->d_inode, dentry, mode, 0);
649 #endif
650 }
651 mnt_drop_write(path.mnt);
652 if (err)
653 goto out_mknod_dput;
654 mutex_unlock(&path.dentry->d_inode->i_mutex);
655 dput(path.dentry);
656 path.dentry = dentry;
657 /* create a new ipn_network item */
658 if (ipn_node->pbp)
659 parms=*ipn_node->pbp;
660 ipnn=kmem_cache_zalloc(ipn_network_cache,GFP_KERNEL);
661 if (!ipnn) {
662 err=-ENOMEM;
663 goto out_mknod_dput_ipnn;
664 }
665 ipnn->connport=kzalloc(parms.maxports * sizeof(struct ipn_node *),GFP_KERNEL);
666 if (!ipnn->connport) {
667 err=-ENOMEM;
668 goto out_mknod_dput_ipnn2;
669 }
670
671 /* module refcnt is incremented for each network, thus
672 * rmmod is forbidden if there are persistent nodes */
673 if (!try_module_get(THIS_MODULE)) {
674 err = -EINVAL;
675 goto out_mknod_dput_ipnn2;
676 }
677 memcpy(&ipnn->sunaddr,sunaddr,addr_len);
678 ipnn->mtu=parms.mtu;
679 ipnn->flags=parms.flags;
680 if (ipnn->flags & IPN_FLAG_FLEXMTU)
681 ipnn->msgpool_cache= NULL;
682 else {
683 ipnn->msgpool_cache=ipn_msgbuf_get(ipnn->mtu);
684 if (!ipnn->msgpool_cache) {
685 err=-ENOMEM;
686 goto out_mknod_dput_putmodule;
687 }
688 }
689 INIT_LIST_HEAD(&ipnn->unconnectqueue);
690 INIT_LIST_HEAD(&ipnn->connectqueue);
691 ipnn->refcnt=0;
692 ipnn->dentry=path.dentry;
693 ipnn->mnt=path.mnt;
694 sema_init(&ipnn->ipnn_mutex,1);
695 ipnn->sunaddr_len=addr_len;
696 ipnn->protocol=ipn_node->protocol;
697 if (ipnn->protocol < 0) ipnn->protocol = 0;
698 ipn_protocol_table[ipnn->protocol]->refcnt++;
699 ipnn->numreaders=0;
700 ipnn->numwriters=0;
701 ipnn->maxports=parms.maxports;
702 atomic_set(&ipnn->msgpool_nelem,0);
703 ipnn->msgpool_size=parms.msgpoolsize;
704 ipnn->proto_private=NULL;
705 init_waitqueue_head(&ipnn->send_wait);
706 ipnn->chrdev=NULL;
707 err=ipn_protocol_table[ipnn->protocol]->ipn_p_newnet(ipnn);
708 if (err)
709 goto out_mknod_dput_putmodule;
710 ipn_insert_network(&ipn_network_table[path.dentry->d_inode->i_ino & (IPN_HASH_SIZE-1)],ipnn);
711 } else {
712 /* join an existing network */
713 if (parms.flags & IPN_FLAG_EXCL) {
714 err=-EEXIST;
715 goto put_fail;
716 }
717 err = inode_permission(path.dentry->d_inode, MAY_EXEC);
718 if (err)
719 goto put_fail;
720 err = -ECONNREFUSED;
721 if (!S_ISSOCK(path.dentry->d_inode->i_mode))
722 goto put_fail;
723 ipnn=ipn_find_network_byinode(path.dentry->d_inode);
724 if (!ipnn || (ipnn->flags & IPN_FLAG_TERMINATED) ||
725 (ipnn->flags & IPN_FLAG_EXCL))
726 goto put_fail;
727 }
728 if (ipn_node->pbp) {
729 kfree(ipn_node->pbp);
730 ipn_node->pbp=NULL;
731 }
732 ipn_node_bind(ipn_node,ipnn);
733 up(&ipn_glob_mutex);
734 return 0;
735
736 put_fail:
737 path_put(&path);
738 out:
739 up(&ipn_glob_mutex);
740 return err;
741
742 out_mknod_dput_putmodule:
743 module_put(THIS_MODULE);
744 out_mknod_dput_ipnn2:
745 kfree(ipnn->connport);
746 out_mknod_dput_ipnn:
747 kmem_cache_free(ipn_network_cache,ipnn);
748 out_mknod_dput:
749 dput(dentry);
750 mutex_unlock(&path.dentry->d_inode->i_mutex);
751 path_put(&path);
752 out_mknod_unlock:
753 if (err==-EEXIST)
754 err=-EADDRINUSE;
755 up(&ipn_glob_mutex);
756 return err;
757 }
758 #else
759 /* pre 3.1.0 */
760 static int ipn_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
761 {
762 struct sockaddr_un *sunaddr=(struct sockaddr_un *)uaddr;
763 struct ipn_node *ipn_node=((struct ipn_sock *)sock->sk)->node;
764 struct nameidata nd;
765 struct ipn_network *ipnn;
766 struct dentry * dentry = NULL;
767 int err;
768 struct pre_bind_parms parms=STD_BIND_PARMS;
769
770 //printk("IPN bind\n");
771
772 if (down_interruptible(&ipn_glob_mutex))
773 return -ERESTARTSYS;
774 if (sock->state != SS_UNCONNECTED ||
775 ipn_node->ipn != NULL) {
776 err= -EISCONN;
777 goto out;
778 }
779
780 if (ipn_node->protocol >= 0 &&
781 (ipn_node->protocol >= IPN_MAX_PROTO ||
782 ipn_protocol_table[ipn_node->protocol] == NULL)) {
783 err= -EPROTONOSUPPORT;
784 goto out;
785 }
786
787 addr_len = ipn_mkname(sunaddr, addr_len);
788 if (addr_len < 0) {
789 err=addr_len;
790 goto out;
791 }
792
793 /* check if there is already an ipn-network socket with that name */
794 #ifndef IPN_PRE2639
795 err = kern_path(sunaddr->sun_path, LOOKUP_FOLLOW, &nd.path);
796 #else
797 err = path_lookup(sunaddr->sun_path, LOOKUP_FOLLOW, &nd);
798 #endif
799 if (err) { /* it does not exist, NEW IPN socket! */
800 unsigned int mode;
801 /* Is it everything okay with the parent? */
802 #ifndef IPN_PRE2639
803 err = kern_path_parent(sunaddr->sun_path, &nd);
804 #else
805 err = path_lookup(sunaddr->sun_path, LOOKUP_PARENT, &nd);
806 #endif
807 if (err)
808 goto out_mknod_parent;
809 /* Do I have the permission to create a file? */
810 dentry = lookup_create(&nd, 0);
811 err = PTR_ERR(dentry);
812 if (IS_ERR(dentry))
813 goto out_mknod_unlock;
814 /*
815 * All right, let's create it.
816 */
817 if (ipn_node->pbp)
818 mode = ipn_node->pbp->mode;
819 else
820 mode = SOCK_INODE(sock)->i_mode;
821 #ifdef IPN_PRE2630
822 mode = S_IFSOCK | (mode & ~current->fs->umask);
823 #else
824 mode = S_IFSOCK | (mode & ~current_umask());
825 #endif
826 #ifdef APPARMOR
827 err = vfs_mknod(nd.path.dentry->d_inode, dentry, nd.path.mnt, mode, 0);
828 #else
829 err = vfs_mknod(nd.path.dentry->d_inode, dentry, mode, 0);
830 #endif
831 if (err)
832 goto out_mknod_dput;
833 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
834 dput(nd.path.dentry);
835 nd.path.dentry = dentry;
836 /* create a new ipn_network item */
837 if (ipn_node->pbp)
838 parms=*ipn_node->pbp;
839 ipnn=kmem_cache_zalloc(ipn_network_cache,GFP_KERNEL);
840 if (!ipnn) {
841 err=-ENOMEM;
842 goto out_mknod_dput_ipnn;
843 }
844 ipnn->connport=kzalloc(parms.maxports * sizeof(struct ipn_node *),GFP_KERNEL);
845 if (!ipnn->connport) {
846 err=-ENOMEM;
847 goto out_mknod_dput_ipnn2;
848 }
849
850 /* module refcnt is incremented for each network, thus
851 * rmmod is forbidden if there are persistent nodes */
852 if (!try_module_get(THIS_MODULE)) {
853 err = -EINVAL;
854 goto out_mknod_dput_ipnn2;
855 }
856 memcpy(&ipnn->sunaddr,sunaddr,addr_len);
857 ipnn->mtu=parms.mtu;
858 ipnn->flags=parms.flags;
859 if (ipnn->flags & IPN_FLAG_FLEXMTU)
860 ipnn->msgpool_cache= NULL;
861 else {
862 ipnn->msgpool_cache=ipn_msgbuf_get(ipnn->mtu);
863 if (!ipnn->msgpool_cache) {
864 err=-ENOMEM;
865 goto out_mknod_dput_putmodule;
866 }
867 }
868 INIT_LIST_HEAD(&ipnn->unconnectqueue);
869 INIT_LIST_HEAD(&ipnn->connectqueue);
870 ipnn->refcnt=0;
871 ipnn->dentry=nd.path.dentry;
872 ipnn->mnt=nd.path.mnt;
873 sema_init(&ipnn->ipnn_mutex,1);
874 ipnn->sunaddr_len=addr_len;
875 ipnn->protocol=ipn_node->protocol;
876 if (ipnn->protocol < 0) ipnn->protocol = 0;
877 ipn_protocol_table[ipnn->protocol]->refcnt++;
878 ipnn->numreaders=0;
879 ipnn->numwriters=0;
880 ipnn->maxports=parms.maxports;
881 atomic_set(&ipnn->msgpool_nelem,0);
882 ipnn->msgpool_size=parms.msgpoolsize;
883 ipnn->proto_private=NULL;
884 init_waitqueue_head(&ipnn->send_wait);
885 ipnn->chrdev=NULL;
886 err=ipn_protocol_table[ipnn->protocol]->ipn_p_newnet(ipnn);
887 if (err)
888 goto out_mknod_dput_putmodule;
889 ipn_insert_network(&ipn_network_table[nd.path.dentry->d_inode->i_ino & (IPN_HASH_SIZE-1)],ipnn);
890 } else {
891 /* join an existing network */
892 if (parms.flags & IPN_FLAG_EXCL) {
893 err=-EEXIST;
894 goto put_fail;
895 }
896 err = inode_permission(nd.path.dentry->d_inode, MAY_EXEC);
897 if (err)
898 goto put_fail;
899 err = -ECONNREFUSED;
900 if (!S_ISSOCK(nd.path.dentry->d_inode->i_mode))
901 goto put_fail;
902 ipnn=ipn_find_network_byinode(nd.path.dentry->d_inode);
903 if (!ipnn || (ipnn->flags & IPN_FLAG_TERMINATED) ||
904 (ipnn->flags & IPN_FLAG_EXCL))
905 goto put_fail;
906 }
907 if (ipn_node->pbp) {
908 kfree(ipn_node->pbp);
909 ipn_node->pbp=NULL;
910 }
911 ipn_node_bind(ipn_node,ipnn);
912 up(&ipn_glob_mutex);
913 return 0;
914
915 put_fail:
916 path_put(&nd.path);
917 out:
918 up(&ipn_glob_mutex);
919 return err;
920
921 out_mknod_dput_putmodule:
922 module_put(THIS_MODULE);
923 out_mknod_dput_ipnn2:
924 kfree(ipnn->connport);
925 out_mknod_dput_ipnn:
926 kmem_cache_free(ipn_network_cache,ipnn);
927 out_mknod_dput:
928 dput(dentry);
929 out_mknod_unlock:
930 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
931 path_put(&nd.path);
932 out_mknod_parent:
933 if (err==-EEXIST)
934 err=-EADDRINUSE;
935 up(&ipn_glob_mutex);
936 return err;
937 }
938 #endif
939
940 /* IPN CONNECT */
941 static int ipn_connect(struct socket *sock, struct sockaddr *addr,
942 int addr_len, int flags){
943 struct sockaddr_un *sunaddr=(struct sockaddr_un*)addr;
944 struct ipn_node *ipn_node=((struct ipn_sock *)sock->sk)->node;
945 #ifndef IPN_PRE2639
946 struct path ndpath;
947 #else
948 struct nameidata nd;
949 #define ndpath nd.path
950 #endif
951
952 struct ipn_network *ipnn,*previousipnn;
953 int err=0;
954 int portno;
955
956 /* the socket cannot be connected twice */
957 if (sock->state != SS_UNCONNECTED)
958 return EISCONN;
959
960 if (down_interruptible(&ipn_glob_mutex))
961 return -ERESTARTSYS;
962
963 if ((previousipnn=ipn_node->ipn) == NULL) { /* unbound */
964 unsigned char mustshutdown=0;
965 err = ipn_mkname(sunaddr, addr_len);
966 if (err < 0)
967 goto out;
968 addr_len=err;
969 #ifndef IPN_PRE2639
970 err = kern_path(sunaddr->sun_path, LOOKUP_FOLLOW, &ndpath);
971 #else
972 err = path_lookup(sunaddr->sun_path, LOOKUP_FOLLOW, &nd);
973 #endif
974 if (err)
975 goto out;
976 err = inode_permission(ndpath.dentry->d_inode, MAY_READ);
977 if (err) {
978 if (err == -EACCES || err == -EROFS)
979 mustshutdown|=RCV_SHUTDOWN;
980 else
981 goto put_fail;
982 }
983 err = inode_permission(ndpath.dentry->d_inode, MAY_WRITE);
984 if (err) {
985 if (err == -EACCES)
986 mustshutdown|=SEND_SHUTDOWN;
987 else
988 goto put_fail;
989 }
990 mustshutdown |= ipn_node->shutdown;
991 /* if the combination of shutdown and permissions leaves
992 * no abilities, connect returns EACCES */
993 if (mustshutdown == SHUTDOWN_XMASK) {
994 err=-EACCES;
995 goto put_fail;
996 } else {
997 err=0;
998 ipn_node->shutdown=mustshutdown;
999 }
1000 if (!S_ISSOCK(ndpath.dentry->d_inode->i_mode)) {
1001 err = -ECONNREFUSED;
1002 goto put_fail;
1003 }
1004 ipnn=ipn_find_network_byinode(ndpath.dentry->d_inode);
1005 if (!ipnn || (ipnn->flags & IPN_FLAG_TERMINATED)) {
1006 err = -ECONNREFUSED;
1007 goto put_fail;
1008 }
1009 if (ipn_node->protocol == IPN_ANY)
1010 ipn_node->protocol=ipnn->protocol;
1011 else if (ipnn->protocol != ipn_node->protocol) {
1012 err = -EPROTO;
1013 goto put_fail;
1014 }
1015 path_put(&ndpath);
1016 ipn_node->ipn=ipnn;
1017 } else
1018 ipnn=ipn_node->ipn;
1019
1020 if (down_interruptible(&ipnn->ipnn_mutex)) {
1021 err=-ERESTARTSYS;
1022 goto out;
1023 }
1024 portno = ipn_protocol_table[ipnn->protocol]->ipn_p_newport(ipn_node);
1025 if (portno >= 0 && portno<ipnn->maxports) {
1026 sock->state = SS_CONNECTED;
1027 ipn_node->portno=portno;
1028 ipnn->connport[portno]=ipn_node;
1029 if (!(ipn_node->flags & IPN_NODEFLAG_BOUND))
1030 ipnn->refcnt++;
1031 else
1032 list_del(&ipn_node->nodelist);
1033 list_add_tail(&ipn_node->nodelist,&ipnn->connectqueue);
1034 ipn_net_update_counters(ipnn,
1035 (ipn_node->shutdown & RCV_SHUTDOWN)?0:1,
1036 (ipn_node->shutdown & SEND_SHUTDOWN)?0:1);
1037 } else {
1038 ipn_node->ipn=previousipnn; /* undo changes on ipn_node->ipn */
1039 err=-EADDRNOTAVAIL;
1040 }
1041 up(&ipnn->ipnn_mutex);
1042 up(&ipn_glob_mutex);
1043 return err;
1044
1045 put_fail:
1046 path_put(&ndpath);
1047 out:
1048 up(&ipn_glob_mutex);
1049 return err;
1050 }
1051
1052 int ipn_node_create_connect(struct ipn_node **ipn_node_out,
1053 struct ipn_network *(* ipnn_map)(void *),void *ipnn_map_arg) {
1054 struct ipn_node *ipn_node;
1055 struct ipn_network *ipnn;
1056 int err=0;
1057 int portno;
1058 ipn_node=ipn_node_create(&init_net);
1059 if (down_interruptible(&ipn_glob_mutex)) {
1060 err=-ERESTARTSYS;
1061 goto err_ipn_node_release;
1062 }
1063 ipnn=ipnn_map(ipnn_map_arg);
1064 ipn_node->ipn=ipnn;
1065 ipn_node->protocol=ipnn->protocol;
1066 if (down_interruptible(&ipnn->ipnn_mutex)) {
1067 err=-ERESTARTSYS;
1068 goto out_glob;
1069 }
1070 portno = ipn_protocol_table[ipnn->protocol]->ipn_p_newport(ipn_node);
1071 if (portno >= 0 && portno<ipnn->maxports) {
1072 ipn_node->portno=portno;
1073 ipnn->connport[portno]=ipn_node;
1074 if (!(ipn_node->flags & IPN_NODEFLAG_BOUND)) {
1075 ipnn->refcnt++;
1076 list_del(&ipn_node->nodelist);
1077 }
1078 *ipn_node_out=ipn_node;
1079 list_add_tail(&ipn_node->nodelist,&ipnn->connectqueue);
1080 ipn_net_update_counters(ipnn,
1081 (ipn_node->shutdown & RCV_SHUTDOWN)?0:1,
1082 (ipn_node->shutdown & SEND_SHUTDOWN)?0:1);
1083 } else {
1084 ipn_node->ipn=NULL;
1085 err=-EADDRNOTAVAIL;
1086 goto out_glob_ipnn;
1087 }
1088
1089 up(&ipnn->ipnn_mutex);
1090 up(&ipn_glob_mutex);
1091 return err;
1092 out_glob_ipnn:
1093 up(&ipnn->ipnn_mutex);
1094 out_glob:
1095 up(&ipn_glob_mutex);
1096 err_ipn_node_release:
1097 ipn_node_release(ipn_node);
1098 ipn_node_out=NULL;
1099 return err;
1100 }
1101
1102 int ipn_node_connect(struct ipn_node *ipn_node)
1103 {
1104 struct ipn_network *ipnn;
1105 int err=0;
1106 int portno;
1107 if (down_interruptible(&ipn_glob_mutex))
1108 return -ERESTARTSYS;
1109
1110 ipnn=ipn_node->ipn;
1111 if (down_interruptible(&ipnn->ipnn_mutex)) {
1112 err=-ERESTARTSYS;
1113 goto out;
1114 }
1115 portno = ipn_protocol_table[ipnn->protocol]->ipn_p_newport(ipn_node);
1116 if (portno >= 0 && portno<ipnn->maxports) {
1117 ipn_node->portno=portno;
1118 ipnn->connport[portno]=ipn_node;
1119 if (!(ipn_node->flags & IPN_NODEFLAG_BOUND)) {
1120 ipnn->refcnt++;
1121 list_del(&ipn_node->nodelist);
1122 }
1123 list_add_tail(&ipn_node->nodelist,&ipnn->connectqueue);
1124 ipn_net_update_counters(ipnn,
1125 (ipn_node->shutdown & RCV_SHUTDOWN)?0:1,
1126 (ipn_node->shutdown & SEND_SHUTDOWN)?0:1);
1127 } else {
1128 ipn_node->ipn=NULL;
1129 err=-EADDRNOTAVAIL;
1130 }
1131
1132 up(&ipnn->ipnn_mutex);
1133 up(&ipn_glob_mutex);
1134 return err;
1135 out:
1136 up(&ipn_glob_mutex);
1137 return err;
1138 }
1139
1140 static int ipn_getname(struct socket *sock, struct sockaddr *uaddr,
1141 int *uaddr_len, int peer) {
1142 struct ipn_node *ipn_node=((struct ipn_sock *)sock->sk)->node;
1143 struct ipn_network *ipnn=ipn_node->ipn;
1144 struct sockaddr_un *sunaddr=(struct sockaddr_un *)uaddr;
1145 int err=0;
1146
1147 if (down_interruptible(&ipn_glob_mutex))
1148 return -ERESTARTSYS;
1149 if (ipnn) {
1150 *uaddr_len = ipnn->sunaddr_len;
1151 memcpy(sunaddr,&ipnn->sunaddr,*uaddr_len);
1152 } else
1153 err = -ENOTCONN;
1154 up(&ipn_glob_mutex);
1155 return err;
1156 }
1157
1158 /* IPN POLL */
1159 unsigned int ipn_node_poll(struct ipn_node *ipn_node, struct file *file, poll_table *wait) {
1160 struct ipn_network *ipnn=ipn_node->ipn;
1161 unsigned int mask=0;
1162
1163 if (ipnn) {
1164 poll_wait(file,&ipn_node->read_wait,wait);
1165 if (ipnn->flags & IPN_FLAG_LOSSLESS)
1166 poll_wait(file,&ipnn->send_wait,wait);
1167 /* POLLIN if recv succeeds,
1168 * POLL{PRI,RDNORM} if there are {oob,non-oob} messages */
1169 if (ipn_node->totmsgcount > 0) mask |= POLLIN;
1170 if (!(list_empty(&ipn_node->msgqueue))) mask |= POLLRDNORM;
1171 if (!(list_empty(&ipn_node->oobmsgqueue))) mask |= POLLPRI;
1172 if ((!(ipnn->flags & IPN_FLAG_LOSSLESS)) |
1173 (atomic_read(&ipnn->msgpool_nelem) < ipnn->msgpool_size))
1174 mask |= POLLOUT | POLLWRNORM;
1175 }
1176 return mask;
1177 }
1178
1179 static unsigned int ipn_poll(struct file *file, struct socket *sock,
1180 poll_table *wait) {
1181 struct ipn_node *ipn_node=((struct ipn_sock *)sock->sk)->node;
1182 return ipn_node_poll(ipn_node, file, wait);
1183 }
1184
1185 /* connect netdev (from ioctl). connect a bound socket to a
1186 * network device TAP or GRAB */
1187 static int ipn_connect_netdev(struct socket *sock,struct ifreq *ifr)
1188 {
1189 int err=0;
1190 struct ipn_node *ipn_node=((struct ipn_sock *)sock->sk)->node;
1191 struct ipn_network *ipnn=ipn_node->ipn;
1192 if (!capable(CAP_NET_ADMIN))
1193 return -EPERM;
1194 if (sock->state != SS_UNCONNECTED)
1195 return -EISCONN;
1196 if (!ipnn)
1197 return -ENOTCONN; /* Maybe we need a different error for "NOT BOUND" */
1198 if (down_interruptible(&ipn_glob_mutex))
1199 return -ERESTARTSYS;
1200 if (down_interruptible(&ipnn->ipnn_mutex)) {
1201 up(&ipn_glob_mutex);
1202 return -ERESTARTSYS;
1203 }
1204 ipn_node->netdev=ipn_netdev_alloc(ipn_node->net,ifr->ifr_flags,ifr->ifr_name,&err);
1205 if (ipn_node->netdev) {
1206 int portno;
1207 portno = ipn_protocol_table[ipnn->protocol]->ipn_p_newport(ipn_node);
1208 if (portno >= 0 && portno<ipnn->maxports) {
1209 sock->state = SS_CONNECTED;
1210 ipn_node->portno=portno;
1211 ipn_node->flags |= ifr->ifr_flags & IPN_NODEFLAG_DEVMASK;
1212 ipnn->connport[portno]=ipn_node;
1213 err=ipn_netdev_activate(ipn_node);
1214 if (err) {
1215 sock->state = SS_UNCONNECTED;
1216 ipn_protocol_table[ipnn->protocol]->ipn_p_delport(ipn_node);
1217 ipn_node->netdev=NULL;
1218 ipn_node->portno= -1;
1219 ipn_node->flags &= ~IPN_NODEFLAG_DEVMASK;
1220 ipnn->connport[portno]=NULL;
1221 } else {
1222 ipn_protocol_table[ipnn->protocol]->ipn_p_postnewport(ipn_node);
1223 list_del(&ipn_node->nodelist);
1224 list_add_tail(&ipn_node->nodelist,&ipnn->connectqueue);
1225 }
1226 } else {
1227 ipn_netdev_close(ipn_node);
1228 err=-EADDRNOTAVAIL;
1229 ipn_node->netdev=NULL;
1230 }
1231 } else
1232 err=-EINVAL;
1233 up(&ipnn->ipnn_mutex);
1234 up(&ipn_glob_mutex);
1235 return err;
1236 }
1237
1238 /* join a netdev, a socket gets connected to a persistent node
1239 * not connected to another socket */
1240 static int ipn_join_netdev(struct socket *sock,struct ifreq *ifr)
1241 {
1242 int err=0;
1243 struct net_device *dev;
1244 struct ipn_node *ipn_node=((struct ipn_sock *)sock->sk)->node;
1245 struct ipn_node *ipn_joined;
1246 struct ipn_network *ipnn=ipn_node->ipn;
1247 if (sock->state != SS_UNCONNECTED)
1248 return -EISCONN;
1249 if (down_interruptible(&ipn_glob_mutex))
1250 return -ERESTARTSYS;
1251 if (down_interruptible(&ipnn->ipnn_mutex)) {
1252 up(&ipn_glob_mutex);
1253 return -ERESTARTSYS;
1254 }
1255 dev=__dev_get_by_name(ipn_node->net,ifr->ifr_name);
1256 if (!dev)
1257 dev=__dev_get_by_index(ipn_node->net,ifr->ifr_ifindex);
1258 if (dev && (ipn_joined=ipn_netdev2node(dev)) != NULL) { /* the interface does exist */
1259 int i;
1260 for (i=0;i<ipnn->maxports && ipn_joined != ipnn->connport[i] ;i++)
1261 ;
1262 if (i < ipnn->maxports) { /* found */
1263 /* ipn_joined is substituted to ipn_node */
1264 ((struct ipn_sock *)sock->sk)->node=ipn_joined;
1265 ipn_joined->flags |= IPN_NODEFLAG_INUSE;
1266 ipnn->refcnt--;
1267 kmem_cache_free(ipn_node_cache,ipn_node);
1268 } else
1269 err=-EPERM;
1270 } else
1271 err=-EADDRNOTAVAIL;
1272 up(&ipnn->ipnn_mutex);
1273 up(&ipn_glob_mutex);
1274 return err;
1275 }
1276
1277 /* set persistence of a node looking for it by interface name
1278 * (it is for sysadm, to close network interfaces)*/
1279 static int ipn_setpersist_netdev(struct ifreq *ifr, int value)
1280 {
1281 struct net_device *dev;
1282 struct ipn_node *ipn_node;
1283 int err=0;
1284 if (!capable(CAP_NET_ADMIN))
1285 return -EPERM;
1286 if (down_interruptible(&ipn_glob_mutex))
1287 return -ERESTARTSYS;
1288 dev=__dev_get_by_name(&init_net,ifr->ifr_name);
1289 if (!dev)
1290 dev=__dev_get_by_index(&init_net,ifr->ifr_ifindex);
1291 if (dev && (ipn_node=ipn_netdev2node(dev)) != NULL)
1292 _ipn_setpersist(ipn_node,value);
1293 else
1294 err=-EADDRNOTAVAIL;
1295 up(&ipn_glob_mutex);
1296 return err;
1297 }
1298
1299 /* IPN IOCTL */
1300
1301 int ipn_node_ioctl(struct ipn_node *ipn_node, unsigned int cmd, unsigned long arg) {
1302 struct ipn_network *ipnn=ipn_node->ipn;
1303 if (ipnn &&
1304 (ipn_protocol_table[ipn_node->protocol]->ipn_p_ioctl != NULL)) {
1305 int rv;
1306 if (down_interruptible(&ipnn->ipnn_mutex))
1307 return -ERESTARTSYS;
1308 rv=ipn_protocol_table[ipn_node->protocol]->ipn_p_ioctl(ipn_node,cmd,arg);
1309 up(&ipnn->ipnn_mutex);
1310 return rv;
1311 } else
1312 return -EOPNOTSUPP;
1313 }
1314
1315 static int ipn_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) {
1316 struct ipn_node *ipn_node=((struct ipn_sock *)sock->sk)->node;
1317 struct ipn_network *ipnn=ipn_node->ipn;
1318 void __user* argp = (void __user*)arg;
1319 struct ifreq ifr;
1320 struct chrdevreq devr;
1321
1322 if (ipn_node->shutdown == SHUTDOWN_XMASK)
1323 return -ECONNRESET;
1324
1325 /* get arguments */
1326 switch (cmd) {
1327 case IPN_CHECK:
1328 return IPN_CHECK;
1329 case IPN_SETPERSIST_NETDEV:
1330 case IPN_CLRPERSIST_NETDEV:
1331 case IPN_CONN_NETDEV:
1332 case IPN_JOIN_NETDEV:
1333 case SIOCSIFHWADDR:
1334 if (copy_from_user(&ifr, argp, sizeof(ifr)))
1335 return -EFAULT;
1336 ifr.ifr_name[IFNAMSIZ-1] = '\0';
1337 break;
1338 case IPN_REGISTER_CHRDEV:
1339 case IPN_JOIN_CHRDEV:
1340 if (copy_from_user(&devr, argp, sizeof(devr)))
1341 return -EFAULT;
1342 /*printk("IPN_REGISTER_CHRDEV %p %d %d %d\n",
1343 argp, sizeof(devr),devr.major, devr.minor);*/
1344 break;
1345 }
1346
1347 /* actions for unconnected and unbound sockets */
1348 switch (cmd) {
1349 case IPN_SETPERSIST_NETDEV:
1350 return ipn_setpersist_netdev(&ifr,1);
1351 case IPN_CLRPERSIST_NETDEV:
1352 return ipn_setpersist_netdev(&ifr,0);
1353 case IPN_JOIN_CHRDEV:
1354 {
1355 int rv;
1356 if (!capable(CAP_MKNOD))
1357 return -EPERM;
1358 if (ipn_node->ipn != NULL)
1359 return -EISCONN;
1360 if (down_interruptible(&ipn_glob_mutex))
1361 return -ERESTARTSYS;
1362 rv=ipn_node_bind(ipn_node, ipn_find_chrdev(&devr));
1363 up(&ipn_glob_mutex);
1364 return rv;
1365 }
1366 case SIOCSIFHWADDR:
1367 if (capable(CAP_NET_ADMIN))
1368 return -EPERM;
1369 if (ipn_node->netdev && (ipn_node->flags &IPN_NODEFLAG_TAP))
1370 return dev_set_mac_address(ipn_node->netdev, &ifr.ifr_hwaddr);
1371 else
1372 return -EADDRNOTAVAIL;
1373 }
1374 if (ipnn == NULL || (ipnn->flags & IPN_FLAG_TERMINATED))
1375 return -ENOTCONN;
1376 /* actions for connected or bound sockets */
1377 switch (cmd) {
1378 case IPN_CONN_NETDEV:
1379 return ipn_connect_netdev(sock,&ifr);
1380 case IPN_JOIN_NETDEV:
1381 return ipn_join_netdev(sock,&ifr);
1382 case IPN_SETPERSIST:
1383 return ipn_setpersist(ipn_node,arg);
1384 case IPN_CHRDEV_PERSIST:
1385 return ipn_chrdev_persistence(ipnn,arg);
1386 case IPN_REGISTER_CHRDEV:
1387 {
1388 int rv;
1389 unsigned int reqmajor=devr.major;
1390 if (down_interruptible(&ipnn->ipnn_mutex))
1391 return -ERESTARTSYS;
1392 rv=ipn_register_chrdev(ipnn,&devr);
1393 if (reqmajor==0 && rv==0) {
1394 if (copy_to_user(argp, &devr, sizeof devr))
1395 rv=EFAULT;
1396 }
1397 up(&ipnn->ipnn_mutex);
1398 return rv;
1399 }
1400 case IPN_UNREGISTER_CHRDEV:
1401 {
1402 int rv;
1403 if (down_interruptible(&ipnn->ipnn_mutex))
1404 return -ERESTARTSYS;
1405 rv=ipn_deregister_chrdev(ipnn);
1406 up(&ipnn->ipnn_mutex);
1407 return rv;
1408 }
1409 default:
1410 return ipn_node_ioctl(ipn_node, cmd, arg);
1411 }
1412 }
1413
1414 /* shutdown: close socket for input or for output.
1415 * shutdown can be called prior to connect and it is not reversible */
1416 static int ipn_shutdown(struct socket *sock, int mode) {
1417 struct ipn_node *ipn_node=((struct ipn_sock *)sock->sk)->node;
1418 struct ipn_network *ipnn=ipn_node->ipn;
1419 int oldshutdown=ipn_node->shutdown;
1420 mode = (mode+1)&(RCV_SHUTDOWN|SEND_SHUTDOWN);
1421
1422 /* define the new mode first... */
1423 ipn_node->shutdown |= mode;
1424
1425 if(ipnn) {
1426 /* ... and wait for all pending ops to be completed */
1427 if (down_interruptible(&ipnn->ipnn_mutex)) {
1428 ipn_node->shutdown = oldshutdown;
1429 return -ERESTARTSYS;
1430 }
1431 oldshutdown=ipn_node->shutdown-oldshutdown;
1432 if (sock->state == SS_CONNECTED && oldshutdown) {
1433 ipn_net_update_counters(ipnn,
1434 (ipn_node->shutdown & RCV_SHUTDOWN)?0:-1,
1435 (ipn_node->shutdown & SEND_SHUTDOWN)?0:-1);
1436 }
1437
1438 /* if recv channel has been shut down, flush the recv queue */
1439 if ((ipn_node->shutdown & RCV_SHUTDOWN))
1440 ipn_flush_recvqueue(ipn_node);
1441 up(&ipnn->ipnn_mutex);
1442 }
1443 return 0;
1444 }
1445
1446 /* injectmsg: a new message is entering the ipn network.
1447 * injectmsg gets called by send and by the grab/tap node */
1448 /* handlemsg is protected from ipn_network changes: ipnn->ipnn_mutex is locked */
1449 int ipn_proto_injectmsg(struct ipn_node *from, struct msgpool_item *msg)
1450 {
1451 struct ipn_network *ipnn=from->ipn;
1452 int err=0;
1453 static int recinject=0;
1454 //printk("INJECTMSG IN\n");
1455 if (recinject)
1456 ipn_protocol_table[ipnn->protocol]->ipn_p_handlemsg(from, msg);
1457 else if (down_interruptible(&ipnn->ipnn_mutex))
1458 err=-ERESTARTSYS;
1459 else {
1460 recinject=1;
1461 ipn_protocol_table[ipnn->protocol]->ipn_p_handlemsg(from, msg);
1462 recinject=0;
1463 up(&ipnn->ipnn_mutex);
1464 }
1465 //printk("INJECTMSG OUT %d\n",err);
1466 return err;
1467 }
1468
1469 /* SEND MSG */
1470 int ipn_node_write(struct ipn_node *ipn_node, struct iovec *msg_iov, int len) {
1471 struct ipn_network *ipnn=ipn_node->ipn;
1472 struct msgpool_item *newmsg;
1473 int err=0;
1474
1475 if (unlikely(ipn_node->shutdown & SEND_SHUTDOWN)) {
1476 if (ipn_node->shutdown == SHUTDOWN_XMASK)
1477 return -ECONNRESET;
1478 else
1479 return -EPIPE;
1480 }
1481 if (len > ipnn->mtu)
1482 return -EOVERFLOW;
1483 newmsg=ipn_msgpool_alloc_locking(ipnn,len);
1484 if (!newmsg)
1485 return -ENOMEM;
1486 newmsg->len=len;
1487 err=memcpy_fromiovec(newmsg->data, msg_iov, len);
1488 if (!err)
1489 ipn_proto_injectmsg(ipn_node, newmsg);
1490 ipn_msgpool_put(newmsg,ipnn);
1491 return len;
1492 }
1493
1494 static int ipn_sendmsg(struct kiocb *kiocb, struct socket *sock,
1495 struct msghdr *msg, size_t len) {
1496 struct ipn_node *ipn_node=((struct ipn_sock *)sock->sk)->node;
1497
1498 if (unlikely(sock->state != SS_CONNECTED))
1499 return -ENOTCONN;
1500 else
1501 return ipn_node_write(ipn_node, msg->msg_iov, len);
1502 }
1503
1504 /* ipn_proto_sendmsg is called by protocol implementation to enqueue a
1505 * for a destination (to).*/
1506 /* enqueue a msgitem on the receiver's queue, the queue is protected by a
1507 * spinlock (msglock) */
1508 void ipn_proto_sendmsg(struct ipn_node *to, struct msgpool_item *msg)
1509 {
1510 if (to) {
1511 if (to->netdev) {
1512 ipn_netdev_sendmsg(to,msg);
1513 } else {
1514 /* socket send */
1515 struct msgitem *msgitem;
1516 struct ipn_network *ipnn=to->ipn;
1517 spin_lock(&to->msglock);
1518 if (likely((to->shutdown & RCV_SHUTDOWN)==0)) {
1519 /*if (unlikely((ipnn->flags & IPN_FLAG_LOSSLESS) == 0 ||
1520 to->totmsgcount >= ipnn->msgpool_size))
1521 yield();*/
1522 if (likely(ipnn->flags & IPN_FLAG_LOSSLESS ||
1523 to->totmsgcount < ipnn->msgpool_size)) {
1524 if ((msgitem=kmem_cache_alloc(ipn_msgitem_cache,GFP_KERNEL))!=NULL) {
1525 msgitem->msg=msg;
1526 to->totmsgcount++;
1527 list_add_tail(&msgitem->list, &to->msgqueue);
1528 ipn_msgpool_hold(msg);
1529 }
1530 }
1531 }
1532 spin_unlock(&to->msglock);
1533 wake_up_interruptible(&to->read_wait);
1534 }
1535 }
1536 }
1537
1538 /* enqueue an oob message. "to" is the destination */
1539 void ipn_proto_oobsendmsg(struct ipn_node *to, struct msgpool_item *msg)
1540 {
1541 if (to) {
1542 if (!to->netdev) { /* no oob to netdev */
1543 struct msgitem *msgitem;
1544 struct ipn_network *ipnn=to->ipn;
1545 spin_lock(&to->msglock);
1546 if ((to->shutdown & RCV_SHUTDOWN_NO_OOB) == 0 &&
1547 (ipnn->flags & IPN_FLAG_LOSSLESS ||
1548 to->oobmsgcount < ipnn->msgpool_size)) {
1549 if ((msgitem=kmem_cache_alloc(ipn_msgitem_cache,GFP_KERNEL))!=NULL) {
1550 msgitem->msg=msg;
1551 to->totmsgcount++;
1552 to->oobmsgcount++;
1553 list_add_tail(&msgitem->list, &to->oobmsgqueue);
1554 ipn_msgpool_hold(msg);
1555 }
1556 }
1557 spin_unlock(&to->msglock);
1558 wake_up_interruptible(&to->read_wait);
1559 }
1560 }
1561 }
1562
1563 /* IPN RECV */
1564 int ipn_node_read(struct ipn_node *ipn_node, struct iovec *msg_iov, size_t len, int *msg_flags, int flags) {
1565 struct ipn_network *ipnn=ipn_node->ipn;
1566 struct msgitem *msgitem;
1567 struct msgpool_item *currmsg;
1568
1569 if (unlikely((ipn_node->shutdown & XRCV_SHUTDOWN) == XRCV_SHUTDOWN)) {
1570 if (ipn_node->shutdown == SHUTDOWN_XMASK) /*EOF, nothing can be read*/
1571 return 0;
1572 else
1573 return -EPIPE; /*trying to read on a write only node */
1574 }
1575
1576 /* wait for a message */
1577 spin_lock(&ipn_node->msglock);
1578 while (ipn_node->totmsgcount == 0) {
1579 spin_unlock(&ipn_node->msglock);
1580 if (flags & MSG_DONTWAIT)
1581 return -EWOULDBLOCK;
1582 if (wait_event_interruptible(ipn_node->read_wait,
1583 !(ipn_node->totmsgcount == 0)))
1584 return -ERESTARTSYS;
1585 spin_lock(&ipn_node->msglock);
1586 }
1587 /* oob gets delivered first. oob are rare */
1588 if (likely(list_empty(&ipn_node->oobmsgqueue)))
1589 msgitem=list_first_entry(&ipn_node->msgqueue, struct msgitem, list);
1590 else {
1591 msgitem=list_first_entry(&ipn_node->oobmsgqueue, struct msgitem, list);
1592 *msg_flags |= MSG_OOB;
1593 ipn_node->oobmsgcount--;
1594 }
1595 list_del(&msgitem->list);
1596 ipn_node->totmsgcount--;
1597 spin_unlock(&ipn_node->msglock);
1598 currmsg=msgitem->msg;
1599 if (currmsg->len < len)
1600 len=currmsg->len;
1601 memcpy_toiovec(msg_iov, currmsg->data, len);
1602 ipn_msgpool_put(currmsg,ipnn);
1603 kmem_cache_free(ipn_msgitem_cache,msgitem);
1604 return len;
1605 }
1606
1607 static int ipn_recvmsg(struct kiocb *kiocb, struct socket *sock,
1608 struct msghdr *msg, size_t len, int flags) {
1609 struct ipn_node *ipn_node=((struct ipn_sock *)sock->sk)->node;
1610
1611 if (unlikely(sock->state != SS_CONNECTED))
1612 return -ENOTCONN;
1613 else
1614 return ipn_node_read(ipn_node, msg->msg_iov, len, &msg->msg_flags, flags);
1615 }
1616
1617 /* resize a network: change the # of communication ports (connport) */
1618 static int ipn_netresize(struct ipn_network *ipnn,int newsize)
1619 {
1620 int oldsize,min;
1621 struct ipn_node **newconnport;
1622 struct ipn_node **oldconnport;
1623 int err;
1624 if (down_interruptible(&ipnn->ipnn_mutex))
1625 return -ERESTARTSYS;
1626 oldsize=ipnn->maxports;
1627 if (newsize == oldsize) {
1628 up(&ipnn->ipnn_mutex);
1629 return 0;
1630 }
1631 min=oldsize;
1632 /* shrink a network. all the ports we are going to eliminate
1633 * must be unused! */
1634 if (newsize < oldsize) {
1635 int i;
1636 for (i=newsize; i<oldsize; i++)
1637 if (ipnn->connport[i]) {
1638 up(&ipnn->ipnn_mutex);
1639 return -EADDRINUSE;
1640 }
1641 min=newsize;
1642 }
1643 oldconnport=ipnn->connport;
1644 /* allocate the new connport array and copy the old one */
1645 newconnport=kzalloc(newsize * sizeof(struct ipn_node *),GFP_KERNEL);
1646 if (!newconnport) {
1647 up(&ipnn->ipnn_mutex);
1648 return -ENOMEM;
1649 }
1650 memcpy(newconnport,oldconnport,min * sizeof(struct ipn_node *));
1651 ipnn->connport=newconnport;
1652 ipnn->maxports=newsize;
1653 /* notify the protocol that the netowrk has been resized */
1654 err=ipn_protocol_table[ipnn->protocol]->ipn_p_resizenet(ipnn,oldsize,newsize);
1655 if (err) {
1656 /* roll back if the resize operation failed for the protocol */
1657 ipnn->connport=oldconnport;
1658 ipnn->maxports=oldsize;
1659 kfree(newconnport);
1660 } else
1661 /* successful mission, network resized */
1662 kfree(oldconnport);
1663 up(&ipnn->ipnn_mutex);
1664 return err;
1665 }
1666
1667 /* IPN SETSOCKOPT */
1668 #ifndef IPN_PRE2632
1669 static int ipn_setsockopt(struct socket *sock, int level, int optname,
1670 char __user *optval, unsigned int optlen)
1671 #else
1672 static int ipn_setsockopt(struct socket *sock, int level, int optname,
1673 char __user *optval, int optlen)
1674 #endif
1675 {
1676 struct ipn_node *ipn_node=((struct ipn_sock *)sock->sk)->node;
1677 struct ipn_network *ipnn=ipn_node->ipn;
1678
1679 if (ipn_node->shutdown == SHUTDOWN_XMASK)
1680 return -ECONNRESET;
1681 if (level != 0 && level != ipn_node->protocol+1)
1682 return -EPROTONOSUPPORT;
1683 if (level > 0) {
1684 /* protocol specific sockopt */
1685 if (ipnn) {
1686 int rv;
1687 if (down_interruptible(&ipnn->ipnn_mutex))
1688 return -ERESTARTSYS;
1689 rv=ipn_protocol_table[ipn_node->protocol]->ipn_p_setsockopt(ipn_node,optname,optval,optlen);
1690 up(&ipnn->ipnn_mutex);
1691 return rv;
1692 } else
1693 return -EOPNOTSUPP;
1694 } else {
1695 if (optname == IPN_SO_DESCR) {
1696 if (optlen > IPN_DESCRLEN)
1697 return -EINVAL;
1698 else {
1699 memset(ipn_node->descr,0,IPN_DESCRLEN);
1700 if (copy_from_user(ipn_node->descr,optval,optlen))
1701 ipn_node->descr[0]=0;
1702 else
1703 ipn_node->descr[optlen-1]=0;
1704 return 0;
1705 }
1706 } else {
1707 if (optlen < sizeof(int))
1708 return -EINVAL;
1709 else if ((optname & IPN_SO_PREBIND) && (ipnn != NULL))
1710 return -EISCONN;
1711 else {
1712 int val;
1713 get_user(val, (int __user *) optval);
1714 if ((optname & IPN_SO_PREBIND) && !ipn_node->pbp) {
1715 struct pre_bind_parms std=STD_BIND_PARMS;
1716 ipn_node->pbp=kzalloc(sizeof(struct pre_bind_parms),GFP_KERNEL);
1717 if (!ipn_node->pbp)
1718 return -ENOMEM;
1719 *(ipn_node->pbp)=std;
1720 }
1721 switch (optname) {
1722 case IPN_SO_PORT:
1723 if (sock->state == SS_UNCONNECTED)
1724 ipn_node->portno=val;
1725 else
1726 return -EISCONN;
1727 break;
1728 case IPN_SO_CHANGE_NUMNODES:
1729 if ((ipn_node->flags & IPN_NODEFLAG_BOUND)!=0) {
1730 if (val <= 0)
1731 return -EINVAL;
1732 else
1733 return ipn_netresize(ipnn,val);
1734 } else
1735 val=-ENOTCONN;
1736 break;
1737 case IPN_SO_WANT_OOB_NUMNODES:
1738 if (val)
1739 ipn_node->flags |= IPN_NODEFLAG_OOB_NUMNODES;
1740 else
1741 ipn_node->flags &= ~IPN_NODEFLAG_OOB_NUMNODES;
1742 break;
1743 case IPN_SO_HANDLE_OOB:
1744 if (val)
1745 ipn_node->shutdown &= ~RCV_SHUTDOWN_NO_OOB;
1746 else
1747 ipn_node->shutdown |= RCV_SHUTDOWN_NO_OOB;
1748 break;
1749 case IPN_SO_MTU:
1750 if (val <= 0)
1751 return -EINVAL;
1752 else
1753 ipn_node->pbp->mtu=val;
1754 break;
1755 case IPN_SO_NUMNODES:
1756 if (val <= 0)
1757 return -EINVAL;
1758 else
1759 ipn_node->pbp->maxports=val;
1760 break;
1761 case IPN_SO_MSGPOOLSIZE:
1762 if (val <= 0)
1763 return -EINVAL;
1764 else
1765 ipn_node->pbp->msgpoolsize=val;
1766 break;
1767 case IPN_SO_FLAGS:
1768 ipn_node->pbp->flags=val;
1769 break;
1770 case IPN_SO_MODE:
1771 ipn_node->pbp->mode=val;
1772 break;
1773 }
1774 return 0;
1775 }
1776 }
1777 }
1778 }
1779
1780 /* IPN GETSOCKOPT */
1781 static int ipn_getsockopt(struct socket *sock, int level, int optname,
1782 char __user *optval, int __user *optlen) {
1783 struct ipn_node *ipn_node=((struct ipn_sock *)sock->sk)->node;
1784 struct ipn_network *ipnn=ipn_node->ipn;
1785 int len;
1786
1787 if (ipn_node->shutdown == SHUTDOWN_XMASK)
1788 return -ECONNRESET;
1789 if (level != 0 && level != ipn_node->protocol+1)
1790 return -EPROTONOSUPPORT;
1791 if (level > 0) {
1792 if (ipnn) {
1793 int rv;
1794 /* protocol specific sockopt */
1795 if (down_interruptible(&ipnn->ipnn_mutex))
1796 return -ERESTARTSYS;
1797 rv=ipn_protocol_table[ipn_node->protocol]->ipn_p_getsockopt(ipn_node,optname,optval,optlen);
1798 up(&ipnn->ipnn_mutex);
1799 return rv;
1800 } else
1801 return -EOPNOTSUPP;
1802 } else {
1803 if (get_user(len, optlen))
1804 return -EFAULT;
1805 if (optname == IPN_SO_DESCR) {
1806 if (len < IPN_DESCRLEN)
1807 return -EINVAL;
1808 else {
1809 if (len > IPN_DESCRLEN)
1810 len=IPN_DESCRLEN;
1811 if(put_user(len, optlen))
1812 return -EFAULT;
1813 if(copy_to_user(optval,ipn_node->descr,len))
1814 return -EFAULT;
1815 return 0;
1816 }
1817 } else {
1818 int val=-2;
1819 switch (optname) {
1820 case IPN_SO_PORT:
1821 val=ipn_node->portno;
1822 break;
1823 case IPN_SO_MTU:
1824 if (ipnn)
1825 val=ipnn->mtu;
1826 else if (ipn_node->pbp)
1827 val=ipn_node->pbp->mtu;
1828 break;
1829 case IPN_SO_NUMNODES:
1830 if (ipnn)
1831 val=ipnn->maxports;
1832 else if (ipn_node->pbp)
1833 val=ipn_node->pbp->maxports;
1834 break;
1835 case IPN_SO_MSGPOOLSIZE:
1836 if (ipnn)
1837 val=ipnn->msgpool_size;
1838 else if (ipn_node->pbp)
1839 val=ipn_node->pbp->msgpoolsize;
1840 break;
1841 case IPN_SO_FLAGS:
1842 if (ipnn)
1843 val=ipnn->flags;
1844 else if (ipn_node->pbp)
1845 val=ipn_node->pbp->flags;
1846 break;
1847 case IPN_SO_MODE:
1848 if (ipnn)
1849 val=-1;
1850 else if (ipn_node->pbp)
1851 val=ipn_node->pbp->mode;
1852 break;
1853 }
1854 if (val < -1)
1855 return -EINVAL;
1856 else {
1857 if (len < sizeof(int))
1858 return -EOVERFLOW;
1859 else {
1860 len = sizeof(int);
1861 if(put_user(len, optlen))
1862 return -EFAULT;
1863 if(copy_to_user(optval,&val,len))
1864 return -EFAULT;
1865 return 0;
1866 }
1867 }
1868 }
1869 }
1870 }
1871
1872 /* BROADCAST/HUB implementation */
1873
1874 static int ipn_bcast_newport(struct ipn_node *newport) {
1875 struct ipn_network *ipnn=newport->ipn;
1876 int i;
1877 for (i=0;i<ipnn->maxports;i++) {
1878 if (ipnn->connport[i] == NULL)
1879 return i;
1880 }
1881 return -1;
1882 }
1883
1884 static int ipn_bcast_handlemsg(struct ipn_node *from,
1885 struct msgpool_item *msgitem){
1886 struct ipn_network *ipnn=from->ipn;
1887
1888 struct ipn_node *ipn_node;
1889 list_for_each_entry(ipn_node, &ipnn->connectqueue, nodelist) {
1890 if (ipn_node != from)
1891 ipn_proto_sendmsg(ipn_node,msgitem);
1892 }
1893 return 0;
1894 }
1895
1896 static void ipn_null_delport(struct ipn_node *oldport) {}
1897 static void ipn_null_postnewport(struct ipn_node *newport) {}
1898 static void ipn_null_predelport(struct ipn_node *oldport) {}
1899 static int ipn_null_newnet(struct ipn_network *newnet) {return 0;}
1900 static int ipn_null_resizenet(struct ipn_network *net,int oldsize,int newsize) {
1901 return 0;}
1902 static void ipn_null_delnet(struct ipn_network *oldnet) {}
1903 static int ipn_null_setsockopt(struct ipn_node *port,int optname,
1904 char __user *optval, int optlen) {return -EOPNOTSUPP;}
1905 static int ipn_null_getsockopt(struct ipn_node *port,int optname,
1906 char __user *optval, int *optlen) {return -EOPNOTSUPP;}
1907 static int ipn_null_ioctl(struct ipn_node *port,unsigned int request,
1908 unsigned long arg) {return -EOPNOTSUPP;}
1909
1910 /* Protocol Registration/deregisteration */
1911
1912 void ipn_init_protocol(struct ipn_protocol *p)
1913 {
1914 if (p->ipn_p_delport == NULL) p->ipn_p_delport=ipn_null_delport;
1915 if (p->ipn_p_postnewport == NULL) p->ipn_p_postnewport=ipn_null_postnewport;
1916 if (p->ipn_p_predelport == NULL) p->ipn_p_predelport=ipn_null_predelport;
1917 if (p->ipn_p_newnet == NULL) p->ipn_p_newnet=ipn_null_newnet;
1918 if (p->ipn_p_resizenet == NULL) p->ipn_p_resizenet=ipn_null_resizenet;
1919 if (p->ipn_p_delnet == NULL) p->ipn_p_delnet=ipn_null_delnet;
1920 if (p->ipn_p_setsockopt == NULL) p->ipn_p_setsockopt=ipn_null_setsockopt;
1921 if (p->ipn_p_getsockopt == NULL) p->ipn_p_getsockopt=ipn_null_getsockopt;
1922 if (p->ipn_p_ioctl == NULL) p->ipn_p_ioctl=ipn_null_ioctl;
1923 }
1924
1925 int ipn_proto_register(int protocol,struct ipn_protocol *ipn_service)
1926 {
1927 int rv=0;
1928 if (ipn_service->ipn_p_newport == NULL ||
1929 ipn_service->ipn_p_handlemsg == NULL)
1930 return -EINVAL;
1931 ipn_init_protocol(ipn_service);
1932 if (protocol > 1 && protocol <= IPN_MAX_PROTO) {
1933 protocol--;
1934 if (down_interruptible(&ipn_glob_mutex))
1935 return -ERESTARTSYS;
1936 if (ipn_protocol_table[protocol])
1937 rv= -EEXIST;
1938 else {
1939 ipn_service->refcnt=0;
1940 ipn_protocol_table[protocol]=ipn_service;
1941 printk(KERN_INFO "IPN: Registered protocol %d\n",protocol+1);
1942 }
1943 up(&ipn_glob_mutex);
1944 } else
1945 rv= -EINVAL;
1946 return rv;
1947 }
1948
1949 int ipn_proto_deregister(int protocol)
1950 {
1951 int rv=0;
1952 if (protocol > 1 && protocol <= IPN_MAX_PROTO) {
1953 protocol--;
1954 if (down_interruptible(&ipn_glob_mutex))
1955 return -ERESTARTSYS;
1956 if (ipn_protocol_table[protocol]) {
1957 if (ipn_protocol_table[protocol]->refcnt == 0) {
1958 ipn_protocol_table[protocol]=NULL;
1959 printk(KERN_INFO "IPN: Unregistered protocol %d\n",protocol+1);
1960 } else
1961 rv=-EADDRINUSE;
1962 } else
1963 rv= -ENOENT;
1964 up(&ipn_glob_mutex);
1965 } else
1966 rv= -EINVAL;
1967 return rv;
1968 }
1969
1970 /* MAIN SECTION */
1971 /* Module constructor/destructor */
1972 static struct net_proto_family ipn_family_ops = {
1973 .family = PF_IPN,
1974 .create = ipn_create,
1975 .owner = THIS_MODULE,
1976 };
1977
1978 /* IPN constructor */
1979 static int ipn_init(void)
1980 {
1981 int rc;
1982
1983 ipn_init_protocol(&ipn_bcast);
1984 ipn_network_cache=kmem_cache_create("ipn_network",sizeof(struct ipn_network),0,0,NULL);
1985 if (!ipn_network_cache) {
1986 printk(KERN_CRIT "%s: Cannot create ipn_network SLAB cache!\n",
1987 __FUNCTION__);
1988 rc=-ENOMEM;
1989 goto out;
1990 }
1991
1992 ipn_node_cache=kmem_cache_create("ipn_node",sizeof(struct ipn_node),0,0,NULL);
1993 if (!ipn_node_cache) {
1994 printk(KERN_CRIT "%s: Cannot create ipn_node SLAB cache!\n",
1995 __FUNCTION__);
1996 rc=-ENOMEM;
1997 goto out_net;
1998 }
1999
2000 ipn_msgitem_cache=kmem_cache_create("ipn_msgitem",sizeof(struct msgitem),0,0,NULL);
2001 if (!ipn_msgitem_cache) {
2002 printk(KERN_CRIT "%s: Cannot create ipn_msgitem SLAB cache!\n",
2003 __FUNCTION__);
2004 rc=-ENOMEM;
2005 goto out_net_node;
2006 }
2007
2008 rc=ipn_msgbuf_init();
2009 if (rc != 0) {
2010 printk(KERN_CRIT "%s: Cannot create ipn_msgbuf SLAB cache\n",
2011 __FUNCTION__);
2012 goto out_net_node_msg;
2013 }
2014
2015 rc=proto_register(&ipn_proto,1);
2016 if (rc != 0) {
2017 printk(KERN_CRIT "%s: Cannot register the protocol!\n",
2018 __FUNCTION__);
2019 goto out_net_node_msg_msgbuf;
2020 }
2021
2022 sock_register(&ipn_family_ops);
2023 ipn_netdev_init();
2024 printk(KERN_INFO "IPN: Virtual Square Project, University of Bologna 2007-09\n");
2025 return 0;
2026
2027 out_net_node_msg_msgbuf:
2028 ipn_msgbuf_fini();
2029 out_net_node_msg:
2030 kmem_cache_destroy(ipn_msgitem_cache);
2031 out_net_node:
2032 kmem_cache_destroy(ipn_node_cache);
2033 out_net:
2034 kmem_cache_destroy(ipn_network_cache);
2035 out:
2036 return rc;
2037 }
2038
2039 /* IPN destructor */
2040 static void ipn_exit(void)
2041 {
2042 ipn_netdev_fini();
2043 if (ipn_msgitem_cache)
2044 kmem_cache_destroy(ipn_msgitem_cache);
2045 if (ipn_node_cache)
2046 kmem_cache_destroy(ipn_node_cache);
2047 if (ipn_network_cache)
2048 kmem_cache_destroy(ipn_network_cache);
2049 ipn_msgbuf_fini();
2050 sock_unregister(PF_IPN);
2051 proto_unregister(&ipn_proto);
2052 printk(KERN_INFO "IPN removed\n");
2053 }
2054
2055 module_init(ipn_init);
2056 module_exit(ipn_exit);
2057
2058 EXPORT_SYMBOL_GPL(ipn_proto_register);
2059 EXPORT_SYMBOL_GPL(ipn_proto_deregister);
2060 EXPORT_SYMBOL_GPL(ipn_proto_sendmsg);
2061 EXPORT_SYMBOL_GPL(ipn_proto_oobsendmsg);
2062 EXPORT_SYMBOL_GPL(ipn_msgpool_alloc);
2063 EXPORT_SYMBOL_GPL(ipn_msgpool_put);
vde git mirror