lib-src/emacsclient.c

   1 /* Client process that communicates with GNU Emacs acting as server.
   2    Copyright (C) 1986, 1987, 1994, 1999, 2000, 2001, 2002, 2003, 2004,
   3                  2005, 2006, 2007 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 3, 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., 51 Franklin Street, Fifth Floor,
  20 Boston, MA 02110-1301, USA.  */
  21
  22
  23 #define NO_SHORTNAMES
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #ifdef WINDOWSNT
  30
  31 /* config.h defines these, which disables sockets altogether! */
  32 # undef _WINSOCKAPI_
  33 # undef _WINSOCK_H
  34
  35 # include <malloc.h>
  36 # include <stdlib.h>
  37 # include <windows.h>
  38
  39 # define NO_SOCKETS_IN_FILE_SYSTEM
  40
  41 # define HSOCKET SOCKET
  42 # define CLOSE_SOCKET closesocket
  43 # define INITIALIZE() (initialize_sockets ())
  44
  45 #else /* !WINDOWSNT */
  46
  47 # include <sys/types.h>
  48
  49 # ifdef HAVE_INET_SOCKETS
  50 #  include <netinet/in.h>
  51 # endif
  52
  53 # define INVALID_SOCKET -1
  54 # define HSOCKET int
  55 # define CLOSE_SOCKET close
  56 # define INITIALIZE()
  57
  58 #endif /* !WINDOWSNT */
  59
  60 #undef signal
  61
  62 #include <stdarg.h>
  63 #include <ctype.h>
  64 #include <stdio.h>
  65 #include "getopt.h"
  66 #ifdef HAVE_UNISTD_H
  67 #include <unistd.h>
  68 #endif
  69
  70 #ifdef VMS
  71 # include "vms-pwd.h"
  72 #else /* not VMS */
  73 #ifdef WINDOWSNT
  74 # include <io.h>
  75 #else /* not WINDOWSNT */
  76 # include <pwd.h>
  77 #endif /* not WINDOWSNT */
  78 #endif /* not VMS */
  79 #include <sys/stat.h>
  80
  81 #include <signal.h>
  82 #include <errno.h>
  83
  84 /* From lisp.h */
  85 #ifndef DIRECTORY_SEP
  86 #define DIRECTORY_SEP '/'
  87 #endif
  88 #ifndef IS_DIRECTORY_SEP
  89 #define IS_DIRECTORY_SEP(_c_) ((_c_) == DIRECTORY_SEP)
  90 #endif
  91 #ifndef IS_DEVICE_SEP
  92 #ifndef DEVICE_SEP
  93 #define IS_DEVICE_SEP(_c_) 0
  94 #else
  95 #define IS_DEVICE_SEP(_c_) ((_c_) == DEVICE_SEP)
  96 #endif
  97 #endif
  98 #ifndef IS_ANY_SEP
  99 #define IS_ANY_SEP(_c_) (IS_DIRECTORY_SEP (_c_))
 100 #endif
 101
 102
 103 \f
 104 char *getenv (), *getwd ();
 105 char *(getcwd) ();
 106
 107 #ifndef VERSION
 108 #define VERSION "unspecified"
 109 #endif
 110 \f
 111
 112 #ifndef EXIT_SUCCESS
 113 #define EXIT_SUCCESS 0
 114 #endif
 115
 116 #ifndef EXIT_FAILURE
 117 #define EXIT_FAILURE 1
 118 #endif
 119
 120 #ifndef FALSE
 121 #define FALSE 0
 122 #endif
 123
 124 #ifndef TRUE
 125 #define TRUE 1
 126 #endif
 127
 128 #ifndef NO_RETURN
 129 #define NO_RETURN
 130 #endif
 131 \f
 132 /* Name used to invoke this program.  */
 133 char *progname;
 134
 135 /* The first argument to main. */
 136 int main_argc;
 137
 138 /* The second argument to main. */
 139 char **main_argv;
 140
 141 /* Nonzero means don't wait for a response from Emacs.  --no-wait.  */
 142 int nowait = 0;
 143
 144 /* Nonzero means args are expressions to be evaluated.  --eval.  */
 145 int eval = 0;
 146
 147 /* Nonzero means don't open a new frame.  --current-frame.  */
 148 int current_frame = 0;
 149
 150 /* Nonzero means open a new graphical frame. */
 151 int window_system = 0;
 152
 153 /* The display on which Emacs should work.  --display.  */
 154 char *display = NULL;
 155
 156 /* Nonzero means open a new Emacs frame on the current terminal. */
 157 int tty = 0;
 158
 159 /* If non-NULL, the name of an editor to fallback to if the server
 160    is not running.  --alternate-editor.   */
 161 const char *alternate_editor = NULL;
 162
 163 /* If non-NULL, the filename of the UNIX socket.  */
 164 char *socket_name = NULL;
 165
 166 /* If non-NULL, the filename of the authentication file.  */
 167 char *server_file = NULL;
 168
 169 /* PID of the Emacs server process.  */
 170 int emacs_pid = 0;
 171
 172 void print_help_and_exit () NO_RETURN;
 173
 174 struct option longopts[] =
 175 {
 176   { "no-wait",  no_argument,       NULL, 'n' },
 177   { "eval",     no_argument,       NULL, 'e' },
 178   { "help",     no_argument,       NULL, 'H' },
 179   { "version",  no_argument,       NULL, 'V' },
 180   { "tty",      no_argument,       NULL, 't' },
 181   { "current-frame", no_argument,  NULL, 'c' },
 182   { "alternate-editor", required_argument, NULL, 'a' },
 183 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
 184   { "socket-name",      required_argument, NULL, 's' },
 185 #endif
 186   { "server-file",      required_argument, NULL, 'f' },
 187   { "display",  required_argument, NULL, 'd' },
 188   { 0, 0, 0, 0 }
 189 };
 190
 191 \f
 192 /* Like malloc but get fatal error if memory is exhausted.  */
 193
 194 long *
 195 xmalloc (size)
 196      unsigned int size;
 197 {
 198   long *result = (long *) malloc (size);
 199   if (result == NULL)
 200     {
 201       perror ("malloc");
 202       exit (EXIT_FAILURE);
 203     }
 204   return result;
 205 }
 206
 207 /* Like strdup but get a fatal error if memory is exhausted. */
 208
 209 char *
 210 xstrdup (const char *s)
 211 {
 212   char *result = strdup (s);
 213   if (result == NULL)
 214     {
 215       perror ("strdup");
 216       exit (EXIT_FAILURE);
 217     }
 218   return result;
 219 }
 220
 221 /* From sysdep.c */
 222 #if !defined (HAVE_GET_CURRENT_DIR_NAME) || defined (BROKEN_GET_CURRENT_DIR_NAME)
 223
 224 /* Return the current working directory.  Returns NULL on errors.
 225    Any other returned value must be freed with free. This is used
 226    only when get_current_dir_name is not defined on the system.  */
 227 char*
 228 get_current_dir_name ()
 229 {
 230   char *buf;
 231   char *pwd;
 232   struct stat dotstat, pwdstat;
 233   /* If PWD is accurate, use it instead of calling getwd.  PWD is
 234      sometimes a nicer name, and using it may avoid a fatal error if a
 235      parent directory is searchable but not readable.  */
 236     if ((pwd = getenv ("PWD")) != 0
 237       && (IS_DIRECTORY_SEP (*pwd) || (*pwd && IS_DEVICE_SEP (pwd[1])))
 238       && stat (pwd, &pwdstat) == 0
 239       && stat (".", &dotstat) == 0
 240       && dotstat.st_ino == pwdstat.st_ino
 241       && dotstat.st_dev == pwdstat.st_dev
 242 #ifdef MAXPATHLEN
 243       && strlen (pwd) < MAXPATHLEN
 244 #endif
 245       )
 246     {
 247       buf = (char *) xmalloc (strlen (pwd) + 1);
 248       if (!buf)
 249         return NULL;
 250       strcpy (buf, pwd);
 251     }
 252 #ifdef HAVE_GETCWD
 253   else
 254     {
 255       size_t buf_size = 1024;
 256       buf = (char *) xmalloc (buf_size);
 257       if (!buf)
 258         return NULL;
 259       for (;;)
 260         {
 261           if (getcwd (buf, buf_size) == buf)
 262             break;
 263           if (errno != ERANGE)
 264             {
 265               int tmp_errno = errno;
 266               free (buf);
 267               errno = tmp_errno;
 268               return NULL;
 269             }
 270           buf_size *= 2;
 271           buf = (char *) realloc (buf, buf_size);
 272           if (!buf)
 273             return NULL;
 274         }
 275     }
 276 #else
 277   else
 278     {
 279       /* We need MAXPATHLEN here.  */
 280       buf = (char *) xmalloc (MAXPATHLEN + 1);
 281       if (!buf)
 282         return NULL;
 283       if (getwd (buf) == NULL)
 284         {
 285           int tmp_errno = errno;
 286           free (buf);
 287           errno = tmp_errno;
 288           return NULL;
 289         }
 290     }
 291 #endif
 292   return buf;
 293 }
 294 #endif
 295
 296 /* Message functions. */
 297
 298 #ifdef WINDOWSNT
 299 int
 300 w32_window_app ()
 301 {
 302   static int window_app = -1;
 303   char szTitle[MAX_PATH];
 304
 305   if (window_app < 0)
 306     /* Checking for STDOUT does not work; it's a valid handle also in
 307        nonconsole apps.  Testing for the console title seems to work. */
 308     window_app = (GetConsoleTitleA (szTitle, MAX_PATH) == 0);
 309
 310   return window_app;
 311 }
 312
 313 /*
 314   execvp wrapper for Windows. Quotes arguments with embedded spaces.
 315
 316   This is necessary due to the broken implementation of exec* routines in
 317   the Microsoft libraries: they concatenate the arguments together without
 318   quoting special characters, and pass the result to CreateProcess, with
 319   predictably bad results.  By contrast, Posix execvp passes the arguments
 320   directly into the argv array of the child process.
 321 */
 322 int
 323 w32_execvp (path, argv)
 324      char *path;
 325      char **argv;
 326 {
 327   int i;
 328
 329   /* Required to allow a .BAT script as alternate editor.  */
 330   argv[0] = (char *) alternate_editor;
 331
 332   for (i = 0; argv[i]; i++)
 333     if (strchr (argv[i], ' '))
 334       {
 335         char *quoted = alloca (strlen (argv[i]) + 3);
 336         sprintf (quoted, "\"%s\"", argv[i]);
 337         argv[i] = quoted;
 338       }
 339
 340   return execvp (path, argv);
 341 }
 342
 343 #undef execvp
 344 #define execvp w32_execvp
 345
 346 #endif /* WINDOWSNT */
 347
 348 void
 349 message (int is_error, char *message, ...)
 350 {
 351   char msg [2048];
 352   va_list args;
 353
 354   va_start (args, message);
 355   vsprintf (msg, message, args);
 356   va_end (args);
 357
 358 #ifdef WINDOWSNT
 359   if (w32_window_app ())
 360     {
 361       if (is_error)
 362         MessageBox (NULL, msg, "Emacsclient ERROR", MB_ICONERROR);
 363       else
 364         MessageBox (NULL, msg, "Emacsclient", MB_ICONINFORMATION);
 365     }
 366   else
 367 #endif
 368     {
 369       FILE *f = is_error ? stderr : stdout;
 370
 371       fputs (msg, f);
 372       fflush (f);
 373     }
 374 }
 375
 376 /* Decode the options from argv and argc.
 377    The global variable `optind' will say how many arguments we used up.  */
 378
 379 void
 380 decode_options (argc, argv)
 381      int argc;
 382      char **argv;
 383 {
 384   alternate_editor = getenv ("ALTERNATE_EDITOR");
 385   display = getenv ("DISPLAY");
 386   if (display && strlen (display) == 0)
 387     display = NULL;
 388
 389   while (1)
 390     {
 391       int opt = getopt_long (argc, argv,
 392 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
 393                              "VHnea:s:f:d:tc",
 394 #else
 395                              "VHnea:f:d:tc",
 396 #endif
 397                              longopts, 0);
 398
 399       if (opt == EOF)
 400         break;
 401
 402       switch (opt)
 403         {
 404         case 0:
 405           /* If getopt returns 0, then it has already processed a
 406              long-named option.  We should do nothing.  */
 407           break;
 408
 409         case 'a':
 410           alternate_editor = optarg;
 411           break;
 412
 413 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
 414         case 's':
 415           socket_name = optarg;
 416           break;
 417 #endif
 418
 419         case 'f':
 420           server_file = optarg;
 421           break;
 422
 423         case 'd':
 424           display = optarg;
 425           break;
 426
 427         case 'n':
 428           nowait = 1;
 429           break;
 430
 431         case 'e':
 432           eval = 1;
 433           break;
 434
 435         case 'V':
 436           message (FALSE, "emacsclient %s\n", VERSION);
 437           exit (EXIT_SUCCESS);
 438           break;
 439
 440         case 't':
 441           tty = 1;
 442           break;
 443
 444         case 'c':
 445           current_frame = 1;
 446           break;
 447
 448         case 'H':
 449           print_help_and_exit ();
 450           break;
 451
 452         default:
 453           message (TRUE, "Try `%s --help' for more information\n", progname);
 454           exit (EXIT_FAILURE);
 455           break;
 456         }
 457     }
 458
 459   if (!tty && display)
 460     window_system = 1;
 461 #if !defined (WINDOWSNT) && !defined (HAVE_CARBON)
 462   else
 463     tty = 1;
 464 #endif
 465
 466   /* --no-wait implies --current-frame on ttys when there are file
 467        arguments or expressions given.  */
 468   if (nowait && tty && argc - optind > 0)
 469     current_frame = 1;
 470
 471   if (current_frame)
 472     {
 473       tty = 0;
 474       window_system = 0;
 475     }
 476
 477   if (tty)
 478     window_system = 0;
 479 }
 480
 481 \f
 482 void
 483 print_help_and_exit ()
 484 {
 485   /* Spaces and tabs are significant in this message; they're chosen so the
 486      message aligns properly both in a tty and in a Windows message box.
 487      Please try to preserve them; otherwise the output is very hard to read
 488      when using emacsclientw.  */
 489   message (FALSE,
 490            "Usage: %s [OPTIONS] FILE...\n\
 491 Tell the Emacs server to visit the specified files.\n\
 492 Every FILE can be either just a FILENAME or [+LINE[:COLUMN]] FILENAME.\n\
 493 \n\
 494 The following OPTIONS are accepted:\n\
 495 -V, --version           Just print version info and return\n\
 496 -H, --help              Print this usage information message\n\
 497 -t, --tty               Open a new Emacs frame on the current terminal\n\
 498 -c, --current-frame     Do not create a new frame;\n\
 499                         use the current Emacs frame\n\
 500 -e, --eval              Evaluate the FILE arguments as ELisp expressions\n\
 501 -n, --no-wait           Don't wait for the server to return\n\
 502 -d, --display=DISPLAY   Visit the file in the given display\n"
 503 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
 504 "-s, --socket-name=FILENAME\n\
 505                         Set filename of the UNIX socket for communication\n"
 506 #endif
 507 "-f, --server-file=FILENAME\n\
 508                         Set filename of the TCP authentication file\n\
 509 -a, --alternate-editor=EDITOR\n\
 510                         Editor to fallback to if the server is not running\n\
 511 \n\
 512 Report bugs to bug-gnu-emacs@gnu.org.\n", progname);
 513   exit (EXIT_SUCCESS);
 514 }
 515
 516 /*
 517   Try to run a different command, or --if no alternate editor is
 518   defined-- exit with an errorcode.
 519 */
 520 void
 521 fail (void)
 522 {
 523   if (alternate_editor)
 524     {
 525       int i = optind - 1;
 526
 527       execvp (alternate_editor, main_argv + i);
 528       message (TRUE, "%s: error executing alternate editor \"%s\"\n",
 529                progname, alternate_editor);
 530     }
 531   exit (EXIT_FAILURE);
 532 }
 533
 534 \f
 535 #if !defined (HAVE_SOCKETS) || !defined (HAVE_INET_SOCKETS)
 536
 537 int
 538 main (argc, argv)
 539      int argc;
 540      char **argv;
 541 {
 542   main_argc = argc;
 543   main_argv = argv;
 544   progname = argv[0];
 545   message (TRUE, "%s: Sorry, the Emacs server is supported only\n"
 546            "on systems with Berkeley sockets.\n",
 547            argv[0]);
 548   fail ();
 549 }
 550
 551 #else /* HAVE_SOCKETS && HAVE_INET_SOCKETS */
 552
 553 #ifdef WINDOWSNT
 554 # include <winsock2.h>
 555 #else
 556 # include <sys/types.h>
 557 # include <sys/socket.h>
 558 # include <sys/un.h>
 559 #endif
 560
 561 #define AUTH_KEY_LENGTH      64
 562 #define SEND_BUFFER_SIZE   4096
 563
 564 extern char *strerror ();
 565 extern int errno;
 566
 567 /* Buffer to accumulate data to send in TCP connections.  */
 568 char send_buffer[SEND_BUFFER_SIZE + 1];
 569 int sblen = 0;  /* Fill pointer for the send buffer.  */
 570 /* Socket used to communicate with the Emacs server process.  */
 571 HSOCKET emacs_socket = 0;
 572
 573 /* Let's send the data to Emacs when either
 574    - the data ends in "\n", or
 575    - the buffer is full (but this shouldn't happen)
 576    Otherwise, we just accumulate it.  */
 577 void
 578 send_to_emacs (s, data)
 579      HSOCKET s;
 580      char *data;
 581 {
 582   while (data)
 583     {
 584       int dlen = strlen (data);
 585       if (dlen + sblen >= SEND_BUFFER_SIZE)
 586         {
 587           int part = SEND_BUFFER_SIZE - sblen;
 588           strncpy (&send_buffer[sblen], data, part);
 589           data += part;
 590           sblen = SEND_BUFFER_SIZE;
 591         }
 592       else if (dlen)
 593         {
 594           strcpy (&send_buffer[sblen], data);
 595           data = NULL;
 596           sblen += dlen;
 597         }
 598       else
 599         break;
 600
 601       if (sblen == SEND_BUFFER_SIZE
 602           || (sblen > 0 && send_buffer[sblen-1] == '\n'))
 603         {
 604           int sent = send (s, send_buffer, sblen, 0);
 605           if (sent != sblen)
 606             strcpy (send_buffer, &send_buffer[sent]);
 607           sblen -= sent;
 608         }
 609     }
 610 }
 611
 612 \f
 613 /* In STR, insert a & before each &, each space, each newline, and
 614    any initial -.  Change spaces to underscores, too, so that the
 615    return value never contains a space.
 616
 617    Does not change the string.  Outputs the result to STREAM.  */
 618 void
 619 quote_argument (s, str)
 620      HSOCKET s;
 621      char *str;
 622 {
 623   char *copy = (char *) xmalloc (strlen (str) * 2 + 1);
 624   char *p, *q;
 625
 626   p = str;
 627   q = copy;
 628   while (*p)
 629     {
 630       if (*p == ' ')
 631         {
 632           *q++ = '&';
 633           *q++ = '_';
 634           p++;
 635         }
 636       else if (*p == '\n')
 637         {
 638           *q++ = '&';
 639           *q++ = 'n';
 640           p++;
 641         }
 642       else
 643         {
 644           if (*p == '&' || (*p == '-' && p == str))
 645             *q++ = '&';
 646           *q++ = *p++;
 647         }
 648     }
 649   *q++ = 0;
 650
 651   send_to_emacs (s, copy);
 652
 653   free (copy);
 654 }
 655
 656
 657 /* The inverse of quote_argument.  Removes quoting in string STR by
 658    modifying the string in place.   Returns STR. */
 659
 660 char *
 661 unquote_argument (str)
 662      char *str;
 663 {
 664   char *p, *q;
 665
 666   if (! str)
 667     return str;
 668
 669   p = str;
 670   q = str;
 671   while (*p)
 672     {
 673       if (*p == '&')
 674         {
 675           p++;
 676           if (*p == '&')
 677             *p = '&';
 678           else if (*p == '_')
 679             *p = ' ';
 680           else if (*p == 'n')
 681             *p = '\n';
 682           else if (*p == '-')
 683             *p = '-';
 684         }
 685       *q++ = *p++;
 686     }
 687   *q = 0;
 688   return str;
 689 }
 690
 691 \f
 692 int
 693 file_name_absolute_p (filename)
 694      const unsigned char *filename;
 695 {
 696   /* Sanity check, it shouldn't happen.  */
 697   if (! filename) return FALSE;
 698
 699   /* /xxx is always an absolute path.  */
 700   if (filename[0] == '/') return TRUE;
 701
 702   /* Empty filenames (which shouldn't happen) are relative.  */
 703   if (filename[0] == '\0') return FALSE;
 704
 705 #ifdef WINDOWSNT
 706   /* X:\xxx is always absolute.  */
 707   if (isalpha (filename[0])
 708       && filename[1] == ':' && (filename[2] == '\\' || filename[2] == '/'))
 709     return TRUE;
 710
 711   /* Both \xxx and \\xxx\yyy are absolute.  */
 712   if (filename[0] == '\\') return TRUE;
 713
 714   /*
 715     FIXME:  There's a corner case not dealt with, "x:y", where:
 716
 717     1) x is a valid drive designation (usually a letter in the A-Z range)
 718        and y is a path, relative to the current directory on drive x.  This
 719        is absolute, *after* fixing the y part to include the current
 720        directory in x.
 721
 722     2) x is a relative file name, and y is an NTFS stream name.  This is a
 723        correct relative path, but it is very unusual.
 724
 725     The trouble is that first case items are also valid examples of the
 726     second case, i.e., "c:test" can be understood as drive:path or as
 727     file:stream.
 728
 729     The "right" fix would involve checking whether
 730     - the current drive/partition is NTFS,
 731     - x is a valid (and accesible) drive designator,
 732     - x:y already exists as a file:stream in the current directory,
 733     - y already exists on the current directory of drive x,
 734     - the auspices are favorable,
 735     and then taking an "informed decision" based on the above.
 736
 737     Whatever the result, Emacs currently does a very bad job of dealing
 738     with NTFS file:streams: it cannot visit them, and the only way to
 739     create one is by setting `buffer-file-name' to point to it (either
 740     manually or with emacsclient). So perhaps resorting to 1) and ignoring
 741     2) for now is the right thing to do.
 742
 743     Anyway, something to decide After the Release.
 744   */
 745 #endif
 746
 747   return FALSE;
 748 }
 749
 750 #ifdef WINDOWSNT
 751 /* Wrapper to make WSACleanup a cdecl, as required by atexit.  */
 752 void
 753 __cdecl close_winsock ()
 754 {
 755   WSACleanup ();
 756 }
 757
 758 /* Initialize the WinSock2 library.  */
 759 void
 760 initialize_sockets ()
 761 {
 762   WSADATA wsaData;
 763
 764   if (WSAStartup (MAKEWORD (2, 0), &wsaData))
 765     {
 766       message (TRUE, "%s: error initializing WinSock2", progname);
 767       exit (EXIT_FAILURE);
 768     }
 769
 770   atexit (close_winsock);
 771 }
 772 #endif /* WINDOWSNT */
 773
 774 \f
 775 /*
 776  * Read the information needed to set up a TCP comm channel with
 777  * the Emacs server: host, port, pid and authentication string.
 778  */
 779 int
 780 get_server_config (server, authentication)
 781      struct sockaddr_in *server;
 782      char *authentication;
 783 {
 784   char dotted[32];
 785   char *port;
 786   char *pid;
 787   FILE *config = NULL;
 788
 789   if (file_name_absolute_p (server_file))
 790     config = fopen (server_file, "rb");
 791   else
 792     {
 793       char *home = getenv ("HOME");
 794
 795       if (home)
 796         {
 797           char *path = alloca (32 + strlen (home) + strlen (server_file));
 798           sprintf (path, "%s/.emacs.d/server/%s", home, server_file);
 799           config = fopen (path, "rb");
 800         }
 801 #ifdef WINDOWSNT
 802       if (!config && (home = getenv ("APPDATA")))
 803         {
 804           char *path = alloca (32 + strlen (home) + strlen (server_file));
 805           sprintf (path, "%s/.emacs.d/server/%s", home, server_file);
 806           config = fopen (path, "rb");
 807         }
 808 #endif
 809     }
 810
 811   if (! config)
 812     return FALSE;
 813
 814   if (fgets (dotted, sizeof dotted, config)
 815       && (port = strchr (dotted, ':'))
 816       && (pid = strchr (port, ' ')))
 817     {
 818       *port++ = '\0';
 819       *pid++  = '\0';
 820     }
 821   else
 822     {
 823       message (TRUE, "%s: invalid configuration info", progname);
 824       exit (EXIT_FAILURE);
 825     }
 826
 827   server->sin_family = AF_INET;
 828   server->sin_addr.s_addr = inet_addr (dotted);
 829   server->sin_port = htons (atoi (port));
 830
 831   if (! fread (authentication, AUTH_KEY_LENGTH, 1, config))
 832     {
 833       message (TRUE, "%s: cannot read authentication info", progname);
 834       exit (EXIT_FAILURE);
 835     }
 836
 837   fclose (config);
 838
 839   emacs_pid = atoi (pid);
 840
 841   return TRUE;
 842 }
 843
 844 HSOCKET
 845 set_tcp_socket ()
 846 {
 847   HSOCKET s;
 848   struct sockaddr_in server;
 849   struct linger l_arg = {1, 1};
 850   char auth_string[AUTH_KEY_LENGTH + 1];
 851
 852   if (! get_server_config (&server, auth_string))
 853     return INVALID_SOCKET;
 854
 855   if (server.sin_addr.s_addr != inet_addr ("127.0.0.1"))
 856     message (FALSE, "%s: connected to remote socket at %s\n",
 857              progname, inet_ntoa (server.sin_addr));
 858
 859   /*
 860    * Open up an AF_INET socket
 861    */
 862   if ((s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
 863     {
 864       message (TRUE, "%s: socket: %s\n", progname, strerror (errno));
 865       return INVALID_SOCKET;
 866     }
 867
 868   /*
 869    * Set up the socket
 870    */
 871   if (connect (s, (struct sockaddr *) &server, sizeof server) < 0)
 872     {
 873       message (TRUE, "%s: connect: %s\n", progname, strerror (errno));
 874       return INVALID_SOCKET;
 875     }
 876
 877   setsockopt (s, SOL_SOCKET, SO_LINGER, (char *) &l_arg, sizeof l_arg);
 878
 879   /*
 880    * Send the authentication
 881    */
 882   auth_string[AUTH_KEY_LENGTH] = '\0';
 883
 884   send_to_emacs (s, "-auth ");
 885   send_to_emacs (s, auth_string);
 886   send_to_emacs (s, "\n");
 887
 888   return s;
 889 }
 890
 891
 892 /* Returns 1 if PREFIX is a prefix of STRING. */
 893 static int
 894 strprefix (char *prefix, char *string)
 895 {
 896   int i;
 897   if (! prefix)
 898     return 1;
 899
 900   if (!string)
 901     return 0;
 902
 903   for (i = 0; prefix[i]; i++)
 904     if (!string[i] || string[i] != prefix[i])
 905       return 0;
 906   return 1;
 907 }
 908
 909
 910 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
 911
 912 /* Three possibilities:
 913    2 - can't be `stat'ed                (sets errno)
 914    1 - isn't owned by us
 915    0 - success: none of the above */
 916
 917 static int
 918 socket_status (socket_name)
 919      char *socket_name;
 920 {
 921   struct stat statbfr;
 922
 923   if (stat (socket_name, &statbfr) == -1)
 924     return 2;
 925
 926   if (statbfr.st_uid != geteuid ())
 927     return 1;
 928
 929   return 0;
 930 }
 931
 932 \f
 933 /* A signal handler that passes the signal to the Emacs process.
 934    Useful for SIGWINCH.  */
 935
 936 SIGTYPE
 937 pass_signal_to_emacs (int signalnum)
 938 {
 939   int old_errno = errno;
 940
 941   if (emacs_pid)
 942     kill (emacs_pid, signalnum);
 943
 944   signal (signalnum, pass_signal_to_emacs);
 945   errno = old_errno;
 946 }
 947
 948 /* Signal handler for SIGCONT; notify the Emacs process that it can
 949    now resume our tty frame.  */
 950
 951 SIGTYPE
 952 handle_sigcont (int signalnum)
 953 {
 954   int old_errno = errno;
 955
 956   if (tcgetpgrp (1) == getpgrp ())
 957     {
 958       /* We are in the foreground. */
 959       send_to_emacs (emacs_socket, "-resume \n");
 960     }
 961   else
 962     {
 963       /* We are in the background; cancel the continue. */
 964       kill (getpid (), SIGSTOP);
 965     }
 966
 967   signal (signalnum, handle_sigcont);
 968   errno = old_errno;
 969 }
 970
 971 /* Signal handler for SIGTSTP; notify the Emacs process that we are
 972    going to sleep.  Normally the suspend is initiated by Emacs via
 973    server-handle-suspend-tty, but if the server gets out of sync with
 974    reality, we may get a SIGTSTP on C-z.  Handling this signal and
 975    notifying Emacs about it should get things under control again. */
 976
 977 SIGTYPE
 978 handle_sigtstp (int signalnum)
 979 {
 980   int old_errno = errno;
 981   sigset_t set;
 982
 983   if (emacs_socket)
 984     send_to_emacs (emacs_socket, "-suspend \n");
 985
 986   /* Unblock this signal and call the default handler by temprarily
 987      changing the handler and resignalling. */
 988   sigprocmask (SIG_BLOCK, NULL, &set);
 989   sigdelset (&set, signalnum);
 990   signal (signalnum, SIG_DFL);
 991   kill (getpid (), signalnum);
 992   sigprocmask (SIG_SETMASK, &set, NULL); /* Let's the above signal through. */
 993   signal (signalnum, handle_sigtstp);
 994
 995   errno = old_errno;
 996 }
 997 /* Set up signal handlers before opening a frame on the current tty.  */
 998
 999 void
1000 init_signals (void)
1001 {
1002   /* Set up signal handlers. */
1003   signal (SIGWINCH, pass_signal_to_emacs);
1004
1005   /* Don't pass SIGINT and SIGQUIT to Emacs, because it has no way of
1006      deciding which terminal the signal came from.  C-g is now a
1007      normal input event on secondary terminals.  */
1008 #if 0
1009   signal (SIGINT, pass_signal_to_emacs);
1010   signal (SIGQUIT, pass_signal_to_emacs);
1011 #endif
1012
1013   signal (SIGCONT, handle_sigcont);
1014   signal (SIGTSTP, handle_sigtstp);
1015   signal (SIGTTOU, handle_sigtstp);
1016 }
1017
1018
1019 HSOCKET
1020 set_local_socket ()
1021 {
1022   HSOCKET s;
1023   struct sockaddr_un server;
1024
1025   /*
1026    * Open up an AF_UNIX socket in this person's home directory
1027    */
1028
1029   if ((s = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
1030     {
1031       message (TRUE, "%s: socket: %s\n", progname, strerror (errno));
1032       return INVALID_SOCKET;
1033     }
1034
1035   server.sun_family = AF_UNIX;
1036
1037   {
1038     int sock_status = 0;
1039     int default_sock = !socket_name;
1040     int saved_errno = 0;
1041
1042     char *server_name = "server";
1043
1044     if (socket_name && !index (socket_name, '/') && !index (socket_name, '\\'))
1045       { /* socket_name is a file name component.  */
1046         server_name = socket_name;
1047         socket_name = NULL;
1048         default_sock = 1;       /* Try both UIDs.  */
1049       }
1050
1051     if (default_sock)
1052       {
1053         socket_name = alloca (100 + strlen (server_name));
1054         sprintf (socket_name, "/tmp/emacs%d/%s",
1055                  (int) geteuid (), server_name);
1056       }
1057
1058     if (strlen (socket_name) < sizeof (server.sun_path))
1059       strcpy (server.sun_path, socket_name);
1060     else
1061       {
1062         message (TRUE, "%s: socket-name %s too long",
1063                  progname, socket_name);
1064         fail ();
1065       }
1066
1067     /* See if the socket exists, and if it's owned by us. */
1068     sock_status = socket_status (server.sun_path);
1069     saved_errno = errno;
1070     if (sock_status && default_sock)
1071       {
1072         /* Failing that, see if LOGNAME or USER exist and differ from
1073            our euid.  If so, look for a socket based on the UID
1074            associated with the name.  This is reminiscent of the logic
1075            that init_editfns uses to set the global Vuser_full_name.  */
1076
1077         char *user_name = (char *) getenv ("LOGNAME");
1078
1079         if (!user_name)
1080           user_name = (char *) getenv ("USER");
1081
1082         if (user_name)
1083           {
1084             struct passwd *pw = getpwnam (user_name);
1085
1086             if (pw && (pw->pw_uid != geteuid ()))
1087               {
1088                 /* We're running under su, apparently. */
1089                 socket_name = alloca (100 + strlen (server_name));
1090                 sprintf (socket_name, "/tmp/emacs%d/%s",
1091                          (int) pw->pw_uid, server_name);
1092
1093                 if (strlen (socket_name) < sizeof (server.sun_path))
1094                   strcpy (server.sun_path, socket_name);
1095                 else
1096                   {
1097                     message (TRUE, "%s: socket-name %s too long",
1098                              progname, socket_name);
1099                     exit (EXIT_FAILURE);
1100                   }
1101
1102                 sock_status = socket_status (server.sun_path);
1103                 saved_errno = errno;
1104               }
1105             else
1106               errno = saved_errno;
1107           }
1108       }
1109
1110     switch (sock_status)
1111       {
1112       case 1:
1113         /* There's a socket, but it isn't owned by us.  This is OK if
1114            we are root. */
1115         if (0 != geteuid ())
1116           {
1117             message (TRUE, "%s: Invalid socket owner\n", progname);
1118             return INVALID_SOCKET;
1119           }
1120         break;
1121
1122       case 2:
1123         /* `stat' failed */
1124         if (saved_errno == ENOENT)
1125           message (TRUE,
1126                    "%s: can't find socket; have you started the server?\n\
1127 To start the server in Emacs, type \"M-x server-start\".\n",
1128                    progname);
1129         else
1130           message (TRUE, "%s: can't stat %s: %s\n",
1131                    progname, server.sun_path, strerror (saved_errno));
1132         return INVALID_SOCKET;
1133       }
1134   }
1135
1136   if (connect (s, (struct sockaddr *) &server, strlen (server.sun_path) + 2)
1137       < 0)
1138     {
1139       message (TRUE, "%s: connect: %s\n", progname, strerror (errno));
1140       return INVALID_SOCKET;
1141     }
1142
1143   return s;
1144 }
1145 #endif /* ! NO_SOCKETS_IN_FILE_SYSTEM */
1146
1147 HSOCKET
1148 set_socket ()
1149 {
1150   HSOCKET s;
1151
1152   INITIALIZE ();
1153
1154 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1155   /* Explicit --socket-name argument.  */
1156   if (socket_name)
1157     {
1158       s = set_local_socket ();
1159       if ((s != INVALID_SOCKET) || alternate_editor)
1160         return s;
1161       message (TRUE, "%s: error accessing socket \"%s\"",
1162                progname, socket_name);
1163       exit (EXIT_FAILURE);
1164     }
1165 #endif
1166
1167   /* Explicit --server-file arg or EMACS_SERVER_FILE variable.  */
1168   if (!server_file)
1169     server_file = getenv ("EMACS_SERVER_FILE");
1170
1171   if (server_file)
1172     {
1173       s = set_tcp_socket ();
1174       if ((s != INVALID_SOCKET) || alternate_editor)
1175         return s;
1176
1177       message (TRUE, "%s: error accessing server file \"%s\"",
1178                progname, server_file);
1179       exit (EXIT_FAILURE);
1180     }
1181
1182 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1183   /* Implicit local socket.  */
1184   s = set_local_socket ();
1185   if (s != INVALID_SOCKET)
1186     return s;
1187 #endif
1188
1189   /* Implicit server file.  */
1190   server_file = "server";
1191   s = set_tcp_socket ();
1192   if ((s != INVALID_SOCKET) || alternate_editor)
1193     return s;
1194
1195   /* No implicit or explicit socket, and no alternate editor.  */
1196   message (TRUE, "%s: No socket or alternate editor.  Please use:\n\n"
1197 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1198 "\t--socket-name\n"
1199 #endif
1200 "\t--server-file      (or environment variable EMACS_SERVER_FILE)\n\
1201 \t--alternate-editor (or environment variable ALTERNATE_EDITOR)\n",
1202            progname);
1203   exit (EXIT_FAILURE);
1204 }
1205
1206 #ifdef WINDOWSNT
1207 FARPROC set_fg;  /* Pointer to AllowSetForegroundWindow.  */
1208 FARPROC get_wc;  /* Pointer to RealGetWindowClassA.  */
1209
1210 BOOL CALLBACK
1211 w32_find_emacs_process (hWnd, lParam)
1212      HWND hWnd;
1213      LPARAM lParam;
1214 {
1215   DWORD pid;
1216   char class[6];
1217
1218   /* Reject any window not of class "Emacs".  */
1219   if (! get_wc (hWnd, class, sizeof (class))
1220       || strcmp (class, "Emacs"))
1221     return TRUE;
1222
1223   /* We only need the process id, not the thread id.  */
1224   (void) GetWindowThreadProcessId (hWnd, &pid);
1225
1226   /* Not the one we're looking for.  */
1227   if (pid != (DWORD) emacs_pid) return TRUE;
1228
1229   /* OK, let's raise it.  */
1230   set_fg (emacs_pid);
1231
1232   /* Stop enumeration.  */
1233   return FALSE;
1234 }
1235
1236 /*
1237  * Search for a window of class "Emacs" and owned by a process with
1238  * process id = emacs_pid.  If found, allow it to grab the focus.
1239  */
1240 void
1241 w32_give_focus ()
1242 {
1243   HMODULE hUser32;
1244
1245   /* It shouldn't happen when dealing with TCP sockets.  */
1246   if (!emacs_pid) return;
1247
1248   if (!(hUser32 = LoadLibrary ("user32.dll"))) return;
1249
1250   /* Modern Windows restrict which processes can set the foreground window.
1251      emacsclient can allow Emacs to grab the focus by calling the function
1252      AllowSetForegroundWindow.  Unfortunately, older Windows (W95, W98 and
1253      NT) lack this function, so we have to check its availability.  */
1254   if ((set_fg = GetProcAddress (hUser32, "AllowSetForegroundWindow"))
1255       && (get_wc = GetProcAddress (hUser32, "RealGetWindowClassA")))
1256     EnumWindows (w32_find_emacs_process, (LPARAM) 0);
1257
1258   FreeLibrary (hUser32);
1259 }
1260 #endif
1261
1262 int
1263 main (argc, argv)
1264      int argc;
1265      char **argv;
1266 {
1267   int i, rl, needlf = 0;
1268   char *cwd, *str;
1269   char string[BUFSIZ+1];
1270
1271   main_argc = argc;
1272   main_argv = argv;
1273   progname = argv[0];
1274
1275   /* Process options.  */
1276   decode_options (argc, argv);
1277
1278   if ((argc - optind < 1) && !eval && !tty && !window_system)
1279     {
1280       message (TRUE, "%s: file name or argument required\n"
1281                "Try `%s --help' for more information\n",
1282                progname, progname);
1283       exit (EXIT_FAILURE);
1284     }
1285
1286   if ((emacs_socket = set_socket ()) == INVALID_SOCKET)
1287     fail ();
1288
1289
1290   cwd = get_current_dir_name ();
1291   if (cwd == 0)
1292     {
1293       /* getwd puts message in STRING if it fails.  */
1294       message (TRUE, "%s: %s\n", progname,
1295                "Cannot get current working directory");
1296       fail ();
1297     }
1298
1299 #ifdef WINDOWSNT
1300   w32_give_focus ();
1301 #endif
1302
1303   /* First of all, send our version number for verification. */
1304   send_to_emacs (emacs_socket, "-version ");
1305   send_to_emacs (emacs_socket, VERSION);
1306   send_to_emacs (emacs_socket, " ");
1307
1308   /* Send over our environment. */
1309   if (!current_frame)
1310     {
1311       extern char **environ;
1312       int i;
1313       for (i = 0; environ[i]; i++)
1314         {
1315           char *name = xstrdup (environ[i]);
1316           char *value = strchr (name, '=');
1317           send_to_emacs (emacs_socket, "-env ");
1318           quote_argument (emacs_socket, environ[i]);
1319           send_to_emacs (emacs_socket, " ");
1320         }
1321     }
1322
1323   /* Send over our current directory. */
1324   if (!current_frame)
1325     {
1326       send_to_emacs (emacs_socket, "-dir ");
1327       quote_argument (emacs_socket, cwd);
1328       send_to_emacs (emacs_socket, "/");
1329       send_to_emacs (emacs_socket, " ");
1330     }
1331
1332  retry:
1333   if (nowait)
1334     send_to_emacs (emacs_socket, "-nowait ");
1335
1336   if (current_frame)
1337     send_to_emacs (emacs_socket, "-current-frame ");
1338
1339   if (display)
1340     {
1341       send_to_emacs (emacs_socket, "-display ");
1342       quote_argument (emacs_socket, display);
1343       send_to_emacs (emacs_socket, " ");
1344     }
1345
1346   if (tty)
1347     {
1348       char *type = getenv ("TERM");
1349       char *tty_name = NULL;
1350 #ifndef WINDOWSNT
1351       tty_name = ttyname (fileno (stdin));
1352 #endif
1353
1354       if (! tty_name)
1355         {
1356           message (TRUE, "%s: could not get terminal name\n", progname);
1357           fail ();
1358         }
1359
1360       if (! type)
1361         {
1362           message (TRUE, "%s: please set the TERM variable to your terminal type\n",
1363                    progname);
1364           fail ();
1365         }
1366
1367       if (! strcmp (type, "eterm"))
1368         {
1369           /* This causes nasty, MULTI_KBOARD-related input lockouts. */
1370           message (TRUE, "%s: opening a frame in an Emacs term buffer"
1371                    " is not supported\n", progname);
1372           fail ();
1373         }
1374 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1375       init_signals ();
1376 #endif
1377
1378       send_to_emacs (emacs_socket, "-tty ");
1379       quote_argument (emacs_socket, tty_name);
1380       send_to_emacs (emacs_socket, " ");
1381       quote_argument (emacs_socket, type);
1382       send_to_emacs (emacs_socket, " ");
1383     }
1384
1385   if (window_system)
1386     send_to_emacs (emacs_socket, "-window-system ");
1387
1388   if ((argc - optind > 0))
1389     {
1390       for (i = optind; i < argc; i++)
1391         {
1392           int relative = 0;
1393
1394           if (eval)
1395             {
1396               /* Don't prepend cwd or anything like that.  */
1397               send_to_emacs (emacs_socket, "-eval ");
1398               quote_argument (emacs_socket, argv[i]);
1399               send_to_emacs (emacs_socket, " ");
1400               continue;
1401             }
1402
1403           if (*argv[i] == '+')
1404             {
1405               char *p = argv[i] + 1;
1406               while (isdigit ((unsigned char) *p) || *p == ':') p++;
1407               if (*p == 0)
1408                 {
1409                   send_to_emacs (emacs_socket, "-position ");
1410                   quote_argument (emacs_socket, argv[i]);
1411                   send_to_emacs (emacs_socket, " ");
1412                   continue;
1413                 }
1414               else
1415                 relative = 1;
1416             }
1417           else if (! file_name_absolute_p (argv[i]))
1418             relative = 1;
1419
1420           send_to_emacs (emacs_socket, "-file ");
1421           if (relative)
1422             {
1423               quote_argument (emacs_socket, cwd);
1424               send_to_emacs (emacs_socket, "/");
1425             }
1426           quote_argument (emacs_socket, argv[i]);
1427           send_to_emacs (emacs_socket, " ");
1428         }
1429     }
1430   else
1431     {
1432       if (!tty && !window_system)
1433         {
1434           while ((str = fgets (string, BUFSIZ, stdin)))
1435             {
1436               if (eval)
1437                 send_to_emacs (emacs_socket, "-eval ");
1438               else
1439                 send_to_emacs (emacs_socket, "-file ");
1440               quote_argument (emacs_socket, str);
1441             }
1442           send_to_emacs (emacs_socket, " ");
1443         }
1444     }
1445
1446   send_to_emacs (emacs_socket, "\n");
1447
1448   /* Wait for an answer. */
1449   if (!eval && !tty && !nowait)
1450     {
1451       printf ("Waiting for Emacs...");
1452       needlf = 2;
1453     }
1454   fflush (stdout);
1455   fsync (1);
1456
1457   /* Now, wait for an answer and print any messages.  */
1458   while ((rl = recv (emacs_socket, string, BUFSIZ, 0)) > 0)
1459     {
1460       char *p;
1461       string[rl] = '\0';
1462
1463       p = string + strlen (string) - 1;
1464       while (p > string && *p == '\n')
1465         *p-- = 0;
1466
1467       if (strprefix ("-good-version ", string))
1468         {
1469           /* -good-version: The versions match. */
1470         }
1471       else if (strprefix ("-emacs-pid ", string))
1472         {
1473           /* -emacs-pid PID: The process id of the Emacs process. */
1474           emacs_pid = strtol (string + strlen ("-emacs-pid"), NULL, 10);
1475         }
1476       else if (strprefix ("-window-system-unsupported ", string))
1477         {
1478           /* -window-system-unsupported: Emacs was compiled without X
1479               support.  Try again on the terminal. */
1480           window_system = 0;
1481           nowait = 0;
1482           tty = 1;
1483           goto retry;
1484         }
1485       else if (strprefix ("-print ", string))
1486         {
1487           /* -print STRING: Print STRING on the terminal. */
1488           str = unquote_argument (string + strlen ("-print "));
1489           if (needlf)
1490             printf ("\n");
1491           printf ("%s", str);
1492           needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1493         }
1494       else if (strprefix ("-error ", string))
1495         {
1496           /* -error DESCRIPTION: Signal an error on the terminal. */
1497           str = unquote_argument (string + strlen ("-error "));
1498           if (needlf)
1499             printf ("\n");
1500           fprintf (stderr, "*ERROR*: %s", str);
1501           needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1502         }
1503 #ifndef WINDOWSNT
1504       else if (strprefix ("-suspend ", string))
1505         {
1506           /* -suspend: Suspend this terminal, i.e., stop the process. */
1507           if (needlf)
1508             printf ("\n");
1509           needlf = 0;
1510           kill (0, SIGSTOP);
1511         }
1512 #endif
1513       else
1514         {
1515           /* Unknown command. */
1516           if (needlf)
1517             printf ("\n");
1518           printf ("*ERROR*: Unknown message: %s", string);
1519           needlf = string[0] == '\0' ? needlf : string[strlen (string) - 1] != '\n';
1520         }
1521     }
1522
1523   if (needlf)
1524     printf ("\n");
1525   fflush (stdout);
1526   fsync (1);
1527
1528   CLOSE_SOCKET (emacs_socket);
1529   return EXIT_SUCCESS;
1530 }
1531
1532 #endif /* HAVE_SOCKETS && HAVE_INET_SOCKETS */
1533
1534 \f
1535 #ifndef HAVE_STRERROR
1536 char *
1537 strerror (errnum)
1538      int errnum;
1539 {
1540   extern char *sys_errlist[];
1541   extern int sys_nerr;
1542
1543   if (errnum >= 0 && errnum < sys_nerr)
1544     return sys_errlist[errnum];
1545   return (char *) "Unknown error";
1546 }
1547
1548 #endif /* ! HAVE_STRERROR */
1549
1550 /* arch-tag: f39bb9c4-73eb-477e-896d-50832e2ca9a7
1551    (do not change this comment) */
1552
1553 /* emacsclient.c ends here */