lib-src/emacsclient.c

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