lib-src/emacsclient.c

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