This source file includes following definitions.
- min
- sockaddr_un_printk
- unix_proto_listen
- unix_proto_setsockopt
- unix_proto_getsockopt
- unix_proto_sendto
- unix_proto_recvfrom
- unix_proto_shutdown
- unix_proto_send
- unix_proto_recv
- unix_data_lookup
- unix_data_alloc
- unix_data_ref
- unix_data_deref
- unix_proto_create
- unix_proto_dup
- unix_proto_release
- unix_proto_bind
- unix_proto_connect
- unix_proto_socketpair
- unix_proto_accept
- unix_proto_getname
- unix_proto_read
- unix_proto_write
- unix_proto_select
- unix_proto_ioctl
- unix_proto_init
1 #include <linux/signal.h>
2 #include <linux/sched.h>
3 #include <linux/kernel.h>
4 #include <linux/errno.h>
5 #include <linux/string.h>
6 #include <linux/stat.h>
7 #include <linux/socket.h>
8 #include <linux/un.h>
9 #include <linux/fcntl.h>
10 #include <linux/termios.h>
11 #include <linux/mm.h>
12 #include <linux/config.h>
13 #include <asm/system.h>
14 #include <asm/segment.h>
15
16 #include "kern_sock.h"
17
18 static struct unix_proto_data {
19 int refcnt;
20 struct socket *socket;
21 int protocol;
22 struct sockaddr_un sockaddr_un;
23 short sockaddr_len;
24 char *buf;
25 int bp_head, bp_tail;
26 struct inode *inode;
27 struct unix_proto_data *peerupd;
28 } unix_datas[NSOCKETS];
29 #define last_unix_data (unix_datas + NSOCKETS - 1)
30
31 #define UN_DATA(SOCK) ((struct unix_proto_data *)(SOCK)->data)
32 #define UN_PATH_OFFSET ((unsigned long)((struct sockaddr_un *)0)->sun_path)
33
34
35
36
37
38
39 #define BUF_SIZE PAGE_SIZE
40 #define UN_BUF_AVAIL(UPD) (((UPD)->bp_head - (UPD)->bp_tail) & (BUF_SIZE-1))
41 #define UN_BUF_SPACE(UPD) ((BUF_SIZE-1) - UN_BUF_AVAIL(UPD))
42
43 static int unix_proto_init(void);
44 static int unix_proto_create(struct socket *sock, int protocol);
45 static int unix_proto_dup(struct socket *newsock, struct socket *oldsock);
46 static int unix_proto_release(struct socket *sock, struct socket *peer);
47 static int unix_proto_bind(struct socket *sock, struct sockaddr *umyaddr,
48 int sockaddr_len);
49 static int unix_proto_connect(struct socket *sock, struct sockaddr *uservaddr,
50 int sockaddr_len, int flags);
51 static int unix_proto_socketpair(struct socket *sock1, struct socket *sock2);
52 static int unix_proto_accept(struct socket *sock, struct socket *newsock,
53 int flags);
54 static int unix_proto_getname(struct socket *sock, struct sockaddr *usockaddr,
55 int *usockaddr_len, int peer);
56 static int unix_proto_read(struct socket *sock, char *ubuf, int size,
57 int nonblock);
58 static int unix_proto_write(struct socket *sock, char *ubuf, int size,
59 int nonblock);
60 static int unix_proto_select(struct socket *sock, int sel_type, select_table * wait);
61 static int unix_proto_ioctl(struct socket *sock, unsigned int cmd,
62 unsigned long arg);
63 static int unix_proto_listen(struct socket *sock, int backlog);
64 static int unix_proto_send (struct socket *sock, void *buff, int len,
65 int nonblock, unsigned flags);
66 static int unix_proto_recv (struct socket *sock, void *buff, int len,
67 int nonblock, unsigned flags);
68 static int unix_proto_sendto (struct socket *sock, void *buff, int len,
69 int nonblock, unsigned flags,
70 struct sockaddr *addr, int addr_len);
71 static int unix_proto_recvfrom (struct socket *sock, void *buff, int len,
72 int nonblock, unsigned flags,
73 struct sockaddr *addr, int *addr_len);
74
75 static int unix_proto_shutdown (struct socket *sock, int how);
76
77 static int unix_proto_setsockopt (struct socket *sock, int level, int optname,
78 char *optval, int optlen);
79 static int unix_proto_getsockopt (struct socket *sock, int level, int optname,
80 char *optval, int *optlen);
81
82 struct proto_ops unix_proto_ops = {
83 unix_proto_init,
84 unix_proto_create,
85 unix_proto_dup,
86 unix_proto_release,
87 unix_proto_bind,
88 unix_proto_connect,
89 unix_proto_socketpair,
90 unix_proto_accept,
91 unix_proto_getname,
92 unix_proto_read,
93 unix_proto_write,
94 unix_proto_select,
95 unix_proto_ioctl,
96 unix_proto_listen,
97 unix_proto_send,
98 unix_proto_recv,
99 unix_proto_sendto,
100 unix_proto_recvfrom,
101 unix_proto_shutdown,
102 unix_proto_setsockopt,
103 unix_proto_getsockopt,
104 NULL,
105 };
106
107 static inline int
108 min (int a, int b)
109 {
110 if (a < b) return (a);
111 return (b);
112 }
113
114 #ifdef SOCK_DEBUG
115 void
116 sockaddr_un_printk(struct sockaddr_un *sockun, int sockaddr_len)
117 {
118 char buf[sizeof(sockun->sun_path) + 1];
119
120 sockaddr_len -= UN_PATH_OFFSET;
121 if (sockun->sun_family != AF_UNIX)
122 printk("sockaddr_un: <BAD FAMILY: %d>\n", sockun->sun_family);
123 else if (sockaddr_len <= 0 || sockaddr_len >= sizeof(buf))
124 printk("sockaddr_un: <BAD LENGTH: %d>\n", sockaddr_len);
125 else {
126 memcpy(buf, sockun->sun_path, sockaddr_len);
127 buf[sockaddr_len] = '\0';
128 printk("sockaddr_un: '%s'[%d]\n", buf,
129 sockaddr_len + UN_PATH_OFFSET);
130 }
131 }
132 #endif
133
134
135 static int
136 unix_proto_listen (struct socket *sock, int backlog)
137 {
138 return (0);
139 }
140
141 static int
142 unix_proto_setsockopt(struct socket *sock, int level, int optname,
143 char *optval, int optlen)
144 {
145 return (-EOPNOTSUPP);
146 }
147
148 static int
149 unix_proto_getsockopt(struct socket *sock, int level, int optname,
150 char *optval, int *optlen)
151 {
152 return (-EOPNOTSUPP);
153 }
154
155 static int
156 unix_proto_sendto(struct socket *sock, void *buff, int len, int nonblock,
157 unsigned flags, struct sockaddr *addr, int addr_len)
158 {
159 return (-EOPNOTSUPP);
160 }
161
162 static int
163 unix_proto_recvfrom(struct socket *sock, void *buff, int len, int nonblock,
164 unsigned flags, struct sockaddr *addr, int *addr_len)
165 {
166 return (-EOPNOTSUPP);
167 }
168
169 static int
170 unix_proto_shutdown (struct socket *sock, int how)
171 {
172 return (-EOPNOTSUPP);
173 }
174
175 static int
176 unix_proto_send(struct socket *sock, void *buff, int len, int nonblock,
177 unsigned flags)
178 {
179
180 if (flags != 0)
181 return (-EINVAL);
182 return (unix_proto_write (sock, buff, len, nonblock));
183 }
184
185 static int
186 unix_proto_recv(struct socket *sock, void *buff, int len, int nonblock,
187 unsigned flags)
188 {
189
190 if (flags != 0)
191 return (-EINVAL);
192 return (unix_proto_read (sock, buff, len, nonblock));
193 }
194
195 static struct unix_proto_data *
196 unix_data_lookup(struct sockaddr_un *sockun, int sockaddr_len,
197 struct inode *inode)
198 {
199 struct unix_proto_data *upd;
200
201 for (upd = unix_datas; upd <= last_unix_data; ++upd) {
202 if (upd->refcnt && upd->socket &&
203 upd->socket->state == SS_UNCONNECTED &&
204 upd->sockaddr_un.sun_family == sockun->sun_family &&
205 upd->inode == inode)
206 return upd;
207 }
208 return NULL;
209 }
210
211 static struct unix_proto_data *
212 unix_data_alloc(void)
213 {
214 struct unix_proto_data *upd;
215
216 cli();
217 for (upd = unix_datas; upd <= last_unix_data; ++upd) {
218 if (!upd->refcnt) {
219 upd->refcnt = 1;
220 sti();
221 upd->socket = NULL;
222 upd->sockaddr_len = 0;
223 upd->buf = NULL;
224 upd->bp_head = upd->bp_tail = 0;
225 upd->inode = NULL;
226 upd->peerupd = NULL;
227 return upd;
228 }
229 }
230 sti();
231 return NULL;
232 }
233
234 static inline void
235 unix_data_ref(struct unix_proto_data *upd)
236 {
237 ++upd->refcnt;
238 PRINTK(("unix_data_ref: refing data 0x%x (%d)\n", upd, upd->refcnt));
239 }
240
241 static void
242 unix_data_deref(struct unix_proto_data *upd)
243 {
244 if (upd->refcnt == 1) {
245 PRINTK(("unix_data_deref: releasing data 0x%x\n", upd));
246 if (upd->buf) {
247 free_page((unsigned long)upd->buf);
248 upd->buf = NULL;
249 upd->bp_head = upd->bp_tail = 0;
250 }
251 }
252 --upd->refcnt;
253 }
254
255
256
257
258
259 static int
260 unix_proto_create(struct socket *sock, int protocol)
261 {
262 struct unix_proto_data *upd;
263
264 PRINTK(("unix_proto_create: socket 0x%x, proto %d\n", sock, protocol));
265 if (protocol != 0) {
266 PRINTK(("unix_proto_create: protocol != 0\n"));
267 return -EINVAL;
268 }
269 if (!(upd = unix_data_alloc())) {
270 printk("unix_proto_create: can't allocate buffer\n");
271 return -ENOMEM;
272 }
273 if (!(upd->buf = (char *)get_free_page(GFP_USER))) {
274 printk("unix_proto_create: can't get page!\n");
275 unix_data_deref(upd);
276 return -ENOMEM;
277 }
278 upd->protocol = protocol;
279 upd->socket = sock;
280 UN_DATA(sock) = upd;
281 PRINTK(("unix_proto_create: allocated data 0x%x\n", upd));
282 return 0;
283 }
284
285 static int
286 unix_proto_dup(struct socket *newsock, struct socket *oldsock)
287 {
288 struct unix_proto_data *upd = UN_DATA(oldsock);
289
290 return unix_proto_create(newsock, upd->protocol);
291 }
292
293 static int
294 unix_proto_release(struct socket *sock, struct socket *peer)
295 {
296 struct unix_proto_data *upd = UN_DATA(sock);
297
298 PRINTK(("unix_proto_release: socket 0x%x, unix_data 0x%x\n",
299 sock, upd));
300 if (!upd)
301 return 0;
302 if (upd->socket != sock) {
303 printk("unix_proto_release: socket link mismatch!\n");
304 return -EINVAL;
305 }
306 if (upd->inode) {
307 PRINTK(("unix_proto_release: releasing inode 0x%x\n",
308 upd->inode));
309 iput(upd->inode);
310 upd->inode = NULL;
311 }
312 UN_DATA(sock) = NULL;
313 upd->socket = NULL;
314 if (upd->peerupd)
315 unix_data_deref(upd->peerupd);
316 unix_data_deref(upd);
317 return 0;
318 }
319
320
321
322
323
324
325
326
327
328
329 static int
330 unix_proto_bind(struct socket *sock, struct sockaddr *umyaddr,
331 int sockaddr_len)
332 {
333 struct unix_proto_data *upd = UN_DATA(sock);
334 char fname[sizeof(((struct sockaddr_un *)0)->sun_path) + 1];
335 int i;
336
337 PRINTK(("unix_proto_bind: socket 0x%x, len=%d\n", sock,
338 sockaddr_len));
339 if (sockaddr_len <= UN_PATH_OFFSET ||
340 sockaddr_len > sizeof(struct sockaddr_un)) {
341 PRINTK(("unix_proto_bind: bad length %d\n", sockaddr_len));
342 return -EINVAL;
343 }
344 if (upd->sockaddr_len || upd->inode) {
345 printk("unix_proto_bind: already bound!\n");
346 return -EINVAL;
347 }
348 verify_area(VERIFY_WRITE,umyaddr, sockaddr_len);
349 memcpy_fromfs(&upd->sockaddr_un, umyaddr, sockaddr_len);
350 if (upd->sockaddr_un.sun_family != AF_UNIX) {
351 PRINTK(("unix_proto_bind: family is %d, not AF_UNIX (%d)\n",
352 upd->sockaddr_un.sun_family, AF_UNIX));
353 return -EINVAL;
354 }
355
356 memcpy(fname, upd->sockaddr_un.sun_path, sockaddr_len-UN_PATH_OFFSET);
357 fname[sockaddr_len-UN_PATH_OFFSET] = '\0';
358 i = do_mknod(fname, S_IFSOCK | 0777, 0);
359 if (i == 0)
360 i = open_namei(fname, 0, S_IFSOCK, &upd->inode, NULL);
361 if (i < 0) {
362 printk("unix_proto_bind: can't open socket %s\n", fname);
363 return i;
364 }
365
366 upd->sockaddr_len = sockaddr_len;
367 PRINTK(("unix_proto_bind: bound socket address: "));
368 #ifdef SOCK_DEBUG
369 sockaddr_un_printk(&upd->sockaddr_un, upd->sockaddr_len);
370 #endif
371 PRINTK(("to inode 0x%x\n", upd->inode));
372 return 0;
373 }
374
375
376
377
378
379 static int
380 unix_proto_connect(struct socket *sock, struct sockaddr *uservaddr,
381 int sockaddr_len, int flags)
382 {
383 int i;
384 struct unix_proto_data *serv_upd;
385 struct sockaddr_un sockun;
386 char fname[sizeof(((struct sockaddr_un *)0)->sun_path) + 1];
387 struct inode *inode;
388
389 PRINTK(("unix_proto_connect: socket 0x%x, servlen=%d\n", sock,
390 sockaddr_len));
391
392 if (sockaddr_len <= UN_PATH_OFFSET ||
393 sockaddr_len > sizeof(struct sockaddr_un)) {
394 PRINTK(("unix_proto_connect: bad length %d\n", sockaddr_len));
395 return -EINVAL;
396 }
397
398 if (sock->state == SS_CONNECTING)
399 return (-EINPROGRESS);
400
401 if (sock->state == SS_CONNECTED)
402 return (-EISCONN);
403
404 verify_area(VERIFY_WRITE,uservaddr, sockaddr_len);
405 memcpy_fromfs(&sockun, uservaddr, sockaddr_len);
406 if (sockun.sun_family != AF_UNIX) {
407 PRINTK(("unix_proto_connect: family is %d, not AF_UNIX (%d)\n",
408 sockun.sun_family, AF_UNIX));
409 return -EINVAL;
410 }
411
412
413
414
415
416
417
418 memcpy(fname, sockun.sun_path, sockaddr_len-UN_PATH_OFFSET);
419 fname[sockaddr_len-UN_PATH_OFFSET] = '\0';
420 i = open_namei(fname, 0, S_IFSOCK, &inode, NULL);
421 if (i < 0) {
422 PRINTK(("unix_proto_connect: can't open socket %s\n", fname));
423 return i;
424 }
425 serv_upd = unix_data_lookup(&sockun, sockaddr_len, inode);
426 iput(inode);
427 if (!serv_upd) {
428 PRINTK(("unix_proto_connect: can't locate peer %s at inode 0x%x\n",
429 fname, inode));
430 return -EINVAL;
431 }
432 if ((i = sock_awaitconn(sock, serv_upd->socket)) < 0) {
433 PRINTK(("unix_proto_connect: can't await connection\n"));
434 return i;
435 }
436 unix_data_ref(UN_DATA(sock->conn));
437 UN_DATA(sock)->peerupd = UN_DATA(sock->conn);
438 return 0;
439 }
440
441
442
443
444
445
446
447 static int
448 unix_proto_socketpair(struct socket *sock1, struct socket *sock2)
449 {
450 struct unix_proto_data *upd1 = UN_DATA(sock1), *upd2 = UN_DATA(sock2);
451
452 unix_data_ref(upd1);
453 unix_data_ref(upd2);
454 upd1->peerupd = upd2;
455 upd2->peerupd = upd1;
456 return 0;
457 }
458
459
460
461
462 static int
463 unix_proto_accept(struct socket *sock, struct socket *newsock, int flags)
464 {
465 struct socket *clientsock;
466
467 PRINTK(("unix_proto_accept: socket 0x%x accepted via socket 0x%x\n",
468 sock, newsock));
469
470
471
472
473
474 while (!(clientsock = sock->iconn)) {
475 if (flags & O_NONBLOCK)
476 return -EAGAIN;
477 interruptible_sleep_on(sock->wait);
478 if (current->signal & ~current->blocked) {
479 PRINTK(("sys_accept: sleep was interrupted\n"));
480 return -ERESTARTSYS;
481 }
482 }
483
484
485
486
487
488 sock->iconn = clientsock->next;
489 clientsock->next = NULL;
490 newsock->conn = clientsock;
491 clientsock->conn = newsock;
492 clientsock->state = SS_CONNECTED;
493 newsock->state = SS_CONNECTED;
494 wake_up(clientsock->wait);
495 unix_data_ref (UN_DATA(newsock->conn));
496 UN_DATA(newsock)->peerupd = UN_DATA(newsock->conn);
497 UN_DATA(newsock)->sockaddr_un = UN_DATA(sock)->sockaddr_un;
498 UN_DATA(newsock)->sockaddr_len = UN_DATA(sock)->sockaddr_len;
499 UN_DATA(newsock->conn)->sockaddr_un = UN_DATA(sock)->sockaddr_un;
500 UN_DATA(newsock->conn)->sockaddr_len = UN_DATA(sock)->sockaddr_len;
501 return 0;
502 }
503
504
505
506
507 static int
508 unix_proto_getname(struct socket *sock, struct sockaddr *usockaddr,
509 int *usockaddr_len, int peer)
510 {
511 struct unix_proto_data *upd;
512 int len;
513
514 PRINTK(("unix_proto_getname: socket 0x%x for %s\n", sock,
515 peer ? "peer" : "self"));
516 if (peer) {
517 if (sock->state != SS_CONNECTED) {
518 PRINTK(("unix_proto_getname: socket not connected\n"));
519 return -EINVAL;
520 }
521 upd = UN_DATA(sock->conn);
522 }
523 else
524 upd = UN_DATA(sock);
525 verify_area(VERIFY_WRITE,usockaddr_len, sizeof(*usockaddr_len));
526 if ((len = get_fs_long(usockaddr_len)) <= 0)
527 return -EINVAL;
528 if (len > upd->sockaddr_len)
529 len = upd->sockaddr_len;
530 if (len) {
531 verify_area(VERIFY_WRITE,usockaddr, len);
532 memcpy_tofs(usockaddr, &upd->sockaddr_un, len);
533 }
534 put_fs_long(len, usockaddr_len);
535 return 0;
536 }
537
538
539
540
541 static int
542 unix_proto_read(struct socket *sock, char *ubuf, int size, int nonblock)
543 {
544 struct unix_proto_data *upd;
545 int todo, avail;
546
547 if ((todo = size) <= 0)
548 return 0;
549 upd = UN_DATA(sock);
550 while (!(avail = UN_BUF_AVAIL(upd))) {
551 if (sock->state != SS_CONNECTED) {
552 PRINTK(("unix_proto_read: socket not connected\n"));
553 return (sock->state == SS_DISCONNECTING) ? 0 : -EINVAL;
554 }
555 PRINTK(("unix_proto_read: no data available...\n"));
556 if (nonblock)
557 return -EAGAIN;
558 interruptible_sleep_on(sock->wait);
559 if (current->signal & ~current->blocked) {
560 PRINTK(("unix_proto_read: interrupted\n"));
561 return -ERESTARTSYS;
562 }
563 if (sock->state == SS_DISCONNECTING) {
564 PRINTK(("unix_proto_read: disconnected\n"));
565 return 0;
566 }
567 }
568
569
570
571
572
573 do {
574 int part, cando;
575
576 if (avail <= 0) {
577 PRINTK(("unix_proto_read: AVAIL IS NEGATIVE!!!\n"));
578 send_sig(SIGKILL,current,1);
579 return -EINTR;
580 }
581
582 if ((cando = todo) > avail)
583 cando = avail;
584 if (cando > (part = BUF_SIZE - upd->bp_tail))
585 cando = part;
586 PRINTK(("unix_proto_read: avail=%d, todo=%d, cando=%d\n",
587 avail, todo, cando));
588 verify_area(VERIFY_WRITE,ubuf, cando);
589 memcpy_tofs(ubuf, upd->buf + upd->bp_tail, cando);
590 upd->bp_tail = (upd->bp_tail + cando) & (BUF_SIZE-1);
591 ubuf += cando;
592 todo -= cando;
593 if (sock->state == SS_CONNECTED)
594 wake_up(sock->conn->wait);
595 avail = UN_BUF_AVAIL(upd);
596 } while (todo && avail);
597 return size - todo;
598 }
599
600
601
602
603
604
605 static int
606 unix_proto_write(struct socket *sock, char *ubuf, int size, int nonblock)
607 {
608 struct unix_proto_data *pupd;
609 int todo, space;
610
611 if ((todo = size) <= 0)
612 return 0;
613 if (sock->state != SS_CONNECTED) {
614 PRINTK(("unix_proto_write: socket not connected\n"));
615 if (sock->state == SS_DISCONNECTING) {
616 send_sig(SIGPIPE,current,1);
617 return -EINTR;
618 }
619 return -EINVAL;
620 }
621 pupd = UN_DATA(sock)->peerupd;
622
623 while (!(space = UN_BUF_SPACE(pupd))) {
624 PRINTK(("unix_proto_write: no space left...\n"));
625 if (nonblock)
626 return -EAGAIN;
627 interruptible_sleep_on(sock->wait);
628 if (current->signal & ~current->blocked) {
629 PRINTK(("unix_proto_write: interrupted\n"));
630 return -ERESTARTSYS;
631 }
632 if (sock->state == SS_DISCONNECTING) {
633 PRINTK(("unix_proto_write: disconnected (SIGPIPE)\n"));
634 send_sig(SIGPIPE,current,1);
635 return -EINTR;
636 }
637 }
638
639
640
641
642
643 do {
644 int part, cando;
645
646 if (space <= 0) {
647 PRINTK(("unix_proto_write: SPACE IS NEGATIVE!!!\n"));
648 send_sig(SIGKILL,current,1);
649 return -EINTR;
650 }
651
652
653
654
655
656 if (sock->state == SS_DISCONNECTING) {
657 send_sig(SIGPIPE,current,1);
658 return -EINTR;
659 }
660 if ((cando = todo) > space)
661 cando = space;
662 if (cando > (part = BUF_SIZE - pupd->bp_head))
663 cando = part;
664 PRINTK(("unix_proto_write: space=%d, todo=%d, cando=%d\n",
665 space, todo, cando));
666 verify_area(VERIFY_WRITE,ubuf, cando);
667 memcpy_fromfs(pupd->buf + pupd->bp_head, ubuf, cando);
668 pupd->bp_head = (pupd->bp_head + cando) & (BUF_SIZE-1);
669 ubuf += cando;
670 todo -= cando;
671 if (sock->state == SS_CONNECTED)
672 wake_up(sock->conn->wait);
673 space = UN_BUF_SPACE(pupd);
674 } while (todo && space);
675 return size - todo;
676 }
677
678 static int
679 unix_proto_select(struct socket *sock, int sel_type, select_table * wait)
680 {
681 struct unix_proto_data *upd, *peerupd;
682
683
684
685
686 if (sock->flags & SO_ACCEPTCON) {
687 if (sel_type == SEL_IN) {
688 PRINTK(("sock_select: %sconnections pending\n",
689 sock->iconn ? "" : "no "));
690 if (sock->iconn)
691 return 1;
692 select_wait(sock->wait, wait);
693 return sock->iconn ? 1 : 0;
694 }
695 PRINTK(("sock_select: nothing else for server socket\n"));
696 select_wait(sock->wait, wait);
697 return 0;
698 }
699
700 if (sel_type == SEL_IN) {
701 upd = UN_DATA(sock);
702 PRINTK(("unix_proto_select: there is%s data available\n",
703 UN_BUF_AVAIL(upd) ? "" : " no"));
704 if (UN_BUF_AVAIL(upd))
705 return 1;
706 else if (sock->state != SS_CONNECTED) {
707 PRINTK(("unix_proto_select: socket not connected (read EOF)\n"));
708 return 1;
709 }
710 select_wait(sock->wait,wait);
711 return 0;
712 }
713 if (sel_type == SEL_OUT) {
714 if (sock->state != SS_CONNECTED) {
715 PRINTK(("unix_proto_select: socket not connected (write EOF)\n"));
716 return 1;
717 }
718 peerupd = UN_DATA(sock->conn);
719 PRINTK(("unix_proto_select: there is%s space available\n",
720 UN_BUF_SPACE(peerupd) ? "" : " no"));
721 if (UN_BUF_SPACE(peerupd) > 0)
722 return 1;
723 select_wait(sock->wait,wait);
724 return 0;
725 }
726
727 PRINTK(("unix_proto_select: there are no exceptions here?!\n"));
728 return 0;
729 }
730
731 static int
732 unix_proto_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
733 {
734 struct unix_proto_data *upd, *peerupd;
735
736 upd = UN_DATA(sock);
737 peerupd = (sock->state == SS_CONNECTED) ? UN_DATA(sock->conn) : NULL;
738
739 switch (cmd) {
740
741 case TIOCINQ:
742 if (sock->flags & SO_ACCEPTCON)
743 return -EINVAL;
744 verify_area(VERIFY_WRITE,(void *)arg, sizeof(unsigned long));
745 if (UN_BUF_AVAIL(upd) || peerupd)
746 put_fs_long(UN_BUF_AVAIL(upd), (unsigned long *)arg);
747 else
748 put_fs_long(1, (unsigned long *)arg);
749 break;
750
751 case TIOCOUTQ:
752 if (sock->flags & SO_ACCEPTCON)
753 return -EINVAL;
754 verify_area(VERIFY_WRITE,(void *)arg, sizeof(unsigned long));
755 if (peerupd)
756 put_fs_long(UN_BUF_SPACE(peerupd),
757 (unsigned long *)arg);
758 else
759 put_fs_long(0, (unsigned long *)arg);
760 break;
761
762 default:
763 return -EINVAL;
764 }
765 return 0;
766 }
767
768 static int
769 unix_proto_init(void)
770 {
771 struct unix_proto_data *upd;
772
773 PRINTK(("unix_proto_init: initializing...\n"));
774 for (upd = unix_datas; upd <= last_unix_data; ++upd)
775 upd->refcnt = 0;
776 return 0;
777 }