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