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