lib-src/emacsclient.c

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