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       sock_err_message ("socket");
 965       return INVALID_SOCKET;
 966     }
 967
 968   /* Set up the socket.  */
 969   if (connect (s, (struct sockaddr *) &server, sizeof server) < 0)
 970     {
 971       sock_err_message ("connect");
 972       return INVALID_SOCKET;
 973     }
 974
 975   setsockopt (s, SOL_SOCKET, SO_LINGER, (char *) &l_arg, sizeof l_arg);
 976
 977   /* Send the authentication.  */
 978   auth_string[AUTH_KEY_LENGTH] = '\0';
 979
 980   send_to_emacs (s, "-auth ");
 981   send_to_emacs (s, auth_string);
 982   send_to_emacs (s, " ");
 983
 984   return s;
 985 }
 986
 987
 988 /* Returns 1 if PREFIX is a prefix of STRING. */
 989 static int
 990 strprefix (const char *prefix, const char *string)
 991 {
 992   return !strncmp (prefix, string, strlen (prefix));
 993 }
 994
 995 /* Get tty name and type.  If successful, return the type in TTY_TYPE
 996    and the name in TTY_NAME, and return 1.  Otherwise, fail if NOABORT
 997    is zero, or return 0 if NOABORT is non-zero.  */
 998
 999 static int
1000 find_tty (const char **tty_type, const char **tty_name, int noabort)
1001 {
1002   const char *type = egetenv ("TERM");
1003   const char *name = ttyname (fileno (stdout));
1004
1005   if (!name)
1006     {
1007       if (noabort)
1008         return 0;
1009       else
1010         {
1011           message (true, "%s: could not get terminal name\n", progname);
1012           fail ();
1013         }
1014     }
1015
1016   if (!type)
1017     {
1018       if (noabort)
1019         return 0;
1020       else
1021         {
1022           message (true, "%s: please set the TERM variable to your terminal type\n",
1023                    progname);
1024           fail ();
1025         }
1026     }
1027
1028   if (strcmp (type, "eterm") == 0)
1029     {
1030       if (noabort)
1031         return 0;
1032       else
1033         {
1034           /* This causes nasty, MULTI_KBOARD-related input lockouts. */
1035           message (true, "%s: opening a frame in an Emacs term buffer"
1036                    " is not supported\n", progname);
1037           fail ();
1038         }
1039     }
1040
1041   *tty_name = name;
1042   *tty_type = type;
1043   return 1;
1044 }
1045
1046
1047 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1048
1049 /* Three possibilities:
1050    2 - can't be `stat'ed                (sets errno)
1051    1 - isn't owned by us
1052    0 - success: none of the above */
1053
1054 static int
1055 socket_status (const char *name)
1056 {
1057   struct stat statbfr;
1058
1059   if (stat (name, &statbfr) == -1)
1060     return 2;
1061
1062   if (statbfr.st_uid != geteuid ())
1063     return 1;
1064
1065   return 0;
1066 }
1067
1068 \f
1069 /* A signal handler that passes the signal to the Emacs process.
1070    Useful for SIGWINCH.  */
1071
1072 static void
1073 pass_signal_to_emacs (int signalnum)
1074 {
1075   int old_errno = errno;
1076
1077   if (emacs_pid)
1078     kill (emacs_pid, signalnum);
1079
1080   signal (signalnum, pass_signal_to_emacs);
1081   errno = old_errno;
1082 }
1083
1084 /* Signal handler for SIGCONT; notify the Emacs process that it can
1085    now resume our tty frame.  */
1086
1087 static void
1088 handle_sigcont (int signalnum)
1089 {
1090   int old_errno = errno;
1091   pid_t pgrp = getpgrp ();
1092   pid_t tcpgrp = tcgetpgrp (1);
1093
1094   if (tcpgrp == pgrp)
1095     {
1096       /* We are in the foreground.  */
1097       send_to_emacs (emacs_socket, "-resume \n");
1098     }
1099   else if (0 <= tcpgrp && tty)
1100     {
1101       /* We are in the background; cancel the continue.  */
1102       kill (-pgrp, SIGTTIN);
1103     }
1104
1105   signal (signalnum, handle_sigcont);
1106   errno = old_errno;
1107 }
1108
1109 /* Signal handler for SIGTSTP; notify the Emacs process that we are
1110    going to sleep.  Normally the suspend is initiated by Emacs via
1111    server-handle-suspend-tty, but if the server gets out of sync with
1112    reality, we may get a SIGTSTP on C-z.  Handling this signal and
1113    notifying Emacs about it should get things under control again.  */
1114
1115 static void
1116 handle_sigtstp (int signalnum)
1117 {
1118   int old_errno = errno;
1119   sigset_t set;
1120
1121   if (emacs_socket)
1122     send_to_emacs (emacs_socket, "-suspend \n");
1123
1124   /* Unblock this signal and call the default handler by temporarily
1125      changing the handler and resignaling.  */
1126   sigprocmask (SIG_BLOCK, NULL, &set);
1127   sigdelset (&set, signalnum);
1128   signal (signalnum, SIG_DFL);
1129   raise (signalnum);
1130   sigprocmask (SIG_SETMASK, &set, NULL); /* Let's the above signal through. */
1131   signal (signalnum, handle_sigtstp);
1132
1133   errno = old_errno;
1134 }
1135
1136
1137 /* Set up signal handlers before opening a frame on the current tty.  */
1138
1139 static void
1140 init_signals (void)
1141 {
1142   /* Set up signal handlers. */
1143   signal (SIGWINCH, pass_signal_to_emacs);
1144
1145   /* Don't pass SIGINT and SIGQUIT to Emacs, because it has no way of
1146      deciding which terminal the signal came from.  C-g is now a
1147      normal input event on secondary terminals.  */
1148 #if 0
1149   signal (SIGINT, pass_signal_to_emacs);
1150   signal (SIGQUIT, pass_signal_to_emacs);
1151 #endif
1152
1153   signal (SIGCONT, handle_sigcont);
1154   signal (SIGTSTP, handle_sigtstp);
1155   signal (SIGTTOU, handle_sigtstp);
1156 }
1157
1158
1159 static HSOCKET
1160 set_local_socket (const char *local_socket_name)
1161 {
1162   HSOCKET s;
1163   struct sockaddr_un server;
1164
1165   /* Open up an AF_UNIX socket in this person's home directory.  */
1166   if ((s = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
1167     {
1168       message (true, "%s: socket: %s\n", progname, strerror (errno));
1169       return INVALID_SOCKET;
1170     }
1171
1172   server.sun_family = AF_UNIX;
1173
1174   {
1175     int sock_status;
1176     int use_tmpdir = 0;
1177     int saved_errno;
1178     const char *server_name = local_socket_name;
1179     const char *tmpdir IF_LINT ( = NULL);
1180     char *tmpdir_storage = NULL;
1181     char *socket_name_storage = NULL;
1182
1183     if (!strchr (local_socket_name, '/') && !strchr (local_socket_name, '\\'))
1184       {
1185         /* socket_name is a file name component.  */
1186         long uid = geteuid ();
1187         use_tmpdir = 1;
1188         tmpdir = egetenv ("TMPDIR");
1189         if (!tmpdir)
1190           {
1191 #ifdef DARWIN_OS
1192 #ifndef _CS_DARWIN_USER_TEMP_DIR
1193 #define _CS_DARWIN_USER_TEMP_DIR 65537
1194 #endif
1195             size_t n = confstr (_CS_DARWIN_USER_TEMP_DIR, NULL, (size_t) 0);
1196             if (n > 0)
1197               {
1198                 tmpdir = tmpdir_storage = xmalloc (n);
1199                 confstr (_CS_DARWIN_USER_TEMP_DIR, tmpdir_storage, n);
1200               }
1201             else
1202 #endif
1203               tmpdir = "/tmp";
1204           }
1205         socket_name_storage =
1206           xmalloc (strlen (tmpdir) + strlen (server_name) + EXTRA_SPACE);
1207         char *z = stpcpy (socket_name_storage, tmpdir);
1208         z += sprintf (z, "/emacs%ld/", uid);
1209         strcpy (z, server_name);
1210         local_socket_name = socket_name_storage;
1211       }
1212
1213     if (strlen (local_socket_name) < sizeof (server.sun_path))
1214       strcpy (server.sun_path, local_socket_name);
1215     else
1216       {
1217         message (true, "%s: socket-name %s too long\n",
1218                  progname, local_socket_name);
1219         fail ();
1220       }
1221
1222     /* See if the socket exists, and if it's owned by us. */
1223     sock_status = socket_status (server.sun_path);
1224     saved_errno = errno;
1225     if (sock_status && use_tmpdir)
1226       {
1227         /* Failing that, see if LOGNAME or USER exist and differ from
1228            our euid.  If so, look for a socket based on the UID
1229            associated with the name.  This is reminiscent of the logic
1230            that init_editfns uses to set the global Vuser_full_name.  */
1231
1232         const char *user_name = egetenv ("LOGNAME");
1233
1234         if (!user_name)
1235           user_name = egetenv ("USER");
1236
1237         if (user_name)
1238           {
1239             struct passwd *pw = getpwnam (user_name);
1240
1241             if (pw && (pw->pw_uid != geteuid ()))
1242               {
1243                 /* We're running under su, apparently. */
1244                 long uid = pw->pw_uid;
1245                 char *user_socket_name
1246                   = xmalloc (strlen (tmpdir) + strlen (server_name)
1247                              + EXTRA_SPACE);
1248                 char *z = stpcpy (user_socket_name, tmpdir);
1249                 z += sprintf (z, "/emacs%ld/", uid);
1250                 strcpy (z, server_name);
1251
1252                 if (strlen (user_socket_name) < sizeof (server.sun_path))
1253                   strcpy (server.sun_path, user_socket_name);
1254                 else
1255                   {
1256                     message (true, "%s: socket-name %s too long\n",
1257                              progname, user_socket_name);
1258                     exit (EXIT_FAILURE);
1259                   }
1260                 free (user_socket_name);
1261
1262                 sock_status = socket_status (server.sun_path);
1263                 saved_errno = errno;
1264               }
1265             else
1266               errno = saved_errno;
1267           }
1268       }
1269
1270     free (socket_name_storage);
1271     free (tmpdir_storage);
1272
1273     switch (sock_status)
1274       {
1275       case 1:
1276         /* There's a socket, but it isn't owned by us.  This is OK if
1277            we are root. */
1278         if (0 != geteuid ())
1279           {
1280             message (true, "%s: Invalid socket owner\n", progname);
1281             return INVALID_SOCKET;
1282           }
1283         break;
1284
1285       case 2:
1286         /* `stat' failed */
1287         if (saved_errno == ENOENT)
1288           message (true,
1289                    "%s: can't find socket; have you started the server?\n\
1290 To start the server in Emacs, type \"M-x server-start\".\n",
1291                    progname);
1292         else
1293           message (true, "%s: can't stat %s: %s\n",
1294                    progname, server.sun_path, strerror (saved_errno));
1295         return INVALID_SOCKET;
1296       }
1297   }
1298
1299   if (connect (s, (struct sockaddr *) &server, strlen (server.sun_path) + 2)
1300       < 0)
1301     {
1302       message (true, "%s: connect: %s\n", progname, strerror (errno));
1303       return INVALID_SOCKET;
1304     }
1305
1306   return s;
1307 }
1308 #endif /* ! NO_SOCKETS_IN_FILE_SYSTEM */
1309
1310 static HSOCKET
1311 set_socket (int no_exit_if_error)
1312 {
1313   HSOCKET s;
1314   const char *local_server_file = server_file;
1315
1316   INITIALIZE ();
1317
1318 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1319   /* Explicit --socket-name argument.  */
1320   if (socket_name)
1321     {
1322       s = set_local_socket (socket_name);
1323       if ((s != INVALID_SOCKET) || no_exit_if_error)
1324         return s;
1325       message (true, "%s: error accessing socket \"%s\"\n",
1326                progname, socket_name);
1327       exit (EXIT_FAILURE);
1328     }
1329 #endif
1330
1331   /* Explicit --server-file arg or EMACS_SERVER_FILE variable.  */
1332   if (!local_server_file)
1333     local_server_file = egetenv ("EMACS_SERVER_FILE");
1334
1335   if (local_server_file)
1336     {
1337       s = set_tcp_socket (local_server_file);
1338       if ((s != INVALID_SOCKET) || no_exit_if_error)
1339         return s;
1340
1341       message (true, "%s: error accessing server file \"%s\"\n",
1342                progname, local_server_file);
1343       exit (EXIT_FAILURE);
1344     }
1345
1346 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1347   /* Implicit local socket.  */
1348   s = set_local_socket ("server");
1349   if (s != INVALID_SOCKET)
1350     return s;
1351 #endif
1352
1353   /* Implicit server file.  */
1354   s = set_tcp_socket ("server");
1355   if ((s != INVALID_SOCKET) || no_exit_if_error)
1356     return s;
1357
1358   /* No implicit or explicit socket, and no alternate editor.  */
1359   message (true, "%s: No socket or alternate editor.  Please use:\n\n"
1360 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1361 "\t--socket-name\n"
1362 #endif
1363 "\t--server-file      (or environment variable EMACS_SERVER_FILE)\n\
1364 \t--alternate-editor (or environment variable ALTERNATE_EDITOR)\n",
1365            progname);
1366   exit (EXIT_FAILURE);
1367 }
1368
1369 #ifdef HAVE_NTGUI
1370 FARPROC set_fg;  /* Pointer to AllowSetForegroundWindow.  */
1371 FARPROC get_wc;  /* Pointer to RealGetWindowClassA.  */
1372
1373 void
1374 w32_set_user_model_id (void)
1375 {
1376   HMODULE shell;
1377   HRESULT (WINAPI * set_user_model) (wchar_t * id);
1378
1379   /* On Windows 7 and later, we need to set the user model ID
1380      to associate emacsclient launched files with Emacs frames
1381      in the UI.  */
1382   shell = LoadLibrary ("shell32.dll");
1383   if (shell)
1384     {
1385       set_user_model
1386         = (void *) GetProcAddress (shell,
1387                                    "SetCurrentProcessExplicitAppUserModelID");
1388       /* If the function is defined, then we are running on Windows 7
1389          or newer, and the UI uses this to group related windows
1390          together.  Since emacs, runemacs, emacsclient are related, we
1391          want them grouped even though the executables are different,
1392          so we need to set a consistent ID between them.  */
1393       if (set_user_model)
1394         set_user_model (L"GNU.Emacs");
1395
1396       FreeLibrary (shell);
1397     }
1398 }
1399
1400 BOOL CALLBACK
1401 w32_find_emacs_process (HWND hWnd, LPARAM lParam)
1402 {
1403   DWORD pid;
1404   char class[6];
1405
1406   /* Reject any window not of class "Emacs".  */
1407   if (! get_wc (hWnd, class, sizeof (class))
1408       || strcmp (class, "Emacs"))
1409     return TRUE;
1410
1411   /* We only need the process id, not the thread id.  */
1412   (void) GetWindowThreadProcessId (hWnd, &pid);
1413
1414   /* Not the one we're looking for.  */
1415   if (pid != (DWORD) emacs_pid) return TRUE;
1416
1417   /* OK, let's raise it.  */
1418   set_fg (emacs_pid);
1419
1420   /* Stop enumeration.  */
1421   return FALSE;
1422 }
1423
1424 /* Search for a window of class "Emacs" and owned by a process with
1425    process id = emacs_pid.  If found, allow it to grab the focus.  */
1426
1427 void
1428 w32_give_focus (void)
1429 {
1430   HANDLE user32;
1431
1432   /* It shouldn't happen when dealing with TCP sockets.  */
1433   if (!emacs_pid) return;
1434
1435   user32 = GetModuleHandle ("user32.dll");
1436
1437   if (!user32)
1438     return;
1439
1440   /* Modern Windows restrict which processes can set the foreground window.
1441      emacsclient can allow Emacs to grab the focus by calling the function
1442      AllowSetForegroundWindow.  Unfortunately, older Windows (W95, W98 and
1443      NT) lack this function, so we have to check its availability.  */
1444   if ((set_fg = GetProcAddress (user32, "AllowSetForegroundWindow"))
1445       && (get_wc = GetProcAddress (user32, "RealGetWindowClassA")))
1446     EnumWindows (w32_find_emacs_process, (LPARAM) 0);
1447 }
1448 #endif /* HAVE_NTGUI */
1449
1450 /* Start the emacs daemon and try to connect to it.  */
1451
1452 static void
1453 start_daemon_and_retry_set_socket (void)
1454 {
1455 #ifndef WINDOWSNT
1456   pid_t dpid;
1457   int status;
1458
1459   dpid = fork ();
1460
1461   if (dpid > 0)
1462     {
1463       pid_t w;
1464       w = waitpid (dpid, &status, WUNTRACED | WCONTINUED);
1465
1466       if ((w == -1) || !WIFEXITED (status) || WEXITSTATUS (status))
1467         {
1468           message (true, "Error: Could not start the Emacs daemon\n");
1469           exit (EXIT_FAILURE);
1470         }
1471
1472       /* Try connecting, the daemon should have started by now.  */
1473       message (true, "Emacs daemon should have started, trying to connect again\n");
1474       if ((emacs_socket = set_socket (1)) == INVALID_SOCKET)
1475         {
1476           message (true, "Error: Cannot connect even after starting the Emacs daemon\n");
1477           exit (EXIT_FAILURE);
1478         }
1479     }
1480   else if (dpid < 0)
1481     {
1482       fprintf (stderr, "Error: Cannot fork!\n");
1483       exit (EXIT_FAILURE);
1484     }
1485   else
1486     {
1487       char emacs[] = "emacs";
1488       char daemon_option[] = "--daemon";
1489       char *d_argv[3];
1490       d_argv[0] = emacs;
1491       d_argv[1] = daemon_option;
1492       d_argv[2] = 0;
1493       if (socket_name != NULL)
1494         {
1495           /* Pass  --daemon=socket_name as argument.  */
1496           const char *deq = "--daemon=";
1497           char *daemon_arg = xmalloc (strlen (deq)
1498                                       + strlen (socket_name) + 1);
1499           strcpy (stpcpy (daemon_arg, deq), socket_name);
1500           d_argv[1] = daemon_arg;
1501         }
1502       execvp ("emacs", d_argv);
1503       message (true, "%s: error starting emacs daemon\n", progname);
1504     }
1505 #else  /* WINDOWSNT */
1506   DWORD wait_result;
1507   HANDLE w32_daemon_event;
1508   STARTUPINFO si;
1509   PROCESS_INFORMATION pi;
1510
1511   ZeroMemory (&si, sizeof si);
1512   si.cb = sizeof si;
1513   ZeroMemory (&pi, sizeof pi);
1514
1515   /* We start Emacs in daemon mode, and then wait for it to signal us
1516      it is ready to accept client connections, by asserting an event
1517      whose name is known to the daemon (defined by nt/inc/ms-w32.h).  */
1518
1519   if (!CreateProcess (NULL, "emacs --daemon", NULL, NULL, FALSE,
1520                       CREATE_NO_WINDOW, NULL, NULL, &si, &pi))
1521     {
1522       char* msg = NULL;
1523
1524       FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
1525                      | FORMAT_MESSAGE_ALLOCATE_BUFFER
1526                      | FORMAT_MESSAGE_ARGUMENT_ARRAY,
1527                      NULL, GetLastError (), 0, (LPTSTR)&msg, 0, NULL);
1528       message (true, "%s: error starting emacs daemon (%s)\n", progname, msg);
1529       exit (EXIT_FAILURE);
1530     }
1531
1532   w32_daemon_event = CreateEvent (NULL, TRUE, FALSE, W32_DAEMON_EVENT);
1533   if (w32_daemon_event == NULL)
1534     {
1535       message (true, "Couldn't create Windows daemon event");
1536       exit (EXIT_FAILURE);
1537     }
1538   if ((wait_result = WaitForSingleObject (w32_daemon_event, INFINITE))
1539       != WAIT_OBJECT_0)
1540     {
1541       char *msg = NULL;
1542
1543       switch (wait_result)
1544         {
1545         case WAIT_ABANDONED:
1546           msg = "The daemon exited unexpectedly";
1547           break;
1548         case WAIT_TIMEOUT:
1549           /* Can't happen due to INFINITE.  */
1550         default:
1551         case WAIT_FAILED:
1552           FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
1553                          | FORMAT_MESSAGE_ALLOCATE_BUFFER
1554                          | FORMAT_MESSAGE_ARGUMENT_ARRAY,
1555                          NULL, GetLastError (), 0, (LPTSTR)&msg, 0, NULL);
1556           break;
1557         }
1558       message (true, "Error: Could not start the Emacs daemon: %s\n", msg);
1559       exit (EXIT_FAILURE);
1560     }
1561   CloseHandle (w32_daemon_event);
1562
1563   /* Try connecting, the daemon should have started by now.  */
1564   /* It's just a progress message, so don't pop a dialog if this is
1565      emacsclientw.  */
1566   if (!w32_window_app ())
1567     message (true,
1568              "Emacs daemon should have started, trying to connect again\n");
1569   if ((emacs_socket = set_socket (1)) == INVALID_SOCKET)
1570     {
1571       message (true,
1572                "Error: Cannot connect even after starting the Emacs daemon\n");
1573       exit (EXIT_FAILURE);
1574     }
1575 #endif  /* WINDOWSNT */
1576 }
1577
1578 int
1579 main (int argc, char **argv)
1580 {
1581   int rl = 0, needlf = 0;
1582   char *cwd, *str;
1583   char string[BUFSIZ+1];
1584   int start_daemon_if_needed;
1585   int exit_status = EXIT_SUCCESS;
1586
1587   main_argv = argv;
1588   progname = argv[0];
1589
1590 #ifdef HAVE_NTGUI
1591   /* On Windows 7 and later, we need to explicitly associate
1592      emacsclient with emacs so the UI behaves sensibly.  This
1593      association does no harm if we're not actually connecting to an
1594      Emacs using a window display.  */
1595   w32_set_user_model_id ();
1596 #endif /* HAVE_NTGUI */
1597
1598   /* Process options.  */
1599   decode_options (argc, argv);
1600
1601   if ((argc - optind < 1) && !eval && current_frame)
1602     {
1603       message (true, "%s: file name or argument required\n"
1604                "Try `%s --help' for more information\n",
1605                progname, progname);
1606       exit (EXIT_FAILURE);
1607     }
1608
1609 #ifndef WINDOWSNT
1610   if (tty)
1611     {
1612       pid_t pgrp = getpgrp ();
1613       pid_t tcpgrp = tcgetpgrp (1);
1614       if (0 <= tcpgrp && tcpgrp != pgrp)
1615         kill (-pgrp, SIGTTIN);
1616     }
1617 #endif /* !WINDOWSNT */
1618
1619   /* If alternate_editor is the empty string, start the emacs daemon
1620      in case of failure to connect.  */
1621   start_daemon_if_needed = (alternate_editor
1622                             && (alternate_editor[0] == '\0'));
1623
1624   emacs_socket = set_socket (alternate_editor || start_daemon_if_needed);
1625   if (emacs_socket == INVALID_SOCKET)
1626     {
1627       if (! start_daemon_if_needed)
1628         fail ();
1629
1630       start_daemon_and_retry_set_socket ();
1631     }
1632
1633   cwd = get_current_dir_name ();
1634   if (cwd == 0)
1635     {
1636       message (true, "%s: %s\n", progname,
1637                "Cannot get current working directory");
1638       fail ();
1639     }
1640
1641 #ifdef HAVE_NTGUI
1642   if (display && !strcmp (display, "w32"))
1643   w32_give_focus ();
1644 #endif /* HAVE_NTGUI */
1645
1646   /* Send over our environment and current directory. */
1647   if (!current_frame)
1648     {
1649       int i;
1650       for (i = 0; environ[i]; i++)
1651         {
1652           send_to_emacs (emacs_socket, "-env ");
1653           quote_argument (emacs_socket, environ[i]);
1654           send_to_emacs (emacs_socket, " ");
1655         }
1656     }
1657   send_to_emacs (emacs_socket, "-dir ");
1658   quote_argument (emacs_socket, cwd);
1659   send_to_emacs (emacs_socket, "/");
1660   send_to_emacs (emacs_socket, " ");
1661
1662  retry:
1663   if (nowait)
1664     send_to_emacs (emacs_socket, "-nowait ");
1665
1666   if (current_frame)
1667     send_to_emacs (emacs_socket, "-current-frame ");
1668
1669   if (display)
1670     {
1671       send_to_emacs (emacs_socket, "-display ");
1672       quote_argument (emacs_socket, display);
1673       send_to_emacs (emacs_socket, " ");
1674     }
1675
1676   if (parent_id)
1677     {
1678       send_to_emacs (emacs_socket, "-parent-id ");
1679       quote_argument (emacs_socket, parent_id);
1680       send_to_emacs (emacs_socket, " ");
1681     }
1682
1683   if (frame_parameters && !current_frame)
1684     {
1685       send_to_emacs (emacs_socket, "-frame-parameters ");
1686       quote_argument (emacs_socket, frame_parameters);
1687       send_to_emacs (emacs_socket, " ");
1688     }
1689
1690   /* Unless we are certain we don't want to occupy the tty, send our
1691      tty information to Emacs.  For example, in daemon mode Emacs may
1692      need to occupy this tty if no other frame is available.  */
1693   if (!current_frame || !eval)
1694     {
1695       const char *tty_type, *tty_name;
1696
1697       if (find_tty (&tty_type, &tty_name, !tty))
1698         {
1699 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1700           init_signals ();
1701 #endif
1702           send_to_emacs (emacs_socket, "-tty ");
1703           quote_argument (emacs_socket, tty_name);
1704           send_to_emacs (emacs_socket, " ");
1705           quote_argument (emacs_socket, tty_type);
1706           send_to_emacs (emacs_socket, " ");
1707         }
1708     }
1709
1710   if (!current_frame && !tty)
1711     send_to_emacs (emacs_socket, "-window-system ");
1712
1713   if ((argc - optind > 0))
1714     {
1715       int i;
1716       for (i = optind; i < argc; i++)
1717         {
1718
1719           if (eval)
1720             {
1721               /* Don't prepend cwd or anything like that.  */
1722               send_to_emacs (emacs_socket, "-eval ");
1723               quote_argument (emacs_socket, argv[i]);
1724               send_to_emacs (emacs_socket, " ");
1725               continue;
1726             }
1727
1728           if (*argv[i] == '+')
1729             {
1730               char *p = argv[i] + 1;
1731               while (isdigit ((unsigned char) *p) || *p == ':') p++;
1732               if (*p == 0)
1733                 {
1734                   send_to_emacs (emacs_socket, "-position ");
1735                   quote_argument (emacs_socket, argv[i]);
1736                   send_to_emacs (emacs_socket, " ");
1737                   continue;
1738                 }
1739             }
1740 #ifdef WINDOWSNT
1741           else if (! file_name_absolute_p (argv[i])
1742                    && (isalpha (argv[i][0]) && argv[i][1] == ':'))
1743             /* Windows can have a different default directory for each
1744                drive, so the cwd passed via "-dir" is not sufficient
1745                to account for that.
1746                If the user uses <drive>:<relpath>, we hence need to be
1747                careful to expand <relpath> with the default directory
1748                corresponding to <drive>.  */
1749             {
1750               char *filename = (char *) xmalloc (MAX_PATH);
1751               DWORD size;
1752
1753               size = GetFullPathName (argv[i], MAX_PATH, filename, NULL);
1754               if (size > 0 && size < MAX_PATH)
1755                 argv[i] = filename;
1756               else
1757                 free (filename);
1758             }
1759 #endif
1760
1761           send_to_emacs (emacs_socket, "-file ");
1762           quote_argument (emacs_socket, argv[i]);
1763           send_to_emacs (emacs_socket, " ");
1764         }
1765     }
1766   else if (eval)
1767     {
1768       /* Read expressions interactively.  */
1769       while ((str = fgets (string, BUFSIZ, stdin)))
1770         {
1771           send_to_emacs (emacs_socket, "-eval ");
1772           quote_argument (emacs_socket, str);
1773         }
1774       send_to_emacs (emacs_socket, " ");
1775     }
1776
1777   send_to_emacs (emacs_socket, "\n");
1778
1779   /* Wait for an answer. */
1780   if (!eval && !tty && !nowait && !quiet)
1781     {
1782       printf ("Waiting for Emacs...");
1783       needlf = 2;
1784     }
1785   fflush (stdout);
1786   while (fdatasync (1) != 0 && errno == EINTR)
1787     continue;
1788
1789   /* Now, wait for an answer and print any messages.  */
1790   while (exit_status == EXIT_SUCCESS)
1791     {
1792       char *p, *end_p;
1793       do
1794         {
1795           errno = 0;
1796           rl = recv (emacs_socket, string, BUFSIZ, 0);
1797         }
1798       /* If we receive a signal (e.g. SIGWINCH, which we pass
1799          through to Emacs), on some OSes we get EINTR and must retry. */
1800       while (rl < 0 && errno == EINTR);
1801
1802       if (rl <= 0)
1803         break;
1804
1805       string[rl] = '\0';
1806
1807       /* Loop over all NL-terminated messages.  */
1808       for (end_p = p = string; end_p != NULL && *end_p != '\0'; p = end_p)
1809         {
1810           end_p = strchr (p, '\n');
1811           if (end_p != NULL)
1812             *end_p++ = '\0';
1813
1814           if (strprefix ("-emacs-pid ", p))
1815             {
1816               /* -emacs-pid PID: The process id of the Emacs process. */
1817               emacs_pid = strtol (p + strlen ("-emacs-pid"), NULL, 10);
1818             }
1819           else if (strprefix ("-window-system-unsupported ", p))
1820             {
1821               /* -window-system-unsupported: Emacs was compiled without support
1822                  for whatever window system we tried.  Try the alternate
1823                  display, or, failing that, try the terminal.  */
1824               if (alt_display)
1825                 {
1826                   display = alt_display;
1827                   alt_display = NULL;
1828                 }
1829               else
1830                 {
1831                   nowait = 0;
1832                   tty = 1;
1833                 }
1834
1835               goto retry;
1836             }
1837           else if (strprefix ("-print ", p))
1838             {
1839               /* -print STRING: Print STRING on the terminal. */
1840               str = unquote_argument (p + strlen ("-print "));
1841               if (needlf)
1842                 printf ("\n");
1843               printf ("%s", str);
1844               needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1845             }
1846           else if (strprefix ("-print-nonl ", p))
1847             {
1848               /* -print-nonl STRING: Print STRING on the terminal.
1849                  Used to continue a preceding -print command.  */
1850               str = unquote_argument (p + strlen ("-print-nonl "));
1851               printf ("%s", str);
1852               needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1853             }
1854           else if (strprefix ("-error ", p))
1855             {
1856               /* -error DESCRIPTION: Signal an error on the terminal. */
1857               str = unquote_argument (p + strlen ("-error "));
1858               if (needlf)
1859                 printf ("\n");
1860               fprintf (stderr, "*ERROR*: %s", str);
1861               needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1862               exit_status = EXIT_FAILURE;
1863             }
1864 #ifdef SIGSTOP
1865           else if (strprefix ("-suspend ", p))
1866             {
1867               /* -suspend: Suspend this terminal, i.e., stop the process. */
1868               if (needlf)
1869                 printf ("\n");
1870               needlf = 0;
1871               kill (0, SIGSTOP);
1872             }
1873 #endif
1874           else
1875             {
1876               /* Unknown command. */
1877               if (needlf)
1878                 printf ("\n");
1879               needlf = 0;
1880               printf ("*ERROR*: Unknown message: %s\n", p);
1881             }
1882         }
1883     }
1884
1885   if (needlf)
1886     printf ("\n");
1887   fflush (stdout);
1888   while (fdatasync (1) != 0 && errno == EINTR)
1889     continue;
1890
1891   if (rl < 0)
1892     exit_status = EXIT_FAILURE;
1893
1894   CLOSE_SOCKET (emacs_socket);
1895   return exit_status;
1896 }
1897
1898 #endif /* HAVE_SOCKETS && HAVE_INET_SOCKETS */