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