lib-src/emacsclient.c

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