1 /*----------------------------------------------------------------------*
2  * File:	rxvtd.C
3  *----------------------------------------------------------------------*
4  *
5  * All portions of code are copyright by their respective author/s.
6  * Copyright (c) 2003-2007 Marc Lehmann <schmorp@schmorp.de>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  *----------------------------------------------------------------------*/
22 
23 #include "../config.h"
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <stdarg.h>
27 #include <string.h>
28 
29 #include <unistd.h>
30 #include <fcntl.h>
31 #include <sys/types.h>
32 #include <sys/stat.h>
33 #include <sys/socket.h>
34 #include <sys/un.h>
35 
36 #if defined(ENABLE_FRILLS) && defined(_POSIX_MEMLOCK) && _POSIX_MEMLOCK > 0
37 # define ENABLE_MLOCK 1
38 #endif
39 
40 #if ENABLE_MLOCK
41 # include <sys/mman.h>
42 #endif
43 
44 #include <errno.h>
45 
46 #include <libptytty.h>
47 
48 #include "rxvt.h"
49 #include "rxvtdaemon.h"
50 
51 struct server : rxvt_connection
52 {
53   log_callback log_cb;
54   getfd_callback getfd_cb;
55 
56   void read_cb (ev::io &w, int revents); ev::io read_ev;
57   void log_msg (const char *msg);
58   int getfd (int remote_fd);
59 
serverserver60   server (int fd)
61   {
62     read_ev.set <server, &server::read_cb> (this);
63     log_cb.set  <server, &server::log_msg> (this);
64     getfd_cb.set<server, &server::getfd>   (this);
65 
66     this->fd = fd;
67     fcntl (fd, F_SETFD, FD_CLOEXEC);
68     fcntl (fd, F_SETFL, 0);
69     read_ev.start (fd, ev::READ);
70   }
71 
72   void err (const char *format = 0, ...);
73 };
74 
75 struct unix_listener
76 {
77   int fd;
78 
79   void accept_cb (ev::io &w, int revents); ev::io accept_ev;
80 
81   unix_listener (int fd);
82   static int open (const char *sockname);
83 };
84 
unix_listener(int fd)85 unix_listener::unix_listener (int fd) : fd (fd)
86 {
87   accept_ev.set<unix_listener, &unix_listener::accept_cb> (this);
88   fcntl (fd, F_SETFD, FD_CLOEXEC);
89   fcntl (fd, F_SETFL, O_NONBLOCK);
90   accept_ev.start (fd, ev::READ);
91 }
92 
open(const char * sockname)93 int unix_listener::open (const char *sockname)
94 {
95   sockaddr_un sa;
96 
97   if (strlen (sockname) >= sizeof(sa.sun_path))
98     {
99       fputs ("socket name too long, aborting.\n", stderr);
100       exit (EXIT_FAILURE);
101     }
102 
103   int fd;
104   if ((fd = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
105     {
106       perror ("unable to create listening socket");
107       exit (EXIT_FAILURE);
108     }
109 
110   sa.sun_family = AF_UNIX;
111   strcpy (sa.sun_path, sockname);
112 
113   unlink (sockname);
114 
115   mode_t omask = umask (0077);
116 
117   if (bind (fd, (sockaddr *)&sa, sizeof (sa)))
118     {
119       perror ("unable to bind listening socket");
120       exit (EXIT_FAILURE);
121     }
122 
123   umask (omask);
124 
125   if (listen (fd, 5))
126     {
127       perror ("unable to listen on socket");
128       exit (EXIT_FAILURE);
129     }
130 
131   return fd;
132 }
133 
accept_cb(ev::io & w,int revents)134 void unix_listener::accept_cb (ev::io &w, int revents)
135 {
136   int fd2 = accept (fd, 0, 0);
137 
138   if (fd2 >= 0)
139     new server (fd2);
140 }
141 
getfd(int remote_fd)142 int server::getfd (int remote_fd)
143 {
144   send ("GETFD");
145   send (remote_fd);
146   return ptytty::recv_fd (fd);
147 }
148 
log_msg(const char * msg)149 void server::log_msg (const char *msg)
150 {
151   send ("MSG"), send (msg);
152 }
153 
err(const char * format,...)154 void server::err (const char *format, ...)
155 {
156   if (format)
157     {
158       char err[1024];
159 
160       va_list ap;
161       va_start (ap, format);
162       vsnprintf (err, 1024, format, ap);
163       va_end (ap);
164 
165       log_msg (err);
166     }
167 
168   send ("END"), send (0);
169   close (fd);
170   delete this;
171 }
172 
read_cb(ev::io & w,int revents)173 void server::read_cb (ev::io &w, int revents)
174 {
175   auto_str tok;
176 
177   if (recv (tok))
178     {
179       if (!strcmp (tok, "NEW"))
180         {
181           stringvec *argv = new stringvec;
182           stringvec *envv = new stringvec;
183 
184           for (;;)
185             {
186               if (!recv (tok))
187                 return err ();
188 
189               if (!strcmp (tok, "END"))
190                 break;
191               else if (!strcmp (tok, "ENV") && recv (tok))
192                 envv->push_back (strdup (tok));
193               else if (!strcmp (tok, "ARG") && recv (tok))
194                 argv->push_back (strdup (tok));
195               else
196                 return err ("protocol error: unexpected NEW token.\n");
197             }
198 
199           {
200             rxvt_term *term = new rxvt_term;
201 
202             term->log_hook = &log_cb;
203             term->getfd_hook = &getfd_cb;
204 
205             bool success = true;
206 
207             try
208               {
209                 term->init (argv, envv);
210               }
211             catch (const std::exception &e)
212               {
213                 log_msg (e.what());
214                 success = false;
215               }
216 
217             term->log_hook = 0;
218 
219             chdir ("/"); // init might change to different working directory
220 
221             if (!success)
222               term->destroy ();
223 
224             send ("END"); send (success ? 1 : 0);
225           }
226         }
227       else if (!strcmp (tok, "QUIT"))
228         _exit (0);
229       else
230         return err ("protocol error: request '%s' unsupported.\n", (char *)tok);
231     }
232   else
233     return err ();
234 }
235 
236 #ifdef ENABLE_FRILLS
237 enum {
238   SD_LISTEN_FDS_START = 3,
239 };
240 
241 // https://www.freedesktop.org/software/systemd/man/sd_listen_fds.html
242 // https://github.com/systemd/systemd/blob/main/src/libsystemd/sd-daemon/sd-daemon.c
get_listen_fds()243 static int get_listen_fds ()
244 {
245   const char *listen_pid = getenv ("LISTEN_PID");
246   if (!listen_pid)
247     return 0;
248 
249   char *end;
250   errno = 0;
251   long pid = strtol (listen_pid, &end, 10);
252   if (errno || end == listen_pid || *end)
253     return -1;
254 
255   if (getpid () != pid)
256     return 0;
257 
258   const char *listen_fds = getenv ("LISTEN_FDS");
259   if (!listen_fds)
260     return 0;
261 
262   errno = 0;
263   long n = strtol (listen_fds, &end, 10);
264   if (errno || end == listen_fds || *end)
265     return -1;
266 
267   if (n <= 0 || n > INT_MAX - SD_LISTEN_FDS_START)
268     return -1;
269 
270   unsetenv ("LISTEN_PID");
271   unsetenv ("LISTEN_FDS");
272   unsetenv ("LISTEN_FDNAMES");
273 
274   return n;
275 }
276 #endif
277 
278 int
main(int argc,char * argv[])279 main (int argc, char *argv[])
280 {
281   try
282     {
283       ptytty::init ();
284     }
285   catch (const std::exception &e)
286     {
287       fputs (e.what (), stderr);
288       return EXIT_FAILURE;
289     }
290 
291   static char opt_fork, opt_opendisplay, opt_quiet;
292 #if ENABLE_PERL
293   static char *opt_eval;
294 #endif
295 #if ENABLE_MLOCK
296   static char opt_lock;
297 #endif
298 
299   for (int i = 1; i < argc; i++)
300     {
301       if (!strcmp (argv [i], "-f") || !strcmp (argv [i], "--fork"))
302         opt_fork = 1;
303       else if (!strcmp (argv [i], "-o") || !strcmp (argv [i], "--opendisplay"))
304         opt_opendisplay = 1;
305       else if (!strcmp (argv [i], "-q") || !strcmp (argv [i], "--quiet"))
306         opt_quiet = 1;
307 #if ENABLE_MLOCK
308       else if (!strcmp (argv [i], "-m") || !strcmp (argv [i], "--mlock"))
309         opt_lock = 1;
310 #endif
311 #if ENABLE_PERL
312       else if (!strcmp (argv [i], "-e") || !strcmp (argv [i], "--eval"))
313         opt_eval = argv [++i];
314 #endif
315       else
316         {
317           rxvt_log ("%s: unknown option '%s', aborting.\n", argv [0], argv [i]);
318           return EXIT_FAILURE;
319         }
320     }
321 
322   rxvt_init ();
323 
324 #if ENABLE_PERL
325   if (opt_eval)
326     {
327       rxvt_perl.init ();
328       rxvt_perl.eval (opt_eval);
329     }
330 #endif
331 
332   // optionally open display and never release it.
333   if (opt_opendisplay)
334     if (const char *dpy = getenv ("DISPLAY"))
335       displays.get (dpy ? dpy : ":0"); // move string logic into rxvt_display maybe?
336 
337   int fd;
338 #ifdef ENABLE_FRILLS
339   int n = get_listen_fds ();
340   if (n > 1)
341     {
342       fputs ("received multiple file descriptors, aborting.\n", stderr);
343       exit (EXIT_FAILURE);
344     }
345   else if (n == 1)
346     {
347       fd = SD_LISTEN_FDS_START;
348       if (!opt_quiet)
349         {
350           printf ("rxvt-unicode daemon listening on fd.\n");
351           fflush (stdout);
352         }
353     }
354   else
355 #endif
356     {
357       char *sockname = rxvt_connection::unix_sockname ();
358       fd = unix_listener::open (sockname);
359       if (!opt_quiet)
360         {
361           printf ("rxvt-unicode daemon listening on %s.\n", sockname);
362           fflush (stdout);
363         }
364       free (sockname);
365     }
366 
367   unix_listener l (fd);
368 
369   chdir ("/");
370 
371   pid_t pid = 0;
372   if (opt_fork)
373     {
374       pid = fork ();
375     }
376 
377 #if ENABLE_MLOCK
378   // Optionally perform an mlockall so this process does not get swapped out.
379   if (opt_lock && !pid)
380     if (mlockall (MCL_CURRENT | MCL_FUTURE) < 0)
381       perror ("unable to lock into ram");
382 #endif
383 
384   if (opt_fork)
385     {
386       if (pid < 0)
387         {
388           rxvt_log ("unable to fork daemon, aborting.\n");
389           return EXIT_FAILURE;
390         }
391       else if (pid > 0)
392         _exit (EXIT_SUCCESS);
393 
394       ev_loop_fork (EV_DEFAULT_UC);
395     }
396 
397   ev_run ();
398 
399   return EXIT_SUCCESS;
400 }
401 
402