git.stricted.de - GitHub/exynos8895/android_kernel_samsung

1 /*

2 * 32bit Socket syscall emulation. Based on arch/sparc64/kernel/sys_sparc32.c.

3 *

12 */

14 #include <linux/kernel.h>

15 #include <linux/gfp.h>

16 #include <linux/fs.h>

17 #include <linux/types.h>

18 #include <linux/file.h>

19 #include <linux/icmpv6.h>

20 #include <linux/socket.h>

21 #include <linux/syscalls.h>

22 #include <linux/filter.h>

23 #include <linux/compat.h>

24 #include <linux/security.h>

26 #include <net/scm.h>

27 #include <net/sock.h>

28 #include <net/ip.h>

29 #include <net/ipv6.h>

30 #include <asm/uaccess.h>

31 #include <net/compat.h>

33 static inline int iov_from_user_compat_to_kern(struct iovec *kiov,

34 struct compat_iovec __user *uiov32,

35 int niov)

36 {

37 int tot_len = 0;

39 while (niov > 0) {

40 compat_uptr_t buf;

41 compat_size_t len;

43 if (get_user(len, &uiov32->iov_len) ||

44 get_user(buf, &uiov32->iov_base)) {

45 tot_len = -EFAULT;

46 break;

47 }

48 tot_len += len;

49 kiov->iov_base = compat_ptr(buf);

50 kiov->iov_len = (__kernel_size_t) len;

51 uiov32++;

52 kiov++;

53 niov--;

54 }

55 return tot_len;

56 }

58 int get_compat_msghdr(struct msghdr *kmsg, struct compat_msghdr __user *umsg)

59 {

60 compat_uptr_t tmp1, tmp2, tmp3;

62 if (!access_ok(VERIFY_READ, umsg, sizeof(*umsg)) ||

63 __get_user(tmp1, &umsg->msg_name) ||

64 __get_user(kmsg->msg_namelen, &umsg->msg_namelen) ||

65 __get_user(tmp2, &umsg->msg_iov) ||

66 __get_user(kmsg->msg_iovlen, &umsg->msg_iovlen) ||

67 __get_user(tmp3, &umsg->msg_control) ||

68 __get_user(kmsg->msg_controllen, &umsg->msg_controllen) ||

69 __get_user(kmsg->msg_flags, &umsg->msg_flags))

70 return -EFAULT;

71 kmsg->msg_name = compat_ptr(tmp1);

72 kmsg->msg_iov = compat_ptr(tmp2);

73 kmsg->msg_control = compat_ptr(tmp3);

74 return 0;

75 }

77 /* I've named the args so it is easy to tell whose space the pointers are in. */

78 int verify_compat_iovec(struct msghdr *kern_msg, struct iovec *kern_iov,

79 struct sockaddr *kern_address, int mode)

80 {

81 int tot_len;

83 if (kern_msg->msg_namelen) {

84 if (mode==VERIFY_READ) {

85 int err = move_addr_to_kernel(kern_msg->msg_name,

86 kern_msg->msg_namelen,

87 kern_address);

88 if (err < 0)

89 return err;

90 }

91 kern_msg->msg_name = kern_address;

92 } else

93 kern_msg->msg_name = NULL;

95 tot_len = iov_from_user_compat_to_kern(kern_iov,

96 (struct compat_iovec __user *)kern_msg->msg_iov,

97 kern_msg->msg_iovlen);

98 if (tot_len >= 0)

99 kern_msg->msg_iov = kern_iov;

100

101 return tot_len;

102 }

103

104 /* Bleech... */

105 #define CMSG_COMPAT_ALIGN(len) ALIGN((len), sizeof(s32))

106

107 #define CMSG_COMPAT_DATA(cmsg) \

108 ((void __user *)((char __user *)(cmsg) + CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr))))

109 #define CMSG_COMPAT_SPACE(len) \

110 (CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr)) + CMSG_COMPAT_ALIGN(len))

111 #define CMSG_COMPAT_LEN(len) \

112 (CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr)) + (len))

113

114 #define CMSG_COMPAT_FIRSTHDR(msg) \

115 (((msg)->msg_controllen) >= sizeof(struct compat_cmsghdr) ? \

116 (struct compat_cmsghdr __user *)((msg)->msg_control) : \

117 (struct compat_cmsghdr __user *)NULL)

118

119 #define CMSG_COMPAT_OK(ucmlen, ucmsg, mhdr) \

