src/rxvtd.C

   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 <pcg@goof.com>
   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 2 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 <cstdio>
  25 #include <cstdlib>
  26 #include <cstdarg>
  27 #include <cstring>
  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 <cerrno>
  45
  46 #include "rxvt.h"
  47 #include "rxvtdaemon.h"
  48 #include "libptytty.h"
  49
  50 struct server : rxvt_connection {
  51   log_callback log_cb;
  52   getfd_callback getfd_cb;
  53
  54   void read_cb (ev::io &w, int revents); ev::io read_ev;
  55   void log_msg (const char *msg);
  56   int getfd (int remote_fd);
  57
  58   server (int fd)
  59   {
  60     read_ev.set <server, &server::read_cb> (this);
  61     log_cb.set  <server, &server::log_msg> (this);
  62     getfd_cb.set<server, &server::getfd>   (this);
  63
  64     this->fd = fd;
  65     fcntl (fd, F_SETFD, FD_CLOEXEC);
  66     fcntl (fd, F_SETFL, 0);
  67     read_ev.start (fd, ev::READ);
  68   }
  69
  70   void err (const char *format = 0, ...);
  71 };
  72
  73 struct unix_listener {
  74   int fd;
  75
  76   void accept_cb (ev::io &w, int revents); ev::io accept_ev;
  77
  78   unix_listener (const char *sockname);
  79 };
  80
  81 unix_listener::unix_listener (const char *sockname)
  82 {
  83   accept_ev.set<unix_listener, &unix_listener::accept_cb> (this);
  84
  85   sockaddr_un sa;
  86
  87   if (strlen (sockname) >= sizeof(sa.sun_path))
  88     {
  89       fputs ("socket name too long, aborting.\n", stderr);
  90       exit (EXIT_FAILURE);
  91     }
  92
  93   if ((fd = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
  94     {
  95       perror ("unable to create listening socket");
  96       exit (EXIT_FAILURE);
  97     }
  98
  99   fcntl (fd, F_SETFD, FD_CLOEXEC);
 100   fcntl (fd, F_SETFL, O_NONBLOCK);
 101
 102   sa.sun_family = AF_UNIX;
 103   strcpy (sa.sun_path, sockname);
 104
 105   unlink (rxvt_connection::unix_sockname ());
 106
 107   mode_t omask = umask (0077);
 108
 109   if (bind (fd, (sockaddr *)&sa, sizeof (sa)))
 110     {
 111       perror ("unable to bind listening socket");
 112       exit (EXIT_FAILURE);
 113     }
 114
 115   umask (omask);
 116
 117   if (listen (fd, 5))
 118     {
 119       perror ("unable to listen on socket");
 120       exit (EXIT_FAILURE);
 121     }
 122
 123   accept_ev.start (fd, ev::READ);
 124 }
 125
 126 void unix_listener::accept_cb (ev::io &w, int revents)
 127 {
 128   int fd2 = accept (fd, 0, 0);
 129
 130   if (fd2 >= 0)
 131     new server (fd2);
 132 }
 133
 134 int server::getfd (int remote_fd)
 135 {
 136   send ("GETFD");
 137   send (remote_fd);
 138   return ptytty::recv_fd (fd);
 139 }
 140
 141 void server::log_msg (const char *msg)
 142 {
 143   send ("MSG"), send (msg);
 144 }
 145
 146 void server::err (const char *format, ...)
 147 {
 148   if (format)
 149     {
 150       char err[1024];
 151
 152       va_list ap;
 153       va_start (ap, format);
 154       vsnprintf (err, 1024, format, ap);
 155       va_end (ap);
 156
 157       log_msg (err);
 158     }
 159
 160   send ("END"), send (0);
 161   close (fd);
 162   delete this;
 163 }
 164
 165 void server::read_cb (ev::io &w, int revents)
 166 {
 167   auto_str tok;
 168
 169   if (recv (tok))
 170     {
 171       if (!strcmp (tok, "NEW"))
 172         {
 173           stringvec *argv = new stringvec;
 174           stringvec *envv = new stringvec;
 175
 176           for (;;)
 177             {
 178               if (!recv (tok))
 179                 return err ();
 180
 181               if (!strcmp (tok, "END"))
 182                 break;
 183               else if (!strcmp (tok, "ENV") && recv (tok))
 184                 envv->push_back (strdup (tok));
 185               else if (!strcmp (tok, "ARG") && recv (tok))
 186                 argv->push_back (strdup (tok));
 187               else
 188                 return err ("protocol error: unexpected NEW token.\n");
 189             }
 190
 191           envv->push_back (0);
 192
 193           {
 194             rxvt_term *term = new rxvt_term;
 195
 196             term->log_hook = &log_cb;
 197             term->getfd_hook = &getfd_cb;
 198
 199             bool success = true;
 200
 201             try
 202               {
 203                 term->init (argv, envv);
 204               }
 205             catch (const class rxvt_failure_exception &e)
 206               {
 207                 success = false;
 208               }
 209
 210             term->log_hook = 0;
 211
 212             chdir ("/"); // init might change to different working directory
 213
 214             if (!success)
 215               term->destroy ();
 216
 217             send ("END"); send (success ? 1 : 0);
 218           }
 219         }
 220       else
 221         return err ("protocol error: request '%s' unsupported.\n", (char *)tok);
 222     }
 223   else
 224     return err ();
 225 }
 226
 227 int opt_fork, opt_opendisplay, opt_quiet;
 228 #if ENABLE_MLOCK
 229 int opt_lock;
 230 #endif
 231
 232 int
 233 main (int argc, const char *const *argv)
 234 {
 235   rxvt_init ();
 236
 237   for (int i = 1; i < argc; i++)
 238     {
 239       if (!strcmp (argv [i], "-f") || !strcmp (argv [i], "--fork"))
 240         opt_fork = 1;
 241       else if (!strcmp (argv [i], "-o") || !strcmp (argv [i], "--opendisplay"))
 242         opt_opendisplay = 1;
 243       else if (!strcmp (argv [i], "-q") || !strcmp (argv [i], "--quiet"))
 244         opt_quiet = 1;
 245 #if ENABLE_MLOCK
 246       else if (!strcmp (argv [i], "-m") || !strcmp (argv [i], "--mlock"))
 247         opt_lock = 1;
 248 #endif
 249       else
 250         {
 251           rxvt_log ("%s: unknown option '%s', aborting.\n", argv [0], argv [i]);
 252           return EXIT_FAILURE;
 253         }
 254     }
 255
 256   // optionally open display and never release it.
 257   if (opt_opendisplay)
 258     if (const char *dpy = getenv ("DISPLAY"))
 259       displays.get (dpy ? dpy : ":0"); // move string logic into rxvt_display maybe?
 260
 261   char *sockname = rxvt_connection::unix_sockname ();
 262   unix_listener l (sockname);
 263
 264   chdir ("/");
 265
 266   if (!opt_quiet)
 267     {
 268       printf ("rxvt-unicode daemon listening on %s.\n", sockname);
 269       fflush (stdout);
 270     }
 271
 272   free (sockname);
 273
 274   pid_t pid = 0;
 275   if (opt_fork)
 276     {
 277       pid = fork ();
 278     }
 279
 280 #if ENABLE_MLOCK
 281   // Optionally perform an mlockall so this process does not get swapped out.
 282   if (opt_lock && !pid)
 283     if (mlockall (MCL_CURRENT | MCL_FUTURE) < 0)
 284       perror ("unable to lock into ram");
 285 #endif
 286
 287   if (opt_fork)
 288     {
 289       if (pid < 0)
 290         {
 291           rxvt_log ("unable to fork daemon, aborting.\n");
 292           return EXIT_FAILURE;
 293         }
 294       else if (pid > 0)
 295         _exit (EXIT_SUCCESS);
 296
 297       ev_default_fork ();
 298     }
 299
 300   ev_loop (0);
 301
 302   return EXIT_SUCCESS;
 303 }
 304