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