120 ((ucmlen) >= sizeof(struct compat_cmsghdr) && \

121 (ucmlen) <= (unsigned long) \

122 ((mhdr)->msg_controllen - \

123 ((char *)(ucmsg) - (char *)(mhdr)->msg_control)))

124

125 static inline struct compat_cmsghdr __user *cmsg_compat_nxthdr(struct msghdr *msg,

126 struct compat_cmsghdr __user *cmsg, int cmsg_len)

127 {

128 char __user *ptr = (char __user *)cmsg + CMSG_COMPAT_ALIGN(cmsg_len);

129 if ((unsigned long)(ptr + 1 - (char __user *)msg->msg_control) >

130 msg->msg_controllen)

131 return NULL;

132 return (struct compat_cmsghdr __user *)ptr;

133 }

134

135 /* There is a lot of hair here because the alignment rules (and

136 * thus placement) of cmsg headers and length are different for

137 * 32-bit apps. -DaveM

138 */

139 int cmsghdr_from_user_compat_to_kern(struct msghdr *kmsg, struct sock *sk,

140 unsigned char *stackbuf, int stackbuf_size)

141 {

142 struct compat_cmsghdr __user *ucmsg;

143 struct cmsghdr *kcmsg, *kcmsg_base;

144 compat_size_t ucmlen;

145 __kernel_size_t kcmlen, tmp;

146 int err = -EFAULT;

147

148 kcmlen = 0;

149 kcmsg_base = kcmsg = (struct cmsghdr *)stackbuf;

150 ucmsg = CMSG_COMPAT_FIRSTHDR(kmsg);

151 while (ucmsg != NULL) {

152 if (get_user(ucmlen, &ucmsg->cmsg_len))

153 return -EFAULT;

154

155 /* Catch bogons. */

156 if (!CMSG_COMPAT_OK(ucmlen, ucmsg, kmsg))

157 return -EINVAL;

158

159 tmp = ((ucmlen - CMSG_COMPAT_ALIGN(sizeof(*ucmsg))) +

160 CMSG_ALIGN(sizeof(struct cmsghdr)));

161 tmp = CMSG_ALIGN(tmp);

162 kcmlen += tmp;

163 ucmsg = cmsg_compat_nxthdr(kmsg, ucmsg, ucmlen);

164 }

165 if (kcmlen == 0)

166 return -EINVAL;

167

168 /* The kcmlen holds the 64-bit version of the control length.

169 * It may not be modified as we do not stick it into the kmsg

170 * until we have successfully copied over all of the data

171 * from the user.

172 */

173 if (kcmlen > stackbuf_size)

174 kcmsg_base = kcmsg = sock_kmalloc(sk, kcmlen, GFP_KERNEL);

175 if (kcmsg == NULL)

176 return -ENOBUFS;

177

178 /* Now copy them over neatly. */

179 memset(kcmsg, 0, kcmlen);

180 ucmsg = CMSG_COMPAT_FIRSTHDR(kmsg);

181 while (ucmsg != NULL) {

182 if (__get_user(ucmlen, &ucmsg->cmsg_len))

183 goto Efault;

184 if (!CMSG_COMPAT_OK(ucmlen, ucmsg, kmsg))

185 goto Einval;

186 tmp = ((ucmlen - CMSG_COMPAT_ALIGN(sizeof(*ucmsg))) +

187 CMSG_ALIGN(sizeof(struct cmsghdr)));

188 if ((char *)kcmsg_base + kcmlen - (char *)kcmsg < CMSG_ALIGN(tmp))

189 goto Einval;

190 kcmsg->cmsg_len = tmp;

191 tmp = CMSG_ALIGN(tmp);

192 if (__get_user(kcmsg->cmsg_level, &ucmsg->cmsg_level) ||

193 __get_user(kcmsg->cmsg_type, &ucmsg->cmsg_type) ||

194 copy_from_user(CMSG_DATA(kcmsg),

195 CMSG_COMPAT_DATA(ucmsg),

196 (ucmlen - CMSG_COMPAT_ALIGN(sizeof(*ucmsg)))))

197 goto Efault;

198

199 /* Advance. */

200 kcmsg = (struct cmsghdr *)((char *)kcmsg + tmp);

201 ucmsg = cmsg_compat_nxthdr(kmsg, ucmsg, ucmlen);

202 }

203

204 /* Ok, looks like we made it. Hook it up and return success. */

205 kmsg->msg_control = kcmsg_base;

206 kmsg->msg_controllen = kcmlen;

207 return 0;

208

209 Einval:

210 err = -EINVAL;

211 Efault:

212 if (kcmsg_base != (struct cmsghdr *)stackbuf)

213 sock_kfree_s(sk, kcmsg_base, kcmlen);

214 return err;

215 }

