lib-src/emacsclient.c

   1 /* Client process that communicates with GNU Emacs acting as server.
   2    Copyright (C) 1986, 1987, 1994, 1999, 2000, 2001, 2003, 2004
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GNU Emacs.
   6
   7 GNU Emacs is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU Emacs is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Emacs; see the file COPYING.  If not, write to
  19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22
  23 #define NO_SHORTNAMES
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #undef signal
  30
  31 #include <ctype.h>
  32 #include <stdio.h>
  33 #include <getopt.h>
  34 #ifdef HAVE_UNISTD_H
  35 #include <unistd.h>
  36 #endif
  37
  38 #ifdef VMS
  39 # include "vms-pwd.h"
  40 #else
  41 # include <pwd.h>
  42 #endif /* not VMS */
  43
  44 #include <signal.h>
  45 #include <errno.h>
  46
  47 \f
  48 char *getenv (), *getwd ();
  49 char *getcwd ();
  50
  51 /* This is defined with -D from the compilation command,
  52    which extracts it from ../lisp/version.el.  */
  53
  54 #ifndef VERSION
  55 #define VERSION "unspecified"
  56 #endif
  57 \f
  58 /* Name used to invoke this program.  */
  59 char *progname;
  60
  61 /* The first argument to main. */
  62 int main_argc;
  63
  64 /* The second argument to main. */
  65 char **main_argv;
  66
  67 /* Nonzero means don't wait for a response from Emacs.  --no-wait.  */
  68 int nowait = 0;
  69
  70 /* Nonzero means args are expressions to be evaluated.  --eval.  */
  71 int eval = 0;
  72
  73 /* The display on which Emacs should work.  --display.  */
  74 char *display = NULL;
  75
  76 /* Nonzero means open a new Emacs frame on the current terminal. */
  77 int frame = 0;
  78
  79 /* If non-NULL, the name of an editor to fallback to if the server
  80    is not running.  --alternate-editor.   */
  81 const char * alternate_editor = NULL;
  82
  83 /* If non-NULL, the filename of the UNIX socket.  */
  84 char *socket_name = NULL;
  85
  86 void print_help_and_exit ();
  87
  88 struct option longopts[] =
  89 {
  90   { "no-wait",  no_argument,       NULL, 'n' },
  91   { "eval",     no_argument,       NULL, 'e' },
  92   { "help",     no_argument,       NULL, 'H' },
  93   { "version",  no_argument,       NULL, 'V' },
  94   { "tty",      no_argument,       NULL, 't' },
  95   { "alternate-editor", required_argument, NULL, 'a' },
  96   { "socket-name",      required_argument, NULL, 's' },
  97   { "display",  required_argument, NULL, 'd' },
  98   { 0, 0, 0, 0 }
  99 };
 100
 101 /* Decode the options from argv and argc.
 102    The global variable `optind' will say how many arguments we used up.  */
 103
 104 void
 105 decode_options (argc, argv)
 106      int argc;
 107      char **argv;
 108 {
 109   while (1)
 110     {
 111       int opt = getopt_long (argc, argv,
 112                              "VHnea:s:d:t", longopts, 0);
 113
 114       if (opt == EOF)
 115         break;
 116
 117       alternate_editor = getenv ("ALTERNATE_EDITOR");
 118
 119       switch (opt)
 120         {
 121         case 0:
 122           /* If getopt returns 0, then it has already processed a
 123              long-named option.  We should do nothing.  */
 124           break;
 125
 126         case 'a':
 127           alternate_editor = optarg;
 128           break;
 129
 130         case 's':
 131           socket_name = optarg;
 132           break;
 133
 134         case 'd':
 135           display = optarg;
 136           break;
 137
 138         case 'n':
 139           nowait = 1;
 140           break;
 141
 142         case 'e':
 143           eval = 1;
 144           break;
 145
 146         case 'V':
 147           printf ("emacsclient %s\n", VERSION);
 148           exit (0);
 149           break;
 150
 151         case 't':
 152           frame = 1;
 153           break;
 154
 155         case 'H':
 156           print_help_and_exit ();
 157           break;
 158
 159         default:
 160           fprintf (stderr, "Try `%s --help' for more information\n", progname);
 161           exit (1);
 162           break;
 163         }
 164     }
 165
 166   if (frame) {
 167     nowait = 0;
 168     display = 0;
 169   }
 170
 171 }
 172
 173 void
 174 print_help_and_exit ()
 175 {
 176   printf (
 177           "Usage: %s [OPTIONS] FILE...\n\
 178 Tell the Emacs server to visit the specified files.\n\
 179 Every FILE can be either just a FILENAME or [+LINE[:COLUMN]] FILENAME.\n\
 180 \n\
 181 The following OPTIONS are accepted:\n\
 182 -V, --version           Just print a version info and return\n\
 183 -H, --help              Print this usage information message\n\
 184 -t, --tty               Open a new Emacs frame on the current terminal\n\
 185 -n, --no-wait           Don't wait for the server to return\n\
 186 -e, --eval              Evaluate the FILE arguments as ELisp expressions\n\
 187 -d, --display=DISPLAY   Visit the file in the given display\n\
 188 -s, --socket-name=FILENAME\n\
 189                         Set the filename of the UNIX socket for communication\n\
 190 -a, --alternate-editor=EDITOR\n\
 191                         Editor to fallback to if the server is not running\n\
 192 \n\
 193 Report bugs to bug-gnu-emacs@gnu.org.\n", progname);
 194   exit (0);
 195 }
 196
 197 /* In NAME, insert a & before each &, each space, each newline, and
 198    any initial -.  Change spaces to underscores, too, so that the
 199    return value never contains a space.  */
 200
 201 void
 202 quote_file_name (name, stream)
 203      char *name;
 204      FILE *stream;
 205 {
 206   char *copy = (char *) malloc (strlen (name) * 2 + 1);
 207   char *p, *q;
 208
 209   p = name;
 210   q = copy;
 211   while (*p)
 212     {
 213       if (*p == ' ')
 214         {
 215           *q++ = '&';
 216           *q++ = '_';
 217           p++;
 218         }
 219       else if (*p == '\n')
 220         {
 221           *q++ = '&';
 222           *q++ = 'n';
 223           p++;
 224         }
 225       else
 226         {
 227           if (*p == '&' || (*p == '-' && p == name))
 228             *q++ = '&';
 229           *q++ = *p++;
 230         }
 231     }
 232   *q++ = 0;
 233
 234   fprintf (stream, copy);
 235
 236   free (copy);
 237 }
 238
 239 /* Like malloc but get fatal error if memory is exhausted.  */
 240
 241 long *
 242 xmalloc (size)
 243      unsigned int size;
 244 {
 245   long *result = (long *) malloc (size);
 246   if (result == NULL)
 247   {
 248     perror ("malloc");
 249     exit (1);
 250   }
 251   return result;
 252 }
 253 \f
 254 /*
 255   Try to run a different command, or --if no alternate editor is
 256   defined-- exit with an errorcode.
 257 */
 258 void
 259 fail (void)
 260 {
 261   if (alternate_editor)
 262     {
 263       int i = optind - 1;
 264       execvp (alternate_editor, main_argv + i);
 265       return;
 266     }
 267   else
 268     {
 269       exit (1);
 270     }
 271 }
 272
 273 int emacs_pid;
 274
 275 #ifdef nec_ews_svr4
 276 extern char *_sobuf ;
 277 #else
 278 #if defined (USG) || defined (DGUX)
 279 unsigned char _sobuf[BUFSIZ+8];
 280 #else
 281 char _sobuf[BUFSIZ];
 282 #endif
 283 #endif
 284
 285 /* A signal handler that passes the signal to the Emacs process.
 286    Useful for SIGWINCH.  */
 287
 288 SIGTYPE
 289 pass_signal_to_emacs (int signalnum)
 290 {
 291   int old_errno = errno;
 292
 293   if (emacs_pid)
 294     kill (emacs_pid, signalnum);
 295
 296   signal (signalnum, pass_signal_to_emacs);
 297   errno = old_errno;
 298 }
 299
 300 /* Set up signal handlers before opening a frame on the current tty.  */
 301
 302 void
 303 init_signals (void)
 304 {
 305   /* Set up signal handlers. */
 306   signal (SIGWINCH, pass_signal_to_emacs);
 307
 308   /* Don't pass SIGINT and SIGQUIT to Emacs, because it has no way of
 309      deciding which terminal the signal came from.  C-g is now a
 310      normal input event on secondary terminals.  */
 311 #if 0
 312   signal (SIGINT, pass_signal_to_emacs);
 313   signal (SIGQUIT, pass_signal_to_emacs);
 314 #endif
 315 }
 316
 317 \f
 318 #if !defined (HAVE_SOCKETS) || defined (NO_SOCKETS_IN_FILE_SYSTEM)
 319
 320 int
 321 main (argc, argv)
 322      int argc;
 323      char **argv;
 324 {
 325   fprintf (stderr, "%s: Sorry, the Emacs server is supported only\n",
 326            argv[0]);
 327   fprintf (stderr, "on systems with Berkeley sockets.\n");
 328
 329   fail ();
 330 }
 331
 332 #else /* HAVE_SOCKETS */
 333
 334 #include <sys/types.h>
 335 #include <sys/socket.h>
 336 #include <sys/un.h>
 337 #include <sys/stat.h>
 338 #include <errno.h>
 339
 340 extern char *strerror ();
 341 extern int errno;
 342
 343 /* Three possibilities:
 344    2 - can't be `stat'ed                (sets errno)
 345    1 - isn't owned by us
 346    0 - success: none of the above */
 347
 348 static int
 349 socket_status (socket_name)
 350      char *socket_name;
 351 {
 352   struct stat statbfr;
 353
 354   if (stat (socket_name, &statbfr) == -1)
 355     return 2;
 356
 357   if (statbfr.st_uid != geteuid ())
 358     return 1;
 359
 360   return 0;
 361 }
 362
 363 /* Returns 1 if PREFIX is a prefix of STRING. */
 364 static int
 365 strprefix (char *prefix, char *string)
 366 {
 367   int i;
 368   if (! prefix)
 369     return 1;
 370
 371   if (!string)
 372     return 0;
 373
 374   for (i = 0; prefix[i]; i++)
 375     if (!string[i] || string[i] != prefix[i])
 376       return 0;
 377   return 1;
 378 }
 379
 380 int
 381 main (argc, argv)
 382      int argc;
 383      char **argv;
 384 {
 385   char *system_name;
 386   int system_name_length;
 387   int s, i, needlf = 0;
 388   FILE *out, *in;
 389   struct sockaddr_un server;
 390   char *cwd, *str;
 391   char string[BUFSIZ];
 392
 393   main_argc = argc;
 394   main_argv = argv;
 395   progname = argv[0];
 396
 397   /* Process options.  */
 398   decode_options (argc, argv);
 399
 400   if ((argc - optind < 1) && !eval && !frame)
 401     {
 402       fprintf (stderr, "%s: file name or argument required\n", progname);
 403       fprintf (stderr, "Try `%s --help' for more information\n", progname);
 404       exit (1);
 405     }
 406
 407   /*
 408    * Open up an AF_UNIX socket in this person's home directory
 409    */
 410
 411   if ((s = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
 412     {
 413       fprintf (stderr, "%s: ", argv[0]);
 414       perror ("socket");
 415       fail ();
 416     }
 417
 418   server.sun_family = AF_UNIX;
 419
 420   {
 421     char *dot;
 422     system_name_length = 32;
 423
 424     while (1)
 425       {
 426         system_name = (char *) xmalloc (system_name_length + 1);
 427
 428         /* system_name must be null-terminated string.  */
 429         system_name[system_name_length] = '\0';
 430
 431         if (gethostname (system_name, system_name_length) == 0)
 432           break;
 433
 434         free (system_name);
 435         system_name_length *= 2;
 436       }
 437
 438     /* We always use the non-dotted host name, for simplicity.  */
 439     dot = index (system_name, '.');
 440     if (dot)
 441       *dot = '\0';
 442   }
 443
 444   {
 445     int sock_status = 0;
 446     int default_sock = !socket_name;
 447     int saved_errno = 0;
 448
 449     if (default_sock)
 450       {
 451         socket_name = alloca (system_name_length + 100);
 452         sprintf (socket_name, "/tmp/emacs%d-%s/server",
 453                  (int) geteuid (), system_name);
 454       }
 455
 456     if (strlen (socket_name) < sizeof (server.sun_path))
 457       strcpy (server.sun_path, socket_name);
 458     else
 459       {
 460         fprintf (stderr, "%s: socket-name %s too long",
 461                  argv[0], socket_name);
 462         fail ();
 463       }
 464
 465     /* See if the socket exists, and if it's owned by us. */
 466     sock_status = socket_status (server.sun_path);
 467     saved_errno = errno;
 468     if (sock_status && default_sock)
 469       {
 470         /* Failing that, see if LOGNAME or USER exist and differ from
 471            our euid.  If so, look for a socket based on the UID
 472            associated with the name.  This is reminiscent of the logic
 473            that init_editfns uses to set the global Vuser_full_name.  */
 474
 475         char *user_name = (char *) getenv ("LOGNAME");
 476         if (!user_name)
 477           user_name = (char *) getenv ("USER");
 478
 479         if (user_name)
 480           {
 481             struct passwd *pw = getpwnam (user_name);
 482             if (pw && (pw->pw_uid != geteuid ()))
 483               {
 484                 /* We're running under su, apparently. */
 485                 sprintf (socket_name, "/tmp/emacs%d-%s/server",
 486                          (int) pw->pw_uid, system_name);
 487
 488                 if (strlen (socket_name) < sizeof (server.sun_path))
 489                   strcpy (server.sun_path, socket_name);
 490                 else
 491                   {
 492                     fprintf (stderr, "%s: socket-name %s too long",
 493                              argv[0], socket_name);
 494                     exit (1);
 495                   }
 496
 497                 sock_status = socket_status (server.sun_path);
 498                 saved_errno = errno;
 499               }
 500           }
 501       }
 502
 503      switch (sock_status)
 504        {
 505        case 1:
 506          /* There's a socket, but it isn't owned by us.  This is OK if
 507             we are root. */
 508          if (0 != geteuid ())
 509            {
 510              fprintf (stderr, "%s: Invalid socket owner\n", argv[0]);
 511              fail ();
 512            }
 513          break;
 514
 515        case 2:
 516          /* `stat' failed */
 517          if (saved_errno == ENOENT)
 518            fprintf (stderr,
 519                     "%s: Can't find socket; have you started the server?\n\
 520 To start the server in Emacs, type \"M-x server-start\".\n",
 521                     argv[0]);
 522          else
 523            fprintf (stderr, "%s: Can't stat %s: %s\n",
 524                     argv[0], server.sun_path, strerror (saved_errno));
 525          fail ();
 526          break;
 527        }
 528   }
 529
 530   if (connect (s, (struct sockaddr *) &server, strlen (server.sun_path) + 2)
 531       < 0)
 532     {
 533       fprintf (stderr, "%s: ", argv[0]);
 534       perror ("connect");
 535       fail ();
 536     }
 537
 538   /* We use the stream OUT to send our command to the server.  */
 539   if ((out = fdopen (s, "r+")) == NULL)
 540     {
 541       fprintf (stderr, "%s: ", argv[0]);
 542       perror ("fdopen");
 543       fail ();
 544     }
 545
 546   /* We use the stream IN to read the response.
 547      We used to use just one stream for both output and input
 548      on the socket, but reversing direction works nonportably:
 549      on some systems, the output appears as the first input;
 550      on other systems it does not.  */
 551   if ((in = fdopen (s, "r+")) == NULL)
 552     {
 553       fprintf (stderr, "%s: ", argv[0]);
 554       perror ("fdopen");
 555       fail ();
 556     }
 557
 558 #ifdef HAVE_GETCWD
 559   cwd = getcwd (string, sizeof string);
 560 #else
 561   cwd = getwd (string);
 562 #endif
 563   if (cwd == 0)
 564     {
 565       /* getwd puts message in STRING if it fails.  */
 566
 567 #ifdef HAVE_GETCWD
 568       fprintf (stderr, "%s: %s (%s)\n", argv[0],
 569                "Cannot get current working directory", strerror (errno));
 570 #else
 571       fprintf (stderr, "%s: %s (%s)\n", argv[0], string, strerror (errno));
 572 #endif
 573       fail ();
 574     }
 575
 576   if (nowait)
 577     fprintf (out, "-nowait ");
 578
 579   if (eval)
 580     fprintf (out, "-eval ");
 581
 582   if (display)
 583     {
 584       fprintf (out, "-display ");
 585       quote_file_name (display, out);
 586       fprintf (out, " ");
 587     }
 588
 589   if (frame)
 590     {
 591       char *tty_name = ttyname (fileno (stdin));
 592       if (! tty_name)
 593         fail ();
 594
 595       init_signals ();
 596
 597       fprintf (out, "-tty ");
 598       quote_file_name (tty_name, out);
 599       fprintf (out, " ");
 600       quote_file_name (getenv("TERM"), out);
 601       fprintf (out, " ");
 602     }
 603
 604   if ((argc - optind > 0))
 605     {
 606       for (i = optind; i < argc; i++)
 607         {
 608           if (eval)
 609             ; /* Don't prepend any cwd or anything like that.  */
 610           else if (*argv[i] == '+')
 611             {
 612               char *p = argv[i] + 1;
 613               while (isdigit ((unsigned char) *p) || *p == ':') p++;
 614               if (*p != 0)
 615                 {
 616                   quote_file_name (cwd, out);
 617                   fprintf (out, "/");
 618                 }
 619             }
 620           else if (*argv[i] != '/')
 621             {
 622               quote_file_name (cwd, out);
 623               fprintf (out, "/");
 624             }
 625
 626           quote_file_name (argv[i], out);
 627           fprintf (out, " ");
 628         }
 629     }
 630   else
 631     {
 632       if (!frame)
 633         {
 634           while ((str = fgets (string, BUFSIZ, stdin)))
 635             {
 636               quote_file_name (str, out);
 637             }
 638           fprintf (out, " ");
 639         }
 640     }
 641
 642   fprintf (out, "\n");
 643   fflush (out);
 644
 645   /* Maybe wait for an answer.   */
 646   if (nowait)
 647     {
 648       return 0;
 649     }
 650
 651   if (!eval && !frame)
 652     {
 653       printf ("Waiting for Emacs...");
 654       needlf = 2;
 655     }
 656   fflush (stdout);
 657
 658   /* Now, wait for an answer and print any messages.  */
 659   while ((str = fgets (string, BUFSIZ, in)))
 660     {
 661       if (frame)
 662         {
 663           if (strprefix ("emacs-pid ", str))
 664             {
 665               emacs_pid = strtol (string + strlen ("emacs-pid"), NULL, 10);
 666             }
 667         }
 668       else
 669         {
 670           if (needlf == 2)
 671             printf ("\n");
 672           printf ("%s", str);
 673           needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
 674         }
 675     }
 676
 677   if (needlf)
 678     printf ("\n");
 679   fflush (stdout);
 680
 681   return 0;
 682 }
 683
 684 #endif /* HAVE_SOCKETS */
 685 \f
 686 #ifndef HAVE_STRERROR
 687 char *
 688 strerror (errnum)
 689      int errnum;
 690 {
 691   extern char *sys_errlist[];
 692   extern int sys_nerr;
 693
 694   if (errnum >= 0 && errnum < sys_nerr)
 695     return sys_errlist[errnum];
 696   return (char *) "Unknown error";
 697 }
 698
 699 #endif /* ! HAVE_STRERROR */
 700
 701 /* arch-tag: f39bb9c4-73eb-477e-896d-50832e2ca9a7
 702    (do not change this comment) */