lib-src/emacsclient.c

   1 /* Client process that communicates with GNU Emacs acting as server.
   2    Copyright (C) 1986-1987, 1994, 1999-2011 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 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   /* --no-wait implies --current-frame on ttys when there are file
 646      arguments or expressions given.  */
 647   if (nowait && tty && argc - optind > 0)
 648     current_frame = 1;
 649
 650 #ifdef WINDOWSNT
 651   if (alternate_editor && alternate_editor[0] == '\0')
 652     {
 653       message (TRUE, "--alternate-editor argument or ALTERNATE_EDITOR variable cannot be\n\
 654 an empty string");
 655       exit (EXIT_FAILURE);
 656     }
 657
 658   /* TTY frames not supported on Windows.  Continue using GUI rather than
 659      forcing the user to change their command-line.  This is required since
 660      tty is set above if certain options are given and $DISPLAY is not set,
 661      which is not obvious to users.  */
 662   if (tty)
 663       tty = 0;
 664
 665 #endif /* WINDOWSNT */
 666 }
 667
 668 \f
 669 static void
 670 print_help_and_exit (void)
 671 {
 672   /* Spaces and tabs are significant in this message; they're chosen so the
 673      message aligns properly both in a tty and in a Windows message box.
 674      Please try to preserve them; otherwise the output is very hard to read
 675      when using emacsclientw.  */
 676   message (FALSE,
 677            "Usage: %s [OPTIONS] FILE...\n\
 678 Tell the Emacs server to visit the specified files.\n\
 679 Every FILE can be either just a FILENAME or [+LINE[:COLUMN]] FILENAME.\n\
 680 \n\
 681 The following OPTIONS are accepted:\n\
 682 -V, --version           Just print version info and return\n\
 683 -H, --help              Print this usage information message\n\
 684 -nw, -t, --tty          Open a new Emacs frame on the current terminal\n\
 685 -c, --create-frame      Create a new frame instead of trying to\n\
 686                         use the current Emacs frame\n\
 687 -F ALIST, --frame-parameters=ALIST\n\
 688                         Set the parameters of a new frame\n\
 689 -e, --eval              Evaluate the FILE arguments as ELisp expressions\n\
 690 -n, --no-wait           Don't wait for the server to return\n\
 691 -q, --quiet             Don't display messages on success\n\
 692 -d DISPLAY, --display=DISPLAY\n\
 693                         Visit the file in the given display\n\
 694 --parent-id=ID          Open in parent window ID, via XEmbed\n"
 695 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
 696 "-s SOCKET, --socket-name=SOCKET\n\
 697                         Set filename of the UNIX socket for communication\n"
 698 #endif
 699 "-f SERVER, --server-file=SERVER\n\
 700                         Set filename of the TCP authentication file\n\
 701 -a EDITOR, --alternate-editor=EDITOR\n\
 702                         Editor to fallback to if the server is not running\n"
 703 #ifndef WINDOWSNT
 704 "                       If EDITOR is the empty string, start Emacs in daemon\n\
 705                         mode and try connecting again\n"
 706 #endif /* not WINDOWSNT */
 707 "\n\
 708 Report bugs with M-x report-emacs-bug.\n", progname);
 709   exit (EXIT_SUCCESS);
 710 }
 711
 712 /*
 713   Try to run a different command, or --if no alternate editor is
 714   defined-- exit with an errorcode.
 715   Uses argv, but gets it from the global variable main_argv.
 716 */
 717 static void
 718 fail (void)
 719 {
 720   if (alternate_editor)
 721     {
 722       int i = optind - 1;
 723
 724       execvp (alternate_editor, main_argv + i);
 725       message (TRUE, "%s: error executing alternate editor \"%s\"\n",
 726                progname, alternate_editor);
 727     }
 728   exit (EXIT_FAILURE);
 729 }
 730
 731 \f
 732 #if !defined (HAVE_SOCKETS) || !defined (HAVE_INET_SOCKETS)
 733
 734 int
 735 main (int argc, char **argv)
 736 {
 737   main_argv = argv;
 738   progname = argv[0];
 739   message (TRUE, "%s: Sorry, the Emacs server is supported only\n"
 740            "on systems with Berkeley sockets.\n",
 741            argv[0]);
 742   fail ();
 743 }
 744
 745 #else /* HAVE_SOCKETS && HAVE_INET_SOCKETS */
 746
 747 #define AUTH_KEY_LENGTH      64
 748 #define SEND_BUFFER_SIZE   4096
 749
 750 extern char *strerror (int);
 751
 752 /* Buffer to accumulate data to send in TCP connections.  */
 753 char send_buffer[SEND_BUFFER_SIZE + 1];
 754 int sblen = 0;  /* Fill pointer for the send buffer.  */
 755 /* Socket used to communicate with the Emacs server process.  */
 756 HSOCKET emacs_socket = 0;
 757
 758 /* On Windows, the socket library was historically separate from the standard
 759    C library, so errors are handled differently.  */
 760 static void
 761 sock_err_message (const char *function_name)
 762 {
 763 #ifdef WINDOWSNT
 764   char* msg = NULL;
 765
 766   FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
 767                  | FORMAT_MESSAGE_ALLOCATE_BUFFER
 768                  | FORMAT_MESSAGE_ARGUMENT_ARRAY,
 769                  NULL, WSAGetLastError (), 0, (LPTSTR)&msg, 0, NULL);
 770
 771   message (TRUE, "%s: %s: %s\n", progname, function_name, msg);
 772
 773   LocalFree (msg);
 774 #else
 775   message (TRUE, "%s: %s: %s\n", progname, function_name, strerror (errno));
 776 #endif
 777 }
 778
 779
 780 /* Let's send the data to Emacs when either
 781    - the data ends in "\n", or
 782    - the buffer is full (but this shouldn't happen)
 783    Otherwise, we just accumulate it.  */
 784 static void
 785 send_to_emacs (HSOCKET s, const char *data)
 786 {
 787   while (data)
 788     {
 789       size_t dlen = strlen (data);
 790       if (dlen + sblen >= SEND_BUFFER_SIZE)
 791         {
 792           int part = SEND_BUFFER_SIZE - sblen;
 793           strncpy (&send_buffer[sblen], data, part);
 794           data += part;
 795           sblen = SEND_BUFFER_SIZE;
 796         }
 797       else if (dlen)
 798         {
 799           strcpy (&send_buffer[sblen], data);
 800           data = NULL;
 801           sblen += dlen;
 802         }
 803       else
 804         break;
 805
 806       if (sblen == SEND_BUFFER_SIZE
 807           || (sblen > 0 && send_buffer[sblen-1] == '\n'))
 808         {
 809           int sent = send (s, send_buffer, sblen, 0);
 810           if (sent != sblen)
 811             strcpy (send_buffer, &send_buffer[sent]);
 812           sblen -= sent;
 813         }
 814     }
 815 }
 816
 817 \f
 818 /* In STR, insert a & before each &, each space, each newline, and
 819    any initial -.  Change spaces to underscores, too, so that the
 820    return value never contains a space.
 821
 822    Does not change the string.  Outputs the result to S.  */
 823 static void
 824 quote_argument (HSOCKET s, const char *str)
 825 {
 826   char *copy = (char *) xmalloc (strlen (str) * 2 + 1);
 827   const char *p;
 828   char *q;
 829
 830   p = str;
 831   q = copy;
 832   while (*p)
 833     {
 834       if (*p == ' ')
 835         {
 836           *q++ = '&';
 837           *q++ = '_';
 838           p++;
 839         }
 840       else if (*p == '\n')
 841         {
 842           *q++ = '&';
 843           *q++ = 'n';
 844           p++;
 845         }
 846       else
 847         {
 848           if (*p == '&' || (*p == '-' && p == str))
 849             *q++ = '&';
 850           *q++ = *p++;
 851         }
 852     }
 853   *q++ = 0;
 854
 855   send_to_emacs (s, copy);
 856
 857   free (copy);
 858 }
 859
 860
 861 /* The inverse of quote_argument.  Removes quoting in string STR by
 862    modifying the string in place.   Returns STR. */
 863
 864 static char *
 865 unquote_argument (char *str)
 866 {
 867   char *p, *q;
 868
 869   if (! str)
 870     return str;
 871
 872   p = str;
 873   q = str;
 874   while (*p)
 875     {
 876       if (*p == '&')
 877         {
 878           p++;
 879           if (*p == '&')
 880             *p = '&';
 881           else if (*p == '_')
 882             *p = ' ';
 883           else if (*p == 'n')
 884             *p = '\n';
 885           else if (*p == '-')
 886             *p = '-';
 887         }
 888       *q++ = *p++;
 889     }
 890   *q = 0;
 891   return str;
 892 }
 893
 894 \f
 895 static int
 896 file_name_absolute_p (const char *filename)
 897 {
 898   /* Sanity check, it shouldn't happen.  */
 899   if (! filename) return FALSE;
 900
 901   /* /xxx is always an absolute path.  */
 902   if (filename[0] == '/') return TRUE;
 903
 904   /* Empty filenames (which shouldn't happen) are relative.  */
 905   if (filename[0] == '\0') return FALSE;
 906
 907 #ifdef WINDOWSNT
 908   /* X:\xxx is always absolute.  */
 909   if (isalpha ((unsigned char) filename[0])
 910       && filename[1] == ':' && (filename[2] == '\\' || filename[2] == '/'))
 911     return TRUE;
 912
 913   /* Both \xxx and \\xxx\yyy are absolute.  */
 914   if (filename[0] == '\\') return TRUE;
 915 #endif
 916
 917   return FALSE;
 918 }
 919
 920 #ifdef WINDOWSNT
 921 /* Wrapper to make WSACleanup a cdecl, as required by atexit.  */
 922 void __cdecl
 923 close_winsock (void)
 924 {
 925   WSACleanup ();
 926 }
 927
 928 /* Initialize the WinSock2 library.  */
 929 void
 930 initialize_sockets (void)
 931 {
 932   WSADATA wsaData;
 933
 934   if (WSAStartup (MAKEWORD (2, 0), &wsaData))
 935     {
 936       message (TRUE, "%s: error initializing WinSock2\n", progname);
 937       exit (EXIT_FAILURE);
 938     }
 939
 940   atexit (close_winsock);
 941 }
 942 #endif /* WINDOWSNT */
 943
 944 \f
 945 /*
 946  * Read the information needed to set up a TCP comm channel with
 947  * the Emacs server: host, port, and authentication string.
 948  */
 949 static int
 950 get_server_config (struct sockaddr_in *server, char *authentication)
 951 {
 952   char dotted[32];
 953   char *port;
 954   FILE *config = NULL;
 955
 956   if (file_name_absolute_p (server_file))
 957     config = fopen (server_file, "rb");
 958   else
 959     {
 960       const char *home = egetenv ("HOME");
 961
 962       if (home)
 963         {
 964           char *path = xmalloc (strlen (home) + strlen (server_file)
 965                                 + EXTRA_SPACE);
 966           strcpy (path, home);
 967           strcat (path, "/.emacs.d/server/");
 968           strcat (path, server_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 (server_file)
 976                                 + EXTRA_SPACE);
 977           strcpy (path, home);
 978           strcat (path, "/.emacs.d/server/");
 979           strcat (path, server_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 (void)
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 (&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 (void)
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 = 0;
1250     int default_sock = !socket_name;
1251     int saved_errno = 0;
1252     const char *server_name = "server";
1253     const char *tmpdir IF_LINT ( = NULL);
1254     char *tmpdir_storage = NULL;
1255     char *socket_name_storage = NULL;
1256
1257     if (socket_name && !strchr (socket_name, '/')
1258         && !strchr (socket_name, '\\'))
1259       {
1260         /* socket_name is a file name component.  */
1261         server_name = socket_name;
1262         socket_name = NULL;
1263         default_sock = 1;       /* Try both UIDs.  */
1264       }
1265
1266     if (default_sock)
1267       {
1268         long uid = geteuid ();
1269         ptrdiff_t tmpdirlen;
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 = socket_name_storage =
1289           xmalloc (tmpdirlen + strlen (server_name) + EXTRA_SPACE);
1290         strcpy (socket_name, tmpdir);
1291         sprintf (socket_name + tmpdirlen, "/emacs%ld/", uid);
1292         strcat (socket_name + tmpdirlen, server_name);
1293       }
1294
1295     if (strlen (socket_name) < sizeof (server.sun_path))
1296       strcpy (server.sun_path, socket_name);
1297     else
1298       {
1299         message (TRUE, "%s: socket-name %s too long\n",
1300                  progname, socket_name);
1301         fail ();
1302       }
1303
1304     /* See if the socket exists, and if it's owned by us. */
1305     sock_status = socket_status (server.sun_path);
1306     saved_errno = errno;
1307     if (sock_status && default_sock)
1308       {
1309         /* Failing that, see if LOGNAME or USER exist and differ from
1310            our euid.  If so, look for a socket based on the UID
1311            associated with the name.  This is reminiscent of the logic
1312            that init_editfns uses to set the global Vuser_full_name.  */
1313
1314         const char *user_name = egetenv ("LOGNAME");
1315
1316         if (!user_name)
1317           user_name = egetenv ("USER");
1318
1319         if (user_name)
1320           {
1321             struct passwd *pw = getpwnam (user_name);
1322
1323             if (pw && (pw->pw_uid != geteuid ()))
1324               {
1325                 /* We're running under su, apparently. */
1326                 long uid = pw->pw_uid;
1327                 ptrdiff_t tmpdirlen = strlen (tmpdir);
1328                 socket_name = xmalloc (tmpdirlen + strlen (server_name)
1329                                        + EXTRA_SPACE);
1330                 strcpy (socket_name, tmpdir);
1331                 sprintf (socket_name + tmpdirlen, "/emacs%ld/", uid);
1332                 strcat (socket_name + tmpdirlen, server_name);
1333
1334                 if (strlen (socket_name) < sizeof (server.sun_path))
1335                   strcpy (server.sun_path, socket_name);
1336                 else
1337                   {
1338                     message (TRUE, "%s: socket-name %s too long\n",
1339                              progname, socket_name);
1340                     exit (EXIT_FAILURE);
1341                   }
1342                 free (socket_name);
1343
1344                 sock_status = socket_status (server.sun_path);
1345                 saved_errno = errno;
1346               }
1347             else
1348               errno = saved_errno;
1349           }
1350       }
1351
1352     free (socket_name_storage);
1353     free (tmpdir_storage);
1354
1355     switch (sock_status)
1356       {
1357       case 1:
1358         /* There's a socket, but it isn't owned by us.  This is OK if
1359            we are root. */
1360         if (0 != geteuid ())
1361           {
1362             message (TRUE, "%s: Invalid socket owner\n", progname);
1363             return INVALID_SOCKET;
1364           }
1365         break;
1366
1367       case 2:
1368         /* `stat' failed */
1369         if (saved_errno == ENOENT)
1370           message (TRUE,
1371                    "%s: can't find socket; have you started the server?\n\
1372 To start the server in Emacs, type \"M-x server-start\".\n",
1373                    progname);
1374         else
1375           message (TRUE, "%s: can't stat %s: %s\n",
1376                    progname, server.sun_path, strerror (saved_errno));
1377         return INVALID_SOCKET;
1378       }
1379   }
1380
1381   if (connect (s, (struct sockaddr *) &server, strlen (server.sun_path) + 2)
1382       < 0)
1383     {
1384       message (TRUE, "%s: connect: %s\n", progname, strerror (errno));
1385       return INVALID_SOCKET;
1386     }
1387
1388   return s;
1389 }
1390 #endif /* ! NO_SOCKETS_IN_FILE_SYSTEM */
1391
1392 static HSOCKET
1393 set_socket (int no_exit_if_error)
1394 {
1395   HSOCKET s;
1396
1397   INITIALIZE ();
1398
1399 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1400   /* Explicit --socket-name argument.  */
1401   if (socket_name)
1402     {
1403       s = set_local_socket ();
1404       if ((s != INVALID_SOCKET) || no_exit_if_error)
1405         return s;
1406       message (TRUE, "%s: error accessing socket \"%s\"\n",
1407                progname, socket_name);
1408       exit (EXIT_FAILURE);
1409     }
1410 #endif
1411
1412   /* Explicit --server-file arg or EMACS_SERVER_FILE variable.  */
1413   if (!server_file)
1414     server_file = egetenv ("EMACS_SERVER_FILE");
1415
1416   if (server_file)
1417     {
1418       s = set_tcp_socket ();
1419       if ((s != INVALID_SOCKET) || no_exit_if_error)
1420         return s;
1421
1422       message (TRUE, "%s: error accessing server file \"%s\"\n",
1423                progname, server_file);
1424       exit (EXIT_FAILURE);
1425     }
1426
1427 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1428   /* Implicit local socket.  */
1429   s = set_local_socket ();
1430   if (s != INVALID_SOCKET)
1431     return s;
1432 #endif
1433
1434   /* Implicit server file.  */
1435   server_file = "server";
1436   s = set_tcp_socket ();
1437   if ((s != INVALID_SOCKET) || no_exit_if_error)
1438     return s;
1439
1440   /* No implicit or explicit socket, and no alternate editor.  */
1441   message (TRUE, "%s: No socket or alternate editor.  Please use:\n\n"
1442 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1443 "\t--socket-name\n"
1444 #endif
1445 "\t--server-file      (or environment variable EMACS_SERVER_FILE)\n\
1446 \t--alternate-editor (or environment variable ALTERNATE_EDITOR)\n",
1447            progname);
1448   exit (EXIT_FAILURE);
1449 }
1450
1451 #ifdef WINDOWSNT
1452 FARPROC set_fg;  /* Pointer to AllowSetForegroundWindow.  */
1453 FARPROC get_wc;  /* Pointer to RealGetWindowClassA.  */
1454
1455 BOOL CALLBACK
1456 w32_find_emacs_process (HWND hWnd, LPARAM lParam)
1457 {
1458   DWORD pid;
1459   char class[6];
1460
1461   /* Reject any window not of class "Emacs".  */
1462   if (! get_wc (hWnd, class, sizeof (class))
1463       || strcmp (class, "Emacs"))
1464     return TRUE;
1465
1466   /* We only need the process id, not the thread id.  */
1467   (void) GetWindowThreadProcessId (hWnd, &pid);
1468
1469   /* Not the one we're looking for.  */
1470   if (pid != (DWORD) emacs_pid) return TRUE;
1471
1472   /* OK, let's raise it.  */
1473   set_fg (emacs_pid);
1474
1475   /* Stop enumeration.  */
1476   return FALSE;
1477 }
1478
1479 /*
1480  * Search for a window of class "Emacs" and owned by a process with
1481  * process id = emacs_pid.  If found, allow it to grab the focus.
1482  */
1483 void
1484 w32_give_focus (void)
1485 {
1486   HANDLE user32;
1487
1488   /* It shouldn't happen when dealing with TCP sockets.  */
1489   if (!emacs_pid) return;
1490
1491   user32 = GetModuleHandle ("user32.dll");
1492
1493   if (!user32)
1494     return;
1495
1496   /* Modern Windows restrict which processes can set the foreground window.
1497      emacsclient can allow Emacs to grab the focus by calling the function
1498      AllowSetForegroundWindow.  Unfortunately, older Windows (W95, W98 and
1499      NT) lack this function, so we have to check its availability.  */
1500   if ((set_fg = GetProcAddress (user32, "AllowSetForegroundWindow"))
1501       && (get_wc = GetProcAddress (user32, "RealGetWindowClassA")))
1502     EnumWindows (w32_find_emacs_process, (LPARAM) 0);
1503 }
1504 #endif
1505
1506 /* Start the emacs daemon and try to connect to it.  */
1507
1508 static void
1509 start_daemon_and_retry_set_socket (void)
1510 {
1511 #ifndef WINDOWSNT
1512   pid_t dpid;
1513   int status;
1514
1515   dpid = fork ();
1516
1517   if (dpid > 0)
1518     {
1519       pid_t w;
1520       w = waitpid (dpid, &status, WUNTRACED | WCONTINUED);
1521
1522       if ((w == -1) || !WIFEXITED (status) || WEXITSTATUS (status))
1523         {
1524           message (TRUE, "Error: Could not start the Emacs daemon\n");
1525           exit (EXIT_FAILURE);
1526         }
1527
1528       /* Try connecting, the daemon should have started by now.  */
1529       message (TRUE, "Emacs daemon should have started, trying to connect again\n");
1530       if ((emacs_socket = set_socket (1)) == INVALID_SOCKET)
1531         {
1532           message (TRUE, "Error: Cannot connect even after starting the Emacs daemon\n");
1533           exit (EXIT_FAILURE);
1534         }
1535     }
1536   else if (dpid < 0)
1537     {
1538       fprintf (stderr, "Error: Cannot fork!\n");
1539       exit (EXIT_FAILURE);
1540     }
1541   else
1542     {
1543       char emacs[] = "emacs";
1544       char daemon_option[] = "--daemon";
1545       char *d_argv[] = {emacs, daemon_option, 0 };
1546       if (socket_name != NULL)
1547         {
1548           /* Pass  --daemon=socket_name as argument.  */
1549           const char *deq = "--daemon=";
1550           char *daemon_arg = xmalloc (strlen (deq)
1551                                       + strlen (socket_name) + 1);
1552           strcpy (daemon_arg, deq);
1553           strcat (daemon_arg, socket_name);
1554           d_argv[1] = daemon_arg;
1555         }
1556       execvp ("emacs", d_argv);
1557       message (TRUE, "%s: error starting emacs daemon\n", progname);
1558     }
1559 #endif /* WINDOWSNT */
1560 }
1561
1562 int
1563 main (int argc, char **argv)
1564 {
1565   int rl = 0, needlf = 0;
1566   char *cwd, *str;
1567   char string[BUFSIZ+1];
1568   int null_socket_name IF_LINT ( = 0);
1569   int null_server_file IF_LINT ( = 0);
1570   int start_daemon_if_needed;
1571   int exit_status = EXIT_SUCCESS;
1572
1573   main_argv = argv;
1574   progname = argv[0];
1575
1576 #ifdef WINDOWSNT
1577   /* On Windows 7 and later, we need to explicitly associate emacsclient
1578      with emacs so the UI behaves sensibly.  */
1579   w32_set_user_model_id ();
1580 #endif
1581
1582   /* Process options.  */
1583   decode_options (argc, argv);
1584
1585   if ((argc - optind < 1) && !eval && current_frame)
1586     {
1587       message (TRUE, "%s: file name or argument required\n"
1588                "Try `%s --help' for more information\n",
1589                progname, progname);
1590       exit (EXIT_FAILURE);
1591     }
1592
1593   /* If alternate_editor is the empty string, start the emacs daemon
1594      in case of failure to connect.  */
1595   start_daemon_if_needed = (alternate_editor
1596                             && (alternate_editor[0] == '\0'));
1597   if (start_daemon_if_needed)
1598     {
1599       /* set_socket changes the values for socket_name and
1600          server_file, we need to reset them, if they were NULL before
1601          for the second call to set_socket.  */
1602       null_socket_name = (socket_name == NULL);
1603       null_server_file = (server_file == NULL);
1604     }
1605
1606   emacs_socket = set_socket (alternate_editor || start_daemon_if_needed);
1607   if (emacs_socket == INVALID_SOCKET)
1608     {
1609       if (! start_daemon_if_needed)
1610         fail ();
1611
1612       /* Reset socket_name and server_file if they were NULL
1613          before the set_socket call.  */
1614       if (null_socket_name)
1615         socket_name = NULL;
1616       if (null_server_file)
1617         server_file = NULL;
1618
1619       start_daemon_and_retry_set_socket ();
1620     }
1621
1622   cwd = get_current_dir_name ();
1623   if (cwd == 0)
1624     {
1625       /* getwd puts message in STRING if it fails.  */
1626       message (TRUE, "%s: %s\n", progname,
1627                "Cannot get current working directory");
1628       fail ();
1629     }
1630
1631 #ifdef WINDOWSNT
1632   w32_give_focus ();
1633 #endif
1634
1635   /* Send over our environment and current directory. */
1636   if (!current_frame)
1637     {
1638       extern char **environ;
1639       int i;
1640       for (i = 0; environ[i]; i++)
1641         {
1642           send_to_emacs (emacs_socket, "-env ");
1643           quote_argument (emacs_socket, environ[i]);
1644           send_to_emacs (emacs_socket, " ");
1645         }
1646     }
1647   send_to_emacs (emacs_socket, "-dir ");
1648   quote_argument (emacs_socket, cwd);
1649   send_to_emacs (emacs_socket, "/");
1650   send_to_emacs (emacs_socket, " ");
1651
1652  retry:
1653   if (nowait)
1654     send_to_emacs (emacs_socket, "-nowait ");
1655
1656   if (current_frame)
1657     send_to_emacs (emacs_socket, "-current-frame ");
1658
1659   if (display)
1660     {
1661       send_to_emacs (emacs_socket, "-display ");
1662       quote_argument (emacs_socket, display);
1663       send_to_emacs (emacs_socket, " ");
1664     }
1665
1666   if (parent_id)
1667     {
1668       send_to_emacs (emacs_socket, "-parent-id ");
1669       quote_argument (emacs_socket, parent_id);
1670       send_to_emacs (emacs_socket, " ");
1671     }
1672
1673   if (frame_parameters && !current_frame)
1674     {
1675       send_to_emacs (emacs_socket, "-frame-parameters ");
1676       quote_argument (emacs_socket, frame_parameters);
1677       send_to_emacs (emacs_socket, " ");
1678     }
1679
1680   /* If using the current frame, send tty information to Emacs anyway.
1681      In daemon mode, Emacs may need to occupy this tty if no other
1682      frame is available.  */
1683   if (tty || (current_frame && !eval))
1684     {
1685       const char *tty_type, *tty_name;
1686
1687       if (find_tty (&tty_type, &tty_name, !tty))
1688         {
1689 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1690           init_signals ();
1691 #endif
1692           send_to_emacs (emacs_socket, "-tty ");
1693           quote_argument (emacs_socket, tty_name);
1694           send_to_emacs (emacs_socket, " ");
1695           quote_argument (emacs_socket, tty_type);
1696           send_to_emacs (emacs_socket, " ");
1697         }
1698     }
1699
1700   if (!current_frame && !tty)
1701     send_to_emacs (emacs_socket, "-window-system ");
1702
1703   if ((argc - optind > 0))
1704     {
1705       int i;
1706       for (i = optind; i < argc; i++)
1707         {
1708
1709           if (eval)
1710             {
1711               /* Don't prepend cwd or anything like that.  */
1712               send_to_emacs (emacs_socket, "-eval ");
1713               quote_argument (emacs_socket, argv[i]);
1714               send_to_emacs (emacs_socket, " ");
1715               continue;
1716             }
1717
1718           if (*argv[i] == '+')
1719             {
1720               char *p = argv[i] + 1;
1721               while (isdigit ((unsigned char) *p) || *p == ':') p++;
1722               if (*p == 0)
1723                 {
1724                   send_to_emacs (emacs_socket, "-position ");
1725                   quote_argument (emacs_socket, argv[i]);
1726                   send_to_emacs (emacs_socket, " ");
1727                   continue;
1728                 }
1729             }
1730 #ifdef WINDOWSNT
1731           else if (! file_name_absolute_p (argv[i])
1732                    && (isalpha (argv[i][0]) && argv[i][1] == ':'))
1733             /* Windows can have a different default directory for each
1734                drive, so the cwd passed via "-dir" is not sufficient
1735                to account for that.
1736                If the user uses <drive>:<relpath>, we hence need to be
1737                careful to expand <relpath> with the default directory
1738                corresponding to <drive>.  */
1739             {
1740               char *filename = (char *) xmalloc (MAX_PATH);
1741               DWORD size;
1742
1743               size = GetFullPathName (argv[i], MAX_PATH, filename, NULL);
1744               if (size > 0 && size < MAX_PATH)
1745                 argv[i] = filename;
1746               else
1747                 free (filename);
1748             }
1749 #endif
1750
1751           send_to_emacs (emacs_socket, "-file ");
1752           quote_argument (emacs_socket, argv[i]);
1753           send_to_emacs (emacs_socket, " ");
1754         }
1755     }
1756   else if (eval)
1757     {
1758       /* Read expressions interactively.  */
1759       while ((str = fgets (string, BUFSIZ, stdin)))
1760         {
1761           send_to_emacs (emacs_socket, "-eval ");
1762           quote_argument (emacs_socket, str);
1763         }
1764       send_to_emacs (emacs_socket, " ");
1765     }
1766
1767   send_to_emacs (emacs_socket, "\n");
1768
1769   /* Wait for an answer. */
1770   if (!eval && !tty && !nowait && !quiet)
1771     {
1772       printf ("Waiting for Emacs...");
1773       needlf = 2;
1774     }
1775   fflush (stdout);
1776   fsync (1);
1777
1778   /* Now, wait for an answer and print any messages.  */
1779   while (exit_status == EXIT_SUCCESS)
1780     {
1781       char *p;
1782       do
1783         {
1784           errno = 0;
1785           rl = recv (emacs_socket, string, BUFSIZ, 0);
1786         }
1787       /* If we receive a signal (e.g. SIGWINCH, which we pass
1788          through to Emacs), on some OSes we get EINTR and must retry. */
1789       while (rl < 0 && errno == EINTR);
1790
1791       if (rl <= 0)
1792         break;
1793
1794       string[rl] = '\0';
1795
1796       p = string + strlen (string) - 1;
1797       while (p > string && *p == '\n')
1798         *p-- = 0;
1799
1800       if (strprefix ("-emacs-pid ", string))
1801         {
1802           /* -emacs-pid PID: The process id of the Emacs process. */
1803           emacs_pid = strtol (string + strlen ("-emacs-pid"), NULL, 10);
1804         }
1805       else if (strprefix ("-window-system-unsupported ", string))
1806         {
1807           /* -window-system-unsupported: Emacs was compiled without X
1808               support.  Try again on the terminal. */
1809           nowait = 0;
1810           tty = 1;
1811           goto retry;
1812         }
1813       else if (strprefix ("-print ", string))
1814         {
1815           /* -print STRING: Print STRING on the terminal. */
1816           str = unquote_argument (string + strlen ("-print "));
1817           if (needlf)
1818             printf ("\n");
1819           printf ("%s", str);
1820           needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1821         }
1822       else if (strprefix ("-error ", string))
1823         {
1824           /* -error DESCRIPTION: Signal an error on the terminal. */
1825           str = unquote_argument (string + strlen ("-error "));
1826           if (needlf)
1827             printf ("\n");
1828           fprintf (stderr, "*ERROR*: %s", str);
1829           needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1830           exit_status = EXIT_FAILURE;
1831         }
1832 #ifdef SIGSTOP
1833       else if (strprefix ("-suspend ", string))
1834         {
1835           /* -suspend: Suspend this terminal, i.e., stop the process. */
1836           if (needlf)
1837             printf ("\n");
1838           needlf = 0;
1839           kill (0, SIGSTOP);
1840         }
1841 #endif
1842       else
1843         {
1844           /* Unknown command. */
1845           if (needlf)
1846             printf ("\n");
1847           printf ("*ERROR*: Unknown message: %s", string);
1848           needlf = string[0]
1849             == '\0' ? needlf : string[strlen (string) - 1] != '\n';
1850         }
1851     }
1852
1853   if (needlf)
1854     printf ("\n");
1855   fflush (stdout);
1856   fsync (1);
1857
1858   if (rl < 0)
1859     exit_status = EXIT_FAILURE;
1860
1861   CLOSE_SOCKET (emacs_socket);
1862   return exit_status;
1863 }
1864
1865 #endif /* HAVE_SOCKETS && HAVE_INET_SOCKETS */
1866
1867 \f
1868 #ifndef HAVE_STRERROR
1869 char *
1870 strerror (errnum)
1871      int errnum;
1872 {
1873   extern char *sys_errlist[];
1874   extern int sys_nerr;
1875
1876   if (errnum >= 0 && errnum < sys_nerr)
1877     return sys_errlist[errnum];
1878   return (char *) "Unknown error";
1879 }
1880
1881 #endif /* ! HAVE_STRERROR */
1882
1883
1884 /* emacsclient.c ends here */