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