lib-src/emacsclient.c

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