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