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 /* config.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 /*
 455   execvp wrapper for Windows.  Quotes arguments with embedded spaces.
 456
 457   This is necessary due to the broken implementation of exec* routines in
 458   the Microsoft libraries: they concatenate the arguments together without
 459   quoting special characters, and pass the result to CreateProcess, with
 460   predictably bad results.  By contrast, POSIX execvp passes the arguments
 461   directly into the argv array of the child process.
 462 */
 463 int
 464 w32_execvp (const char *path, char **argv)
 465 {
 466   int i;
 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 /*
 716   Try to run a different command, or --if no alternate editor is
 717   defined-- exit with an errorcode.
 718   Uses argv, but gets it from the global variable main_argv.
 719 */
 720 static _Noreturn void
 721 fail (void)
 722 {
 723   if (alternate_editor)
 724     {
 725       int i = optind - 1;
 726
 727       execvp (alternate_editor, main_argv + i);
 728       message (TRUE, "%s: error executing alternate editor \"%s\"\n",
 729                progname, alternate_editor);
 730     }
 731   exit (EXIT_FAILURE);
 732 }
 733
 734 \f
 735 #if !defined (HAVE_SOCKETS) || !defined (HAVE_INET_SOCKETS)
 736
 737 int
 738 main (int argc, char **argv)
 739 {
 740   main_argv = argv;
 741   progname = argv[0];
 742   message (TRUE, "%s: Sorry, the Emacs server is supported only\n"
 743            "on systems with Berkeley sockets.\n",
 744            argv[0]);
 745   fail ();
 746 }
 747
 748 #else /* HAVE_SOCKETS && HAVE_INET_SOCKETS */
 749
 750 #define AUTH_KEY_LENGTH      64
 751 #define SEND_BUFFER_SIZE   4096
 752
 753 extern char *strerror (int);
 754
 755 /* Buffer to accumulate data to send in TCP connections.  */
 756 char send_buffer[SEND_BUFFER_SIZE + 1];
 757 int sblen = 0;  /* Fill pointer for the send buffer.  */
 758 /* Socket used to communicate with the Emacs server process.  */
 759 HSOCKET emacs_socket = 0;
 760
 761 /* On Windows, the socket library was historically separate from the standard
 762    C library, so errors are handled differently.  */
 763 static void
 764 sock_err_message (const char *function_name)
 765 {
 766 #ifdef WINDOWSNT
 767   char* msg = NULL;
 768
 769   FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
 770                  | FORMAT_MESSAGE_ALLOCATE_BUFFER
 771                  | FORMAT_MESSAGE_ARGUMENT_ARRAY,
 772                  NULL, WSAGetLastError (), 0, (LPTSTR)&msg, 0, NULL);
 773
 774   message (TRUE, "%s: %s: %s\n", progname, function_name, msg);
 775
 776   LocalFree (msg);
 777 #else
 778   message (TRUE, "%s: %s: %s\n", progname, function_name, strerror (errno));
 779 #endif
 780 }
 781
 782
 783 /* Let's send the data to Emacs when either
 784    - the data ends in "\n", or
 785    - the buffer is full (but this shouldn't happen)
 786    Otherwise, we just accumulate it.  */
 787 static void
 788 send_to_emacs (HSOCKET s, const char *data)
 789 {
 790   size_t dlen;
 791
 792   if (!data)
 793     return;
 794
 795   dlen = strlen (data);
 796   while (*data)
 797     {
 798       size_t part = min (dlen, SEND_BUFFER_SIZE - sblen);
 799       memcpy (&send_buffer[sblen], data, part);
 800       data += part;
 801       sblen += part;
 802
 803       if (sblen == SEND_BUFFER_SIZE
 804           || (sblen > 0 && send_buffer[sblen-1] == '\n'))
 805         {
 806           int sent = send (s, send_buffer, sblen, 0);
 807           if (sent < 0)
 808             {
 809               message (TRUE, "%s: failed to send %d bytes to socket: %s\n",
 810                        progname, sblen, strerror (errno));
 811               fail ();
 812             }
 813           if (sent != sblen)
 814             memmove (send_buffer, &send_buffer[sent], sblen - sent);
 815           sblen -= sent;
 816         }
 817
 818       dlen -= part;
 819     }
 820 }
 821
 822 \f
 823 /* In STR, insert a & before each &, each space, each newline, and
 824    any initial -.  Change spaces to underscores, too, so that the
 825    return value never contains a space.
 826
 827    Does not change the string.  Outputs the result to S.  */
 828 static void
 829 quote_argument (HSOCKET s, const char *str)
 830 {
 831   char *copy = (char *) xmalloc (strlen (str) * 2 + 1);
 832   const char *p;
 833   char *q;
 834
 835   p = str;
 836   q = copy;
 837   while (*p)
 838     {
 839       if (*p == ' ')
 840         {
 841           *q++ = '&';
 842           *q++ = '_';
 843           p++;
 844         }
 845       else if (*p == '\n')
 846         {
 847           *q++ = '&';
 848           *q++ = 'n';
 849           p++;
 850         }
 851       else
 852         {
 853           if (*p == '&' || (*p == '-' && p == str))
 854             *q++ = '&';
 855           *q++ = *p++;
 856         }
 857     }
 858   *q++ = 0;
 859
 860   send_to_emacs (s, copy);
 861
 862   free (copy);
 863 }
 864
 865
 866 /* The inverse of quote_argument.  Removes quoting in string STR by
 867    modifying the string in place.   Returns STR. */
 868
 869 static char *
 870 unquote_argument (char *str)
 871 {
 872   char *p, *q;
 873
 874   if (! str)
 875     return str;
 876
 877   p = str;
 878   q = str;
 879   while (*p)
 880     {
 881       if (*p == '&')
 882         {
 883           p++;
 884           if (*p == '&')
 885             *p = '&';
 886           else if (*p == '_')
 887             *p = ' ';
 888           else if (*p == 'n')
 889             *p = '\n';
 890           else if (*p == '-')
 891             *p = '-';
 892         }
 893       *q++ = *p++;
 894     }
 895   *q = 0;
 896   return str;
 897 }
 898
 899 \f
 900 static int
 901 file_name_absolute_p (const char *filename)
 902 {
 903   /* Sanity check, it shouldn't happen.  */
 904   if (! filename) return FALSE;
 905
 906   /* /xxx is always an absolute path.  */
 907   if (filename[0] == '/') return TRUE;
 908
 909   /* Empty filenames (which shouldn't happen) are relative.  */
 910   if (filename[0] == '\0') return FALSE;
 911
 912 #ifdef WINDOWSNT
 913   /* X:\xxx is always absolute.  */
 914   if (isalpha ((unsigned char) filename[0])
 915       && filename[1] == ':' && (filename[2] == '\\' || filename[2] == '/'))
 916     return TRUE;
 917
 918   /* Both \xxx and \\xxx\yyy are absolute.  */
 919   if (filename[0] == '\\') return TRUE;
 920 #endif
 921
 922   return FALSE;
 923 }
 924
 925 #ifdef WINDOWSNT
 926 /* Wrapper to make WSACleanup a cdecl, as required by atexit.  */
 927 void __cdecl
 928 close_winsock (void)
 929 {
 930   WSACleanup ();
 931 }
 932
 933 /* Initialize the WinSock2 library.  */
 934 void
 935 initialize_sockets (void)
 936 {
 937   WSADATA wsaData;
 938
 939   if (WSAStartup (MAKEWORD (2, 0), &wsaData))
 940     {
 941       message (TRUE, "%s: error initializing WinSock2\n", progname);
 942       exit (EXIT_FAILURE);
 943     }
 944
 945   atexit (close_winsock);
 946 }
 947 #endif /* WINDOWSNT */
 948
 949 \f
 950 /*
 951  * Read the information needed to set up a TCP comm channel with
 952  * the Emacs server: host, port, and authentication string.
 953  */
 954 static int
 955 get_server_config (const char *config_file, struct sockaddr_in *server,
 956                    char *authentication)
 957 {
 958   char dotted[32];
 959   char *port;
 960   FILE *config = NULL;
 961
 962   if (file_name_absolute_p (config_file))
 963     config = fopen (config_file, "rb");
 964   else
 965     {
 966       const char *home = egetenv ("HOME");
 967
 968       if (home)
 969         {
 970           char *path = xmalloc (strlen (home) + strlen (config_file)
 971                                 + EXTRA_SPACE);
 972           strcpy (path, home);
 973           strcat (path, "/.emacs.d/server/");
 974           strcat (path, config_file);
 975           config = fopen (path, "rb");
 976           free (path);
 977         }
 978 #ifdef WINDOWSNT
 979       if (!config && (home = egetenv ("APPDATA")))
 980         {
 981           char *path = xmalloc (strlen (home) + strlen (config_file)
 982                                 + EXTRA_SPACE);
 983           strcpy (path, home);
 984           strcat (path, "/.emacs.d/server/");
 985           strcat (path, config_file);
 986           config = fopen (path, "rb");
 987           free (path);
 988         }
 989 #endif
 990     }
 991
 992   if (! config)
 993     return FALSE;
 994
 995   if (fgets (dotted, sizeof dotted, config)
 996       && (port = strchr (dotted, ':')))
 997     *port++ = '\0';
 998   else
 999     {
1000       message (TRUE, "%s: invalid configuration info\n", progname);
1001       exit (EXIT_FAILURE);
1002     }
1003
1004   server->sin_family = AF_INET;
1005   server->sin_addr.s_addr = inet_addr (dotted);
1006   server->sin_port = htons (atoi (port));
1007
1008   if (! fread (authentication, AUTH_KEY_LENGTH, 1, config))
1009     {
1010       message (TRUE, "%s: cannot read authentication info\n", progname);
1011       exit (EXIT_FAILURE);
1012     }
1013
1014   fclose (config);
1015
1016   return TRUE;
1017 }
1018
1019 static HSOCKET
1020 set_tcp_socket (const char *local_server_file)
1021 {
1022   HSOCKET s;
1023   struct sockaddr_in server;
1024   struct linger l_arg = {1, 1};
1025   char auth_string[AUTH_KEY_LENGTH + 1];
1026
1027   if (! get_server_config (local_server_file, &server, auth_string))
1028     return INVALID_SOCKET;
1029
1030   if (server.sin_addr.s_addr != inet_addr ("127.0.0.1") && !quiet)
1031     message (FALSE, "%s: connected to remote socket at %s\n",
1032              progname, inet_ntoa (server.sin_addr));
1033
1034   /*
1035    * Open up an AF_INET socket
1036    */
1037   if ((s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
1038     {
1039       sock_err_message ("socket");
1040       return INVALID_SOCKET;
1041     }
1042
1043   /*
1044    * Set up the socket
1045    */
1046   if (connect (s, (struct sockaddr *) &server, sizeof server) < 0)
1047     {
1048       sock_err_message ("connect");
1049       return INVALID_SOCKET;
1050     }
1051
1052   setsockopt (s, SOL_SOCKET, SO_LINGER, (char *) &l_arg, sizeof l_arg);
1053
1054   /*
1055    * Send the authentication
1056    */
1057   auth_string[AUTH_KEY_LENGTH] = '\0';
1058
1059   send_to_emacs (s, "-auth ");
1060   send_to_emacs (s, auth_string);
1061   send_to_emacs (s, " ");
1062
1063   return s;
1064 }
1065
1066
1067 /* Returns 1 if PREFIX is a prefix of STRING. */
1068 static int
1069 strprefix (const char *prefix, const char *string)
1070 {
1071   return !strncmp (prefix, string, strlen (prefix));
1072 }
1073
1074 /* Get tty name and type.  If successful, return the type in TTY_TYPE
1075    and the name in TTY_NAME, and return 1.  Otherwise, fail if NOABORT
1076    is zero, or return 0 if NOABORT is non-zero.  */
1077
1078 static int
1079 find_tty (const char **tty_type, const char **tty_name, int noabort)
1080 {
1081   const char *type = egetenv ("TERM");
1082   const char *name = ttyname (fileno (stdout));
1083
1084   if (!name)
1085     {
1086       if (noabort)
1087         return 0;
1088       else
1089         {
1090           message (TRUE, "%s: could not get terminal name\n", progname);
1091           fail ();
1092         }
1093     }
1094
1095   if (!type)
1096     {
1097       if (noabort)
1098         return 0;
1099       else
1100         {
1101           message (TRUE, "%s: please set the TERM variable to your terminal type\n",
1102                    progname);
1103           fail ();
1104         }
1105     }
1106
1107   if (strcmp (type, "eterm") == 0)
1108     {
1109       if (noabort)
1110         return 0;
1111       else
1112         {
1113           /* This causes nasty, MULTI_KBOARD-related input lockouts. */
1114           message (TRUE, "%s: opening a frame in an Emacs term buffer"
1115                    " is not supported\n", progname);
1116           fail ();
1117         }
1118     }
1119
1120   *tty_name = name;
1121   *tty_type = type;
1122   return 1;
1123 }
1124
1125
1126 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1127
1128 /* Three possibilities:
1129    2 - can't be `stat'ed                (sets errno)
1130    1 - isn't owned by us
1131    0 - success: none of the above */
1132
1133 static int
1134 socket_status (const char *name)
1135 {
1136   struct stat statbfr;
1137
1138   if (stat (name, &statbfr) == -1)
1139     return 2;
1140
1141   if (statbfr.st_uid != geteuid ())
1142     return 1;
1143
1144   return 0;
1145 }
1146
1147 \f
1148 /* A signal handler that passes the signal to the Emacs process.
1149    Useful for SIGWINCH.  */
1150
1151 static void
1152 pass_signal_to_emacs (int signalnum)
1153 {
1154   int old_errno = errno;
1155
1156   if (emacs_pid)
1157     kill (emacs_pid, signalnum);
1158
1159   signal (signalnum, pass_signal_to_emacs);
1160   errno = old_errno;
1161 }
1162
1163 /* Signal handler for SIGCONT; notify the Emacs process that it can
1164    now resume our tty frame.  */
1165
1166 static void
1167 handle_sigcont (int signalnum)
1168 {
1169   int old_errno = errno;
1170
1171   if (tcgetpgrp (1) == getpgrp ())
1172     {
1173       /* We are in the foreground. */
1174       send_to_emacs (emacs_socket, "-resume \n");
1175     }
1176   else
1177     {
1178       /* We are in the background; cancel the continue. */
1179       kill (getpid (), SIGSTOP);
1180     }
1181
1182   signal (signalnum, handle_sigcont);
1183   errno = old_errno;
1184 }
1185
1186 /* Signal handler for SIGTSTP; notify the Emacs process that we are
1187    going to sleep.  Normally the suspend is initiated by Emacs via
1188    server-handle-suspend-tty, but if the server gets out of sync with
1189    reality, we may get a SIGTSTP on C-z.  Handling this signal and
1190    notifying Emacs about it should get things under control again. */
1191
1192 static void
1193 handle_sigtstp (int signalnum)
1194 {
1195   int old_errno = errno;
1196   sigset_t set;
1197
1198   if (emacs_socket)
1199     send_to_emacs (emacs_socket, "-suspend \n");
1200
1201   /* Unblock this signal and call the default handler by temporarily
1202      changing the handler and resignaling.  */
1203   sigprocmask (SIG_BLOCK, NULL, &set);
1204   sigdelset (&set, signalnum);
1205   signal (signalnum, SIG_DFL);
1206   kill (getpid (), signalnum);
1207   sigprocmask (SIG_SETMASK, &set, NULL); /* Let's the above signal through. */
1208   signal (signalnum, handle_sigtstp);
1209
1210   errno = old_errno;
1211 }
1212
1213
1214 /* Set up signal handlers before opening a frame on the current tty.  */
1215
1216 static void
1217 init_signals (void)
1218 {
1219   /* Set up signal handlers. */
1220   signal (SIGWINCH, pass_signal_to_emacs);
1221
1222   /* Don't pass SIGINT and SIGQUIT to Emacs, because it has no way of
1223      deciding which terminal the signal came from.  C-g is now a
1224      normal input event on secondary terminals.  */
1225 #if 0
1226   signal (SIGINT, pass_signal_to_emacs);
1227   signal (SIGQUIT, pass_signal_to_emacs);
1228 #endif
1229
1230   signal (SIGCONT, handle_sigcont);
1231   signal (SIGTSTP, handle_sigtstp);
1232   signal (SIGTTOU, handle_sigtstp);
1233 }
1234
1235
1236 static HSOCKET
1237 set_local_socket (const char *local_socket_name)
1238 {
1239   HSOCKET s;
1240   struct sockaddr_un server;
1241
1242   /*
1243    * Open up an AF_UNIX socket in this person's home directory
1244    */
1245
1246   if ((s = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
1247     {
1248       message (TRUE, "%s: socket: %s\n", progname, strerror (errno));
1249       return INVALID_SOCKET;
1250     }
1251
1252   server.sun_family = AF_UNIX;
1253
1254   {
1255     int sock_status;
1256     int use_tmpdir = 0;
1257     int saved_errno;
1258     const char *server_name = local_socket_name;
1259     const char *tmpdir IF_LINT ( = NULL);
1260     char *tmpdir_storage = NULL;
1261     char *socket_name_storage = NULL;
1262
1263     if (!strchr (local_socket_name, '/') && !strchr (local_socket_name, '\\'))
1264       {
1265         /* socket_name is a file name component.  */
1266         long uid = geteuid ();
1267         ptrdiff_t tmpdirlen;
1268         use_tmpdir = 1;
1269         tmpdir = egetenv ("TMPDIR");
1270         if (!tmpdir)
1271           {
1272 #ifdef DARWIN_OS
1273 #ifndef _CS_DARWIN_USER_TEMP_DIR
1274 #define _CS_DARWIN_USER_TEMP_DIR 65537
1275 #endif
1276             size_t n = confstr (_CS_DARWIN_USER_TEMP_DIR, NULL, (size_t) 0);
1277             if (n > 0)
1278               {
1279                 tmpdir = tmpdir_storage = xmalloc (n);
1280                 confstr (_CS_DARWIN_USER_TEMP_DIR, tmpdir_storage, n);
1281               }
1282             else
1283 #endif
1284               tmpdir = "/tmp";
1285           }
1286         tmpdirlen = strlen (tmpdir);
1287         socket_name_storage =
1288           xmalloc (tmpdirlen + strlen (server_name) + EXTRA_SPACE);
1289         strcpy (socket_name_storage, tmpdir);
1290         sprintf (socket_name_storage + tmpdirlen, "/emacs%ld/", uid);
1291         strcat (socket_name_storage + tmpdirlen, server_name);
1292         local_socket_name = socket_name_storage;
1293       }
1294
1295     if (strlen (local_socket_name) < sizeof (server.sun_path))
1296       strcpy (server.sun_path, local_socket_name);
1297     else
1298       {
1299         message (TRUE, "%s: socket-name %s too long\n",
1300                  progname, local_socket_name);
1301         fail ();
1302       }
1303
1304     /* See if the socket exists, and if it's owned by us. */
1305     sock_status = socket_status (server.sun_path);
1306     saved_errno = errno;
1307     if (sock_status && use_tmpdir)
1308       {
1309         /* Failing that, see if LOGNAME or USER exist and differ from
1310            our euid.  If so, look for a socket based on the UID
1311            associated with the name.  This is reminiscent of the logic
1312            that init_editfns uses to set the global Vuser_full_name.  */
1313
1314         const char *user_name = egetenv ("LOGNAME");
1315
1316         if (!user_name)
1317           user_name = egetenv ("USER");
1318
1319         if (user_name)
1320           {
1321             struct passwd *pw = getpwnam (user_name);
1322
1323             if (pw && (pw->pw_uid != geteuid ()))
1324               {
1325                 /* We're running under su, apparently. */
1326                 long uid = pw->pw_uid;
1327                 ptrdiff_t tmpdirlen = strlen (tmpdir);
1328                 char *user_socket_name
1329                   = xmalloc (tmpdirlen + strlen (server_name) + EXTRA_SPACE);
1330                 strcpy (user_socket_name, tmpdir);
1331                 sprintf (user_socket_name + tmpdirlen, "/emacs%ld/", uid);
1332                 strcat (user_socket_name + tmpdirlen, server_name);
1333
1334                 if (strlen (user_socket_name) < sizeof (server.sun_path))
1335                   strcpy (server.sun_path, user_socket_name);
1336                 else
1337                   {
1338                     message (TRUE, "%s: socket-name %s too long\n",
1339                              progname, user_socket_name);
1340                     exit (EXIT_FAILURE);
1341                   }
1342                 free (user_socket_name);
1343
1344                 sock_status = socket_status (server.sun_path);
1345                 saved_errno = errno;
1346               }
1347             else
1348               errno = saved_errno;
1349           }
1350       }
1351
1352     free (socket_name_storage);
1353     free (tmpdir_storage);
1354
1355     switch (sock_status)
1356       {
1357       case 1:
1358         /* There's a socket, but it isn't owned by us.  This is OK if
1359            we are root. */
1360         if (0 != geteuid ())
1361           {
1362             message (TRUE, "%s: Invalid socket owner\n", progname);
1363             return INVALID_SOCKET;
1364           }
1365         break;
1366
1367       case 2:
1368         /* `stat' failed */
1369         if (saved_errno == ENOENT)
1370           message (TRUE,
1371                    "%s: can't find socket; have you started the server?\n\
1372 To start the server in Emacs, type \"M-x server-start\".\n",
1373                    progname);
1374         else
1375           message (TRUE, "%s: can't stat %s: %s\n",
1376                    progname, server.sun_path, strerror (saved_errno));
1377         return INVALID_SOCKET;
1378       }
1379   }
1380
1381   if (connect (s, (struct sockaddr *) &server, strlen (server.sun_path) + 2)
1382       < 0)
1383     {
1384       message (TRUE, "%s: connect: %s\n", progname, strerror (errno));
1385       return INVALID_SOCKET;
1386     }
1387
1388   return s;
1389 }
1390 #endif /* ! NO_SOCKETS_IN_FILE_SYSTEM */
1391
1392 static HSOCKET
1393 set_socket (int no_exit_if_error)
1394 {
1395   HSOCKET s;
1396   const char *local_server_file = server_file;
1397
1398   INITIALIZE ();
1399
1400 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1401   /* Explicit --socket-name argument.  */
1402   if (socket_name)
1403     {
1404       s = set_local_socket (socket_name);
1405       if ((s != INVALID_SOCKET) || no_exit_if_error)
1406         return s;
1407       message (TRUE, "%s: error accessing socket \"%s\"\n",
1408                progname, socket_name);
1409       exit (EXIT_FAILURE);
1410     }
1411 #endif
1412
1413   /* Explicit --server-file arg or EMACS_SERVER_FILE variable.  */
1414   if (!local_server_file)
1415     local_server_file = egetenv ("EMACS_SERVER_FILE");
1416
1417   if (local_server_file)
1418     {
1419       s = set_tcp_socket (local_server_file);
1420       if ((s != INVALID_SOCKET) || no_exit_if_error)
1421         return s;
1422
1423       message (TRUE, "%s: error accessing server file \"%s\"\n",
1424                progname, local_server_file);
1425       exit (EXIT_FAILURE);
1426     }
1427
1428 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1429   /* Implicit local socket.  */
1430   s = set_local_socket ("server");
1431   if (s != INVALID_SOCKET)
1432     return s;
1433 #endif
1434
1435   /* Implicit server file.  */
1436   s = set_tcp_socket ("server");
1437   if ((s != INVALID_SOCKET) || no_exit_if_error)
1438     return s;
1439
1440   /* No implicit or explicit socket, and no alternate editor.  */
1441   message (TRUE, "%s: No socket or alternate editor.  Please use:\n\n"
1442 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1443 "\t--socket-name\n"
1444 #endif
1445 "\t--server-file      (or environment variable EMACS_SERVER_FILE)\n\
1446 \t--alternate-editor (or environment variable ALTERNATE_EDITOR)\n",
1447            progname);
1448   exit (EXIT_FAILURE);
1449 }
1450
1451 #ifdef WINDOWSNT
1452 FARPROC set_fg;  /* Pointer to AllowSetForegroundWindow.  */
1453 FARPROC get_wc;  /* Pointer to RealGetWindowClassA.  */
1454
1455 BOOL CALLBACK
1456 w32_find_emacs_process (HWND hWnd, LPARAM lParam)
1457 {
1458   DWORD pid;
1459   char class[6];
1460
1461   /* Reject any window not of class "Emacs".  */
1462   if (! get_wc (hWnd, class, sizeof (class))
1463       || strcmp (class, "Emacs"))
1464     return TRUE;
1465
1466   /* We only need the process id, not the thread id.  */
1467   (void) GetWindowThreadProcessId (hWnd, &pid);
1468
1469   /* Not the one we're looking for.  */
1470   if (pid != (DWORD) emacs_pid) return TRUE;
1471
1472   /* OK, let's raise it.  */
1473   set_fg (emacs_pid);
1474
1475   /* Stop enumeration.  */
1476   return FALSE;
1477 }
1478
1479 /*
1480  * Search for a window of class "Emacs" and owned by a process with
1481  * process id = emacs_pid.  If found, allow it to grab the focus.
1482  */
1483 void
1484 w32_give_focus (void)
1485 {
1486   HANDLE user32;
1487
1488   /* It shouldn't happen when dealing with TCP sockets.  */
1489   if (!emacs_pid) return;
1490
1491   user32 = GetModuleHandle ("user32.dll");
1492
1493   if (!user32)
1494     return;
1495
1496   /* Modern Windows restrict which processes can set the foreground window.
1497      emacsclient can allow Emacs to grab the focus by calling the function
1498      AllowSetForegroundWindow.  Unfortunately, older Windows (W95, W98 and
1499      NT) lack this function, so we have to check its availability.  */
1500   if ((set_fg = GetProcAddress (user32, "AllowSetForegroundWindow"))
1501       && (get_wc = GetProcAddress (user32, "RealGetWindowClassA")))
1502     EnumWindows (w32_find_emacs_process, (LPARAM) 0);
1503 }
1504 #endif
1505
1506 /* Start the emacs daemon and try to connect to it.  */
1507
1508 static void
1509 start_daemon_and_retry_set_socket (void)
1510 {
1511 #ifndef WINDOWSNT
1512   pid_t dpid;
1513   int status;
1514
1515   dpid = fork ();
1516
1517   if (dpid > 0)
1518     {
1519       pid_t w;
1520       w = waitpid (dpid, &status, WUNTRACED | WCONTINUED);
1521
1522       if ((w == -1) || !WIFEXITED (status) || WEXITSTATUS (status))
1523         {
1524           message (TRUE, "Error: Could not start the Emacs daemon\n");
1525           exit (EXIT_FAILURE);
1526         }
1527
1528       /* Try connecting, the daemon should have started by now.  */
1529       message (TRUE, "Emacs daemon should have started, trying to connect again\n");
1530       if ((emacs_socket = set_socket (1)) == INVALID_SOCKET)
1531         {
1532           message (TRUE, "Error: Cannot connect even after starting the Emacs daemon\n");
1533           exit (EXIT_FAILURE);
1534         }
1535     }
1536   else if (dpid < 0)
1537     {
1538       fprintf (stderr, "Error: Cannot fork!\n");
1539       exit (EXIT_FAILURE);
1540     }
1541   else
1542     {
1543       char emacs[] = "emacs";
1544       char daemon_option[] = "--daemon";
1545       char *d_argv[] = {emacs, daemon_option, 0 };
1546       if (socket_name != NULL)
1547         {
1548           /* Pass  --daemon=socket_name as argument.  */
1549           const char *deq = "--daemon=";
1550           char *daemon_arg = xmalloc (strlen (deq)
1551                                       + strlen (socket_name) + 1);
1552           strcpy (daemon_arg, deq);
1553           strcat (daemon_arg, socket_name);
1554           d_argv[1] = daemon_arg;
1555         }
1556       execvp ("emacs", d_argv);
1557       message (TRUE, "%s: error starting emacs daemon\n", progname);
1558     }
1559 #endif /* WINDOWSNT */
1560 }
1561
1562 int
1563 main (int argc, char **argv)
1564 {
1565   int rl = 0, needlf = 0;
1566   char *cwd, *str;
1567   char string[BUFSIZ+1];
1568   int start_daemon_if_needed;
1569   int exit_status = EXIT_SUCCESS;
1570
1571   main_argv = argv;
1572   progname = argv[0];
1573
1574 #ifdef WINDOWSNT
1575   /* On Windows 7 and later, we need to explicitly associate emacsclient
1576      with emacs so the UI behaves sensibly.  */
1577   w32_set_user_model_id ();
1578 #endif
1579
1580   /* Process options.  */
1581   decode_options (argc, argv);
1582
1583   if ((argc - optind < 1) && !eval && current_frame)
1584     {
1585       message (TRUE, "%s: file name or argument required\n"
1586                "Try `%s --help' for more information\n",
1587                progname, progname);
1588       exit (EXIT_FAILURE);
1589     }
1590
1591   /* If alternate_editor is the empty string, start the emacs daemon
1592      in case of failure to connect.  */
1593   start_daemon_if_needed = (alternate_editor
1594                             && (alternate_editor[0] == '\0'));
1595
1596   emacs_socket = set_socket (alternate_editor || start_daemon_if_needed);
1597   if (emacs_socket == INVALID_SOCKET)
1598     {
1599       if (! start_daemon_if_needed)
1600         fail ();
1601
1602       start_daemon_and_retry_set_socket ();
1603     }
1604
1605   cwd = get_current_dir_name ();
1606   if (cwd == 0)
1607     {
1608       /* getwd puts message in STRING if it fails.  */
1609       message (TRUE, "%s: %s\n", progname,
1610                "Cannot get current working directory");
1611       fail ();
1612     }
1613
1614 #ifdef WINDOWSNT
1615   w32_give_focus ();
1616 #endif
1617
1618   /* Send over our environment and current directory. */
1619   if (!current_frame)
1620     {
1621 #ifndef WINDOWSNT
1622       /* This is defined in stdlib.h on MS-Windows.  It's defined in
1623          unistd.h on some POSIX hosts, but not all (Bug#10155).  */
1624       extern char **environ;
1625 #endif
1626       int i;
1627       for (i = 0; environ[i]; i++)
1628         {
1629           send_to_emacs (emacs_socket, "-env ");
1630           quote_argument (emacs_socket, environ[i]);
1631           send_to_emacs (emacs_socket, " ");
1632         }
1633     }
1634   send_to_emacs (emacs_socket, "-dir ");
1635   quote_argument (emacs_socket, cwd);
1636   send_to_emacs (emacs_socket, "/");
1637   send_to_emacs (emacs_socket, " ");
1638
1639  retry:
1640   if (nowait)
1641     send_to_emacs (emacs_socket, "-nowait ");
1642
1643   if (current_frame)
1644     send_to_emacs (emacs_socket, "-current-frame ");
1645
1646   if (display)
1647     {
1648       send_to_emacs (emacs_socket, "-display ");
1649       quote_argument (emacs_socket, display);
1650       send_to_emacs (emacs_socket, " ");
1651     }
1652
1653   if (parent_id)
1654     {
1655       send_to_emacs (emacs_socket, "-parent-id ");
1656       quote_argument (emacs_socket, parent_id);
1657       send_to_emacs (emacs_socket, " ");
1658     }
1659
1660   if (frame_parameters && !current_frame)
1661     {
1662       send_to_emacs (emacs_socket, "-frame-parameters ");
1663       quote_argument (emacs_socket, frame_parameters);
1664       send_to_emacs (emacs_socket, " ");
1665     }
1666
1667   /* Unless we are certain we don't want to occupy the tty, send our
1668      tty information to Emacs.  For example, in daemon mode Emacs may
1669      need to occupy this tty if no other frame is available.  */
1670   if (!current_frame || !eval)
1671     {
1672       const char *tty_type, *tty_name;
1673
1674       if (find_tty (&tty_type, &tty_name, !tty))
1675         {
1676 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1677           init_signals ();
1678 #endif
1679           send_to_emacs (emacs_socket, "-tty ");
1680           quote_argument (emacs_socket, tty_name);
1681           send_to_emacs (emacs_socket, " ");
1682           quote_argument (emacs_socket, tty_type);
1683           send_to_emacs (emacs_socket, " ");
1684         }
1685     }
1686
1687   if (!current_frame && !tty)
1688     send_to_emacs (emacs_socket, "-window-system ");
1689
1690   if ((argc - optind > 0))
1691     {
1692       int i;
1693       for (i = optind; i < argc; i++)
1694         {
1695
1696           if (eval)
1697             {
1698               /* Don't prepend cwd or anything like that.  */
1699               send_to_emacs (emacs_socket, "-eval ");
1700               quote_argument (emacs_socket, argv[i]);
1701               send_to_emacs (emacs_socket, " ");
1702               continue;
1703             }
1704
1705           if (*argv[i] == '+')
1706             {
1707               char *p = argv[i] + 1;
1708               while (isdigit ((unsigned char) *p) || *p == ':') p++;
1709               if (*p == 0)
1710                 {
1711                   send_to_emacs (emacs_socket, "-position ");
1712                   quote_argument (emacs_socket, argv[i]);
1713                   send_to_emacs (emacs_socket, " ");
1714                   continue;
1715                 }
1716             }
1717 #ifdef WINDOWSNT
1718           else if (! file_name_absolute_p (argv[i])
1719                    && (isalpha (argv[i][0]) && argv[i][1] == ':'))
1720             /* Windows can have a different default directory for each
1721                drive, so the cwd passed via "-dir" is not sufficient
1722                to account for that.
1723                If the user uses <drive>:<relpath>, we hence need to be
1724                careful to expand <relpath> with the default directory
1725                corresponding to <drive>.  */
1726             {
1727               char *filename = (char *) xmalloc (MAX_PATH);
1728               DWORD size;
1729
1730               size = GetFullPathName (argv[i], MAX_PATH, filename, NULL);
1731               if (size > 0 && size < MAX_PATH)
1732                 argv[i] = filename;
1733               else
1734                 free (filename);
1735             }
1736 #endif
1737
1738           send_to_emacs (emacs_socket, "-file ");
1739           quote_argument (emacs_socket, argv[i]);
1740           send_to_emacs (emacs_socket, " ");
1741         }
1742     }
1743   else if (eval)
1744     {
1745       /* Read expressions interactively.  */
1746       while ((str = fgets (string, BUFSIZ, stdin)))
1747         {
1748           send_to_emacs (emacs_socket, "-eval ");
1749           quote_argument (emacs_socket, str);
1750         }
1751       send_to_emacs (emacs_socket, " ");
1752     }
1753
1754   send_to_emacs (emacs_socket, "\n");
1755
1756   /* Wait for an answer. */
1757   if (!eval && !tty && !nowait && !quiet)
1758     {
1759       printf ("Waiting for Emacs...");
1760       needlf = 2;
1761     }
1762   fflush (stdout);
1763   fsync (1);
1764
1765   /* Now, wait for an answer and print any messages.  */
1766   while (exit_status == EXIT_SUCCESS)
1767     {
1768       char *p, *end_p;
1769       do
1770         {
1771           errno = 0;
1772           rl = recv (emacs_socket, string, BUFSIZ, 0);
1773         }
1774       /* If we receive a signal (e.g. SIGWINCH, which we pass
1775          through to Emacs), on some OSes we get EINTR and must retry. */
1776       while (rl < 0 && errno == EINTR);
1777
1778       if (rl <= 0)
1779         break;
1780
1781       string[rl] = '\0';
1782
1783       /* Loop over all NL-terminated messages.  */
1784       for (end_p = p = string; end_p != NULL && *end_p != '\0'; p = end_p)
1785         {
1786           end_p = strchr (p, '\n');
1787           if (end_p != NULL)
1788             *end_p++ = '\0';
1789
1790           if (strprefix ("-emacs-pid ", p))
1791             {
1792               /* -emacs-pid PID: The process id of the Emacs process. */
1793               emacs_pid = strtol (p + strlen ("-emacs-pid"), NULL, 10);
1794             }
1795           else if (strprefix ("-window-system-unsupported ", p))
1796             {
1797               /* -window-system-unsupported: Emacs was compiled without X
1798                  support.  Try again on the terminal. */
1799               nowait = 0;
1800               tty = 1;
1801               goto retry;
1802             }
1803           else if (strprefix ("-print ", p))
1804             {
1805               /* -print STRING: Print STRING on the terminal. */
1806               str = unquote_argument (p + strlen ("-print "));
1807               if (needlf)
1808                 printf ("\n");
1809               printf ("%s", str);
1810               needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1811             }
1812           else if (strprefix ("-print-nonl ", p))
1813             {
1814               /* -print-nonl STRING: Print STRING on the terminal.
1815                  Used to continue a preceding -print command.  */
1816               str = unquote_argument (p + strlen ("-print-nonl "));
1817               printf ("%s", str);
1818               needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1819             }
1820           else if (strprefix ("-error ", p))
1821             {
1822               /* -error DESCRIPTION: Signal an error on the terminal. */
1823               str = unquote_argument (p + strlen ("-error "));
1824               if (needlf)
1825                 printf ("\n");
1826               fprintf (stderr, "*ERROR*: %s", str);
1827               needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1828               exit_status = EXIT_FAILURE;
1829             }
1830 #ifdef SIGSTOP
1831           else if (strprefix ("-suspend ", p))
1832             {
1833               /* -suspend: Suspend this terminal, i.e., stop the process. */
1834               if (needlf)
1835                 printf ("\n");
1836               needlf = 0;
1837               kill (0, SIGSTOP);
1838             }
1839 #endif
1840           else
1841             {
1842               /* Unknown command. */
1843               if (needlf)
1844                 printf ("\n");
1845               needlf = 0;
1846               printf ("*ERROR*: Unknown message: %s\n", p);
1847             }
1848         }
1849     }
1850
1851   if (needlf)
1852     printf ("\n");
1853   fflush (stdout);
1854   fsync (1);
1855
1856   if (rl < 0)
1857     exit_status = EXIT_FAILURE;
1858
1859   CLOSE_SOCKET (emacs_socket);
1860   return exit_status;
1861 }
1862
1863 #endif /* HAVE_SOCKETS && HAVE_INET_SOCKETS */
1864
1865 \f
1866 #ifndef HAVE_STRERROR
1867 char *
1868 strerror (errnum)
1869      int errnum;
1870 {
1871   extern char *sys_errlist[];
1872   extern int sys_nerr;
1873
1874   if (errnum >= 0 && errnum < sys_nerr)
1875     return sys_errlist[errnum];
1876   return (char *) "Unknown error";
1877 }
1878
1879 #endif /* ! HAVE_STRERROR */
1880
1881
1882 /* emacsclient.c ends here */