lib-src/emacsclient.c

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