sap: Properly manage object memory.
[vlc.git] / src / network / rootwrap.c
1 /*****************************************************************************
2  * rootwrap.c
3  *****************************************************************************
4  * Copyright © 2005 Rémi Denis-Courmont
5  * $Id$
6  *
7  * Author: Rémi Denis-Courmont <rem # videolan.org>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 #if HAVE_CONFIG_H
25 # include <config.h>
26 #endif
27
28 #if defined (HAVE_GETEUID) && !defined (SYS_BEOS)
29 # define ENABLE_ROOTWRAP 1
30 #endif
31
32 #ifdef ENABLE_ROOTWRAP
33
34 #include <stdlib.h> /* exit() */
35 #include <stdio.h>
36 #include <string.h>
37
38 #include <sys/types.h>
39 #include <unistd.h>
40 #include <fcntl.h>
41 #include <sys/socket.h>
42 #ifdef HAVE_SYS_TIME_H
43 #include <sys/time.h>
44 #endif
45 #include <sys/uio.h>
46 #include <sys/resource.h> /* getrlimit() */
47 #include <sys/wait.h>
48 #include <sys/un.h>
49 #include <pwd.h> /* getpwnam(), getpwuid() */
50 #include <grp.h> /* setgroups() */
51 #include <errno.h>
52 #include <netinet/in.h>
53 #include <pthread.h>
54
55 #if defined (AF_INET6) && !defined (IPV6_V6ONLY)
56 # warning Uho, your IPv6 support is broken and has been disabled. Fix your C library.
57 # undef AF_INET6
58 #endif
59
60 #ifndef AF_LOCAL
61 # define AF_LOCAL AF_UNIX
62 #endif
63
64 /*#ifndef HAVE_CLEARENV
65 extern char **environ;
66
67 static int clearenv (void)
68 {
69     environ = NULL;
70     return 0;
71 }
72 #endif*/
73
74 /**
75  * Tries to find a real non-root user to use
76  */
77 static struct passwd *guess_user (void)
78 {
79     const char *name;
80     struct passwd *pw;
81     uid_t uid;
82
83     /* Try real UID */
84     uid = getuid ();
85     if (uid)
86         if ((pw = getpwuid (uid)) != NULL)
87             return pw;
88
89     /* Try sudo */
90     name = getenv ("SUDO_USER");
91     if (name != NULL)
92         if ((pw = getpwnam (name)) != NULL)
93             return pw;
94
95     /* Try VLC_USER */
96     name = getenv ("VLC_USER");
97     if (name != NULL)
98         if ((pw = getpwnam (name)) != NULL)
99             return pw;
100
101     /* Try vlc */
102     if ((pw = getpwnam ("vlc")) != NULL)
103         return pw;
104
105     return getpwuid (0);
106 }
107
108
109 static int is_allowed_port (uint16_t port)
110 {
111     port = ntohs (port);
112
113     return (port == 80) || (port == 443) || (port == 554);
114 }
115
116
117 static int send_err (int fd, int err)
118 {
119     return send (fd, &err, sizeof (err), 0) == sizeof (err) ? 0 : -1;
120 }
121
122 /**
123  * Ugly POSIX(?) code to pass a file descriptor to another process
124  */
125 static int send_fd (int p, int fd)
126 {
127     struct msghdr hdr;
128     struct iovec iov;
129     struct cmsghdr *cmsg;
130     char buf[CMSG_SPACE (sizeof (fd))];
131     int val = 0;
132
133     hdr.msg_name = NULL;
134     hdr.msg_namelen = 0;
135     hdr.msg_iov = &iov;
136     hdr.msg_iovlen = 1;
137     hdr.msg_control = buf;
138     hdr.msg_controllen = sizeof (buf);
139
140     iov.iov_base = &val;
141     iov.iov_len = sizeof (val);
142
143     cmsg = CMSG_FIRSTHDR (&hdr);
144     cmsg->cmsg_level = SOL_SOCKET;
145     cmsg->cmsg_type = SCM_RIGHTS;
146     cmsg->cmsg_len = CMSG_LEN (sizeof (fd));
147     memcpy (CMSG_DATA (cmsg), &fd, sizeof (fd));
148     hdr.msg_controllen = cmsg->cmsg_len;
149
150     return sendmsg (p, &hdr, 0) == sizeof (val) ? 0 : -1;
151 }
152
153
154 /**
155  * Background process run as root to open privileged TCP ports.
156  */
157 static void rootprocess (int fd)
158 {
159     struct sockaddr_storage ss;
160
161     /* TODO:
162      *  - use libcap if available,
163      *  - call chroot
164      */
165     while (recv (fd, &ss, sizeof (ss), 0) == sizeof (ss))
166     {
167         unsigned len;
168         int sock;
169
170         switch (ss.ss_family)
171         {
172             case AF_INET:
173                 if (!is_allowed_port (((struct sockaddr_in *)&ss)->sin_port))
174                 {
175                     if (send_err (fd, EACCES))
176                         return;
177                     continue;
178                 }
179                 len = sizeof (struct sockaddr_in);
180                 break;
181
182 #ifdef AF_INET6
183             case AF_INET6:
184                 if (!is_allowed_port (((struct sockaddr_in6 *)&ss)->sin6_port))
185                 {
186                     if (send_err (fd, EACCES))
187                         return;
188                     continue;
189                 }
190                 len = sizeof (struct sockaddr_in6);
191                 break;
192 #endif
193
194             default:
195                 if (send_err (fd, EAFNOSUPPORT))
196                     return;
197                 continue;
198         }
199
200         sock = socket (ss.ss_family, SOCK_STREAM, IPPROTO_TCP);
201         if (sock != -1)
202         {
203             const int val = 1;
204
205             setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, &val, sizeof (val));
206 #ifdef AF_INET6
207             if (ss.ss_family == AF_INET6)
208                 setsockopt (sock, IPPROTO_IPV6, IPV6_V6ONLY, &val, sizeof (val));
209 #endif
210             if (bind (sock, (struct sockaddr *)&ss, len) == 0)
211             {
212                 send_fd (fd, sock);
213                 close (sock);
214                 continue;
215             }
216         }
217         send_err (fd, errno);
218     }
219 }
220
221 static int rootwrap_sock = -1;
222 static pid_t rootwrap_pid = -1;
223
224 static void close_rootwrap (void)
225 {
226     close (rootwrap_sock);
227     waitpid (rootwrap_pid, NULL, 0);
228 }
229
230 void rootwrap (void)
231 {
232     struct rlimit lim;
233     int fd, pair[2];
234     struct passwd *pw;
235     uid_t u;
236
237     u = geteuid ();
238     /* Are we running with root privileges? */
239     if (u != 0)
240     {
241         setuid (u);
242         return;
243     }
244
245     /* Make sure 0, 1 and 2 are opened, and only these. */
246     if (getrlimit (RLIMIT_NOFILE, &lim))
247         exit (1);
248
249     for (fd = 3; ((unsigned)fd) < lim.rlim_cur; fd++)
250         close (fd);
251
252     fd = dup (2);
253     if (fd <= 2)
254         exit (1);
255     close (fd);
256
257     fputs ("starting VLC root wrapper...", stderr);
258
259     pw = guess_user ();
260     if (pw == NULL)
261         return; /* Should we rather print an error and exit ? */
262
263     u = pw->pw_uid,
264     fprintf (stderr, " using UID %u (%s)\n", (unsigned)u, pw->pw_name);
265     if (u == 0)
266     {
267         fputs ("***************************************\n"
268                "* Running VLC as root is discouraged. *\n"
269                "***************************************\n"
270                "\n"
271                " It is potentially dangerous, "
272                 "and might not even work properly.\n", stderr);
273         return;
274     }
275
276     /* GID */
277     initgroups (pw->pw_name, pw->pw_gid);
278     setgid (pw->pw_gid);
279
280     if (socketpair (AF_LOCAL, SOCK_STREAM, 0, pair))
281     {
282         perror ("socketpair");
283         goto nofork;
284     }
285
286     switch (rootwrap_pid = fork ())
287     {
288         case -1:
289             perror ("fork");
290             close (pair[0]);
291             close (pair[1]);
292             break;
293
294         case 0:
295             close (0);
296             close (1);
297             close (2);
298             close (pair[0]);
299             rootprocess (pair[1]);
300             exit (0);
301
302         default:
303             close (pair[1]);
304             rootwrap_sock = pair[0];
305             break;
306     }
307
308 nofork:
309     /* UID */
310     setuid (u);
311
312     atexit (close_rootwrap);
313 }
314
315
316 /**
317  * Ugly POSIX(?) code to receive a file descriptor from another process
318  */
319 static int recv_fd (int p)
320 {
321     struct msghdr hdr;
322     struct iovec iov;
323     struct cmsghdr *cmsg;
324     int val, fd;
325     char buf[CMSG_SPACE (sizeof (fd))];
326
327     hdr.msg_name = NULL;
328     hdr.msg_namelen = 0;
329     hdr.msg_iov = &iov;
330     hdr.msg_iovlen = 1;
331     hdr.msg_control = buf;
332     hdr.msg_controllen = sizeof (buf);
333
334     iov.iov_base = &val;
335     iov.iov_len = sizeof (val);
336
337     if (recvmsg (p, &hdr, 0) != sizeof (val))
338         return -1;
339
340     for (cmsg = CMSG_FIRSTHDR (&hdr); cmsg != NULL;
341          cmsg = CMSG_NXTHDR (&hdr, cmsg))
342     {
343         if ((cmsg->cmsg_level == SOL_SOCKET)
344          && (cmsg->cmsg_type = SCM_RIGHTS)
345          && (cmsg->cmsg_len >= CMSG_LEN (sizeof (fd))))
346         {
347             memcpy (&fd, CMSG_DATA (cmsg), sizeof (fd));
348             return fd;
349         }
350     }
351
352     return -1;
353 }
354
355 /**
356  * Tries to obtain a bound TCP socket from the root process
357  */
358 int rootwrap_bind (int family, int socktype, int protocol,
359                    const struct sockaddr *addr, size_t alen)
360 {
361     /* can't use libvlc */
362     static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
363
364     struct sockaddr_storage ss;
365     int fd;
366
367     if (rootwrap_sock == -1)
368     {
369         errno = EACCES;
370         return -1;
371     }
372
373     switch (family)
374     {
375         case AF_INET:
376             if (alen < sizeof (struct sockaddr_in))
377             {
378                 errno = EINVAL;
379                 return -1;
380             }
381             break;
382
383 #ifdef AF_INET6
384         case AF_INET6:
385             if (alen < sizeof (struct sockaddr_in6))
386             {
387                 errno = EINVAL;
388                 return -1;
389             }
390             break;
391 #endif
392
393         default:
394             errno = EAFNOSUPPORT;
395             return -1;
396     }
397
398     if (family != addr->sa_family)
399     {
400         errno = EAFNOSUPPORT;
401         return -1;
402     }
403
404     /* Only TCP is implemented at the moment */
405     if ((socktype != SOCK_STREAM)
406      || (protocol && (protocol != IPPROTO_TCP)))
407     {
408         errno = EACCES;
409         return -1;
410     }
411
412     memset (&ss, 0, sizeof (ss));
413     memcpy (&ss, addr, alen > sizeof (ss) ? sizeof (ss) : alen);
414
415     pthread_mutex_lock (&mutex);
416     if (send (rootwrap_sock, &ss, sizeof (ss), 0) != sizeof (ss))
417         return -1;
418
419     fd = recv_fd (rootwrap_sock);
420     pthread_mutex_unlock (&mutex);
421
422     if (fd != -1)
423     {
424         int val;
425
426         val = fcntl (fd, F_GETFL, 0);
427         fcntl (fd, F_SETFL, ((val != -1) ? val : 0) | O_NONBLOCK);
428     }
429
430     return fd;
431 }
432
433 #else
434 # include <stddef.h>
435
436 struct sockaddr;
437
438 void rootwrap (void)
439 {
440 }
441
442 int rootwrap_bind (int family, int socktype, int protocol,
443                    const struct sockaddr *addr, size_t alen)
444 {
445     (void)family;
446     (void)socktype;
447     (void)protocol;
448     (void)addr;
449     (void)alen;
450     return -1;
451 }
452
453 #endif /* ENABLE_ROOTWRAP */