216

217 int put_cmsg_compat(struct msghdr *kmsg, int level, int type, int len, void *data)

218 {

219 struct compat_timeval ctv;

220 struct compat_timespec cts[3];

221 struct compat_cmsghdr __user *cm = (struct compat_cmsghdr __user *) kmsg->msg_control;

222 struct compat_cmsghdr cmhdr;

223 int cmlen;

224

225 if (cm == NULL || kmsg->msg_controllen < sizeof(*cm)) {

226 kmsg->msg_flags |= MSG_CTRUNC;

227 return 0; /* XXX: return error? check spec. */

228 }

229

230 if (level == SOL_SOCKET && type == SCM_TIMESTAMP) {

231 struct timeval *tv = (struct timeval *)data;

232 ctv.tv_sec = tv->tv_sec;

233 ctv.tv_usec = tv->tv_usec;

234 data = &ctv;

235 len = sizeof(ctv);

236 }

237 if (level == SOL_SOCKET &&

238 (type == SCM_TIMESTAMPNS || type == SCM_TIMESTAMPING)) {

239 int count = type == SCM_TIMESTAMPNS ? 1 : 3;

240 int i;

241 struct timespec *ts = (struct timespec *)data;

242 for (i = 0; i < count; i++) {

243 cts[i].tv_sec = ts[i].tv_sec;

244 cts[i].tv_nsec = ts[i].tv_nsec;

245 }

246 data = &cts;

247 len = sizeof(cts[0]) * count;

248 }

249

250 cmlen = CMSG_COMPAT_LEN(len);

251 if (kmsg->msg_controllen < cmlen) {

252 kmsg->msg_flags |= MSG_CTRUNC;

253 cmlen = kmsg->msg_controllen;

254 }

255 cmhdr.cmsg_level = level;

256 cmhdr.cmsg_type = type;

257 cmhdr.cmsg_len = cmlen;

258

259 if (copy_to_user(cm, &cmhdr, sizeof cmhdr))

260 return -EFAULT;

261 if (copy_to_user(CMSG_COMPAT_DATA(cm), data, cmlen - sizeof(struct compat_cmsghdr)))

262 return -EFAULT;

263 cmlen = CMSG_COMPAT_SPACE(len);

264 if (kmsg->msg_controllen < cmlen)

265 cmlen = kmsg->msg_controllen;

266 kmsg->msg_control += cmlen;

267 kmsg->msg_controllen -= cmlen;

268 return 0;

269 }

270

271 void scm_detach_fds_compat(struct msghdr *kmsg, struct scm_cookie *scm)

272 {

273 struct compat_cmsghdr __user *cm = (struct compat_cmsghdr __user *) kmsg->msg_control;

274 int fdmax = (kmsg->msg_controllen - sizeof(struct compat_cmsghdr)) / sizeof(int);

275 int fdnum = scm->fp->count;

276 struct file **fp = scm->fp->fp;

277 int __user *cmfptr;

278 int err = 0, i;

279

280 if (fdnum < fdmax)

281 fdmax = fdnum;

282

283 for (i = 0, cmfptr = (int __user *) CMSG_COMPAT_DATA(cm); i < fdmax; i++, cmfptr++) {

284 int new_fd;

285 err = security_file_receive(fp[i]);

286 if (err)

287 break;

288 err = get_unused_fd_flags(MSG_CMSG_CLOEXEC & kmsg->msg_flags

289 ? O_CLOEXEC : 0);

290 if (err < 0)

291 break;

292 new_fd = err;

293 err = put_user(new_fd, cmfptr);

294 if (err) {

295 put_unused_fd(new_fd);

296 break;

297 }

298 /* Bump the usage count and install the file. */

299 get_file(fp[i]);

300 fd_install(new_fd, fp[i]);

301 }

302

303 if (i > 0) {

304 int cmlen = CMSG_COMPAT_LEN(i * sizeof(int));

305 err = put_user(SOL_SOCKET, &cm->cmsg_level);

306 if (!err)

307 err = put_user(SCM_RIGHTS, &cm->cmsg_type);

308 if (!err)

309 err = put_user(cmlen, &cm->cmsg_len);

310 if (!err) {

311 cmlen = CMSG_COMPAT_SPACE(i * sizeof(int));

312 kmsg->msg_control += cmlen;

313 kmsg->msg_controllen -= cmlen;

314 }

315 }

316 if (i < fdnum)

317 kmsg->msg_flags |= MSG_CTRUNC;

318

319 /*

320 * All of the files that fit in the message have had their

321 * usage counts incremented, so we just free the list.

322 */

323 __scm_destroy(scm);

324 }

