![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to unix.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Early Linux] / linux / net|
Return to unix.c CVS log | Up to [Early Linux] / linux / net |
1.1 root 1: #include <signal.h>
2: #include <errno.h>
3: #include <linux/string.h>
4: #include <linux/sched.h>
5: #include <linux/kernel.h>
6: #include <asm/system.h>
7: #include <asm/segment.h>
8: #include <sys/socket.h>
9: #include <sys/un.h>
10: #include <sys/stat.h>
11: #include <fcntl.h>
12: #include <termios.h>
13: #include "kern_sock.h"
14:
15: static struct unix_proto_data {
16: int refcnt; /* cnt of reference 0=free */
17: struct socket *socket; /* socket we're bound to */
18: int protocol;
19: struct sockaddr_un sockaddr_un;
20: short sockaddr_len; /* >0 if name bound */
21: char *buf;
22: int bp_head, bp_tail;
23: struct inode *inode;
24: struct unix_proto_data *peerupd;
25: } unix_datas[NSOCKETS];
26: #define last_unix_data (unix_datas + NSOCKETS - 1)
27:
28: #define UN_DATA(SOCK) ((struct unix_proto_data *)(SOCK)->data)
29: #define UN_PATH_OFFSET ((unsigned long)((struct sockaddr_un *)0)->sun_path)
30:
31: /*
32: * buffer size must be power of 2. buffer mgmt inspired by pipe code.
33: * note that buffer contents can wraparound, and we can write one byte less
34: * than full size to discern full vs empty.
35: */
36: #define BUF_SIZE PAGE_SIZE
37: #define UN_BUF_AVAIL(UPD) (((UPD)->bp_head - (UPD)->bp_tail) & (BUF_SIZE-1))
38: #define UN_BUF_SPACE(UPD) ((BUF_SIZE-1) - UN_BUF_AVAIL(UPD))
39:
40: static int unix_proto_init(void);
41: static int unix_proto_create(struct socket *sock, int protocol);
42: static int unix_proto_dup(struct socket *newsock, struct socket *oldsock);
43: static int unix_proto_release(struct socket *sock, struct socket *peer);
44: static int unix_proto_bind(struct socket *sock, struct sockaddr *umyaddr,
45: int sockaddr_len);
46: static int unix_proto_connect(struct socket *sock, struct sockaddr *uservaddr,
47: int sockaddr_len);
48: static int unix_proto_socketpair(struct socket *sock1, struct socket *sock2);
49: static int unix_proto_accept(struct socket *sock, struct socket *newsock);
50: static int unix_proto_getname(struct socket *sock, struct sockaddr *usockaddr,
51: int *usockaddr_len, int peer);
52: static int unix_proto_read(struct socket *sock, char *ubuf, int size,
53: int nonblock);
54: static int unix_proto_write(struct socket *sock, char *ubuf, int size,
55: int nonblock);
56: static int unix_proto_select(struct socket *sock, int which);
57: static int unix_proto_ioctl(struct socket *sock, unsigned int cmd,
58: unsigned long arg);
59:
60: struct proto_ops unix_proto_ops = {
61: unix_proto_init,
62: unix_proto_create,
63: unix_proto_dup,
64: unix_proto_release,
65: unix_proto_bind,
66: unix_proto_connect,
67: unix_proto_socketpair,
68: unix_proto_accept,
69: unix_proto_getname,
70: unix_proto_read,
71: unix_proto_write,
72: unix_proto_select,
73: unix_proto_ioctl
74: };
75:
76: #ifdef SOCK_DEBUG
77: void
78: sockaddr_un_printk(struct sockaddr_un *sockun, int sockaddr_len)
79: {
80: char buf[sizeof(sockun->sun_path) + 1];
81:
82: sockaddr_len -= UN_PATH_OFFSET;
83: if (sockun->sun_family != AF_UNIX)
84: printk("sockaddr_un: <BAD FAMILY: %d>\n", sockun->sun_family);
85: else if (sockaddr_len <= 0 || sockaddr_len >= sizeof(buf)-1)
86: printk("sockaddr_un: <BAD LENGTH: %d>\n", sockaddr_len);
87: else {
88: memcpy(buf, sockun->sun_path, sockaddr_len);
89: buf[sockaddr_len] = '\0';
90: printk("sockaddr_un: '%s'[%d]\n", buf,
91: sockaddr_len + UN_PATH_OFFSET);
92: }
93: }
94: #endif
95:
96: static struct unix_proto_data *
97: unix_data_lookup(struct sockaddr_un *sockun, int sockaddr_len)
98: {
99: struct unix_proto_data *upd;
100:
101: for (upd = unix_datas; upd <= last_unix_data; ++upd) {
102: if (upd->refcnt && upd->socket &&
103: upd->sockaddr_len == sockaddr_len &&
104: memcmp(&upd->sockaddr_un, sockun, sockaddr_len) == 0)
105: return upd;
106: }
107: return NULL;
108: }
109:
110: static struct unix_proto_data *
111: unix_data_alloc(void)
112: {
113: struct unix_proto_data *upd;
114:
115: cli();
116: for (upd = unix_datas; upd <= last_unix_data; ++upd) {
117: if (!upd->refcnt) {
118: upd->refcnt = 1;
119: sti();
120: upd->socket = NULL;
121: upd->sockaddr_len = 0;
122: upd->buf = NULL;
123: upd->bp_head = upd->bp_tail = 0;
124: upd->inode = NULL;
125: upd->peerupd = NULL;
126: return upd;
127: }
128: }
129: sti();
130: return NULL;
131: }
132:
133: static inline void
134: unix_data_ref(struct unix_proto_data *upd)
135: {
136: ++upd->refcnt;
137: PRINTK("unix_data_ref: refing data 0x%x (%d)\n", upd, upd->refcnt);
138: }
139:
140: static void
141: unix_data_deref(struct unix_proto_data *upd)
142: {
143: if (upd->refcnt == 1) {
144: PRINTK("unix_data_deref: releasing data 0x%x\n", upd);
145: if (upd->buf) {
146: free_page((unsigned long)upd->buf);
147: upd->buf = NULL;
148: upd->bp_head = upd->bp_tail = 0;
149: }
150: }
151: --upd->refcnt;
152: }
153:
154: /*
155: * upon a create, we allocate an empty protocol data, and grab a page to
156: * buffer writes
157: */
158: static int
159: unix_proto_create(struct socket *sock, int protocol)
160: {
161: struct unix_proto_data *upd;
162:
163: PRINTK("unix_proto_create: socket 0x%x, proto %d\n", sock, protocol);
164: if (protocol != 0) {
165: PRINTK("unix_proto_create: protocol != 0\n");
166: return -EINVAL;
167: }
168: if (!(upd = unix_data_alloc())) {
169: printk("unix_proto_create: can't allocate buffer\n");
170: return -ENOMEM;
171: }
172: if (!(upd->buf = (char *)get_free_page())) {
173: printk("unix_proto_create: can't get page!\n");
174: unix_data_deref(upd);
175: return -ENOMEM;
176: }
177: upd->protocol = protocol;
178: upd->socket = sock;
179: UN_DATA(sock) = upd;
180: PRINTK("unix_proto_create: allocated data 0x%x\n", upd);
181: return 0;
182: }
183:
184: static int
185: unix_proto_dup(struct socket *newsock, struct socket *oldsock)
186: {
187: struct unix_proto_data *upd = UN_DATA(oldsock);
188:
189: return unix_proto_create(newsock, upd->protocol);
190: }
191:
192: static int
193: unix_proto_release(struct socket *sock, struct socket *peer)
194: {
195: struct unix_proto_data *upd = UN_DATA(sock);
196:
197: PRINTK("unix_proto_release: socket 0x%x, unix_data 0x%x\n",
198: sock, upd);
199: if (!upd)
200: return 0;
201: if (upd->socket != sock) {
202: printk("unix_proto_release: socket link mismatch!\n");
203: return -EINVAL;
204: }
205: if (upd->inode) {
206: PRINTK("unix_proto_release: releasing inode 0x%x\n",
207: upd->inode);
208: iput(upd->inode);
209: upd->inode = NULL;
210: }
211: UN_DATA(sock) = NULL;
212: upd->socket = NULL;
213: if (upd->peerupd)
214: unix_data_deref(upd->peerupd);
215: unix_data_deref(upd);
216: return 0;
217: }
218:
219: /*
220: * bind a name to a socket. this is where much of the work is done. we
221: * allocate a fresh page for the buffer, grab the appropriate inode and
222: * set things up.
223: *
224: * XXX what should we do if an address is already bound? here we return
225: * EINVAL, but it may be necessary to re-bind. i think thats what bsd does
226: * in the case of datagram sockets
227: */
228: static int
229: unix_proto_bind(struct socket *sock, struct sockaddr *umyaddr,
230: int sockaddr_len)
231: {
232: struct unix_proto_data *upd = UN_DATA(sock);
233: char fname[sizeof(((struct sockaddr_un *)0)->sun_path) + 1];
234: int i;
235: unsigned long old_fs;
236: unsigned short old_euid;
237:
238: PRINTK("unix_proto_bind: socket 0x%x, len=%d\n", sock,
239: sockaddr_len);
240: if (sockaddr_len <= UN_PATH_OFFSET ||
241: sockaddr_len >= sizeof(struct sockaddr_un)) {
242: PRINTK("unix_proto_bind: bad length %d\n", sockaddr_len);
243: return -EINVAL;
244: }
245: if (upd->sockaddr_len || upd->inode) {
246: printk("unix_proto_bind: already bound!\n");
247: return -EINVAL;
248: }
249: verify_area(umyaddr, sockaddr_len);
250: memcpy_fromfs(&upd->sockaddr_un, umyaddr, sockaddr_len);
251: if (upd->sockaddr_un.sun_family != AF_UNIX) {
252: PRINTK("unix_proto_bind: family is %d, not AF_UNIX (%d)\n",
253: upd->sockaddr_un.sun_family, AF_UNIX);
254: return -EINVAL;
255: }
256:
257: /*
258: * W A R N I N G
259: * this is a terrible hack. i want to create a socket in the
260: * filesystem and get its inode. sys_mknod() can create one for
261: * me, but it needs superuser privs and doesn't give me the inode.
262: * we fake suser here and get the file created... ugh.
263: */
264: memcpy(fname, upd->sockaddr_un.sun_path, sockaddr_len-UN_PATH_OFFSET);
265: fname[sockaddr_len-UN_PATH_OFFSET] = '\0';
266: old_fs = get_fs();
267: set_fs(get_ds());
268: old_euid = current->euid;
269: current->euid = 0;
270: i = sys_mknod(fname, S_IFSOCK, 0);
271: current->euid = old_euid;
272: if (i == 0)
273: i = open_namei(fname, 0, S_IFSOCK, &upd->inode);
274: set_fs(old_fs);
275: if (i < 0) {
276: printk("unix_proto_bind: can't open socket %s\n", fname);
277: return i;
278: }
279:
280: upd->sockaddr_len = sockaddr_len; /* now its legal */
281: PRINTK("unix_proto_bind: bound socket address: ");
282: #ifdef SOCK_DEBUG
283: sockaddr_un_printk(&upd->sockaddr_un, upd->sockaddr_len);
284: #endif
285: return 0;
286: }
287:
288: /*
289: * perform a connection. we can only connect to unix sockets (i can't for
290: * the life of me find an application where that wouldn't be the case!)
291: */
292: static int
293: unix_proto_connect(struct socket *sock, struct sockaddr *uservaddr,
294: int sockaddr_len)
295: {
296: int i;
297: struct unix_proto_data *serv_upd;
298: struct sockaddr_un sockun;
299:
300: PRINTK("unix_proto_connect: socket 0x%x, servlen=%d\n", sock,
301: sockaddr_len);
302: if (sockaddr_len <= UN_PATH_OFFSET ||
303: sockaddr_len >= sizeof(struct sockaddr_un)) {
304: PRINTK("unix_proto_connect: bad length %d\n", sockaddr_len);
305: return -EINVAL;
306: }
307: verify_area(uservaddr, sockaddr_len);
308: memcpy_fromfs(&sockun, uservaddr, sockaddr_len);
309: if (sockun.sun_family != AF_UNIX) {
310: PRINTK("unix_proto_connect: family is %d, not AF_UNIX (%d)\n",
311: sockun.sun_family, AF_UNIX);
312: return -EINVAL;
313: }
314: if (!(serv_upd = unix_data_lookup(&sockun, sockaddr_len))) {
315: PRINTK("unix_proto_connect: can't locate peer\n");
316: return -EINVAL;
317: }
318: if ((i = sock_awaitconn(sock, serv_upd->socket)) < 0) {
319: PRINTK("unix_proto_connect: can't await connection\n");
320: return i;
321: }
322: unix_data_ref(UN_DATA(sock->conn));
323: UN_DATA(sock)->peerupd = UN_DATA(sock->conn); /* ref server */
324: return 0;
325: }
326:
327: /*
328: * to do a socketpair, we make just connect the two datas, easy! since we
329: * always wait on the socket inode, they're no contention for a wait area,
330: * and deadlock prevention in the case of a process writing to itself is,
331: * ignored, in true unix fashion!
332: */
333: static int
334: unix_proto_socketpair(struct socket *sock1, struct socket *sock2)
335: {
336: struct unix_proto_data *upd1 = UN_DATA(sock1), *upd2 = UN_DATA(sock2);
337:
338: unix_data_ref(upd1);
339: unix_data_ref(upd2);
340: upd1->peerupd = upd2;
341: upd2->peerupd = upd1;
342: return 0;
343: }
344:
345: /*
346: * on accept, we ref the peer's data for safe writes
347: */
348: static int
349: unix_proto_accept(struct socket *sock, struct socket *newsock)
350: {
351: PRINTK("unix_proto_accept: socket 0x%x accepted via socket 0x%x\n",
352: sock, newsock);
353: unix_data_ref(UN_DATA(newsock->conn));
354: UN_DATA(newsock)->peerupd = UN_DATA(newsock->conn);
355: return 0;
356: }
357:
358: /*
359: * gets the current name or the name of the connected socket.
360: */
361: static int
362: unix_proto_getname(struct socket *sock, struct sockaddr *usockaddr,
363: int *usockaddr_len, int peer)
364: {
365: struct unix_proto_data *upd;
366: int len;
367:
368: PRINTK("unix_proto_getname: socket 0x%x for %s\n", sock,
369: peer ? "peer" : "self");
370: if (peer) {
371: if (sock->state != SS_CONNECTED) {
372: PRINTK("unix_proto_getname: socket not connected\n");
373: return -EINVAL;
374: }
375: upd = UN_DATA(sock->conn);
376: }
377: else
378: upd = UN_DATA(sock);
379: verify_area(usockaddr_len, sizeof(*usockaddr_len));
380: if ((len = get_fs_long(usockaddr_len)) <= 0)
381: return -EINVAL;
382: if (len > upd->sockaddr_len)
383: len = upd->sockaddr_len;
384: if (len) {
385: verify_area(usockaddr, len);
386: memcpy_tofs(usockaddr, &upd->sockaddr_un, len);
387: }
388: put_fs_long(len, usockaddr_len);
389: return 0;
390: }
391:
392: /*
393: * we read from our own buf.
394: */
395: static int
396: unix_proto_read(struct socket *sock, char *ubuf, int size, int nonblock)
397: {
398: struct unix_proto_data *upd;
399: int todo, avail;
400:
401: if ((todo = size) <= 0)
402: return 0;
403: upd = UN_DATA(sock);
404: while (!(avail = UN_BUF_AVAIL(upd))) {
405: if (sock->state != SS_CONNECTED) {
406: PRINTK("unix_proto_read: socket not connected\n");
407: return (sock->state == SS_DISCONNECTING) ? 0 : -EINVAL;
408: }
409: PRINTK("unix_proto_read: no data available...\n");
410: if (nonblock)
411: return -EAGAIN;
412: interruptible_sleep_on(sock->wait);
413: if (current->signal & ~current->blocked) {
414: PRINTK("unix_proto_read: interrupted\n");
415: return -ERESTARTSYS;
416: }
417: if (sock->state == SS_DISCONNECTING) {
418: PRINTK("unix_proto_read: disconnected\n");
419: return 0;
420: }
421: }
422:
423: /*
424: * copy from the read buffer into the user's buffer, watching for
425: * wraparound. then we wake up the writer
426: */
427: do {
428: int part, cando;
429:
430: if (avail <= 0) {
431: PRINTK("unix_proto_read: AVAIL IS NEGATIVE!!!\n");
432: current->signal |= (1 << (SIGKILL-1));
433: return -EINTR;
434: }
435:
436: if ((cando = todo) > avail)
437: cando = avail;
438: if (cando > (part = BUF_SIZE - upd->bp_tail))
439: cando = part;
440: PRINTK("unix_proto_read: avail=%d, todo=%d, cando=%d\n",
441: avail, todo, cando);
442: verify_area(ubuf, cando);
443: memcpy_tofs(ubuf, upd->buf + upd->bp_tail, cando);
444: upd->bp_tail = (upd->bp_tail + cando) & (BUF_SIZE-1);
445: ubuf += cando;
446: todo -= cando;
447: if (sock->state == SS_CONNECTED)
448: wake_up(sock->conn->wait);
449: avail = UN_BUF_AVAIL(upd);
450: } while (todo && avail);
451: return size - todo;
452: }
453:
454: /*
455: * we write to our peer's buf. when we connected we ref'd this peer so we
456: * are safe that the buffer remains, even after the peer has disconnected,
457: * which we check other ways.
458: */
459: static int
460: unix_proto_write(struct socket *sock, char *ubuf, int size, int nonblock)
461: {
462: struct unix_proto_data *pupd;
463: int todo, space;
464:
465: if ((todo = size) <= 0)
466: return 0;
467: if (sock->state != SS_CONNECTED) {
468: PRINTK("unix_proto_write: socket not connected\n");
469: if (sock->state == SS_DISCONNECTING) {
470: current->signal |= (1 << (SIGPIPE-1));
471: return -EINTR;
472: }
473: return -EINVAL;
474: }
475: pupd = UN_DATA(sock)->peerupd; /* safer than sock->conn */
476:
477: while (!(space = UN_BUF_SPACE(pupd))) {
478: PRINTK("unix_proto_write: no space left...\n");
479: if (nonblock)
480: return 0;
481: interruptible_sleep_on(sock->wait);
482: if (current->signal & ~current->blocked) {
483: PRINTK("unix_proto_write: interrupted\n");
484: return -EINTR;
485: }
486: if (sock->state == SS_DISCONNECTING) {
487: PRINTK("unix_proto_write: disconnected (SIGPIPE)\n");
488: current->signal |= (1 << (SIGPIPE-1));
489: return -EINTR;
490: }
491: }
492:
493: /*
494: * copy from the user's buffer to the write buffer, watching for
495: * wraparound. then we wake up the reader
496: */
497: do {
498: int part, cando;
499:
500: if (space <= 0) {
501: PRINTK("unix_proto_write: SPACE IS NEGATIVE!!!\n");
502: current->signal |= (1 << (SIGKILL-1));
503: return -EINTR;
504: }
505:
506: /*
507: * we may become disconnected inside this loop, so watch
508: * for it (peerupd is safe until we close)
509: */
510: if (sock->state == SS_DISCONNECTING) {
511: current->signal |= (1 << (SIGPIPE-1));
512: return -EINTR;
513: }
514: if ((cando = todo) > space)
515: cando = space;
516: if (cando > (part = BUF_SIZE - pupd->bp_head))
517: cando = part;
518: PRINTK("unix_proto_write: space=%d, todo=%d, cando=%d\n",
519: space, todo, cando);
520: verify_area(ubuf, cando);
521: memcpy_fromfs(pupd->buf + pupd->bp_head, ubuf, cando);
522: pupd->bp_head = (pupd->bp_head + cando) & (BUF_SIZE-1);
523: ubuf += cando;
524: todo -= cando;
525: if (sock->state == SS_CONNECTED)
526: wake_up(sock->conn->wait);
527: space = UN_BUF_SPACE(pupd);
528: } while (todo && space);
529: return size - todo;
530: }
531:
532: static int
533: unix_proto_select(struct socket *sock, int which)
534: {
535: struct unix_proto_data *upd, *peerupd;
536:
537: if (which == SEL_IN) {
538: upd = UN_DATA(sock);
539: PRINTK("unix_proto_select: there is%s data available\n",
540: UN_BUF_AVAIL(upd) ? "" : " no");
541: if (UN_BUF_AVAIL(upd)) /* even if disconnected */
542: return 1;
543: else if (sock->state != SS_CONNECTED) {
544: PRINTK("unix_proto_select: socket not connected (read EOF)\n");
545: return 1;
546: }
547: else
548: return 0;
549: }
550: if (which == SEL_OUT) {
551: if (sock->state != SS_CONNECTED) {
552: PRINTK("unix_proto_select: socket not connected (write EOF)\n");
553: return 1;
554: }
555: peerupd = UN_DATA(sock->conn);
556: PRINTK("unix_proto_select: there is%s space available\n",
557: UN_BUF_SPACE(peerupd) ? "" : " no");
558: return (UN_BUF_SPACE(peerupd) > 0);
559: }
560: /* SEL_EX */
561: PRINTK("unix_proto_select: there are no exceptions here?!\n");
562: return 0;
563: }
564:
565: static int
566: unix_proto_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
567: {
568: struct unix_proto_data *upd, *peerupd;
569:
570: upd = UN_DATA(sock);
571: peerupd = (sock->state == SS_CONNECTED) ? UN_DATA(sock->conn) : NULL;
572:
573: switch (cmd) {
574: case TIOCINQ:
575: verify_area((void *)arg, sizeof(unsigned long));
576: if (UN_BUF_AVAIL(upd) || peerupd)
577: put_fs_long(UN_BUF_AVAIL(upd), (unsigned long *)arg);
578: else
579: put_fs_long(1, (unsigned long *)arg); /* read EOF */
580: break;
581:
582: case TIOCOUTQ:
583: verify_area((void *)arg, sizeof(unsigned long));
584: if (peerupd)
585: put_fs_long(UN_BUF_SPACE(peerupd),
586: (unsigned long *)arg);
587: else
588: put_fs_long(0, (unsigned long *)arg);
589: break;
590:
591: default:
592: return -EINVAL;
593: }
594: return 0;
595: }
596:
597: static int
598: unix_proto_init(void)
599: {
600: struct unix_proto_data *upd;
601:
602: PRINTK("unix_proto_init: initializing...\n");
603: for (upd = unix_datas; upd <= last_unix_data; ++upd)
604: upd->refcnt = 0;
605: return 0;
606: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.