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