325

326 /*

327 * A struct sock_filter is architecture independent.

328 */

329 struct compat_sock_fprog {

330 u16 len;

331 compat_uptr_t filter; /* struct sock_filter * */

332 };

333

334 static int do_set_attach_filter(struct socket *sock, int level, int optname,

335 char __user *optval, unsigned int optlen)

336 {

337 struct compat_sock_fprog __user *fprog32 = (struct compat_sock_fprog __user *)optval;

338 struct sock_fprog __user *kfprog = compat_alloc_user_space(sizeof(struct sock_fprog));

339 compat_uptr_t ptr;

340 u16 len;

341

342 if (!access_ok(VERIFY_READ, fprog32, sizeof(*fprog32)) ||

343 !access_ok(VERIFY_WRITE, kfprog, sizeof(struct sock_fprog)) ||

344 __get_user(len, &fprog32->len) ||

345 __get_user(ptr, &fprog32->filter) ||

346 __put_user(len, &kfprog->len) ||

347 __put_user(compat_ptr(ptr), &kfprog->filter))

348 return -EFAULT;

349

350 return sock_setsockopt(sock, level, optname, (char __user *)kfprog,

351 sizeof(struct sock_fprog));

352 }

353

354 static int do_set_sock_timeout(struct socket *sock, int level,

355 int optname, char __user *optval, unsigned int optlen)

356 {

357 struct compat_timeval __user *up = (struct compat_timeval __user *) optval;

358 struct timeval ktime;

359 mm_segment_t old_fs;

360 int err;

361

362 if (optlen < sizeof(*up))

363 return -EINVAL;

364 if (!access_ok(VERIFY_READ, up, sizeof(*up)) ||

365 __get_user(ktime.tv_sec, &up->tv_sec) ||

366 __get_user(ktime.tv_usec, &up->tv_usec))

367 return -EFAULT;

368 old_fs = get_fs();

369 set_fs(KERNEL_DS);

370 err = sock_setsockopt(sock, level, optname, (char *) &ktime, sizeof(ktime));

371 set_fs(old_fs);

372

373 return err;

374 }

375

376 static int compat_sock_setsockopt(struct socket *sock, int level, int optname,

377 char __user *optval, unsigned int optlen)

378 {

379 if (optname == SO_ATTACH_FILTER)

380 return do_set_attach_filter(sock, level, optname,

381 optval, optlen);

382 if (optname == SO_RCVTIMEO || optname == SO_SNDTIMEO)

383 return do_set_sock_timeout(sock, level, optname, optval, optlen);

384

385 return sock_setsockopt(sock, level, optname, optval, optlen);

386 }

387

388 asmlinkage long compat_sys_setsockopt(int fd, int level, int optname,

389 char __user *optval, unsigned int optlen)

390 {

391 int err;

392 struct socket *sock;

393

394 if ((sock = sockfd_lookup(fd, &err))!=NULL)

395 {

396 err = security_socket_setsockopt(sock,level,optname);

397 if (err) {

398 sockfd_put(sock);

399 return err;

400 }

401

402 if (level == SOL_SOCKET)

403 err = compat_sock_setsockopt(sock, level,

404 optname, optval, optlen);

405 else if (sock->ops->compat_setsockopt)

406 err = sock->ops->compat_setsockopt(sock, level,

407 optname, optval, optlen);

408 else

409 err = sock->ops->setsockopt(sock, level,

410 optname, optval, optlen);

411 sockfd_put(sock);

412 }

413 return err;

414 }

415

416 static int do_get_sock_timeout(struct socket *sock, int level, int optname,

417 char __user *optval, int __user *optlen)

418 {

419 struct compat_timeval __user *up;

420 struct timeval ktime;

421 mm_segment_t old_fs;

422 int len, err;

423

424 up = (struct compat_timeval __user *) optval;

425 if (get_user(len, optlen))

426 return -EFAULT;

427 if (len < sizeof(*up))

428 return -EINVAL;

429 len = sizeof(ktime);

430 old_fs = get_fs();

431 set_fs(KERNEL_DS);

432 err = sock_getsockopt(sock, level, optname, (char *) &ktime, &len);

433 set_fs(old_fs);

434

435 if (!err) {

436 if (put_user(sizeof(*up), optlen) ||

437 !access_ok(VERIFY_WRITE, up, sizeof(*up)) ||

438 __put_user(ktime.tv_sec, &up->tv_sec) ||

439 __put_user(ktime.tv_usec, &up->tv_usec))

440 err = -EFAULT;

441 }

442 return err;

443 }

