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%s%s%s", progname, "\
 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 ", "\
 644 -F ALIST, --frame-parameters=ALIST\n\
 645                         Set the parameters of a new frame\n\
 646 -e, --eval              Evaluate the FILE arguments as ELisp expressions\n\
 647 -n, --no-wait           Don't wait for the server to return\n\
 648 -q, --quiet             Don't display messages on success\n\
 649 -d DISPLAY, --display=DISPLAY\n\
 650                         Visit the file in the given display\n\
 651 ", "\
 652 --parent-id=ID          Open in parent window ID, via XEmbed\n"
 653 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
 654 "-s SOCKET, --socket-name=SOCKET\n\
 655                         Set filename of the UNIX socket for communication\n"
 656 #endif
 657 "-f SERVER, --server-file=SERVER\n\
 658                         Set filename of the TCP authentication file\n\
 659 -a EDITOR, --alternate-editor=EDITOR\n\
 660                         Editor to fallback to if the server is not running\n"
 661 #ifndef WINDOWSNT
 662 "                       If EDITOR is the empty string, start Emacs in daemon\n\
 663                         mode and try connecting again\n"
 664 #endif /* not WINDOWSNT */
 665 "\n\
 666 Report bugs with M-x report-emacs-bug.\n");
 667   exit (EXIT_SUCCESS);
 668 }
 669
 670 /* Try to run a different command, or --if no alternate editor is
 671    defined-- exit with an errorcode.
 672    Uses argv, but gets it from the global variable main_argv.  */
 673
 674 static _Noreturn void
 675 fail (void)
 676 {
 677   if (alternate_editor)
 678     {
 679       int i = optind - 1;
 680
 681       execvp (alternate_editor, main_argv + i);
 682       message (TRUE, "%s: error executing alternate editor \"%s\"\n",
 683                progname, alternate_editor);
 684     }
 685   exit (EXIT_FAILURE);
 686 }
 687
 688 \f
 689 #if !defined (HAVE_SOCKETS) || !defined (HAVE_INET_SOCKETS)
 690
 691 int
 692 main (int argc, char **argv)
 693 {
 694   main_argv = argv;
 695   progname = argv[0];
 696   message (TRUE, "%s: Sorry, the Emacs server is supported only\n"
 697            "on systems with Berkeley sockets.\n",
 698            argv[0]);
 699   fail ();
 700 }
 701
 702 #else /* HAVE_SOCKETS && HAVE_INET_SOCKETS */
 703
 704 #define AUTH_KEY_LENGTH      64
 705 #define SEND_BUFFER_SIZE   4096
 706
 707 /* Buffer to accumulate data to send in TCP connections.  */
 708 char send_buffer[SEND_BUFFER_SIZE + 1];
 709 int sblen = 0;  /* Fill pointer for the send buffer.  */
 710 /* Socket used to communicate with the Emacs server process.  */
 711 HSOCKET emacs_socket = 0;
 712
 713 /* On Windows, the socket library was historically separate from the
 714    standard C library, so errors are handled differently.  */
 715
 716 static void
 717 sock_err_message (const char *function_name)
 718 {
 719 #ifdef WINDOWSNT
 720   char* msg = NULL;
 721
 722   FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
 723                  | FORMAT_MESSAGE_ALLOCATE_BUFFER
 724                  | FORMAT_MESSAGE_ARGUMENT_ARRAY,
 725                  NULL, WSAGetLastError (), 0, (LPTSTR)&msg, 0, NULL);
 726
 727   message (TRUE, "%s: %s: %s\n", progname, function_name, msg);
 728
 729   LocalFree (msg);
 730 #else
 731   message (TRUE, "%s: %s: %s\n", progname, function_name, strerror (errno));
 732 #endif
 733 }
 734
 735
 736 /* Let's send the data to Emacs when either
 737    - the data ends in "\n", or
 738    - the buffer is full (but this shouldn't happen)
 739    Otherwise, we just accumulate it.  */
 740 static void
 741 send_to_emacs (HSOCKET s, const char *data)
 742 {
 743   size_t dlen;
 744
 745   if (!data)
 746     return;
 747
 748   dlen = strlen (data);
 749   while (*data)
 750     {
 751       size_t part = min (dlen, SEND_BUFFER_SIZE - sblen);
 752       memcpy (&send_buffer[sblen], data, part);
 753       data += part;
 754       sblen += part;
 755
 756       if (sblen == SEND_BUFFER_SIZE
 757           || (sblen > 0 && send_buffer[sblen-1] == '\n'))
 758         {
 759           int sent = send (s, send_buffer, sblen, 0);
 760           if (sent < 0)
 761             {
 762               message (TRUE, "%s: failed to send %d bytes to socket: %s\n",
 763                        progname, sblen, strerror (errno));
 764               fail ();
 765             }
 766           if (sent != sblen)
 767             memmove (send_buffer, &send_buffer[sent], sblen - sent);
 768           sblen -= sent;
 769         }
 770
 771       dlen -= part;
 772     }
 773 }
 774
 775 \f
 776 /* In STR, insert a & before each &, each space, each newline, and
 777    any initial -.  Change spaces to underscores, too, so that the
 778    return value never contains a space.
 779
 780    Does not change the string.  Outputs the result to S.  */
 781 static void
 782 quote_argument (HSOCKET s, const char *str)
 783 {
 784   char *copy = (char *) xmalloc (strlen (str) * 2 + 1);
 785   const char *p;
 786   char *q;
 787
 788   p = str;
 789   q = copy;
 790   while (*p)
 791     {
 792       if (*p == ' ')
 793         {
 794           *q++ = '&';
 795           *q++ = '_';
 796           p++;
 797         }
 798       else if (*p == '\n')
 799         {
 800           *q++ = '&';
 801           *q++ = 'n';
 802           p++;
 803         }
 804       else
 805         {
 806           if (*p == '&' || (*p == '-' && p == str))
 807             *q++ = '&';
 808           *q++ = *p++;
 809         }
 810     }
 811   *q++ = 0;
 812
 813   send_to_emacs (s, copy);
 814
 815   free (copy);
 816 }
 817
 818
 819 /* The inverse of quote_argument.  Removes quoting in string STR by
 820    modifying the string in place.   Returns STR.  */
 821
 822 static char *
 823 unquote_argument (char *str)
 824 {
 825   char *p, *q;
 826
 827   if (! str)
 828     return str;
 829
 830   p = str;
 831   q = str;
 832   while (*p)
 833     {
 834       if (*p == '&')
 835         {
 836           p++;
 837           if (*p == '&')
 838             *p = '&';
 839           else if (*p == '_')
 840             *p = ' ';
 841           else if (*p == 'n')
 842             *p = '\n';
 843           else if (*p == '-')
 844             *p = '-';
 845         }
 846       *q++ = *p++;
 847     }
 848   *q = 0;
 849   return str;
 850 }
 851
 852 \f
 853 static int
 854 file_name_absolute_p (const char *filename)
 855 {
 856   /* Sanity check, it shouldn't happen.  */
 857   if (! filename) return FALSE;
 858
 859   /* /xxx is always an absolute path.  */
 860   if (filename[0] == '/') return TRUE;
 861
 862   /* Empty filenames (which shouldn't happen) are relative.  */
 863   if (filename[0] == '\0') return FALSE;
 864
 865 #ifdef WINDOWSNT
 866   /* X:\xxx is always absolute.  */
 867   if (isalpha ((unsigned char) filename[0])
 868       && filename[1] == ':' && (filename[2] == '\\' || filename[2] == '/'))
 869     return TRUE;
 870
 871   /* Both \xxx and \\xxx\yyy are absolute.  */
 872   if (filename[0] == '\\') return TRUE;
 873 #endif
 874
 875   return FALSE;
 876 }
 877
 878 #ifdef WINDOWSNT
 879 /* Wrapper to make WSACleanup a cdecl, as required by atexit.  */
 880 void __cdecl
 881 close_winsock (void)
 882 {
 883   WSACleanup ();
 884 }
 885
 886 /* Initialize the WinSock2 library.  */
 887 void
 888 initialize_sockets (void)
 889 {
 890   WSADATA wsaData;
 891
 892   if (WSAStartup (MAKEWORD (2, 0), &wsaData))
 893     {
 894       message (TRUE, "%s: error initializing WinSock2\n", progname);
 895       exit (EXIT_FAILURE);
 896     }
 897
 898   atexit (close_winsock);
 899 }
 900 #endif /* WINDOWSNT */
 901
 902 \f
 903 /* Read the information needed to set up a TCP comm channel with
 904    the Emacs server: host, port, and authentication string.  */
 905
 906 static int
 907 get_server_config (const char *config_file, struct sockaddr_in *server,
 908                    char *authentication)
 909 {
 910   char dotted[32];
 911   char *port;
 912   FILE *config = NULL;
 913
 914   if (file_name_absolute_p (config_file))
 915     config = fopen (config_file, "rb");
 916   else
 917     {
 918       const char *home = egetenv ("HOME");
 919
 920       if (home)
 921         {
 922           char *path = xmalloc (strlen (home) + strlen (config_file)
 923                                 + EXTRA_SPACE);
 924           strcpy (path, home);
 925           strcat (path, "/.emacs.d/server/");
 926           strcat (path, config_file);
 927           config = fopen (path, "rb");
 928           free (path);
 929         }
 930 #ifdef WINDOWSNT
 931       if (!config && (home = egetenv ("APPDATA")))
 932         {
 933           char *path = xmalloc (strlen (home) + strlen (config_file)
 934                                 + EXTRA_SPACE);
 935           strcpy (path, home);
 936           strcat (path, "/.emacs.d/server/");
 937           strcat (path, config_file);
 938           config = fopen (path, "rb");
 939           free (path);
 940         }
 941 #endif
 942     }
 943
 944   if (! config)
 945     return FALSE;
 946
 947   if (fgets (dotted, sizeof dotted, config)
 948       && (port = strchr (dotted, ':')))
 949     *port++ = '\0';
 950   else
 951     {
 952       message (TRUE, "%s: invalid configuration info\n", progname);
 953       exit (EXIT_FAILURE);
 954     }
 955
 956   server->sin_family = AF_INET;
 957   server->sin_addr.s_addr = inet_addr (dotted);
 958   server->sin_port = htons (atoi (port));
 959
 960   if (! fread (authentication, AUTH_KEY_LENGTH, 1, config))
 961     {
 962       message (TRUE, "%s: cannot read authentication info\n", progname);
 963       exit (EXIT_FAILURE);
 964     }
 965
 966   fclose (config);
 967
 968   return TRUE;
 969 }
 970
 971 static HSOCKET
 972 set_tcp_socket (const char *local_server_file)
 973 {
 974   HSOCKET s;
 975   struct sockaddr_in server;
 976   struct linger l_arg = {1, 1};
 977   char auth_string[AUTH_KEY_LENGTH + 1];
 978
 979   if (! get_server_config (local_server_file, &server, auth_string))
 980     return INVALID_SOCKET;
 981
 982   if (server.sin_addr.s_addr != inet_addr ("127.0.0.1") && !quiet)
 983     message (FALSE, "%s: connected to remote socket at %s\n",
 984              progname, inet_ntoa (server.sin_addr));
 985
 986   /* Open up an AF_INET socket.  */
 987   if ((s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
 988     {
 989       sock_err_message ("socket");
 990       return INVALID_SOCKET;
 991     }
 992
 993   /* Set up the socket.  */
 994   if (connect (s, (struct sockaddr *) &server, sizeof server) < 0)
 995     {
 996       sock_err_message ("connect");
 997       return INVALID_SOCKET;
 998     }
 999
1000   setsockopt (s, SOL_SOCKET, SO_LINGER, (char *) &l_arg, sizeof l_arg);
1001
1002   /* Send the authentication.  */
1003   auth_string[AUTH_KEY_LENGTH] = '\0';
1004
1005   send_to_emacs (s, "-auth ");
1006   send_to_emacs (s, auth_string);
1007   send_to_emacs (s, " ");
1008
1009   return s;
1010 }
1011
1012
1013 /* Returns 1 if PREFIX is a prefix of STRING. */
1014 static int
1015 strprefix (const char *prefix, const char *string)
1016 {
1017   return !strncmp (prefix, string, strlen (prefix));
1018 }
1019
1020 /* Get tty name and type.  If successful, return the type in TTY_TYPE
1021    and the name in TTY_NAME, and return 1.  Otherwise, fail if NOABORT
1022    is zero, or return 0 if NOABORT is non-zero.  */
1023
1024 static int
1025 find_tty (const char **tty_type, const char **tty_name, int noabort)
1026 {
1027   const char *type = egetenv ("TERM");
1028   const char *name = ttyname (fileno (stdout));
1029
1030   if (!name)
1031     {
1032       if (noabort)
1033         return 0;
1034       else
1035         {
1036           message (TRUE, "%s: could not get terminal name\n", progname);
1037           fail ();
1038         }
1039     }
1040
1041   if (!type)
1042     {
1043       if (noabort)
1044         return 0;
1045       else
1046         {
1047           message (TRUE, "%s: please set the TERM variable to your terminal type\n",
1048                    progname);
1049           fail ();
1050         }
1051     }
1052
1053   if (strcmp (type, "eterm") == 0)
1054     {
1055       if (noabort)
1056         return 0;
1057       else
1058         {
1059           /* This causes nasty, MULTI_KBOARD-related input lockouts. */
1060           message (TRUE, "%s: opening a frame in an Emacs term buffer"
1061                    " is not supported\n", progname);
1062           fail ();
1063         }
1064     }
1065
1066   *tty_name = name;
1067   *tty_type = type;
1068   return 1;
1069 }
1070
1071
1072 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1073
1074 /* Three possibilities:
1075    2 - can't be `stat'ed                (sets errno)
1076    1 - isn't owned by us
1077    0 - success: none of the above */
1078
1079 static int
1080 socket_status (const char *name)
1081 {
1082   struct stat statbfr;
1083
1084   if (stat (name, &statbfr) == -1)
1085     return 2;
1086
1087   if (statbfr.st_uid != geteuid ())
1088     return 1;
1089
1090   return 0;
1091 }
1092
1093 \f
1094 /* A signal handler that passes the signal to the Emacs process.
1095    Useful for SIGWINCH.  */
1096
1097 static void
1098 pass_signal_to_emacs (int signalnum)
1099 {
1100   int old_errno = errno;
1101
1102   if (emacs_pid)
1103     kill (emacs_pid, signalnum);
1104
1105   signal (signalnum, pass_signal_to_emacs);
1106   errno = old_errno;
1107 }
1108
1109 /* Signal handler for SIGCONT; notify the Emacs process that it can
1110    now resume our tty frame.  */
1111
1112 static void
1113 handle_sigcont (int signalnum)
1114 {
1115   int old_errno = errno;
1116
1117   if (tcgetpgrp (1) == getpgrp ())
1118     {
1119       /* We are in the foreground. */
1120       send_to_emacs (emacs_socket, "-resume \n");
1121     }
1122   else
1123     {
1124       /* We are in the background; cancel the continue. */
1125       raise (SIGSTOP);
1126     }
1127
1128   signal (signalnum, handle_sigcont);
1129   errno = old_errno;
1130 }
1131
1132 /* Signal handler for SIGTSTP; notify the Emacs process that we are
1133    going to sleep.  Normally the suspend is initiated by Emacs via
1134    server-handle-suspend-tty, but if the server gets out of sync with
1135    reality, we may get a SIGTSTP on C-z.  Handling this signal and
1136    notifying Emacs about it should get things under control again.  */
1137
1138 static void
1139 handle_sigtstp (int signalnum)
1140 {
1141   int old_errno = errno;
1142   sigset_t set;
1143
1144   if (emacs_socket)
1145     send_to_emacs (emacs_socket, "-suspend \n");
1146
1147   /* Unblock this signal and call the default handler by temporarily
1148      changing the handler and resignaling.  */
1149   sigprocmask (SIG_BLOCK, NULL, &set);
1150   sigdelset (&set, signalnum);
1151   signal (signalnum, SIG_DFL);
1152   raise (signalnum);
1153   sigprocmask (SIG_SETMASK, &set, NULL); /* Let's the above signal through. */
1154   signal (signalnum, handle_sigtstp);
1155
1156   errno = old_errno;
1157 }
1158
1159
1160 /* Set up signal handlers before opening a frame on the current tty.  */
1161
1162 static void
1163 init_signals (void)
1164 {
1165   /* Set up signal handlers. */
1166   signal (SIGWINCH, pass_signal_to_emacs);
1167
1168   /* Don't pass SIGINT and SIGQUIT to Emacs, because it has no way of
1169      deciding which terminal the signal came from.  C-g is now a
1170      normal input event on secondary terminals.  */
1171 #if 0
1172   signal (SIGINT, pass_signal_to_emacs);
1173   signal (SIGQUIT, pass_signal_to_emacs);
1174 #endif
1175
1176   signal (SIGCONT, handle_sigcont);
1177   signal (SIGTSTP, handle_sigtstp);
1178   signal (SIGTTOU, handle_sigtstp);
1179 }
1180
1181
1182 static HSOCKET
1183 set_local_socket (const char *local_socket_name)
1184 {
1185   HSOCKET s;
1186   struct sockaddr_un server;
1187
1188   /* Open up an AF_UNIX socket in this person's home directory.  */
1189   if ((s = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
1190     {
1191       message (TRUE, "%s: socket: %s\n", progname, strerror (errno));
1192       return INVALID_SOCKET;
1193     }
1194
1195   server.sun_family = AF_UNIX;
1196
1197   {
1198     int sock_status;
1199     int use_tmpdir = 0;
1200     int saved_errno;
1201     const char *server_name = local_socket_name;
1202     const char *tmpdir IF_LINT ( = NULL);
1203     char *tmpdir_storage = NULL;
1204     char *socket_name_storage = NULL;
1205
1206     if (!strchr (local_socket_name, '/') && !strchr (local_socket_name, '\\'))
1207       {
1208         /* socket_name is a file name component.  */
1209         long uid = geteuid ();
1210         ptrdiff_t tmpdirlen;
1211         use_tmpdir = 1;
1212         tmpdir = egetenv ("TMPDIR");
1213         if (!tmpdir)
1214           {
1215 #ifdef DARWIN_OS
1216 #ifndef _CS_DARWIN_USER_TEMP_DIR
1217 #define _CS_DARWIN_USER_TEMP_DIR 65537
1218 #endif
1219             size_t n = confstr (_CS_DARWIN_USER_TEMP_DIR, NULL, (size_t) 0);
1220             if (n > 0)
1221               {
1222                 tmpdir = tmpdir_storage = xmalloc (n);
1223                 confstr (_CS_DARWIN_USER_TEMP_DIR, tmpdir_storage, n);
1224               }
1225             else
1226 #endif
1227               tmpdir = "/tmp";
1228           }
1229         tmpdirlen = strlen (tmpdir);
1230         socket_name_storage =
1231           xmalloc (tmpdirlen + strlen (server_name) + EXTRA_SPACE);
1232         strcpy (socket_name_storage, tmpdir);
1233         sprintf (socket_name_storage + tmpdirlen, "/emacs%ld/", uid);
1234         strcat (socket_name_storage + tmpdirlen, server_name);
1235         local_socket_name = socket_name_storage;
1236       }
1237
1238     if (strlen (local_socket_name) < sizeof (server.sun_path))
1239       strcpy (server.sun_path, local_socket_name);
1240     else
1241       {
1242         message (TRUE, "%s: socket-name %s too long\n",
1243                  progname, local_socket_name);
1244         fail ();
1245       }
1246
1247     /* See if the socket exists, and if it's owned by us. */
1248     sock_status = socket_status (server.sun_path);
1249     saved_errno = errno;
1250     if (sock_status && use_tmpdir)
1251       {
1252         /* Failing that, see if LOGNAME or USER exist and differ from
1253            our euid.  If so, look for a socket based on the UID
1254            associated with the name.  This is reminiscent of the logic
1255            that init_editfns uses to set the global Vuser_full_name.  */
1256
1257         const char *user_name = egetenv ("LOGNAME");
1258
1259         if (!user_name)
1260           user_name = egetenv ("USER");
1261
1262         if (user_name)
1263           {
1264             struct passwd *pw = getpwnam (user_name);
1265
1266             if (pw && (pw->pw_uid != geteuid ()))
1267               {
1268                 /* We're running under su, apparently. */
1269                 long uid = pw->pw_uid;
1270                 ptrdiff_t tmpdirlen = strlen (tmpdir);
1271                 char *user_socket_name
1272                   = xmalloc (tmpdirlen + strlen (server_name) + EXTRA_SPACE);
1273                 strcpy (user_socket_name, tmpdir);
1274                 sprintf (user_socket_name + tmpdirlen, "/emacs%ld/", uid);
1275                 strcat (user_socket_name + tmpdirlen, server_name);
1276
1277                 if (strlen (user_socket_name) < sizeof (server.sun_path))
1278                   strcpy (server.sun_path, user_socket_name);
1279                 else
1280                   {
1281                     message (TRUE, "%s: socket-name %s too long\n",
1282                              progname, user_socket_name);
1283                     exit (EXIT_FAILURE);
1284                   }
1285                 free (user_socket_name);
1286
1287                 sock_status = socket_status (server.sun_path);
1288                 saved_errno = errno;
1289               }
1290             else
1291               errno = saved_errno;
1292           }
1293       }
1294
1295     free (socket_name_storage);
1296     free (tmpdir_storage);
1297
1298     switch (sock_status)
1299       {
1300       case 1:
1301         /* There's a socket, but it isn't owned by us.  This is OK if
1302            we are root. */
1303         if (0 != geteuid ())
1304           {
1305             message (TRUE, "%s: Invalid socket owner\n", progname);
1306             return INVALID_SOCKET;
1307           }
1308         break;
1309
1310       case 2:
1311         /* `stat' failed */
1312         if (saved_errno == ENOENT)
1313           message (TRUE,
1314                    "%s: can't find socket; have you started the server?\n\
1315 To start the server in Emacs, type \"M-x server-start\".\n",
1316                    progname);
1317         else
1318           message (TRUE, "%s: can't stat %s: %s\n",
1319                    progname, server.sun_path, strerror (saved_errno));
1320         return INVALID_SOCKET;
1321       }
1322   }
1323
1324   if (connect (s, (struct sockaddr *) &server, strlen (server.sun_path) + 2)
1325       < 0)
1326     {
1327       message (TRUE, "%s: connect: %s\n", progname, strerror (errno));
1328       return INVALID_SOCKET;
1329     }
1330
1331   return s;
1332 }
1333 #endif /* ! NO_SOCKETS_IN_FILE_SYSTEM */
1334
1335 static HSOCKET
1336 set_socket (int no_exit_if_error)
1337 {
1338   HSOCKET s;
1339   const char *local_server_file = server_file;
1340
1341   INITIALIZE ();
1342
1343 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1344   /* Explicit --socket-name argument.  */
1345   if (socket_name)
1346     {
1347       s = set_local_socket (socket_name);
1348       if ((s != INVALID_SOCKET) || no_exit_if_error)
1349         return s;
1350       message (TRUE, "%s: error accessing socket \"%s\"\n",
1351                progname, socket_name);
1352       exit (EXIT_FAILURE);
1353     }
1354 #endif
1355
1356   /* Explicit --server-file arg or EMACS_SERVER_FILE variable.  */
1357   if (!local_server_file)
1358     local_server_file = egetenv ("EMACS_SERVER_FILE");
1359
1360   if (local_server_file)
1361     {
1362       s = set_tcp_socket (local_server_file);
1363       if ((s != INVALID_SOCKET) || no_exit_if_error)
1364         return s;
1365
1366       message (TRUE, "%s: error accessing server file \"%s\"\n",
1367                progname, local_server_file);
1368       exit (EXIT_FAILURE);
1369     }
1370
1371 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1372   /* Implicit local socket.  */
1373   s = set_local_socket ("server");
1374   if (s != INVALID_SOCKET)
1375     return s;
1376 #endif
1377
1378   /* Implicit server file.  */
1379   s = set_tcp_socket ("server");
1380   if ((s != INVALID_SOCKET) || no_exit_if_error)
1381     return s;
1382
1383   /* No implicit or explicit socket, and no alternate editor.  */
1384   message (TRUE, "%s: No socket or alternate editor.  Please use:\n\n"
1385 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1386 "\t--socket-name\n"
1387 #endif
1388 "\t--server-file      (or environment variable EMACS_SERVER_FILE)\n\
1389 \t--alternate-editor (or environment variable ALTERNATE_EDITOR)\n",
1390            progname);
1391   exit (EXIT_FAILURE);
1392 }
1393
1394 #ifdef HAVE_NTGUI
1395 FARPROC set_fg;  /* Pointer to AllowSetForegroundWindow.  */
1396 FARPROC get_wc;  /* Pointer to RealGetWindowClassA.  */
1397
1398 void
1399 w32_set_user_model_id (void)
1400 {
1401   HMODULE shell;
1402   HRESULT (WINAPI * set_user_model) (wchar_t * id);
1403
1404   /* On Windows 7 and later, we need to set the user model ID
1405      to associate emacsclient launched files with Emacs frames
1406      in the UI.  */
1407   shell = LoadLibrary ("shell32.dll");
1408   if (shell)
1409     {
1410       set_user_model
1411         = (void *) GetProcAddress (shell,
1412                                    "SetCurrentProcessExplicitAppUserModelID");
1413       /* If the function is defined, then we are running on Windows 7
1414          or newer, and the UI uses this to group related windows
1415          together.  Since emacs, runemacs, emacsclient are related, we
1416          want them grouped even though the executables are different,
1417          so we need to set a consistent ID between them.  */
1418       if (set_user_model)
1419         set_user_model (L"GNU.Emacs");
1420
1421       FreeLibrary (shell);
1422     }
1423 }
1424
1425 BOOL CALLBACK
1426 w32_find_emacs_process (HWND hWnd, LPARAM lParam)
1427 {
1428   DWORD pid;
1429   char class[6];
1430
1431   /* Reject any window not of class "Emacs".  */
1432   if (! get_wc (hWnd, class, sizeof (class))
1433       || strcmp (class, "Emacs"))
1434     return TRUE;
1435
1436   /* We only need the process id, not the thread id.  */
1437   (void) GetWindowThreadProcessId (hWnd, &pid);
1438
1439   /* Not the one we're looking for.  */
1440   if (pid != (DWORD) emacs_pid) return TRUE;
1441
1442   /* OK, let's raise it.  */
1443   set_fg (emacs_pid);
1444
1445   /* Stop enumeration.  */
1446   return FALSE;
1447 }
1448
1449 /* Search for a window of class "Emacs" and owned by a process with
1450    process id = emacs_pid.  If found, allow it to grab the focus.  */
1451
1452 void
1453 w32_give_focus (void)
1454 {
1455   HANDLE user32;
1456
1457   /* It shouldn't happen when dealing with TCP sockets.  */
1458   if (!emacs_pid) return;
1459
1460   user32 = GetModuleHandle ("user32.dll");
1461
1462   if (!user32)
1463     return;
1464
1465   /* Modern Windows restrict which processes can set the foreground window.
1466      emacsclient can allow Emacs to grab the focus by calling the function
1467      AllowSetForegroundWindow.  Unfortunately, older Windows (W95, W98 and
1468      NT) lack this function, so we have to check its availability.  */
1469   if ((set_fg = GetProcAddress (user32, "AllowSetForegroundWindow"))
1470       && (get_wc = GetProcAddress (user32, "RealGetWindowClassA")))
1471     EnumWindows (w32_find_emacs_process, (LPARAM) 0);
1472 }
1473 #endif /* HAVE_NTGUI */
1474
1475 /* Start the emacs daemon and try to connect to it.  */
1476
1477 static void
1478 start_daemon_and_retry_set_socket (void)
1479 {
1480 #ifndef WINDOWSNT
1481   pid_t dpid;
1482   int status;
1483
1484   dpid = fork ();
1485
1486   if (dpid > 0)
1487     {
1488       pid_t w;
1489       w = waitpid (dpid, &status, WUNTRACED | WCONTINUED);
1490
1491       if ((w == -1) || !WIFEXITED (status) || WEXITSTATUS (status))
1492         {
1493           message (TRUE, "Error: Could not start the Emacs daemon\n");
1494           exit (EXIT_FAILURE);
1495         }
1496
1497       /* Try connecting, the daemon should have started by now.  */
1498       message (TRUE, "Emacs daemon should have started, trying to connect again\n");
1499       if ((emacs_socket = set_socket (1)) == INVALID_SOCKET)
1500         {
1501           message (TRUE, "Error: Cannot connect even after starting the Emacs daemon\n");
1502           exit (EXIT_FAILURE);
1503         }
1504     }
1505   else if (dpid < 0)
1506     {
1507       fprintf (stderr, "Error: Cannot fork!\n");
1508       exit (EXIT_FAILURE);
1509     }
1510   else
1511     {
1512       char emacs[] = "emacs";
1513       char daemon_option[] = "--daemon";
1514       char *d_argv[3];
1515       d_argv[0] = emacs;
1516       d_argv[1] = daemon_option;
1517       d_argv[2] = 0;
1518       if (socket_name != NULL)
1519         {
1520           /* Pass  --daemon=socket_name as argument.  */
1521           const char *deq = "--daemon=";
1522           char *daemon_arg = xmalloc (strlen (deq)
1523                                       + strlen (socket_name) + 1);
1524           strcpy (daemon_arg, deq);
1525           strcat (daemon_arg, socket_name);
1526           d_argv[1] = daemon_arg;
1527         }
1528       execvp ("emacs", d_argv);
1529       message (TRUE, "%s: error starting emacs daemon\n", progname);
1530     }
1531 #endif /* WINDOWSNT */
1532 }
1533
1534 int
1535 main (int argc, char **argv)
1536 {
1537   int rl = 0, needlf = 0;
1538   char *cwd, *str;
1539   char string[BUFSIZ+1];
1540   int start_daemon_if_needed;
1541   int exit_status = EXIT_SUCCESS;
1542
1543   main_argv = argv;
1544   progname = argv[0];
1545
1546 #ifdef HAVE_NTGUI
1547   /* On Windows 7 and later, we need to explicitly associate
1548      emacsclient with emacs so the UI behaves sensibly.  This
1549      association does no harm if we're not actually connecting to an
1550      Emacs using a window display.  */
1551   w32_set_user_model_id ();
1552 #endif /* HAVE_NTGUI */
1553
1554   /* Process options.  */
1555   decode_options (argc, argv);
1556
1557   if ((argc - optind < 1) && !eval && current_frame)
1558     {
1559       message (TRUE, "%s: file name or argument required\n"
1560                "Try `%s --help' for more information\n",
1561                progname, progname);
1562       exit (EXIT_FAILURE);
1563     }
1564
1565   /* If alternate_editor is the empty string, start the emacs daemon
1566      in case of failure to connect.  */
1567   start_daemon_if_needed = (alternate_editor
1568                             && (alternate_editor[0] == '\0'));
1569
1570   emacs_socket = set_socket (alternate_editor || start_daemon_if_needed);
1571   if (emacs_socket == INVALID_SOCKET)
1572     {
1573       if (! start_daemon_if_needed)
1574         fail ();
1575
1576       start_daemon_and_retry_set_socket ();
1577     }
1578
1579   cwd = get_current_dir_name ();
1580   if (cwd == 0)
1581     {
1582       message (TRUE, "%s: %s\n", progname,
1583                "Cannot get current working directory");
1584       fail ();
1585     }
1586
1587 #ifdef HAVE_NTGUI
1588   if (display && !strcmp (display, "w32"))
1589   w32_give_focus ();
1590 #endif /* HAVE_NTGUI */
1591
1592   /* Send over our environment and current directory. */
1593   if (!current_frame)
1594     {
1595       int i;
1596       for (i = 0; environ[i]; i++)
1597         {
1598           send_to_emacs (emacs_socket, "-env ");
1599           quote_argument (emacs_socket, environ[i]);
1600           send_to_emacs (emacs_socket, " ");
1601         }
1602     }
1603   send_to_emacs (emacs_socket, "-dir ");
1604   quote_argument (emacs_socket, cwd);
1605   send_to_emacs (emacs_socket, "/");
1606   send_to_emacs (emacs_socket, " ");
1607
1608  retry:
1609   if (nowait)
1610     send_to_emacs (emacs_socket, "-nowait ");
1611
1612   if (current_frame)
1613     send_to_emacs (emacs_socket, "-current-frame ");
1614
1615   if (display)
1616     {
1617       send_to_emacs (emacs_socket, "-display ");
1618       quote_argument (emacs_socket, display);
1619       send_to_emacs (emacs_socket, " ");
1620     }
1621
1622   if (parent_id)
1623     {
1624       send_to_emacs (emacs_socket, "-parent-id ");
1625       quote_argument (emacs_socket, parent_id);
1626       send_to_emacs (emacs_socket, " ");
1627     }
1628
1629   if (frame_parameters && !current_frame)
1630     {
1631       send_to_emacs (emacs_socket, "-frame-parameters ");
1632       quote_argument (emacs_socket, frame_parameters);
1633       send_to_emacs (emacs_socket, " ");
1634     }
1635
1636   /* Unless we are certain we don't want to occupy the tty, send our
1637      tty information to Emacs.  For example, in daemon mode Emacs may
1638      need to occupy this tty if no other frame is available.  */
1639   if (!current_frame || !eval)
1640     {
1641       const char *tty_type, *tty_name;
1642
1643       if (find_tty (&tty_type, &tty_name, !tty))
1644         {
1645 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1646           init_signals ();
1647 #endif
1648           send_to_emacs (emacs_socket, "-tty ");
1649           quote_argument (emacs_socket, tty_name);
1650           send_to_emacs (emacs_socket, " ");
1651           quote_argument (emacs_socket, tty_type);
1652           send_to_emacs (emacs_socket, " ");
1653         }
1654     }
1655
1656   if (!current_frame && !tty)
1657     send_to_emacs (emacs_socket, "-window-system ");
1658
1659   if ((argc - optind > 0))
1660     {
1661       int i;
1662       for (i = optind; i < argc; i++)
1663         {
1664
1665           if (eval)
1666             {
1667               /* Don't prepend cwd or anything like that.  */
1668               send_to_emacs (emacs_socket, "-eval ");
1669               quote_argument (emacs_socket, argv[i]);
1670               send_to_emacs (emacs_socket, " ");
1671               continue;
1672             }
1673
1674           if (*argv[i] == '+')
1675             {
1676               char *p = argv[i] + 1;
1677               while (isdigit ((unsigned char) *p) || *p == ':') p++;
1678               if (*p == 0)
1679                 {
1680                   send_to_emacs (emacs_socket, "-position ");
1681                   quote_argument (emacs_socket, argv[i]);
1682                   send_to_emacs (emacs_socket, " ");
1683                   continue;
1684                 }
1685             }
1686 #ifdef WINDOWSNT
1687           else if (! file_name_absolute_p (argv[i])
1688                    && (isalpha (argv[i][0]) && argv[i][1] == ':'))
1689             /* Windows can have a different default directory for each
1690                drive, so the cwd passed via "-dir" is not sufficient
1691                to account for that.
1692                If the user uses <drive>:<relpath>, we hence need to be
1693                careful to expand <relpath> with the default directory
1694                corresponding to <drive>.  */
1695             {
1696               char *filename = (char *) xmalloc (MAX_PATH);
1697               DWORD size;
1698
1699               size = GetFullPathName (argv[i], MAX_PATH, filename, NULL);
1700               if (size > 0 && size < MAX_PATH)
1701                 argv[i] = filename;
1702               else
1703                 free (filename);
1704             }
1705 #endif
1706
1707           send_to_emacs (emacs_socket, "-file ");
1708           quote_argument (emacs_socket, argv[i]);
1709           send_to_emacs (emacs_socket, " ");
1710         }
1711     }
1712   else if (eval)
1713     {
1714       /* Read expressions interactively.  */
1715       while ((str = fgets (string, BUFSIZ, stdin)))
1716         {
1717           send_to_emacs (emacs_socket, "-eval ");
1718           quote_argument (emacs_socket, str);
1719         }
1720       send_to_emacs (emacs_socket, " ");
1721     }
1722
1723   send_to_emacs (emacs_socket, "\n");
1724
1725   /* Wait for an answer. */
1726   if (!eval && !tty && !nowait && !quiet)
1727     {
1728       printf ("Waiting for Emacs...");
1729       needlf = 2;
1730     }
1731   fflush (stdout);
1732   while (fdatasync (1) != 0 && errno == EINTR)
1733     continue;
1734
1735   /* Now, wait for an answer and print any messages.  */
1736   while (exit_status == EXIT_SUCCESS)
1737     {
1738       char *p, *end_p;
1739       do
1740         {
1741           errno = 0;
1742           rl = recv (emacs_socket, string, BUFSIZ, 0);
1743         }
1744       /* If we receive a signal (e.g. SIGWINCH, which we pass
1745          through to Emacs), on some OSes we get EINTR and must retry. */
1746       while (rl < 0 && errno == EINTR);
1747
1748       if (rl <= 0)
1749         break;
1750
1751       string[rl] = '\0';
1752
1753       /* Loop over all NL-terminated messages.  */
1754       for (end_p = p = string; end_p != NULL && *end_p != '\0'; p = end_p)
1755         {
1756           end_p = strchr (p, '\n');
1757           if (end_p != NULL)
1758             *end_p++ = '\0';
1759
1760           if (strprefix ("-emacs-pid ", p))
1761             {
1762               /* -emacs-pid PID: The process id of the Emacs process. */
1763               emacs_pid = strtol (p + strlen ("-emacs-pid"), NULL, 10);
1764             }
1765           else if (strprefix ("-window-system-unsupported ", p))
1766             {
1767               /* -window-system-unsupported: Emacs was compiled without support
1768                  for whatever window system we tried.  Try the alternate
1769                  display, or, failing that, try the terminal.  */
1770               if (alt_display)
1771                 {
1772                   display = alt_display;
1773                   alt_display = NULL;
1774                 }
1775               else
1776                 {
1777                   nowait = 0;
1778                   tty = 1;
1779                 }
1780
1781               goto retry;
1782             }
1783           else if (strprefix ("-print ", p))
1784             {
1785               /* -print STRING: Print STRING on the terminal. */
1786               str = unquote_argument (p + strlen ("-print "));
1787               if (needlf)
1788                 printf ("\n");
1789               printf ("%s", str);
1790               needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1791             }
1792           else if (strprefix ("-print-nonl ", p))
1793             {
1794               /* -print-nonl STRING: Print STRING on the terminal.
1795                  Used to continue a preceding -print command.  */
1796               str = unquote_argument (p + strlen ("-print-nonl "));
1797               printf ("%s", str);
1798               needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1799             }
1800           else if (strprefix ("-error ", p))
1801             {
1802               /* -error DESCRIPTION: Signal an error on the terminal. */
1803               str = unquote_argument (p + strlen ("-error "));
1804               if (needlf)
1805                 printf ("\n");
1806               fprintf (stderr, "*ERROR*: %s", str);
1807               needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1808               exit_status = EXIT_FAILURE;
1809             }
1810 #ifdef SIGSTOP
1811           else if (strprefix ("-suspend ", p))
1812             {
1813               /* -suspend: Suspend this terminal, i.e., stop the process. */
1814               if (needlf)
1815                 printf ("\n");
1816               needlf = 0;
1817               kill (0, SIGSTOP);
1818             }
1819 #endif
1820           else
1821             {
1822               /* Unknown command. */
1823               if (needlf)
1824                 printf ("\n");
1825               needlf = 0;
1826               printf ("*ERROR*: Unknown message: %s\n", p);
1827             }
1828         }
1829     }
1830
1831   if (needlf)
1832     printf ("\n");
1833   fflush (stdout);
1834   while (fdatasync (1) != 0 && errno == EINTR)
1835     continue;
1836
1837   if (rl < 0)
1838     exit_status = EXIT_FAILURE;
1839
1840   CLOSE_SOCKET (emacs_socket);
1841   return exit_status;
1842 }
1843
1844 #endif /* HAVE_SOCKETS && HAVE_INET_SOCKETS */