[PATCH] (1/2) inode trimming
[opensuse:kernel.git] / arch / sparc64 / solaris / socket.c
1 /* $Id: socket.c,v 1.5 2001/02/13 01:16:44 davem Exp $
2  * socket.c: Socket syscall emulation for Solaris 2.6+
3  *
4  * Copyright (C) 1998 Jakub Jelinek (jj@ultra.linux.cz)
5  *
6  * 1999-08-19 Fixed socketpair code 
7  *            Jason Rappleye (rappleye@ccr.buffalo.edu)
8  */
9
10 #include <linux/types.h>
11 #include <linux/smp_lock.h>
12 #include <linux/mm.h>
13 #include <linux/slab.h>
14 #include <linux/socket.h>
15 #include <linux/file.h>
16
17 #include <asm/uaccess.h>
18 #include <asm/string.h>
19 #include <asm/oplib.h>
20 #include <asm/idprom.h>
21
22 #include "conv.h"
23
24 #define SOCK_SOL_STREAM         2
25 #define SOCK_SOL_DGRAM          1
26 #define SOCK_SOL_RAW            4
27 #define SOCK_SOL_RDM            5
28 #define SOCK_SOL_SEQPACKET      6
29
30 #define SOL_SO_SNDLOWAT         0x1003
31 #define SOL_SO_RCVLOWAT         0x1004
32 #define SOL_SO_SNDTIMEO         0x1005
33 #define SOL_SO_RCVTIMEO         0x1006
34 #define SOL_SO_STATE            0x2000
35
36 #define SOL_SS_NDELAY           0x040
37 #define SOL_SS_NONBLOCK         0x080
38 #define SOL_SS_ASYNC            0x100
39
40 #define SO_STATE                0x000e
41
42 static int socket_check(int family, int type)
43 {
44         if (family != PF_UNIX && family != PF_INET)
45                 return -ESOCKTNOSUPPORT;
46         switch (type) {
47         case SOCK_SOL_STREAM: type = SOCK_STREAM; break;
48         case SOCK_SOL_DGRAM: type = SOCK_DGRAM; break;
49         case SOCK_SOL_RAW: type = SOCK_RAW; break;
50         case SOCK_SOL_RDM: type = SOCK_RDM; break;
51         case SOCK_SOL_SEQPACKET: type = SOCK_SEQPACKET; break;
52         default: return -EINVAL;
53         }
54         return type;
55 }
56
57 static int solaris_to_linux_sockopt(int optname) 
58 {
59         switch (optname) {
60         case SOL_SO_SNDLOWAT: optname = SO_SNDLOWAT; break;
61         case SOL_SO_RCVLOWAT: optname = SO_RCVLOWAT; break;
62         case SOL_SO_SNDTIMEO: optname = SO_SNDTIMEO; break;
63         case SOL_SO_RCVTIMEO: optname = SO_RCVTIMEO; break;
64         case SOL_SO_STATE: optname = SO_STATE; break;
65         };
66         
67         return optname;
68 }
69         
70 asmlinkage int solaris_socket(int family, int type, int protocol)
71 {
72         int (*sys_socket)(int, int, int) =
73                 (int (*)(int, int, int))SYS(socket);
74
75         type = socket_check (family, type);
76         if (type < 0) return type;
77         return sys_socket(family, type, protocol);
78 }
79
80 asmlinkage int solaris_socketpair(int *usockvec)
81 {
82         int (*sys_socketpair)(int, int, int, int *) =
83                 (int (*)(int, int, int, int *))SYS(socketpair);
84
85         /* solaris socketpair really only takes one arg at the syscall
86          * level, int * usockvec. The libs apparently take care of 
87          * making sure that family==AF_UNIX and type==SOCK_STREAM. The 
88          * pointer we really want ends up residing in the first (and
89          * supposedly only) argument.
90          */
91
92         return sys_socketpair(AF_UNIX, SOCK_STREAM, 0, (int *)usockvec);
93 }
94
95 asmlinkage int solaris_bind(int fd, struct sockaddr *addr, int addrlen)
96 {
97         int (*sys_bind)(int, struct sockaddr *, int) =
98                 (int (*)(int, struct sockaddr *, int))SUNOS(104);
99
100         return sys_bind(fd, addr, addrlen);
101 }
102
103 asmlinkage int solaris_setsockopt(int fd, int level, int optname, u32 optval, int optlen)
104 {
105         int (*sunos_setsockopt)(int, int, int, u32, int) =
106                 (int (*)(int, int, int, u32, int))SUNOS(105);
107
108         optname = solaris_to_linux_sockopt(optname);
109         if (optname < 0)
110                 return optname;
111         if (optname == SO_STATE)
112                 return 0;
113
114         return sunos_setsockopt(fd, level, optname, optval, optlen);
115 }
116
117 asmlinkage int solaris_getsockopt(int fd, int level, int optname, u32 optval, u32 optlen)
118 {
119         int (*sunos_getsockopt)(int, int, int, u32, u32) =
120                 (int (*)(int, int, int, u32, u32))SUNOS(118);
121
122         optname = solaris_to_linux_sockopt(optname);
123         if (optname < 0)
124                 return optname;
125
126         if (optname == SO_STATE)
127                 optname = SOL_SO_STATE;
128
129         return sunos_getsockopt(fd, level, optname, optval, optlen);
130 }
131
132 asmlinkage int solaris_connect(int fd, struct sockaddr *addr, int addrlen)
133 {
134         int (*sys_connect)(int, struct sockaddr *, int) =
135                 (int (*)(int, struct sockaddr *, int))SYS(connect);
136
137         return sys_connect(fd, addr, addrlen);
138 }
139
140 asmlinkage int solaris_accept(int fd, struct sockaddr *addr, int *addrlen)
141 {
142         int (*sys_accept)(int, struct sockaddr *, int *) =
143                 (int (*)(int, struct sockaddr *, int *))SYS(accept);
144
145         return sys_accept(fd, addr, addrlen);
146 }
147
148 asmlinkage int solaris_listen(int fd, int backlog)
149 {
150         int (*sys_listen)(int, int) =
151                 (int (*)(int, int))SUNOS(106);
152
153         return sys_listen(fd, backlog);
154 }
155
156 asmlinkage int solaris_shutdown(int fd, int how)
157 {
158         int (*sys_shutdown)(int, int) =
159                 (int (*)(int, int))SYS(shutdown);
160
161         return sys_shutdown(fd, how);
162 }
163
164 #define MSG_SOL_OOB             0x1
165 #define MSG_SOL_PEEK            0x2
166 #define MSG_SOL_DONTROUTE       0x4
167 #define MSG_SOL_EOR             0x8
168 #define MSG_SOL_CTRUNC          0x10
169 #define MSG_SOL_TRUNC           0x20
170 #define MSG_SOL_WAITALL         0x40
171 #define MSG_SOL_DONTWAIT        0x80
172
173 static int solaris_to_linux_msgflags(int flags)
174 {
175         int fl = flags & (MSG_OOB|MSG_PEEK|MSG_DONTROUTE);
176         
177         if (flags & MSG_SOL_EOR) fl |= MSG_EOR;
178         if (flags & MSG_SOL_CTRUNC) fl |= MSG_CTRUNC;
179         if (flags & MSG_SOL_TRUNC) fl |= MSG_TRUNC;
180         if (flags & MSG_SOL_WAITALL) fl |= MSG_WAITALL;
181         if (flags & MSG_SOL_DONTWAIT) fl |= MSG_DONTWAIT;
182         return fl;
183 }
184
185 static int linux_to_solaris_msgflags(int flags)
186 {
187         int fl = flags & (MSG_OOB|MSG_PEEK|MSG_DONTROUTE);
188         
189         if (flags & MSG_EOR) fl |= MSG_SOL_EOR;
190         if (flags & MSG_CTRUNC) fl |= MSG_SOL_CTRUNC;
191         if (flags & MSG_TRUNC) fl |= MSG_SOL_TRUNC;
192         if (flags & MSG_WAITALL) fl |= MSG_SOL_WAITALL;
193         if (flags & MSG_DONTWAIT) fl |= MSG_SOL_DONTWAIT;
194         return fl;
195 }
196
197 asmlinkage int solaris_recvfrom(int s, char *buf, int len, int flags, u32 from, u32 fromlen)
198 {
199         int (*sys_recvfrom)(int, void *, size_t, unsigned, struct sockaddr *, int *) =
200                 (int (*)(int, void *, size_t, unsigned, struct sockaddr *, int *))SYS(recvfrom);
201         
202         return sys_recvfrom(s, buf, len, solaris_to_linux_msgflags(flags), (struct sockaddr *)A(from), (int *)A(fromlen));
203 }
204
205 asmlinkage int solaris_recv(int s, char *buf, int len, int flags)
206 {
207         int (*sys_recvfrom)(int, void *, size_t, unsigned, struct sockaddr *, int *) =
208                 (int (*)(int, void *, size_t, unsigned, struct sockaddr *, int *))SYS(recvfrom);
209         
210         return sys_recvfrom(s, buf, len, solaris_to_linux_msgflags(flags), NULL, NULL);
211 }
212
213 asmlinkage int solaris_sendto(int s, char *buf, int len, int flags, u32 to, u32 tolen)
214 {
215         int (*sys_sendto)(int, void *, size_t, unsigned, struct sockaddr *, int *) =
216                 (int (*)(int, void *, size_t, unsigned, struct sockaddr *, int *))SYS(sendto);
217         
218         return sys_sendto(s, buf, len, solaris_to_linux_msgflags(flags), (struct sockaddr *)A(to), (int *)A(tolen));
219 }
220
221 asmlinkage int solaris_send(int s, char *buf, int len, int flags)
222 {
223         int (*sys_sendto)(int, void *, size_t, unsigned, struct sockaddr *, int *) =
224                 (int (*)(int, void *, size_t, unsigned, struct sockaddr *, int *))SYS(sendto);
225         
226         return sys_sendto(s, buf, len, solaris_to_linux_msgflags(flags), NULL, NULL);
227 }
228
229 asmlinkage int solaris_getpeername(int fd, struct sockaddr *addr, int *addrlen)
230 {
231         int (*sys_getpeername)(int, struct sockaddr *, int *) =
232                 (int (*)(int, struct sockaddr *, int *))SYS(getpeername);
233
234         return sys_getpeername(fd, addr, addrlen);
235 }
236
237 asmlinkage int solaris_getsockname(int fd, struct sockaddr *addr, int *addrlen)
238 {
239         int (*sys_getsockname)(int, struct sockaddr *, int *) =
240                 (int (*)(int, struct sockaddr *, int *))SYS(getsockname);
241
242         return sys_getsockname(fd, addr, addrlen);
243 }
244
245 /* XXX This really belongs in some header file... -DaveM */
246 #define MAX_SOCK_ADDR   128             /* 108 for Unix domain - 
247                                            16 for IP, 16 for IPX,
248                                            24 for IPv6,
249                                            about 80 for AX.25 */
250
251 extern __inline__ struct socket *sockfd_lookup(int fd, int *err)
252 {
253         struct file *file;
254         struct inode *inode;
255
256         if (!(file = fget(fd))) {
257                 *err = -EBADF;
258                 return NULL;
259         }
260
261         inode = file->f_dentry->d_inode;
262         if (!inode->i_sock) {
263                 *err = -ENOTSOCK;
264                 fput(file);
265                 return NULL;
266         }
267
268         return SOCKET_I(inode);
269 }
270
271 extern __inline__ void sockfd_put(struct socket *sock)
272 {
273         fput(sock->file);
274 }
275
276 struct sol_nmsghdr {
277         u32             msg_name;
278         int             msg_namelen;
279         u32             msg_iov;
280         u32             msg_iovlen;
281         u32             msg_control;
282         u32             msg_controllen;
283         u32             msg_flags;
284 };
285
286 struct sol_cmsghdr {
287         u32             cmsg_len;
288         int             cmsg_level;
289         int             cmsg_type;
290         unsigned char   cmsg_data[0];
291 };
292
293 struct iovec32 {
294         u32             iov_base;
295         u32 iov_len;
296 };
297
298 static inline int iov_from_user32_to_kern(struct iovec *kiov,
299                                           struct iovec32 *uiov32,
300                                           int niov)
301 {
302         int tot_len = 0;
303
304         while(niov > 0) {
305                 u32 len, buf;
306
307                 if(get_user(len, &uiov32->iov_len) ||
308                    get_user(buf, &uiov32->iov_base)) {
309                         tot_len = -EFAULT;
310                         break;
311                 }
312                 tot_len += len;
313                 kiov->iov_base = (void *)A(buf);
314                 kiov->iov_len = (__kernel_size_t) len;
315                 uiov32++;
316                 kiov++;
317                 niov--;
318         }
319         return tot_len;
320 }
321
322 static inline int msghdr_from_user32_to_kern(struct msghdr *kmsg,
323                                              struct sol_nmsghdr *umsg)
324 {
325         u32 tmp1, tmp2, tmp3;
326         int err;
327
328         err = get_user(tmp1, &umsg->msg_name);
329         err |= __get_user(tmp2, &umsg->msg_iov);
330         err |= __get_user(tmp3, &umsg->msg_control);
331         if (err)
332                 return -EFAULT;
333
334         kmsg->msg_name = (void *)A(tmp1);
335         kmsg->msg_iov = (struct iovec *)A(tmp2);
336         kmsg->msg_control = (void *)A(tmp3);
337
338         err = get_user(kmsg->msg_namelen, &umsg->msg_namelen);
339         err |= get_user(kmsg->msg_controllen, &umsg->msg_controllen);
340         err |= get_user(kmsg->msg_flags, &umsg->msg_flags);
341         
342         kmsg->msg_flags = solaris_to_linux_msgflags(kmsg->msg_flags);
343         
344         return err;
345 }
346
347 /* I've named the args so it is easy to tell whose space the pointers are in. */
348 static int verify_iovec32(struct msghdr *kern_msg, struct iovec *kern_iov,
349                           char *kern_address, int mode)
350 {
351         int tot_len;
352
353         if(kern_msg->msg_namelen) {
354                 if(mode==VERIFY_READ) {
355                         int err = move_addr_to_kernel(kern_msg->msg_name,
356                                                       kern_msg->msg_namelen,
357                                                       kern_address);
358                         if(err < 0)
359                                 return err;
360                 }
361                 kern_msg->msg_name = kern_address;
362         } else
363                 kern_msg->msg_name = NULL;
364
365         if(kern_msg->msg_iovlen > UIO_FASTIOV) {
366                 kern_iov = kmalloc(kern_msg->msg_iovlen * sizeof(struct iovec),
367                                    GFP_KERNEL);
368                 if(!kern_iov)
369                         return -ENOMEM;
370         }
371
372         tot_len = iov_from_user32_to_kern(kern_iov,
373                                           (struct iovec32 *)kern_msg->msg_iov,
374                                           kern_msg->msg_iovlen);
375         if(tot_len >= 0)
376                 kern_msg->msg_iov = kern_iov;
377         else if(kern_msg->msg_iovlen > UIO_FASTIOV)
378                 kfree(kern_iov);
379
380         return tot_len;
381 }
382
383 asmlinkage int solaris_sendmsg(int fd, struct sol_nmsghdr *user_msg, unsigned user_flags)
384 {
385         struct socket *sock;
386         char address[MAX_SOCK_ADDR];
387         struct iovec iov[UIO_FASTIOV];
388         unsigned char ctl[sizeof(struct cmsghdr) + 20];
389         unsigned char *ctl_buf = ctl;
390         struct msghdr kern_msg;
391         int err, total_len;
392
393         if(msghdr_from_user32_to_kern(&kern_msg, user_msg))
394                 return -EFAULT;
395         if(kern_msg.msg_iovlen > UIO_MAXIOV)
396                 return -EINVAL;
397         err = verify_iovec32(&kern_msg, iov, address, VERIFY_READ);
398         if (err < 0)
399                 goto out;
400         total_len = err;
401
402         if(kern_msg.msg_controllen) {
403                 struct sol_cmsghdr *ucmsg = (struct sol_cmsghdr *)kern_msg.msg_control;
404                 unsigned long *kcmsg;
405                 __kernel_size_t32 cmlen;
406
407                 if(kern_msg.msg_controllen > sizeof(ctl) &&
408                    kern_msg.msg_controllen <= 256) {
409                         err = -ENOBUFS;
410                         ctl_buf = kmalloc(kern_msg.msg_controllen, GFP_KERNEL);
411                         if(!ctl_buf)
412                                 goto out_freeiov;
413                 }
414                 __get_user(cmlen, &ucmsg->cmsg_len);
415                 kcmsg = (unsigned long *) ctl_buf;
416                 *kcmsg++ = (unsigned long)cmlen;
417                 err = -EFAULT;
418                 if(copy_from_user(kcmsg, &ucmsg->cmsg_level,
419                                   kern_msg.msg_controllen - sizeof(__kernel_size_t32)))
420                         goto out_freectl;
421                 kern_msg.msg_control = ctl_buf;
422         }
423         kern_msg.msg_flags = solaris_to_linux_msgflags(user_flags);
424
425         lock_kernel();
426         sock = sockfd_lookup(fd, &err);
427         if (sock != NULL) {
428                 if (sock->file->f_flags & O_NONBLOCK)
429                         kern_msg.msg_flags |= MSG_DONTWAIT;
430                 err = sock_sendmsg(sock, &kern_msg, total_len);
431                 sockfd_put(sock);
432         }
433         unlock_kernel();
434
435 out_freectl:
436         /* N.B. Use kfree here, as kern_msg.msg_controllen might change? */
437         if(ctl_buf != ctl)
438                 kfree(ctl_buf);
439 out_freeiov:
440         if(kern_msg.msg_iov != iov)
441                 kfree(kern_msg.msg_iov);
442 out:
443         return err;
444 }
445
446 asmlinkage int solaris_recvmsg(int fd, struct sol_nmsghdr *user_msg, unsigned int user_flags)
447 {
448         struct iovec iovstack[UIO_FASTIOV];
449         struct msghdr kern_msg;
450         char addr[MAX_SOCK_ADDR];
451         struct socket *sock;
452         struct iovec *iov = iovstack;
453         struct sockaddr *uaddr;
454         int *uaddr_len;
455         unsigned long cmsg_ptr;
456         int err, total_len, len = 0;
457
458         if(msghdr_from_user32_to_kern(&kern_msg, user_msg))
459                 return -EFAULT;
460         if(kern_msg.msg_iovlen > UIO_MAXIOV)
461                 return -EINVAL;
462
463         uaddr = kern_msg.msg_name;
464         uaddr_len = &user_msg->msg_namelen;
465         err = verify_iovec32(&kern_msg, iov, addr, VERIFY_WRITE);
466         if (err < 0)
467                 goto out;
468         total_len = err;
469
470         cmsg_ptr = (unsigned long) kern_msg.msg_control;
471         kern_msg.msg_flags = 0;
472
473         lock_kernel();
474         sock = sockfd_lookup(fd, &err);
475         if (sock != NULL) {
476                 if (sock->file->f_flags & O_NONBLOCK)
477                         user_flags |= MSG_DONTWAIT;
478                 err = sock_recvmsg(sock, &kern_msg, total_len, user_flags);
479                 if(err >= 0)
480                         len = err;
481                 sockfd_put(sock);
482         }
483         unlock_kernel();
484
485         if(uaddr != NULL && err >= 0)
486                 err = move_addr_to_user(addr, kern_msg.msg_namelen, uaddr, uaddr_len);
487         if(err >= 0) {
488                 err = __put_user(linux_to_solaris_msgflags(kern_msg.msg_flags), &user_msg->msg_flags);
489                 if(!err) {
490                         /* XXX Convert cmsg back into userspace 32-bit format... */
491                         err = __put_user((unsigned long)kern_msg.msg_control - cmsg_ptr,
492                                          &user_msg->msg_controllen);
493                 }
494         }
495
496         if(kern_msg.msg_iov != iov)
497                 kfree(kern_msg.msg_iov);
498 out:
499         if(err < 0)
500                 return err;
501         return len;
502 }