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