444

445 static int compat_sock_getsockopt(struct socket *sock, int level, int optname,

446 char __user *optval, int __user *optlen)

447 {

448 if (optname == SO_RCVTIMEO || optname == SO_SNDTIMEO)

449 return do_get_sock_timeout(sock, level, optname, optval, optlen);

450 return sock_getsockopt(sock, level, optname, optval, optlen);

451 }

452

453 int compat_sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)

454 {

455 struct compat_timeval __user *ctv =

456 (struct compat_timeval __user*) userstamp;

457 int err = -ENOENT;

458 struct timeval tv;

459

460 if (!sock_flag(sk, SOCK_TIMESTAMP))

461 sock_enable_timestamp(sk, SOCK_TIMESTAMP);

462 tv = ktime_to_timeval(sk->sk_stamp);

463 if (tv.tv_sec == -1)

464 return err;

465 if (tv.tv_sec == 0) {

466 sk->sk_stamp = ktime_get_real();

467 tv = ktime_to_timeval(sk->sk_stamp);

468 }

469 err = 0;

470 if (put_user(tv.tv_sec, &ctv->tv_sec) ||

471 put_user(tv.tv_usec, &ctv->tv_usec))

472 err = -EFAULT;

473 return err;

474 }

475 EXPORT_SYMBOL(compat_sock_get_timestamp);

476

477 int compat_sock_get_timestampns(struct sock *sk, struct timespec __user *userstamp)

478 {

479 struct compat_timespec __user *ctv =

480 (struct compat_timespec __user*) userstamp;

481 int err = -ENOENT;

482 struct timespec ts;

483

484 if (!sock_flag(sk, SOCK_TIMESTAMP))

485 sock_enable_timestamp(sk, SOCK_TIMESTAMP);

486 ts = ktime_to_timespec(sk->sk_stamp);

487 if (ts.tv_sec == -1)

488 return err;

489 if (ts.tv_sec == 0) {

490 sk->sk_stamp = ktime_get_real();

491 ts = ktime_to_timespec(sk->sk_stamp);

492 }

493 err = 0;

494 if (put_user(ts.tv_sec, &ctv->tv_sec) ||

495 put_user(ts.tv_nsec, &ctv->tv_nsec))

496 err = -EFAULT;

497 return err;

498 }

499 EXPORT_SYMBOL(compat_sock_get_timestampns);

500

501 asmlinkage long compat_sys_getsockopt(int fd, int level, int optname,

502 char __user *optval, int __user *optlen)

503 {

504 int err;

505 struct socket *sock;

506

507 if ((sock = sockfd_lookup(fd, &err))!=NULL)

508 {

509 err = security_socket_getsockopt(sock, level,

510 optname);

511 if (err) {

512 sockfd_put(sock);

513 return err;

514 }

515

516 if (level == SOL_SOCKET)

517 err = compat_sock_getsockopt(sock, level,

518 optname, optval, optlen);

519 else if (sock->ops->compat_getsockopt)

520 err = sock->ops->compat_getsockopt(sock, level,

521 optname, optval, optlen);

522 else

523 err = sock->ops->getsockopt(sock, level,

524 optname, optval, optlen);

525 sockfd_put(sock);

526 }

527 return err;

528 }

529

530 struct compat_group_req {

531 __u32 gr_interface;

532 struct __kernel_sockaddr_storage gr_group

533 __attribute__ ((aligned(4)));

534 } __packed;

535

536 struct compat_group_source_req {

537 __u32 gsr_interface;

538 struct __kernel_sockaddr_storage gsr_group

539 __attribute__ ((aligned(4)));

540 struct __kernel_sockaddr_storage gsr_source

541 __attribute__ ((aligned(4)));

542 } __packed;

543

544 struct compat_group_filter {

545 __u32 gf_interface;

546 struct __kernel_sockaddr_storage gf_group

547 __attribute__ ((aligned(4)));

548 __u32 gf_fmode;

549 __u32 gf_numsrc;

550 struct __kernel_sockaddr_storage gf_slist[1]

551 __attribute__ ((aligned(4)));

552 } __packed;

553

