lib-src/emacsclient.c

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