compat.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886
  1. /*
  2. * 32bit Socket syscall emulation. Based on arch/sparc64/kernel/sys_sparc32.c.
  3. *
  4. * Copyright (C) 2000 VA Linux Co
  5. * Copyright (C) 2000 Don Dugger <n0ano@valinux.com>
  6. * Copyright (C) 1999 Arun Sharma <arun.sharma@intel.com>
  7. * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  8. * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
  9. * Copyright (C) 2000 Hewlett-Packard Co.
  10. * Copyright (C) 2000 David Mosberger-Tang <davidm@hpl.hp.com>
  11. * Copyright (C) 2000,2001 Andi Kleen, SuSE Labs
  12. */
  13. #include <linux/kernel.h>
  14. #include <linux/gfp.h>
  15. #include <linux/fs.h>
  16. #include <linux/types.h>
  17. #include <linux/file.h>
  18. #include <linux/icmpv6.h>
  19. #include <linux/socket.h>
  20. #include <linux/syscalls.h>
  21. #include <linux/filter.h>
  22. #include <linux/compat.h>
  23. #include <linux/security.h>
  24. #include <linux/export.h>
  25. #include <net/scm.h>
  26. #include <net/sock.h>
  27. #include <net/ip.h>
  28. #include <net/ipv6.h>
  29. #include <asm/uaccess.h>
  30. #include <net/compat.h>
  31. static inline int iov_from_user_compat_to_kern(struct iovec *kiov,
  32. struct compat_iovec __user *uiov32,
  33. int niov)
  34. {
  35. int tot_len = 0;
  36. while (niov > 0) {
  37. compat_uptr_t buf;
  38. compat_size_t len;
  39. if (get_user(len, &uiov32->iov_len) ||
  40. get_user(buf, &uiov32->iov_base))
  41. return -EFAULT;
  42. if (len > INT_MAX - tot_len)
  43. len = INT_MAX - tot_len;
  44. tot_len += len;
  45. kiov->iov_base = compat_ptr(buf);
  46. kiov->iov_len = (__kernel_size_t) len;
  47. uiov32++;
  48. kiov++;
  49. niov--;
  50. }
  51. return tot_len;
  52. }
  53. int get_compat_msghdr(struct msghdr *kmsg, struct compat_msghdr __user *umsg)
  54. {
  55. compat_uptr_t tmp1, tmp2, tmp3;
  56. if (!access_ok(VERIFY_READ, umsg, sizeof(*umsg)) ||
  57. __get_user(tmp1, &umsg->msg_name) ||
  58. __get_user(kmsg->msg_namelen, &umsg->msg_namelen) ||
  59. __get_user(tmp2, &umsg->msg_iov) ||
  60. __get_user(kmsg->msg_iovlen, &umsg->msg_iovlen) ||
  61. __get_user(tmp3, &umsg->msg_control) ||
  62. __get_user(kmsg->msg_controllen, &umsg->msg_controllen) ||
  63. __get_user(kmsg->msg_flags, &umsg->msg_flags))
  64. return -EFAULT;
  65. if (kmsg->msg_namelen > sizeof(struct sockaddr_storage))
  66. return -EINVAL;
  67. kmsg->msg_name = compat_ptr(tmp1);
  68. kmsg->msg_iov = compat_ptr(tmp2);
  69. kmsg->msg_control = compat_ptr(tmp3);
  70. return 0;
  71. }
  72. /* I've named the args so it is easy to tell whose space the pointers are in. */
  73. int verify_compat_iovec(struct msghdr *kern_msg, struct iovec *kern_iov,
  74. struct sockaddr_storage *kern_address, int mode)
  75. {
  76. int tot_len;
  77. if (kern_msg->msg_namelen) {
  78. if (mode == VERIFY_READ) {
  79. int err = move_addr_to_kernel(kern_msg->msg_name,
  80. kern_msg->msg_namelen,
  81. kern_address);
  82. if (err < 0)
  83. return err;
  84. }
  85. if (kern_msg->msg_name)
  86. kern_msg->msg_name = kern_address;
  87. } else
  88. kern_msg->msg_name = NULL;
  89. tot_len = iov_from_user_compat_to_kern(kern_iov,
  90. (struct compat_iovec __user *)kern_msg->msg_iov,
  91. kern_msg->msg_iovlen);
  92. if (tot_len >= 0)
  93. kern_msg->msg_iov = kern_iov;
  94. return tot_len;
  95. }
  96. /* Bleech... */
  97. #define CMSG_COMPAT_ALIGN(len) ALIGN((len), sizeof(s32))
  98. #define CMSG_COMPAT_DATA(cmsg) \
  99. ((void __user *)((char __user *)(cmsg) + CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr))))
  100. #define CMSG_COMPAT_SPACE(len) \
  101. (CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr)) + CMSG_COMPAT_ALIGN(len))
  102. #define CMSG_COMPAT_LEN(len) \
  103. (CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr)) + (len))
  104. #define CMSG_COMPAT_FIRSTHDR(msg) \
  105. (((msg)->msg_controllen) >= sizeof(struct compat_cmsghdr) ? \
  106. (struct compat_cmsghdr __user *)((msg)->msg_control) : \
  107. (struct compat_cmsghdr __user *)NULL)
  108. #define CMSG_COMPAT_OK(ucmlen, ucmsg, mhdr) \
  109. ((ucmlen) >= sizeof(struct compat_cmsghdr) && \
  110. (ucmlen) <= (unsigned long) \
  111. ((mhdr)->msg_controllen - \
  112. ((char *)(ucmsg) - (char *)(mhdr)->msg_control)))
  113. static inline struct compat_cmsghdr __user *cmsg_compat_nxthdr(struct msghdr *msg,
  114. struct compat_cmsghdr __user *cmsg, int cmsg_len)
  115. {
  116. char __user *ptr = (char __user *)cmsg + CMSG_COMPAT_ALIGN(cmsg_len);
  117. if ((unsigned long)(ptr + 1 - (char __user *)msg->msg_control) >
  118. msg->msg_controllen)
  119. return NULL;
  120. return (struct compat_cmsghdr __user *)ptr;
  121. }
  122. /* There is a lot of hair here because the alignment rules (and
  123. * thus placement) of cmsg headers and length are different for
  124. * 32-bit apps. -DaveM
  125. */
  126. int cmsghdr_from_user_compat_to_kern(struct msghdr *kmsg, struct sock *sk,
  127. unsigned char *stackbuf, int stackbuf_size)
  128. {
  129. struct compat_cmsghdr __user *ucmsg;
  130. struct cmsghdr *kcmsg, *kcmsg_base;
  131. compat_size_t ucmlen;
  132. __kernel_size_t kcmlen, tmp;
  133. int err = -EFAULT;
  134. kcmlen = 0;
  135. kcmsg_base = kcmsg = (struct cmsghdr *)stackbuf;
  136. ucmsg = CMSG_COMPAT_FIRSTHDR(kmsg);
  137. while (ucmsg != NULL) {
  138. if (get_user(ucmlen, &ucmsg->cmsg_len))
  139. return -EFAULT;
  140. /* Catch bogons. */
  141. if (!CMSG_COMPAT_OK(ucmlen, ucmsg, kmsg))
  142. return -EINVAL;
  143. tmp = ((ucmlen - CMSG_COMPAT_ALIGN(sizeof(*ucmsg))) +
  144. CMSG_ALIGN(sizeof(struct cmsghdr)));
  145. tmp = CMSG_ALIGN(tmp);
  146. kcmlen += tmp;
  147. ucmsg = cmsg_compat_nxthdr(kmsg, ucmsg, ucmlen);
  148. }
  149. if (kcmlen == 0)
  150. return -EINVAL;
  151. /* The kcmlen holds the 64-bit version of the control length.
  152. * It may not be modified as we do not stick it into the kmsg
  153. * until we have successfully copied over all of the data
  154. * from the user.
  155. */
  156. if (kcmlen > stackbuf_size)
  157. kcmsg_base = kcmsg = sock_kmalloc(sk, kcmlen, GFP_KERNEL);
  158. if (kcmsg == NULL)
  159. return -ENOBUFS;
  160. /* Now copy them over neatly. */
  161. memset(kcmsg, 0, kcmlen);
  162. ucmsg = CMSG_COMPAT_FIRSTHDR(kmsg);
  163. while (ucmsg != NULL) {
  164. if (__get_user(ucmlen, &ucmsg->cmsg_len))
  165. goto Efault;
  166. if (!CMSG_COMPAT_OK(ucmlen, ucmsg, kmsg))
  167. goto Einval;
  168. tmp = ((ucmlen - CMSG_COMPAT_ALIGN(sizeof(*ucmsg))) +
  169. CMSG_ALIGN(sizeof(struct cmsghdr)));
  170. if ((char *)kcmsg_base + kcmlen - (char *)kcmsg < CMSG_ALIGN(tmp))
  171. goto Einval;
  172. kcmsg->cmsg_len = tmp;
  173. tmp = CMSG_ALIGN(tmp);
  174. if (__get_user(kcmsg->cmsg_level, &ucmsg->cmsg_level) ||
  175. __get_user(kcmsg->cmsg_type, &ucmsg->cmsg_type) ||
  176. copy_from_user(CMSG_DATA(kcmsg),
  177. CMSG_COMPAT_DATA(ucmsg),
  178. (ucmlen - CMSG_COMPAT_ALIGN(sizeof(*ucmsg)))))
  179. goto Efault;
  180. /* Advance. */
  181. kcmsg = (struct cmsghdr *)((char *)kcmsg + tmp);
  182. ucmsg = cmsg_compat_nxthdr(kmsg, ucmsg, ucmlen);
  183. }
  184. /* Ok, looks like we made it. Hook it up and return success. */
  185. kmsg->msg_control = kcmsg_base;
  186. kmsg->msg_controllen = kcmlen;
  187. return 0;
  188. Einval:
  189. err = -EINVAL;
  190. Efault:
  191. if (kcmsg_base != (struct cmsghdr *)stackbuf)
  192. sock_kfree_s(sk, kcmsg_base, kcmlen);
  193. return err;
  194. }
  195. int put_cmsg_compat(struct msghdr *kmsg, int level, int type, int len, void *data)
  196. {
  197. struct compat_cmsghdr __user *cm = (struct compat_cmsghdr __user *) kmsg->msg_control;
  198. struct compat_cmsghdr cmhdr;
  199. struct compat_timeval ctv;
  200. struct compat_timespec cts[3];
  201. int cmlen;
  202. if (cm == NULL || kmsg->msg_controllen < sizeof(*cm)) {
  203. kmsg->msg_flags |= MSG_CTRUNC;
  204. return 0; /* XXX: return error? check spec. */
  205. }
  206. if (!COMPAT_USE_64BIT_TIME) {
  207. if (level == SOL_SOCKET && type == SCM_TIMESTAMP) {
  208. struct timeval *tv = (struct timeval *)data;
  209. ctv.tv_sec = tv->tv_sec;
  210. ctv.tv_usec = tv->tv_usec;
  211. data = &ctv;
  212. len = sizeof(ctv);
  213. }
  214. if (level == SOL_SOCKET &&
  215. (type == SCM_TIMESTAMPNS || type == SCM_TIMESTAMPING)) {
  216. int count = type == SCM_TIMESTAMPNS ? 1 : 3;
  217. int i;
  218. struct timespec *ts = (struct timespec *)data;
  219. for (i = 0; i < count; i++) {
  220. cts[i].tv_sec = ts[i].tv_sec;
  221. cts[i].tv_nsec = ts[i].tv_nsec;
  222. }
  223. data = &cts;
  224. len = sizeof(cts[0]) * count;
  225. }
  226. }
  227. cmlen = CMSG_COMPAT_LEN(len);
  228. if (kmsg->msg_controllen < cmlen) {
  229. kmsg->msg_flags |= MSG_CTRUNC;
  230. cmlen = kmsg->msg_controllen;
  231. }
  232. cmhdr.cmsg_level = level;
  233. cmhdr.cmsg_type = type;
  234. cmhdr.cmsg_len = cmlen;
  235. if (copy_to_user(cm, &cmhdr, sizeof cmhdr))
  236. return -EFAULT;
  237. if (copy_to_user(CMSG_COMPAT_DATA(cm), data, cmlen - sizeof(struct compat_cmsghdr)))
  238. return -EFAULT;
  239. cmlen = CMSG_COMPAT_SPACE(len);
  240. if (kmsg->msg_controllen < cmlen)
  241. cmlen = kmsg->msg_controllen;
  242. kmsg->msg_control += cmlen;
  243. kmsg->msg_controllen -= cmlen;
  244. return 0;
  245. }
  246. void scm_detach_fds_compat(struct msghdr *kmsg, struct scm_cookie *scm)
  247. {
  248. struct compat_cmsghdr __user *cm = (struct compat_cmsghdr __user *) kmsg->msg_control;
  249. int fdmax = (kmsg->msg_controllen - sizeof(struct compat_cmsghdr)) / sizeof(int);
  250. int fdnum = scm->fp->count;
  251. struct file **fp = scm->fp->fp;
  252. int __user *cmfptr;
  253. int err = 0, i;
  254. if (fdnum < fdmax)
  255. fdmax = fdnum;
  256. for (i = 0, cmfptr = (int __user *) CMSG_COMPAT_DATA(cm); i < fdmax; i++, cmfptr++) {
  257. int new_fd;
  258. err = security_file_receive(fp[i]);
  259. if (err)
  260. break;
  261. err = get_unused_fd_flags(MSG_CMSG_CLOEXEC & kmsg->msg_flags
  262. ? O_CLOEXEC : 0);
  263. if (err < 0)
  264. break;
  265. new_fd = err;
  266. err = put_user(new_fd, cmfptr);
  267. if (err) {
  268. put_unused_fd(new_fd);
  269. break;
  270. }
  271. /* Bump the usage count and install the file. */
  272. fd_install(new_fd, get_file(fp[i]));
  273. }
  274. if (i > 0) {
  275. int cmlen = CMSG_COMPAT_LEN(i * sizeof(int));
  276. err = put_user(SOL_SOCKET, &cm->cmsg_level);
  277. if (!err)
  278. err = put_user(SCM_RIGHTS, &cm->cmsg_type);
  279. if (!err)
  280. err = put_user(cmlen, &cm->cmsg_len);
  281. if (!err) {
  282. cmlen = CMSG_COMPAT_SPACE(i * sizeof(int));
  283. kmsg->msg_control += cmlen;
  284. kmsg->msg_controllen -= cmlen;
  285. }
  286. }
  287. if (i < fdnum)
  288. kmsg->msg_flags |= MSG_CTRUNC;
  289. /*
  290. * All of the files that fit in the message have had their
  291. * usage counts incremented, so we just free the list.
  292. */
  293. __scm_destroy(scm);
  294. }
  295. static int do_set_attach_filter(struct socket *sock, int level, int optname,
  296. char __user *optval, unsigned int optlen)
  297. {
  298. struct compat_sock_fprog __user *fprog32 = (struct compat_sock_fprog __user *)optval;
  299. struct sock_fprog __user *kfprog = compat_alloc_user_space(sizeof(struct sock_fprog));
  300. compat_uptr_t ptr;
  301. u16 len;
  302. if (!access_ok(VERIFY_READ, fprog32, sizeof(*fprog32)) ||
  303. !access_ok(VERIFY_WRITE, kfprog, sizeof(struct sock_fprog)) ||
  304. __get_user(len, &fprog32->len) ||
  305. __get_user(ptr, &fprog32->filter) ||
  306. __put_user(len, &kfprog->len) ||
  307. __put_user(compat_ptr(ptr), &kfprog->filter))
  308. return -EFAULT;
  309. return sock_setsockopt(sock, level, optname, (char __user *)kfprog,
  310. sizeof(struct sock_fprog));
  311. }
  312. static int do_set_sock_timeout(struct socket *sock, int level,
  313. int optname, char __user *optval, unsigned int optlen)
  314. {
  315. struct compat_timeval __user *up = (struct compat_timeval __user *)optval;
  316. struct timeval ktime;
  317. mm_segment_t old_fs;
  318. int err;
  319. if (optlen < sizeof(*up))
  320. return -EINVAL;
  321. if (!access_ok(VERIFY_READ, up, sizeof(*up)) ||
  322. __get_user(ktime.tv_sec, &up->tv_sec) ||
  323. __get_user(ktime.tv_usec, &up->tv_usec))
  324. return -EFAULT;
  325. old_fs = get_fs();
  326. set_fs(KERNEL_DS);
  327. err = sock_setsockopt(sock, level, optname, (char *)&ktime, sizeof(ktime));
  328. set_fs(old_fs);
  329. return err;
  330. }
  331. static int compat_sock_setsockopt(struct socket *sock, int level, int optname,
  332. char __user *optval, unsigned int optlen)
  333. {
  334. if (optname == SO_ATTACH_FILTER)
  335. return do_set_attach_filter(sock, level, optname,
  336. optval, optlen);
  337. if (optname == SO_RCVTIMEO || optname == SO_SNDTIMEO)
  338. return do_set_sock_timeout(sock, level, optname, optval, optlen);
  339. return sock_setsockopt(sock, level, optname, optval, optlen);
  340. }
  341. asmlinkage long compat_sys_setsockopt(int fd, int level, int optname,
  342. char __user *optval, unsigned int optlen)
  343. {
  344. int err;
  345. struct socket *sock = sockfd_lookup(fd, &err);
  346. if (sock) {
  347. err = security_socket_setsockopt(sock, level, optname);
  348. if (err) {
  349. sockfd_put(sock);
  350. return err;
  351. }
  352. if (level == SOL_SOCKET)
  353. err = compat_sock_setsockopt(sock, level,
  354. optname, optval, optlen);
  355. else if (sock->ops->compat_setsockopt)
  356. err = sock->ops->compat_setsockopt(sock, level,
  357. optname, optval, optlen);
  358. else
  359. err = sock->ops->setsockopt(sock, level,
  360. optname, optval, optlen);
  361. sockfd_put(sock);
  362. }
  363. return err;
  364. }
  365. static int do_get_sock_timeout(struct socket *sock, int level, int optname,
  366. char __user *optval, int __user *optlen)
  367. {
  368. struct compat_timeval __user *up;
  369. struct timeval ktime;
  370. mm_segment_t old_fs;
  371. int len, err;
  372. up = (struct compat_timeval __user *) optval;
  373. if (get_user(len, optlen))
  374. return -EFAULT;
  375. if (len < sizeof(*up))
  376. return -EINVAL;
  377. len = sizeof(ktime);
  378. old_fs = get_fs();
  379. set_fs(KERNEL_DS);
  380. err = sock_getsockopt(sock, level, optname, (char *) &ktime, &len);
  381. set_fs(old_fs);
  382. if (!err) {
  383. if (put_user(sizeof(*up), optlen) ||
  384. !access_ok(VERIFY_WRITE, up, sizeof(*up)) ||
  385. __put_user(ktime.tv_sec, &up->tv_sec) ||
  386. __put_user(ktime.tv_usec, &up->tv_usec))
  387. err = -EFAULT;
  388. }
  389. return err;
  390. }
  391. static int compat_sock_getsockopt(struct socket *sock, int level, int optname,
  392. char __user *optval, int __user *optlen)
  393. {
  394. if (optname == SO_RCVTIMEO || optname == SO_SNDTIMEO)
  395. return do_get_sock_timeout(sock, level, optname, optval, optlen);
  396. return sock_getsockopt(sock, level, optname, optval, optlen);
  397. }
  398. int compat_sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
  399. {
  400. struct compat_timeval __user *ctv;
  401. int err;
  402. struct timeval tv;
  403. if (COMPAT_USE_64BIT_TIME)
  404. return sock_get_timestamp(sk, userstamp);
  405. ctv = (struct compat_timeval __user *) userstamp;
  406. err = -ENOENT;
  407. if (!sock_flag(sk, SOCK_TIMESTAMP))
  408. sock_enable_timestamp(sk, SOCK_TIMESTAMP);
  409. tv = ktime_to_timeval(sk->sk_stamp);
  410. if (tv.tv_sec == -1)
  411. return err;
  412. if (tv.tv_sec == 0) {
  413. sk->sk_stamp = ktime_get_real();
  414. tv = ktime_to_timeval(sk->sk_stamp);
  415. }
  416. err = 0;
  417. if (put_user(tv.tv_sec, &ctv->tv_sec) ||
  418. put_user(tv.tv_usec, &ctv->tv_usec))
  419. err = -EFAULT;
  420. return err;
  421. }
  422. EXPORT_SYMBOL(compat_sock_get_timestamp);
  423. int compat_sock_get_timestampns(struct sock *sk, struct timespec __user *userstamp)
  424. {
  425. struct compat_timespec __user *ctv;
  426. int err;
  427. struct timespec ts;
  428. if (COMPAT_USE_64BIT_TIME)
  429. return sock_get_timestampns (sk, userstamp);
  430. ctv = (struct compat_timespec __user *) userstamp;
  431. err = -ENOENT;
  432. if (!sock_flag(sk, SOCK_TIMESTAMP))
  433. sock_enable_timestamp(sk, SOCK_TIMESTAMP);
  434. ts = ktime_to_timespec(sk->sk_stamp);
  435. if (ts.tv_sec == -1)
  436. return err;
  437. if (ts.tv_sec == 0) {
  438. sk->sk_stamp = ktime_get_real();
  439. ts = ktime_to_timespec(sk->sk_stamp);
  440. }
  441. err = 0;
  442. if (put_user(ts.tv_sec, &ctv->tv_sec) ||
  443. put_user(ts.tv_nsec, &ctv->tv_nsec))
  444. err = -EFAULT;
  445. return err;
  446. }
  447. EXPORT_SYMBOL(compat_sock_get_timestampns);
  448. asmlinkage long compat_sys_getsockopt(int fd, int level, int optname,
  449. char __user *optval, int __user *optlen)
  450. {
  451. int err;
  452. struct socket *sock = sockfd_lookup(fd, &err);
  453. if (sock) {
  454. err = security_socket_getsockopt(sock, level, optname);
  455. if (err) {
  456. sockfd_put(sock);
  457. return err;
  458. }
  459. if (level == SOL_SOCKET)
  460. err = compat_sock_getsockopt(sock, level,
  461. optname, optval, optlen);
  462. else if (sock->ops->compat_getsockopt)
  463. err = sock->ops->compat_getsockopt(sock, level,
  464. optname, optval, optlen);
  465. else
  466. err = sock->ops->getsockopt(sock, level,
  467. optname, optval, optlen);
  468. sockfd_put(sock);
  469. }
  470. return err;
  471. }
  472. struct compat_group_req {
  473. __u32 gr_interface;
  474. struct __kernel_sockaddr_storage gr_group
  475. __attribute__ ((aligned(4)));
  476. } __packed;
  477. struct compat_group_source_req {
  478. __u32 gsr_interface;
  479. struct __kernel_sockaddr_storage gsr_group
  480. __attribute__ ((aligned(4)));
  481. struct __kernel_sockaddr_storage gsr_source
  482. __attribute__ ((aligned(4)));
  483. } __packed;
  484. struct compat_group_filter {
  485. __u32 gf_interface;
  486. struct __kernel_sockaddr_storage gf_group
  487. __attribute__ ((aligned(4)));
  488. __u32 gf_fmode;
  489. __u32 gf_numsrc;
  490. struct __kernel_sockaddr_storage gf_slist[1]
  491. __attribute__ ((aligned(4)));
  492. } __packed;
  493. #define __COMPAT_GF0_SIZE (sizeof(struct compat_group_filter) - \
  494. sizeof(struct __kernel_sockaddr_storage))
  495. int compat_mc_setsockopt(struct sock *sock, int level, int optname,
  496. char __user *optval, unsigned int optlen,
  497. int (*setsockopt)(struct sock *, int, int, char __user *, unsigned int))
  498. {
  499. char __user *koptval = optval;
  500. int koptlen = optlen;
  501. switch (optname) {
  502. case MCAST_JOIN_GROUP:
  503. case MCAST_LEAVE_GROUP:
  504. {
  505. struct compat_group_req __user *gr32 = (void *)optval;
  506. struct group_req __user *kgr =
  507. compat_alloc_user_space(sizeof(struct group_req));
  508. u32 interface;
  509. if (!access_ok(VERIFY_READ, gr32, sizeof(*gr32)) ||
  510. !access_ok(VERIFY_WRITE, kgr, sizeof(struct group_req)) ||
  511. __get_user(interface, &gr32->gr_interface) ||
  512. __put_user(interface, &kgr->gr_interface) ||
  513. copy_in_user(&kgr->gr_group, &gr32->gr_group,
  514. sizeof(kgr->gr_group)))
  515. return -EFAULT;
  516. koptval = (char __user *)kgr;
  517. koptlen = sizeof(struct group_req);
  518. break;
  519. }
  520. case MCAST_JOIN_SOURCE_GROUP:
  521. case MCAST_LEAVE_SOURCE_GROUP:
  522. case MCAST_BLOCK_SOURCE:
  523. case MCAST_UNBLOCK_SOURCE:
  524. {
  525. struct compat_group_source_req __user *gsr32 = (void *)optval;
  526. struct group_source_req __user *kgsr = compat_alloc_user_space(
  527. sizeof(struct group_source_req));
  528. u32 interface;
  529. if (!access_ok(VERIFY_READ, gsr32, sizeof(*gsr32)) ||
  530. !access_ok(VERIFY_WRITE, kgsr,
  531. sizeof(struct group_source_req)) ||
  532. __get_user(interface, &gsr32->gsr_interface) ||
  533. __put_user(interface, &kgsr->gsr_interface) ||
  534. copy_in_user(&kgsr->gsr_group, &gsr32->gsr_group,
  535. sizeof(kgsr->gsr_group)) ||
  536. copy_in_user(&kgsr->gsr_source, &gsr32->gsr_source,
  537. sizeof(kgsr->gsr_source)))
  538. return -EFAULT;
  539. koptval = (char __user *)kgsr;
  540. koptlen = sizeof(struct group_source_req);
  541. break;
  542. }
  543. case MCAST_MSFILTER:
  544. {
  545. struct compat_group_filter __user *gf32 = (void *)optval;
  546. struct group_filter __user *kgf;
  547. u32 interface, fmode, numsrc;
  548. if (!access_ok(VERIFY_READ, gf32, __COMPAT_GF0_SIZE) ||
  549. __get_user(interface, &gf32->gf_interface) ||
  550. __get_user(fmode, &gf32->gf_fmode) ||
  551. __get_user(numsrc, &gf32->gf_numsrc))
  552. return -EFAULT;
  553. koptlen = optlen + sizeof(struct group_filter) -
  554. sizeof(struct compat_group_filter);
  555. if (koptlen < GROUP_FILTER_SIZE(numsrc))
  556. return -EINVAL;
  557. kgf = compat_alloc_user_space(koptlen);
  558. if (!access_ok(VERIFY_WRITE, kgf, koptlen) ||
  559. __put_user(interface, &kgf->gf_interface) ||
  560. __put_user(fmode, &kgf->gf_fmode) ||
  561. __put_user(numsrc, &kgf->gf_numsrc) ||
  562. copy_in_user(&kgf->gf_group, &gf32->gf_group,
  563. sizeof(kgf->gf_group)) ||
  564. (numsrc && copy_in_user(kgf->gf_slist, gf32->gf_slist,
  565. numsrc * sizeof(kgf->gf_slist[0]))))
  566. return -EFAULT;
  567. koptval = (char __user *)kgf;
  568. break;
  569. }
  570. default:
  571. break;
  572. }
  573. return setsockopt(sock, level, optname, koptval, koptlen);
  574. }
  575. EXPORT_SYMBOL(compat_mc_setsockopt);
  576. int compat_mc_getsockopt(struct sock *sock, int level, int optname,
  577. char __user *optval, int __user *optlen,
  578. int (*getsockopt)(struct sock *, int, int, char __user *, int __user *))
  579. {
  580. struct compat_group_filter __user *gf32 = (void *)optval;
  581. struct group_filter __user *kgf;
  582. int __user *koptlen;
  583. u32 interface, fmode, numsrc;
  584. int klen, ulen, err;
  585. if (optname != MCAST_MSFILTER)
  586. return getsockopt(sock, level, optname, optval, optlen);
  587. koptlen = compat_alloc_user_space(sizeof(*koptlen));
  588. if (!access_ok(VERIFY_READ, optlen, sizeof(*optlen)) ||
  589. __get_user(ulen, optlen))
  590. return -EFAULT;
  591. /* adjust len for pad */
  592. klen = ulen + sizeof(*kgf) - sizeof(*gf32);
  593. if (klen < GROUP_FILTER_SIZE(0))
  594. return -EINVAL;
  595. if (!access_ok(VERIFY_WRITE, koptlen, sizeof(*koptlen)) ||
  596. __put_user(klen, koptlen))
  597. return -EFAULT;
  598. /* have to allow space for previous compat_alloc_user_space, too */
  599. kgf = compat_alloc_user_space(klen+sizeof(*optlen));
  600. if (!access_ok(VERIFY_READ, gf32, __COMPAT_GF0_SIZE) ||
  601. __get_user(interface, &gf32->gf_interface) ||
  602. __get_user(fmode, &gf32->gf_fmode) ||
  603. __get_user(numsrc, &gf32->gf_numsrc) ||
  604. __put_user(interface, &kgf->gf_interface) ||
  605. __put_user(fmode, &kgf->gf_fmode) ||
  606. __put_user(numsrc, &kgf->gf_numsrc) ||
  607. copy_in_user(&kgf->gf_group, &gf32->gf_group, sizeof(kgf->gf_group)))
  608. return -EFAULT;
  609. err = getsockopt(sock, level, optname, (char __user *)kgf, koptlen);
  610. if (err)
  611. return err;
  612. if (!access_ok(VERIFY_READ, koptlen, sizeof(*koptlen)) ||
  613. __get_user(klen, koptlen))
  614. return -EFAULT;
  615. ulen = klen - (sizeof(*kgf)-sizeof(*gf32));
  616. if (!access_ok(VERIFY_WRITE, optlen, sizeof(*optlen)) ||
  617. __put_user(ulen, optlen))
  618. return -EFAULT;
  619. if (!access_ok(VERIFY_READ, kgf, klen) ||
  620. !access_ok(VERIFY_WRITE, gf32, ulen) ||
  621. __get_user(interface, &kgf->gf_interface) ||
  622. __get_user(fmode, &kgf->gf_fmode) ||
  623. __get_user(numsrc, &kgf->gf_numsrc) ||
  624. __put_user(interface, &gf32->gf_interface) ||
  625. __put_user(fmode, &gf32->gf_fmode) ||
  626. __put_user(numsrc, &gf32->gf_numsrc))
  627. return -EFAULT;
  628. if (numsrc) {
  629. int copylen;
  630. klen -= GROUP_FILTER_SIZE(0);
  631. copylen = numsrc * sizeof(gf32->gf_slist[0]);
  632. if (copylen > klen)
  633. copylen = klen;
  634. if (copy_in_user(gf32->gf_slist, kgf->gf_slist, copylen))
  635. return -EFAULT;
  636. }
  637. return err;
  638. }
  639. EXPORT_SYMBOL(compat_mc_getsockopt);
  640. /* Argument list sizes for compat_sys_socketcall */
  641. #define AL(x) ((x) * sizeof(u32))
  642. static unsigned char nas[21] = {
  643. AL(0), AL(3), AL(3), AL(3), AL(2), AL(3),
  644. AL(3), AL(3), AL(4), AL(4), AL(4), AL(6),
  645. AL(6), AL(2), AL(5), AL(5), AL(3), AL(3),
  646. AL(4), AL(5), AL(4)
  647. };
  648. #undef AL
  649. asmlinkage long compat_sys_sendmsg(int fd, struct compat_msghdr __user *msg, unsigned int flags)
  650. {
  651. if (flags & MSG_CMSG_COMPAT)
  652. return -EINVAL;
  653. return __sys_sendmsg(fd, (struct msghdr __user *)msg, flags | MSG_CMSG_COMPAT);
  654. }
  655. asmlinkage long compat_sys_sendmmsg(int fd, struct compat_mmsghdr __user *mmsg,
  656. unsigned int vlen, unsigned int flags)
  657. {
  658. if (flags & MSG_CMSG_COMPAT)
  659. return -EINVAL;
  660. return __sys_sendmmsg(fd, (struct mmsghdr __user *)mmsg, vlen,
  661. flags | MSG_CMSG_COMPAT);
  662. }
  663. asmlinkage long compat_sys_recvmsg(int fd, struct compat_msghdr __user *msg, unsigned int flags)
  664. {
  665. if (flags & MSG_CMSG_COMPAT)
  666. return -EINVAL;
  667. return __sys_recvmsg(fd, (struct msghdr __user *)msg, flags | MSG_CMSG_COMPAT);
  668. }
  669. asmlinkage long compat_sys_recv(int fd, void __user *buf, size_t len, unsigned int flags)
  670. {
  671. return sys_recv(fd, buf, len, flags | MSG_CMSG_COMPAT);
  672. }
  673. asmlinkage long compat_sys_recvfrom(int fd, void __user *buf, size_t len,
  674. unsigned int flags, struct sockaddr __user *addr,
  675. int __user *addrlen)
  676. {
  677. return sys_recvfrom(fd, buf, len, flags | MSG_CMSG_COMPAT, addr, addrlen);
  678. }
  679. asmlinkage long compat_sys_recvmmsg(int fd, struct compat_mmsghdr __user *mmsg,
  680. unsigned int vlen, unsigned int flags,
  681. struct compat_timespec __user *timeout)
  682. {
  683. int datagrams;
  684. struct timespec ktspec;
  685. if (flags & MSG_CMSG_COMPAT)
  686. return -EINVAL;
  687. if (COMPAT_USE_64BIT_TIME)
  688. return __sys_recvmmsg(fd, (struct mmsghdr __user *)mmsg, vlen,
  689. flags | MSG_CMSG_COMPAT,
  690. (struct timespec *) timeout);
  691. if (timeout == NULL)
  692. return __sys_recvmmsg(fd, (struct mmsghdr __user *)mmsg, vlen,
  693. flags | MSG_CMSG_COMPAT, NULL);
  694. if (get_compat_timespec(&ktspec, timeout))
  695. return -EFAULT;
  696. datagrams = __sys_recvmmsg(fd, (struct mmsghdr __user *)mmsg, vlen,
  697. flags | MSG_CMSG_COMPAT, &ktspec);
  698. if (datagrams > 0 && put_compat_timespec(&ktspec, timeout))
  699. datagrams = -EFAULT;
  700. return datagrams;
  701. }
  702. asmlinkage long compat_sys_socketcall(int call, u32 __user *args)
  703. {
  704. int ret;
  705. u32 a[6];
  706. u32 a0, a1;
  707. if (call < SYS_SOCKET || call > SYS_SENDMMSG)
  708. return -EINVAL;
  709. if (copy_from_user(a, args, nas[call]))
  710. return -EFAULT;
  711. a0 = a[0];
  712. a1 = a[1];
  713. switch (call) {
  714. case SYS_SOCKET:
  715. ret = sys_socket(a0, a1, a[2]);
  716. break;
  717. case SYS_BIND:
  718. ret = sys_bind(a0, compat_ptr(a1), a[2]);
  719. break;
  720. case SYS_CONNECT:
  721. ret = sys_connect(a0, compat_ptr(a1), a[2]);
  722. break;
  723. case SYS_LISTEN:
  724. ret = sys_listen(a0, a1);
  725. break;
  726. case SYS_ACCEPT:
  727. ret = sys_accept4(a0, compat_ptr(a1), compat_ptr(a[2]), 0);
  728. break;
  729. case SYS_GETSOCKNAME:
  730. ret = sys_getsockname(a0, compat_ptr(a1), compat_ptr(a[2]));
  731. break;
  732. case SYS_GETPEERNAME:
  733. ret = sys_getpeername(a0, compat_ptr(a1), compat_ptr(a[2]));
  734. break;
  735. case SYS_SOCKETPAIR:
  736. ret = sys_socketpair(a0, a1, a[2], compat_ptr(a[3]));
  737. break;
  738. case SYS_SEND:
  739. ret = sys_send(a0, compat_ptr(a1), a[2], a[3]);
  740. break;
  741. case SYS_SENDTO:
  742. ret = sys_sendto(a0, compat_ptr(a1), a[2], a[3], compat_ptr(a[4]), a[5]);
  743. break;
  744. case SYS_RECV:
  745. ret = compat_sys_recv(a0, compat_ptr(a1), a[2], a[3]);
  746. break;
  747. case SYS_RECVFROM:
  748. ret = compat_sys_recvfrom(a0, compat_ptr(a1), a[2], a[3],
  749. compat_ptr(a[4]), compat_ptr(a[5]));
  750. break;
  751. case SYS_SHUTDOWN:
  752. ret = sys_shutdown(a0, a1);
  753. break;
  754. case SYS_SETSOCKOPT:
  755. ret = compat_sys_setsockopt(a0, a1, a[2],
  756. compat_ptr(a[3]), a[4]);
  757. break;
  758. case SYS_GETSOCKOPT:
  759. ret = compat_sys_getsockopt(a0, a1, a[2],
  760. compat_ptr(a[3]), compat_ptr(a[4]));
  761. break;
  762. case SYS_SENDMSG:
  763. ret = compat_sys_sendmsg(a0, compat_ptr(a1), a[2]);
  764. break;
  765. case SYS_SENDMMSG:
  766. ret = compat_sys_sendmmsg(a0, compat_ptr(a1), a[2], a[3]);
  767. break;
  768. case SYS_RECVMSG:
  769. ret = compat_sys_recvmsg(a0, compat_ptr(a1), a[2]);
  770. break;
  771. case SYS_RECVMMSG:
  772. ret = compat_sys_recvmmsg(a0, compat_ptr(a1), a[2], a[3],
  773. compat_ptr(a[4]));
  774. break;
  775. case SYS_ACCEPT4:
  776. ret = sys_accept4(a0, compat_ptr(a1), compat_ptr(a[2]), a[3]);
  777. break;
  778. default:
  779. ret = -EINVAL;
  780. break;
  781. }
  782. return ret;
  783. }