554 #define __COMPAT_GF0_SIZE (sizeof(struct compat_group_filter) - \

555 sizeof(struct __kernel_sockaddr_storage))

556

557

558 int compat_mc_setsockopt(struct sock *sock, int level, int optname,

559 char __user *optval, unsigned int optlen,

560 int (*setsockopt)(struct sock *,int,int,char __user *,unsigned int))

561 {

562 char __user *koptval = optval;

563 int koptlen = optlen;

564

565 switch (optname) {

566 case MCAST_JOIN_GROUP:

567 case MCAST_LEAVE_GROUP:

568 {

569 struct compat_group_req __user *gr32 = (void *)optval;

570 struct group_req __user *kgr =

571 compat_alloc_user_space(sizeof(struct group_req));

572 u32 interface;

573

574 if (!access_ok(VERIFY_READ, gr32, sizeof(*gr32)) ||

575 !access_ok(VERIFY_WRITE, kgr, sizeof(struct group_req)) ||

576 __get_user(interface, &gr32->gr_interface) ||

577 __put_user(interface, &kgr->gr_interface) ||

578 copy_in_user(&kgr->gr_group, &gr32->gr_group,

579 sizeof(kgr->gr_group)))

580 return -EFAULT;

581 koptval = (char __user *)kgr;

582 koptlen = sizeof(struct group_req);

583 break;

584 }

585 case MCAST_JOIN_SOURCE_GROUP:

586 case MCAST_LEAVE_SOURCE_GROUP:

587 case MCAST_BLOCK_SOURCE:

588 case MCAST_UNBLOCK_SOURCE:

589 {

590 struct compat_group_source_req __user *gsr32 = (void *)optval;

591 struct group_source_req __user *kgsr = compat_alloc_user_space(

592 sizeof(struct group_source_req));

593 u32 interface;

594

595 if (!access_ok(VERIFY_READ, gsr32, sizeof(*gsr32)) ||

596 !access_ok(VERIFY_WRITE, kgsr,

597 sizeof(struct group_source_req)) ||

598 __get_user(interface, &gsr32->gsr_interface) ||

599 __put_user(interface, &kgsr->gsr_interface) ||

600 copy_in_user(&kgsr->gsr_group, &gsr32->gsr_group,

601 sizeof(kgsr->gsr_group)) ||

602 copy_in_user(&kgsr->gsr_source, &gsr32->gsr_source,

603 sizeof(kgsr->gsr_source)))

604 return -EFAULT;

605 koptval = (char __user *)kgsr;

606 koptlen = sizeof(struct group_source_req);

607 break;

608 }

609 case MCAST_MSFILTER:

610 {

611 struct compat_group_filter __user *gf32 = (void *)optval;

612 struct group_filter __user *kgf;

613 u32 interface, fmode, numsrc;

614

615 if (!access_ok(VERIFY_READ, gf32, __COMPAT_GF0_SIZE) ||

616 __get_user(interface, &gf32->gf_interface) ||

617 __get_user(fmode, &gf32->gf_fmode) ||

618 __get_user(numsrc, &gf32->gf_numsrc))

619 return -EFAULT;

620 koptlen = optlen + sizeof(struct group_filter) -

621 sizeof(struct compat_group_filter);

622 if (koptlen < GROUP_FILTER_SIZE(numsrc))

623 return -EINVAL;

624 kgf = compat_alloc_user_space(koptlen);

625 if (!access_ok(VERIFY_WRITE, kgf, koptlen) ||

626 __put_user(interface, &kgf->gf_interface) ||

627 __put_user(fmode, &kgf->gf_fmode) ||

628 __put_user(numsrc, &kgf->gf_numsrc) ||

629 copy_in_user(&kgf->gf_group, &gf32->gf_group,

630 sizeof(kgf->gf_group)) ||

631 (numsrc && copy_in_user(kgf->gf_slist, gf32->gf_slist,

632 numsrc * sizeof(kgf->gf_slist[0]))))

633 return -EFAULT;

634 koptval = (char __user *)kgf;

635 break;

636 }

637

638 default:

639 break;

640 }

641 return setsockopt(sock, level, optname, koptval, koptlen);

642 }

643

644 EXPORT_SYMBOL(compat_mc_setsockopt);

645

646 int compat_mc_getsockopt(struct sock *sock, int level, int optname,

647 char __user *optval, int __user *optlen,

648 int (*getsockopt)(struct sock *,int,int,char __user *,int __user *))

