lib-src/emacsclient.c

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