lib-src/emacsclient.c

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