649 {

650 struct compat_group_filter __user *gf32 = (void *)optval;

651 struct group_filter __user *kgf;

652 int __user *koptlen;

653 u32 interface, fmode, numsrc;

654 int klen, ulen, err;

655

656 if (optname != MCAST_MSFILTER)

657 return getsockopt(sock, level, optname, optval, optlen);

658

659 koptlen = compat_alloc_user_space(sizeof(*koptlen));

660 if (!access_ok(VERIFY_READ, optlen, sizeof(*optlen)) ||

661 __get_user(ulen, optlen))

662 return -EFAULT;

663

664 /* adjust len for pad */

665 klen = ulen + sizeof(*kgf) - sizeof(*gf32);

666

667 if (klen < GROUP_FILTER_SIZE(0))

668 return -EINVAL;

669

670 if (!access_ok(VERIFY_WRITE, koptlen, sizeof(*koptlen)) ||

671 __put_user(klen, koptlen))

672 return -EFAULT;

673

674 /* have to allow space for previous compat_alloc_user_space, too */

675 kgf = compat_alloc_user_space(klen+sizeof(*optlen));

676

677 if (!access_ok(VERIFY_READ, gf32, __COMPAT_GF0_SIZE) ||

678 __get_user(interface, &gf32->gf_interface) ||

679 __get_user(fmode, &gf32->gf_fmode) ||

680 __get_user(numsrc, &gf32->gf_numsrc) ||

681 __put_user(interface, &kgf->gf_interface) ||

682 __put_user(fmode, &kgf->gf_fmode) ||

683 __put_user(numsrc, &kgf->gf_numsrc) ||

684 copy_in_user(&kgf->gf_group,&gf32->gf_group,sizeof(kgf->gf_group)))

685 return -EFAULT;

686

687 err = getsockopt(sock, level, optname, (char __user *)kgf, koptlen);

688 if (err)

689 return err;

690

691 if (!access_ok(VERIFY_READ, koptlen, sizeof(*koptlen)) ||

692 __get_user(klen, koptlen))

693 return -EFAULT;

694

695 ulen = klen - (sizeof(*kgf)-sizeof(*gf32));

696

697 if (!access_ok(VERIFY_WRITE, optlen, sizeof(*optlen)) ||

698 __put_user(ulen, optlen))

699 return -EFAULT;

700

701 if (!access_ok(VERIFY_READ, kgf, klen) ||

702 !access_ok(VERIFY_WRITE, gf32, ulen) ||

703 __get_user(interface, &kgf->gf_interface) ||

704 __get_user(fmode, &kgf->gf_fmode) ||

705 __get_user(numsrc, &kgf->gf_numsrc) ||

706 __put_user(interface, &gf32->gf_interface) ||

707 __put_user(fmode, &gf32->gf_fmode) ||

708 __put_user(numsrc, &gf32->gf_numsrc))

709 return -EFAULT;

710 if (numsrc) {

711 int copylen;

712

713 klen -= GROUP_FILTER_SIZE(0);

714 copylen = numsrc * sizeof(gf32->gf_slist[0]);

715 if (copylen > klen)

716 copylen = klen;

717 if (copy_in_user(gf32->gf_slist, kgf->gf_slist, copylen))

718 return -EFAULT;

719 }

720 return err;

721 }

722

723 EXPORT_SYMBOL(compat_mc_getsockopt);

724

725

726 /* Argument list sizes for compat_sys_socketcall */

727 #define AL(x) ((x) * sizeof(u32))

728 static unsigned char nas[20]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),

729 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),

730 AL(6),AL(2),AL(5),AL(5),AL(3),AL(3),

731 AL(4),AL(5)};

732 #undef AL

733

734 asmlinkage long compat_sys_sendmsg(int fd, struct compat_msghdr __user *msg, unsigned flags)

735 {

736 return sys_sendmsg(fd, (struct msghdr __user *)msg, flags | MSG_CMSG_COMPAT);

737 }

738

739 asmlinkage long compat_sys_recvmsg(int fd, struct compat_msghdr __user *msg, unsigned int flags)

740 {

741 return sys_recvmsg(fd, (struct msghdr __user *)msg, flags | MSG_CMSG_COMPAT);

742 }

743

744 asmlinkage long compat_sys_recv(int fd, void __user *buf, size_t len, unsigned flags)

745 {

746 return sys_recv(fd, buf, len, flags | MSG_CMSG_COMPAT);

747 }

748

749 asmlinkage long compat_sys_recvfrom(int fd, void __user *buf, size_t len,

750 unsigned flags, struct sockaddr __user *addr,

751 int __user *addrlen)

