lib-src/emacsclient.c

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