1 /* scm.c - Socket level control messages processing.
3 * Author: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
4 * Alignment and value checking mods by Craig Metz
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
12 #include <linux/signal.h>
13 #include <linux/errno.h>
14 #include <linux/sched.h>
16 #include <linux/kernel.h>
17 #include <linux/major.h>
18 #include <linux/stat.h>
19 #include <linux/socket.h>
20 #include <linux/file.h>
21 #include <linux/fcntl.h>
22 #include <linux/net.h>
23 #include <linux/interrupt.h>
24 #include <linux/netdevice.h>
26 #include <asm/system.h>
27 #include <asm/uaccess.h>
29 #include <linux/inet.h>
30 #include <linux/netdevice.h>
32 #include <net/protocol.h>
36 #include <linux/skbuff.h>
42 * Only allow a user to send credentials, that they could set with
46 static __inline__
int scm_check_creds(struct ucred
*creds
)
48 if ((creds
->pid
== current
->pid
|| capable(CAP_SYS_ADMIN
)) &&
49 ((creds
->uid
== current
->uid
|| creds
->uid
== current
->euid
||
50 creds
->uid
== current
->suid
) || capable(CAP_SETUID
)) &&
51 ((creds
->gid
== current
->gid
|| creds
->gid
== current
->egid
||
52 creds
->gid
== current
->sgid
) || capable(CAP_SETGID
))) {
58 static int scm_fp_copy(struct cmsghdr
*cmsg
, struct scm_fp_list
**fplp
)
60 int *fdp
= (int*)CMSG_DATA(cmsg
);
61 struct scm_fp_list
*fpl
= *fplp
;
65 num
= (cmsg
->cmsg_len
- CMSG_ALIGN(sizeof(struct cmsghdr
)))/sizeof(int);
75 fpl
= kmalloc(sizeof(struct scm_fp_list
), GFP_KERNEL
);
81 fpp
= &fpl
->fp
[fpl
->count
];
83 if (fpl
->count
+ num
> SCM_MAX_FD
)
87 * Verify the descriptors and increment the usage count.
90 for (i
=0; i
< num
; i
++)
95 if (fd
< 0 || !(file
= fget(fd
)))
103 void __scm_destroy(struct scm_cookie
*scm
)
105 struct scm_fp_list
*fpl
= scm
->fp
;
110 for (i
=fpl
->count
-1; i
>=0; i
--)
116 int __scm_send(struct socket
*sock
, struct msghdr
*msg
, struct scm_cookie
*p
)
118 struct cmsghdr
*cmsg
;
121 for (cmsg
= CMSG_FIRSTHDR(msg
); cmsg
; cmsg
= CMSG_NXTHDR(msg
, cmsg
))
125 /* Verify that cmsg_len is at least sizeof(struct cmsghdr) */
126 if ((unsigned long)(((char*)cmsg
- (char*)msg
->msg_control
)
127 + cmsg
->cmsg_len
) > msg
->msg_controllen
)
130 if (cmsg
->cmsg_level
!= SOL_SOCKET
)
133 switch (cmsg
->cmsg_type
)
136 err
=scm_fp_copy(cmsg
, &p
->fp
);
140 case SCM_CREDENTIALS
:
141 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof(struct ucred
)))
143 memcpy(&p
->creds
, CMSG_DATA(cmsg
), sizeof(struct ucred
));
144 err
= scm_check_creds(&p
->creds
);
153 if (p
->fp
&& !p
->fp
->count
)
160 if (msg
->msg_flags
& MSG_CTLFLAGS
)
170 int put_cmsg(struct msghdr
* msg
, int level
, int type
, int len
, void *data
)
172 struct cmsghdr
*cm
= (struct cmsghdr
*)msg
->msg_control
;
173 struct cmsghdr cmhdr
;
174 int cmlen
= CMSG_LEN(len
);
177 if (cm
==NULL
|| msg
->msg_controllen
< sizeof(*cm
)) {
178 msg
->msg_flags
|= MSG_CTRUNC
;
179 return 0; /* XXX: return error? check spec. */
181 if (msg
->msg_controllen
< cmlen
) {
182 msg
->msg_flags
|= MSG_CTRUNC
;
183 cmlen
= msg
->msg_controllen
;
185 cmhdr
.cmsg_level
= level
;
186 cmhdr
.cmsg_type
= type
;
187 cmhdr
.cmsg_len
= cmlen
;
190 if (copy_to_user(cm
, &cmhdr
, sizeof cmhdr
))
192 if (copy_to_user(CMSG_DATA(cm
), data
, cmlen
- sizeof(struct cmsghdr
)))
194 cmlen
= CMSG_SPACE(len
);
195 msg
->msg_control
+= cmlen
;
196 msg
->msg_controllen
-= cmlen
;
202 void scm_detach_fds(struct msghdr
*msg
, struct scm_cookie
*scm
)
204 struct cmsghdr
*cm
= (struct cmsghdr
*)msg
->msg_control
;
206 int fdmax
= (msg
->msg_controllen
- sizeof(struct cmsghdr
))/sizeof(int);
207 int fdnum
= scm
->fp
->count
;
208 struct file
**fp
= scm
->fp
->fp
;
215 for (i
=0, cmfptr
=(int*)CMSG_DATA(cm
); i
<fdmax
; i
++, cmfptr
++)
218 err
= get_unused_fd();
222 err
= put_user(new_fd
, cmfptr
);
224 put_unused_fd(new_fd
);
227 /* Bump the usage count and install the file. */
229 current
->files
->fd
[new_fd
] = fp
[i
];
234 int cmlen
= CMSG_LEN(i
*sizeof(int));
236 err
= put_user(SOL_SOCKET
, &cm
->cmsg_level
);
238 err
= put_user(SCM_RIGHTS
, &cm
->cmsg_type
);
240 err
= put_user(cmlen
, &cm
->cmsg_len
);
242 cmlen
= CMSG_SPACE(i
*sizeof(int));
243 msg
->msg_control
+= cmlen
;
244 msg
->msg_controllen
-= cmlen
;
248 msg
->msg_flags
|= MSG_CTRUNC
;
251 * All of the files that fit in the message have had their
252 * usage counts incremented, so we just free the list.
257 struct scm_fp_list
*scm_fp_dup(struct scm_fp_list
*fpl
)
259 struct scm_fp_list
*new_fpl
;
265 new_fpl
= kmalloc(sizeof(*fpl
), GFP_KERNEL
);
267 memcpy(new_fpl
, fpl
, sizeof(*fpl
));
269 for (i
=fpl
->count
-1; i
>=0; i
--)
270 fpl
->fp
[i
]->f_count
++;