752 {

753 return sys_recvfrom(fd, buf, len, flags | MSG_CMSG_COMPAT, addr, addrlen);

754 }

755

756 asmlinkage long compat_sys_recvmmsg(int fd, struct compat_mmsghdr __user *mmsg,

757 unsigned vlen, unsigned int flags,

758 struct compat_timespec __user *timeout)

759 {

760 int datagrams;

761 struct timespec ktspec;

762

763 if (timeout == NULL)

764 return __sys_recvmmsg(fd, (struct mmsghdr __user *)mmsg, vlen,

765 flags | MSG_CMSG_COMPAT, NULL);

766

767 if (get_compat_timespec(&ktspec, timeout))

768 return -EFAULT;

769

770 datagrams = __sys_recvmmsg(fd, (struct mmsghdr __user *)mmsg, vlen,

771 flags | MSG_CMSG_COMPAT, &ktspec);

772 if (datagrams > 0 && put_compat_timespec(&ktspec, timeout))

773 datagrams = -EFAULT;

774

775 return datagrams;

776 }

777

778 asmlinkage long compat_sys_socketcall(int call, u32 __user *args)

779 {

780 int ret;

781 u32 a[6];

782 u32 a0, a1;

783

784 if (call < SYS_SOCKET || call > SYS_RECVMMSG)

785 return -EINVAL;

786 if (copy_from_user(a, args, nas[call]))

787 return -EFAULT;

788 a0 = a[0];

789 a1 = a[1];

790

791 switch (call) {

792 case SYS_SOCKET:

793 ret = sys_socket(a0, a1, a[2]);

794 break;

795 case SYS_BIND:

796 ret = sys_bind(a0, compat_ptr(a1), a[2]);

797 break;

798 case SYS_CONNECT:

799 ret = sys_connect(a0, compat_ptr(a1), a[2]);

800 break;

801 case SYS_LISTEN:

802 ret = sys_listen(a0, a1);

803 break;

804 case SYS_ACCEPT:

805 ret = sys_accept4(a0, compat_ptr(a1), compat_ptr(a[2]), 0);

806 break;

807 case SYS_GETSOCKNAME:

808 ret = sys_getsockname(a0, compat_ptr(a1), compat_ptr(a[2]));

809 break;

810 case SYS_GETPEERNAME:

811 ret = sys_getpeername(a0, compat_ptr(a1), compat_ptr(a[2]));

812 break;

813 case SYS_SOCKETPAIR:

814 ret = sys_socketpair(a0, a1, a[2], compat_ptr(a[3]));

815 break;

816 case SYS_SEND:

817 ret = sys_send(a0, compat_ptr(a1), a[2], a[3]);

818 break;

819 case SYS_SENDTO:

820 ret = sys_sendto(a0, compat_ptr(a1), a[2], a[3], compat_ptr(a[4]), a[5]);

821 break;

822 case SYS_RECV:

823 ret = compat_sys_recv(a0, compat_ptr(a1), a[2], a[3]);

824 break;

825 case SYS_RECVFROM:

826 ret = compat_sys_recvfrom(a0, compat_ptr(a1), a[2], a[3],

827 compat_ptr(a[4]), compat_ptr(a[5]));

828 break;

829 case SYS_SHUTDOWN:

830 ret = sys_shutdown(a0,a1);

831 break;

832 case SYS_SETSOCKOPT:

833 ret = compat_sys_setsockopt(a0, a1, a[2],

834 compat_ptr(a[3]), a[4]);

835 break;

836 case SYS_GETSOCKOPT:

837 ret = compat_sys_getsockopt(a0, a1, a[2],

838 compat_ptr(a[3]), compat_ptr(a[4]));

839 break;

840 case SYS_SENDMSG:

841 ret = compat_sys_sendmsg(a0, compat_ptr(a1), a[2]);

842 break;

843 case SYS_RECVMSG:

844 ret = compat_sys_recvmsg(a0, compat_ptr(a1), a[2]);

845 break;

846 case SYS_RECVMMSG:

847 ret = compat_sys_recvmmsg(a0, compat_ptr(a1), a[2], a[3],

848 compat_ptr(a[4]));

849 break;

850 case SYS_ACCEPT4:

851 ret = sys_accept4(a0, compat_ptr(a1), compat_ptr(a[2]), a[3]);

852 break;

853 default:

854 ret = -EINVAL;

855 break;

856 }

857 return ret;

858 }