开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
socket.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：13k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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.  */
  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>
  17. #include <asm/uaccess.h>
  18. #include <asm/string.h>
  19. #include <asm/oplib.h>
  20. #include <asm/idprom.h>
  22. #include "conv.h"
  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
  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
  36. #define SOL_SS_NDELAY 0x040
  37. #define SOL_SS_NONBLOCK 0x080
  38. #define SOL_SS_ASYNC 0x100
  40. #define SO_STATE 0x000e
  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. }
  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. };
  67. return optname;
  68. }
  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);
  75. type = socket_check (family, type);
  76. if (type < 0) return type;
  77. return sys_socket(family, type, protocol);
  78. }
  80. asmlinkage int solaris_socketpair(int *usockvec)
  81. {
  82. int (*sys_socketpair)(int, int, int, int *) =
  83. (int (*)(int, int, int, int *))SYS(socketpair);
  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.  */
  92. return sys_socketpair(AF_UNIX, SOCK_STREAM, 0, (int *)usockvec);
  93. }
  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);
  100. return sys_bind(fd, addr, addrlen);
  101. }
  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);
  108. optname = solaris_to_linux_sockopt(optname);
  109. if (optname < 0)
  110. return optname;
  111. if (optname == SO_STATE)
  112. return 0;
  114. return sunos_setsockopt(fd, level, optname, optval, optlen);
  115. }
  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);
  122. optname = solaris_to_linux_sockopt(optname);
  123. if (optname < 0)
  124. return optname;
  126. if (optname == SO_STATE)
  127. optname = SOL_SO_STATE;
  129. return sunos_getsockopt(fd, level, optname, optval, optlen);
  130. }
  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);
  137. return sys_connect(fd, addr, addrlen);
  138. }
  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);
  145. return sys_accept(fd, addr, addrlen);
  146. }
  148. asmlinkage int solaris_listen(int fd, int backlog)
  149. {
  150. int (*sys_listen)(int, int) =
  151. (int (*)(int, int))SUNOS(106);
  153. return sys_listen(fd, backlog);
  154. }
  156. asmlinkage int solaris_shutdown(int fd, int how)
  157. {
  158. int (*sys_shutdown)(int, int) =
  159. (int (*)(int, int))SYS(shutdown);
  161. return sys_shutdown(fd, how);
  162. }
  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
  173. static int solaris_to_linux_msgflags(int flags)
  174. {
  175. int fl = flags & (MSG_OOB|MSG_PEEK|MSG_DONTROUTE);
  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. }
  185. static int linux_to_solaris_msgflags(int flags)
  186. {
  187. int fl = flags & (MSG_OOB|MSG_PEEK|MSG_DONTROUTE);
  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. }
  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);
  202. return sys_recvfrom(s, buf, len, solaris_to_linux_msgflags(flags), (struct sockaddr *)A(from), (int *)A(fromlen));
  203. }
  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);
  210. return sys_recvfrom(s, buf, len, solaris_to_linux_msgflags(flags), NULL, NULL);
  211. }
  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);
  218. return sys_sendto(s, buf, len, solaris_to_linux_msgflags(flags), (struct sockaddr *)A(to), (int *)A(tolen));
  219. }
  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);
  226. return sys_sendto(s, buf, len, solaris_to_linux_msgflags(flags), NULL, NULL);
  227. }
  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);
  234. return sys_getpeername(fd, addr, addrlen);
  235. }
  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);
  242. return sys_getsockname(fd, addr, addrlen);
  243. }
  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 */
  251. /* XXX These as well... */
  252. extern __inline__ struct socket *socki_lookup(struct inode *inode)
  253. {
  254. return &inode->u.socket_i;
  255. }
  257. extern __inline__ struct socket *sockfd_lookup(int fd, int *err)
  258. {
  259. struct file *file;
  260. struct inode *inode;
  262. if (!(file = fget(fd))) {
  263. *err = -EBADF;
  264. return NULL;
  265. }
  267. inode = file->f_dentry->d_inode;
  268. if (!inode->i_sock || !socki_lookup(inode)) {
  269. *err = -ENOTSOCK;
  270. fput(file);
  271. return NULL;
  272. }
  274. return socki_lookup(inode);
  275. }
  277. extern __inline__ void sockfd_put(struct socket *sock)
  278. {
  279. fput(sock->file);
  280. }
  282. struct sol_nmsghdr {
  283. u32 msg_name;
  284. int msg_namelen;
  285. u32 msg_iov;
  286. u32 msg_iovlen;
  287. u32 msg_control;
  288. u32 msg_controllen;
  289. u32 msg_flags;
  290. };
  292. struct sol_cmsghdr {
  293. u32 cmsg_len;
  294. int cmsg_level;
  295. int cmsg_type;
  296. unsigned char cmsg_data[0];
  297. };
  299. struct iovec32 {
  300. u32 iov_base;
  301. u32 iov_len;
  302. };
  304. static inline int iov_from_user32_to_kern(struct iovec *kiov,
  305.   struct iovec32 *uiov32,
  306.   int niov)
  307. {
  308. int tot_len = 0;
  310. while(niov > 0) {
  311. u32 len, buf;
  313. if(get_user(len, &uiov32->iov_len) ||
  314.    get_user(buf, &uiov32->iov_base)) {
  315. tot_len = -EFAULT;
  316. break;
  317. }
  318. tot_len += len;
  319. kiov->iov_base = (void *)A(buf);
  320. kiov->iov_len = (__kernel_size_t) len;
  321. uiov32++;
  322. kiov++;
  323. niov--;
  324. }
  325. return tot_len;
  326. }
  328. static inline int msghdr_from_user32_to_kern(struct msghdr *kmsg,
  329.      struct sol_nmsghdr *umsg)
  330. {
  331. u32 tmp1, tmp2, tmp3;
  332. int err;
  334. err = get_user(tmp1, &umsg->msg_name);
  335. err |= __get_user(tmp2, &umsg->msg_iov);
  336. err |= __get_user(tmp3, &umsg->msg_control);
  337. if (err)
  338. return -EFAULT;
  340. kmsg->msg_name = (void *)A(tmp1);
  341. kmsg->msg_iov = (struct iovec *)A(tmp2);
  342. kmsg->msg_control = (void *)A(tmp3);
  344. err = get_user(kmsg->msg_namelen, &umsg->msg_namelen);
  345. err |= get_user(kmsg->msg_controllen, &umsg->msg_controllen);
  346. err |= get_user(kmsg->msg_flags, &umsg->msg_flags);
  348. kmsg->msg_flags = solaris_to_linux_msgflags(kmsg->msg_flags);
  350. return err;
  351. }
  353. /* I've named the args so it is easy to tell whose space the pointers are in. */
  354. static int verify_iovec32(struct msghdr *kern_msg, struct iovec *kern_iov,
  355.   char *kern_address, int mode)
  356. {
  357. int tot_len;
  359. if(kern_msg->msg_namelen) {
  360. if(mode==VERIFY_READ) {
  361. int err = move_addr_to_kernel(kern_msg->msg_name,
  362.       kern_msg->msg_namelen,
  363.       kern_address);
  364. if(err < 0)
  365. return err;
  366. }
  367. kern_msg->msg_name = kern_address;
  368. } else
  369. kern_msg->msg_name = NULL;
  371. if(kern_msg->msg_iovlen > UIO_FASTIOV) {
  372. kern_iov = kmalloc(kern_msg->msg_iovlen * sizeof(struct iovec),
  373.    GFP_KERNEL);
  374. if(!kern_iov)
  375. return -ENOMEM;
  376. }
  378. tot_len = iov_from_user32_to_kern(kern_iov,
  379.   (struct iovec32 *)kern_msg->msg_iov,
  380.   kern_msg->msg_iovlen);
  381. if(tot_len >= 0)
  382. kern_msg->msg_iov = kern_iov;
  383. else if(kern_msg->msg_iovlen > UIO_FASTIOV)
  384. kfree(kern_iov);
  386. return tot_len;
  387. }
  389. asmlinkage int solaris_sendmsg(int fd, struct sol_nmsghdr *user_msg, unsigned user_flags)
  390. {
  391. struct socket *sock;
  392. char address[MAX_SOCK_ADDR];
  393. struct iovec iov[UIO_FASTIOV];
  394. unsigned char ctl[sizeof(struct cmsghdr) + 20];
  395. unsigned char *ctl_buf = ctl;
  396. struct msghdr kern_msg;
  397. int err, total_len;
  399. if(msghdr_from_user32_to_kern(&kern_msg, user_msg))
  400. return -EFAULT;
  401. if(kern_msg.msg_iovlen > UIO_MAXIOV)
  402. return -EINVAL;
  403. err = verify_iovec32(&kern_msg, iov, address, VERIFY_READ);
  404. if (err < 0)
  405. goto out;
  406. total_len = err;
  408. if(kern_msg.msg_controllen) {
  409. struct sol_cmsghdr *ucmsg = (struct sol_cmsghdr *)kern_msg.msg_control;
  410. unsigned long *kcmsg;
  411. __kernel_size_t32 cmlen;
  413. if(kern_msg.msg_controllen > sizeof(ctl) &&
  414.    kern_msg.msg_controllen <= 256) {
  415. err = -ENOBUFS;
  416. ctl_buf = kmalloc(kern_msg.msg_controllen, GFP_KERNEL);
  417. if(!ctl_buf)
  418. goto out_freeiov;
  419. }
  420. __get_user(cmlen, &ucmsg->cmsg_len);
  421. kcmsg = (unsigned long *) ctl_buf;
  422. *kcmsg++ = (unsigned long)cmlen;
  423. err = -EFAULT;
  424. if(copy_from_user(kcmsg, &ucmsg->cmsg_level,
  425.   kern_msg.msg_controllen - sizeof(__kernel_size_t32)))
  426. goto out_freectl;
  427. kern_msg.msg_control = ctl_buf;
  428. }
  429. kern_msg.msg_flags = solaris_to_linux_msgflags(user_flags);
  431. lock_kernel();
  432. sock = sockfd_lookup(fd, &err);
  433. if (sock != NULL) {
  434. if (sock->file->f_flags & O_NONBLOCK)
  435. kern_msg.msg_flags |= MSG_DONTWAIT;
  436. err = sock_sendmsg(sock, &kern_msg, total_len);
  437. sockfd_put(sock);
  438. }
  439. unlock_kernel();
  441. out_freectl:
  442. /* N.B. Use kfree here, as kern_msg.msg_controllen might change? */
  443. if(ctl_buf != ctl)
  444. kfree(ctl_buf);
  445. out_freeiov:
  446. if(kern_msg.msg_iov != iov)
  447. kfree(kern_msg.msg_iov);
  448. out:
  449. return err;
  450. }
  452. asmlinkage int solaris_recvmsg(int fd, struct sol_nmsghdr *user_msg, unsigned int user_flags)
  453. {
  454. struct iovec iovstack[UIO_FASTIOV];
  455. struct msghdr kern_msg;
  456. char addr[MAX_SOCK_ADDR];
  457. struct socket *sock;
  458. struct iovec *iov = iovstack;
  459. struct sockaddr *uaddr;
  460. int *uaddr_len;
  461. unsigned long cmsg_ptr;
  462. int err, total_len, len = 0;
  464. if(msghdr_from_user32_to_kern(&kern_msg, user_msg))
  465. return -EFAULT;
  466. if(kern_msg.msg_iovlen > UIO_MAXIOV)
  467. return -EINVAL;
  469. uaddr = kern_msg.msg_name;
  470. uaddr_len = &user_msg->msg_namelen;
  471. err = verify_iovec32(&kern_msg, iov, addr, VERIFY_WRITE);
  472. if (err < 0)
  473. goto out;
  474. total_len = err;
  476. cmsg_ptr = (unsigned long) kern_msg.msg_control;
  477. kern_msg.msg_flags = 0;
  479. lock_kernel();
  480. sock = sockfd_lookup(fd, &err);
  481. if (sock != NULL) {
  482. if (sock->file->f_flags & O_NONBLOCK)
  483. user_flags |= MSG_DONTWAIT;
  484. err = sock_recvmsg(sock, &kern_msg, total_len, user_flags);
  485. if(err >= 0)
  486. len = err;
  487. sockfd_put(sock);
  488. }
  489. unlock_kernel();
  491. if(uaddr != NULL && err >= 0)
  492. err = move_addr_to_user(addr, kern_msg.msg_namelen, uaddr, uaddr_len);
  493. if(err >= 0) {
  494. err = __put_user(linux_to_solaris_msgflags(kern_msg.msg_flags), &user_msg->msg_flags);
  495. if(!err) {
  496. /* XXX Convert cmsg back into userspace 32-bit format... */
  497. err = __put_user((unsigned long)kern_msg.msg_control - cmsg_ptr,
  498.  &user_msg->msg_controllen);
  499. }
  500. }
  502. if(kern_msg.msg_iov != iov)
  503. kfree(kern_msg.msg_iov);
  504. out:
  505. if(err < 0)
  506. return err;
  507. return len;
  508. }