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