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 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 (struct sockaddr_in *server, char *authentication)
 959 {
 960   char dotted[32];
 961   char *port;
 962   FILE *config = NULL;
 963
 964   if (file_name_absolute_p (server_file))
 965     config = fopen (server_file, "rb");
 966   else
 967     {
 968       const char *home = egetenv ("HOME");
 969
 970       if (home)
 971         {
 972           char *path = xmalloc (strlen (home) + strlen (server_file)
 973                                 + EXTRA_SPACE);
 974           strcpy (path, home);
 975           strcat (path, "/.emacs.d/server/");
 976           strcat (path, server_file);
 977           config = fopen (path, "rb");
 978           free (path);
 979         }
 980 #ifdef WINDOWSNT
 981       if (!config && (home = egetenv ("APPDATA")))
 982         {
 983           char *path = xmalloc (strlen (home) + strlen (server_file)
 984                                 + EXTRA_SPACE);
 985           strcpy (path, home);
 986           strcat (path, "/.emacs.d/server/");
 987           strcat (path, server_file);
 988           config = fopen (path, "rb");
 989           free (path);
 990         }
 991 #endif
 992     }
 993
 994   if (! config)
 995     return FALSE;
 996
 997   if (fgets (dotted, sizeof dotted, config)
 998       && (port = strchr (dotted, ':')))
 999     *port++ = '\0';
1000   else
1001     {
1002       message (TRUE, "%s: invalid configuration info\n", progname);
1003       exit (EXIT_FAILURE);
1004     }
1005
1006   server->sin_family = AF_INET;
1007   server->sin_addr.s_addr = inet_addr (dotted);
1008   server->sin_port = htons (atoi (port));
1009
1010   if (! fread (authentication, AUTH_KEY_LENGTH, 1, config))
1011     {
1012       message (TRUE, "%s: cannot read authentication info\n", progname);
1013       exit (EXIT_FAILURE);
1014     }
1015
1016   fclose (config);
1017
1018   return TRUE;
1019 }
1020
1021 static HSOCKET
1022 set_tcp_socket (void)
1023 {
1024   HSOCKET s;
1025   struct sockaddr_in server;
1026   struct linger l_arg = {1, 1};
1027   char auth_string[AUTH_KEY_LENGTH + 1];
1028
1029   if (! get_server_config (&server, auth_string))
1030     return INVALID_SOCKET;
1031
1032   if (server.sin_addr.s_addr != inet_addr ("127.0.0.1") && !quiet)
1033     message (FALSE, "%s: connected to remote socket at %s\n",
1034              progname, inet_ntoa (server.sin_addr));
1035
1036   /*
1037    * Open up an AF_INET socket
1038    */
1039   if ((s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
1040     {
1041       sock_err_message ("socket");
1042       return INVALID_SOCKET;
1043     }
1044
1045   /*
1046    * Set up the socket
1047    */
1048   if (connect (s, (struct sockaddr *) &server, sizeof server) < 0)
1049     {
1050       sock_err_message ("connect");
1051       return INVALID_SOCKET;
1052     }
1053
1054   setsockopt (s, SOL_SOCKET, SO_LINGER, (char *) &l_arg, sizeof l_arg);
1055
1056   /*
1057    * Send the authentication
1058    */
1059   auth_string[AUTH_KEY_LENGTH] = '\0';
1060
1061   send_to_emacs (s, "-auth ");
1062   send_to_emacs (s, auth_string);
1063   send_to_emacs (s, " ");
1064
1065   return s;
1066 }
1067
1068
1069 /* Returns 1 if PREFIX is a prefix of STRING. */
1070 static int
1071 strprefix (const char *prefix, const char *string)
1072 {
1073   return !strncmp (prefix, string, strlen (prefix));
1074 }
1075
1076 /* Get tty name and type.  If successful, return the type in TTY_TYPE
1077    and the name in TTY_NAME, and return 1.  Otherwise, fail if NOABORT
1078    is zero, or return 0 if NOABORT is non-zero.  */
1079
1080 static int
1081 find_tty (const char **tty_type, const char **tty_name, int noabort)
1082 {
1083   const char *type = egetenv ("TERM");
1084   const char *name = ttyname (fileno (stdout));
1085
1086   if (!name)
1087     {
1088       if (noabort)
1089         return 0;
1090       else
1091         {
1092           message (TRUE, "%s: could not get terminal name\n", progname);
1093           fail ();
1094         }
1095     }
1096
1097   if (!type)
1098     {
1099       if (noabort)
1100         return 0;
1101       else
1102         {
1103           message (TRUE, "%s: please set the TERM variable to your terminal type\n",
1104                    progname);
1105           fail ();
1106         }
1107     }
1108
1109   if (strcmp (type, "eterm") == 0)
1110     {
1111       if (noabort)
1112         return 0;
1113       else
1114         {
1115           /* This causes nasty, MULTI_KBOARD-related input lockouts. */
1116           message (TRUE, "%s: opening a frame in an Emacs term buffer"
1117                    " is not supported\n", progname);
1118           fail ();
1119         }
1120     }
1121
1122   *tty_name = name;
1123   *tty_type = type;
1124   return 1;
1125 }
1126
1127
1128 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1129
1130 /* Three possibilities:
1131    2 - can't be `stat'ed                (sets errno)
1132    1 - isn't owned by us
1133    0 - success: none of the above */
1134
1135 static int
1136 socket_status (const char *name)
1137 {
1138   struct stat statbfr;
1139
1140   if (stat (name, &statbfr) == -1)
1141     return 2;
1142
1143   if (statbfr.st_uid != geteuid ())
1144     return 1;
1145
1146   return 0;
1147 }
1148
1149 \f
1150 /* A signal handler that passes the signal to the Emacs process.
1151    Useful for SIGWINCH.  */
1152
1153 static void
1154 pass_signal_to_emacs (int signalnum)
1155 {
1156   int old_errno = errno;
1157
1158   if (emacs_pid)
1159     kill (emacs_pid, signalnum);
1160
1161   signal (signalnum, pass_signal_to_emacs);
1162   errno = old_errno;
1163 }
1164
1165 /* Signal handler for SIGCONT; notify the Emacs process that it can
1166    now resume our tty frame.  */
1167
1168 static void
1169 handle_sigcont (int signalnum)
1170 {
1171   int old_errno = errno;
1172
1173   if (tcgetpgrp (1) == getpgrp ())
1174     {
1175       /* We are in the foreground. */
1176       send_to_emacs (emacs_socket, "-resume \n");
1177     }
1178   else
1179     {
1180       /* We are in the background; cancel the continue. */
1181       kill (getpid (), SIGSTOP);
1182     }
1183
1184   signal (signalnum, handle_sigcont);
1185   errno = old_errno;
1186 }
1187
1188 /* Signal handler for SIGTSTP; notify the Emacs process that we are
1189    going to sleep.  Normally the suspend is initiated by Emacs via
1190    server-handle-suspend-tty, but if the server gets out of sync with
1191    reality, we may get a SIGTSTP on C-z.  Handling this signal and
1192    notifying Emacs about it should get things under control again. */
1193
1194 static void
1195 handle_sigtstp (int signalnum)
1196 {
1197   int old_errno = errno;
1198   sigset_t set;
1199
1200   if (emacs_socket)
1201     send_to_emacs (emacs_socket, "-suspend \n");
1202
1203   /* Unblock this signal and call the default handler by temporarily
1204      changing the handler and resignaling.  */
1205   sigprocmask (SIG_BLOCK, NULL, &set);
1206   sigdelset (&set, signalnum);
1207   signal (signalnum, SIG_DFL);
1208   kill (getpid (), signalnum);
1209   sigprocmask (SIG_SETMASK, &set, NULL); /* Let's the above signal through. */
1210   signal (signalnum, handle_sigtstp);
1211
1212   errno = old_errno;
1213 }
1214
1215
1216 /* Set up signal handlers before opening a frame on the current tty.  */
1217
1218 static void
1219 init_signals (void)
1220 {
1221   /* Set up signal handlers. */
1222   signal (SIGWINCH, pass_signal_to_emacs);
1223
1224   /* Don't pass SIGINT and SIGQUIT to Emacs, because it has no way of
1225      deciding which terminal the signal came from.  C-g is now a
1226      normal input event on secondary terminals.  */
1227 #if 0
1228   signal (SIGINT, pass_signal_to_emacs);
1229   signal (SIGQUIT, pass_signal_to_emacs);
1230 #endif
1231
1232   signal (SIGCONT, handle_sigcont);
1233   signal (SIGTSTP, handle_sigtstp);
1234   signal (SIGTTOU, handle_sigtstp);
1235 }
1236
1237
1238 static HSOCKET
1239 set_local_socket (void)
1240 {
1241   HSOCKET s;
1242   struct sockaddr_un server;
1243
1244   /*
1245    * Open up an AF_UNIX socket in this person's home directory
1246    */
1247
1248   if ((s = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
1249     {
1250       message (TRUE, "%s: socket: %s\n", progname, strerror (errno));
1251       return INVALID_SOCKET;
1252     }
1253
1254   server.sun_family = AF_UNIX;
1255
1256   {
1257     int sock_status = 0;
1258     int default_sock = !socket_name;
1259     int saved_errno = 0;
1260     const char *server_name = "server";
1261     const char *tmpdir IF_LINT ( = NULL);
1262     char *tmpdir_storage = NULL;
1263     char *socket_name_storage = NULL;
1264
1265     if (socket_name && !strchr (socket_name, '/')
1266         && !strchr (socket_name, '\\'))
1267       {
1268         /* socket_name is a file name component.  */
1269         server_name = socket_name;
1270         socket_name = NULL;
1271         default_sock = 1;       /* Try both UIDs.  */
1272       }
1273
1274     if (default_sock)
1275       {
1276         long uid = geteuid ();
1277         ptrdiff_t tmpdirlen;
1278         tmpdir = egetenv ("TMPDIR");
1279         if (!tmpdir)
1280           {
1281 #ifdef DARWIN_OS
1282 #ifndef _CS_DARWIN_USER_TEMP_DIR
1283 #define _CS_DARWIN_USER_TEMP_DIR 65537
1284 #endif
1285             size_t n = confstr (_CS_DARWIN_USER_TEMP_DIR, NULL, (size_t) 0);
1286             if (n > 0)
1287               {
1288                 tmpdir = tmpdir_storage = xmalloc (n);
1289                 confstr (_CS_DARWIN_USER_TEMP_DIR, tmpdir, n);
1290               }
1291             else
1292 #endif
1293               tmpdir = "/tmp";
1294           }
1295         tmpdirlen = strlen (tmpdir);
1296         socket_name = socket_name_storage =
1297           xmalloc (tmpdirlen + strlen (server_name) + EXTRA_SPACE);
1298         strcpy (socket_name, tmpdir);
1299         sprintf (socket_name + tmpdirlen, "/emacs%ld/", uid);
1300         strcat (socket_name + tmpdirlen, server_name);
1301       }
1302
1303     if (strlen (socket_name) < sizeof (server.sun_path))
1304       strcpy (server.sun_path, socket_name);
1305     else
1306       {
1307         message (TRUE, "%s: socket-name %s too long\n",
1308                  progname, socket_name);
1309         fail ();
1310       }
1311
1312     /* See if the socket exists, and if it's owned by us. */
1313     sock_status = socket_status (server.sun_path);
1314     saved_errno = errno;
1315     if (sock_status && default_sock)
1316       {
1317         /* Failing that, see if LOGNAME or USER exist and differ from
1318            our euid.  If so, look for a socket based on the UID
1319            associated with the name.  This is reminiscent of the logic
1320            that init_editfns uses to set the global Vuser_full_name.  */
1321
1322         const char *user_name = egetenv ("LOGNAME");
1323
1324         if (!user_name)
1325           user_name = egetenv ("USER");
1326
1327         if (user_name)
1328           {
1329             struct passwd *pw = getpwnam (user_name);
1330
1331             if (pw && (pw->pw_uid != geteuid ()))
1332               {
1333                 /* We're running under su, apparently. */
1334                 long uid = pw->pw_uid;
1335                 ptrdiff_t tmpdirlen = strlen (tmpdir);
1336                 socket_name = xmalloc (tmpdirlen + strlen (server_name)
1337                                        + EXTRA_SPACE);
1338                 strcpy (socket_name, tmpdir);
1339                 sprintf (socket_name + tmpdirlen, "/emacs%ld/", uid);
1340                 strcat (socket_name + tmpdirlen, server_name);
1341
1342                 if (strlen (socket_name) < sizeof (server.sun_path))
1343                   strcpy (server.sun_path, socket_name);
1344                 else
1345                   {
1346                     message (TRUE, "%s: socket-name %s too long\n",
1347                              progname, socket_name);
1348                     exit (EXIT_FAILURE);
1349                   }
1350                 free (socket_name);
1351
1352                 sock_status = socket_status (server.sun_path);
1353                 saved_errno = errno;
1354               }
1355             else
1356               errno = saved_errno;
1357           }
1358       }
1359
1360     free (socket_name_storage);
1361     free (tmpdir_storage);
1362
1363     switch (sock_status)
1364       {
1365       case 1:
1366         /* There's a socket, but it isn't owned by us.  This is OK if
1367            we are root. */
1368         if (0 != geteuid ())
1369           {
1370             message (TRUE, "%s: Invalid socket owner\n", progname);
1371             return INVALID_SOCKET;
1372           }
1373         break;
1374
1375       case 2:
1376         /* `stat' failed */
1377         if (saved_errno == ENOENT)
1378           message (TRUE,
1379                    "%s: can't find socket; have you started the server?\n\
1380 To start the server in Emacs, type \"M-x server-start\".\n",
1381                    progname);
1382         else
1383           message (TRUE, "%s: can't stat %s: %s\n",
1384                    progname, server.sun_path, strerror (saved_errno));
1385         return INVALID_SOCKET;
1386       }
1387   }
1388
1389   if (connect (s, (struct sockaddr *) &server, strlen (server.sun_path) + 2)
1390       < 0)
1391     {
1392       message (TRUE, "%s: connect: %s\n", progname, strerror (errno));
1393       return INVALID_SOCKET;
1394     }
1395
1396   return s;
1397 }
1398 #endif /* ! NO_SOCKETS_IN_FILE_SYSTEM */
1399
1400 static HSOCKET
1401 set_socket (int no_exit_if_error)
1402 {
1403   HSOCKET s;
1404
1405   INITIALIZE ();
1406
1407 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1408   /* Explicit --socket-name argument.  */
1409   if (socket_name)
1410     {
1411       s = set_local_socket ();
1412       if ((s != INVALID_SOCKET) || no_exit_if_error)
1413         return s;
1414       message (TRUE, "%s: error accessing socket \"%s\"\n",
1415                progname, socket_name);
1416       exit (EXIT_FAILURE);
1417     }
1418 #endif
1419
1420   /* Explicit --server-file arg or EMACS_SERVER_FILE variable.  */
1421   if (!server_file)
1422     server_file = egetenv ("EMACS_SERVER_FILE");
1423
1424   if (server_file)
1425     {
1426       s = set_tcp_socket ();
1427       if ((s != INVALID_SOCKET) || no_exit_if_error)
1428         return s;
1429
1430       message (TRUE, "%s: error accessing server file \"%s\"\n",
1431                progname, server_file);
1432       exit (EXIT_FAILURE);
1433     }
1434
1435 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1436   /* Implicit local socket.  */
1437   s = set_local_socket ();
1438   if (s != INVALID_SOCKET)
1439     return s;
1440 #endif
1441
1442   /* Implicit server file.  */
1443   server_file = "server";
1444   s = set_tcp_socket ();
1445   if ((s != INVALID_SOCKET) || no_exit_if_error)
1446     return s;
1447
1448   /* No implicit or explicit socket, and no alternate editor.  */
1449   message (TRUE, "%s: No socket or alternate editor.  Please use:\n\n"
1450 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1451 "\t--socket-name\n"
1452 #endif
1453 "\t--server-file      (or environment variable EMACS_SERVER_FILE)\n\
1454 \t--alternate-editor (or environment variable ALTERNATE_EDITOR)\n",
1455            progname);
1456   exit (EXIT_FAILURE);
1457 }
1458
1459 #ifdef WINDOWSNT
1460 FARPROC set_fg;  /* Pointer to AllowSetForegroundWindow.  */
1461 FARPROC get_wc;  /* Pointer to RealGetWindowClassA.  */
1462
1463 BOOL CALLBACK
1464 w32_find_emacs_process (HWND hWnd, LPARAM lParam)
1465 {
1466   DWORD pid;
1467   char class[6];
1468
1469   /* Reject any window not of class "Emacs".  */
1470   if (! get_wc (hWnd, class, sizeof (class))
1471       || strcmp (class, "Emacs"))
1472     return TRUE;
1473
1474   /* We only need the process id, not the thread id.  */
1475   (void) GetWindowThreadProcessId (hWnd, &pid);
1476
1477   /* Not the one we're looking for.  */
1478   if (pid != (DWORD) emacs_pid) return TRUE;
1479
1480   /* OK, let's raise it.  */
1481   set_fg (emacs_pid);
1482
1483   /* Stop enumeration.  */
1484   return FALSE;
1485 }
1486
1487 /*
1488  * Search for a window of class "Emacs" and owned by a process with
1489  * process id = emacs_pid.  If found, allow it to grab the focus.
1490  */
1491 void
1492 w32_give_focus (void)
1493 {
1494   HANDLE user32;
1495
1496   /* It shouldn't happen when dealing with TCP sockets.  */
1497   if (!emacs_pid) return;
1498
1499   user32 = GetModuleHandle ("user32.dll");
1500
1501   if (!user32)
1502     return;
1503
1504   /* Modern Windows restrict which processes can set the foreground window.
1505      emacsclient can allow Emacs to grab the focus by calling the function
1506      AllowSetForegroundWindow.  Unfortunately, older Windows (W95, W98 and
1507      NT) lack this function, so we have to check its availability.  */
1508   if ((set_fg = GetProcAddress (user32, "AllowSetForegroundWindow"))
1509       && (get_wc = GetProcAddress (user32, "RealGetWindowClassA")))
1510     EnumWindows (w32_find_emacs_process, (LPARAM) 0);
1511 }
1512 #endif
1513
1514 /* Start the emacs daemon and try to connect to it.  */
1515
1516 static void
1517 start_daemon_and_retry_set_socket (void)
1518 {
1519 #ifndef WINDOWSNT
1520   pid_t dpid;
1521   int status;
1522
1523   dpid = fork ();
1524
1525   if (dpid > 0)
1526     {
1527       pid_t w;
1528       w = waitpid (dpid, &status, WUNTRACED | WCONTINUED);
1529
1530       if ((w == -1) || !WIFEXITED (status) || WEXITSTATUS (status))
1531         {
1532           message (TRUE, "Error: Could not start the Emacs daemon\n");
1533           exit (EXIT_FAILURE);
1534         }
1535
1536       /* Try connecting, the daemon should have started by now.  */
1537       message (TRUE, "Emacs daemon should have started, trying to connect again\n");
1538       if ((emacs_socket = set_socket (1)) == INVALID_SOCKET)
1539         {
1540           message (TRUE, "Error: Cannot connect even after starting the Emacs daemon\n");
1541           exit (EXIT_FAILURE);
1542         }
1543     }
1544   else if (dpid < 0)
1545     {
1546       fprintf (stderr, "Error: Cannot fork!\n");
1547       exit (EXIT_FAILURE);
1548     }
1549   else
1550     {
1551       char emacs[] = "emacs";
1552       char daemon_option[] = "--daemon";
1553       char *d_argv[] = {emacs, daemon_option, 0 };
1554       if (socket_name != NULL)
1555         {
1556           /* Pass  --daemon=socket_name as argument.  */
1557           const char *deq = "--daemon=";
1558           char *daemon_arg = xmalloc (strlen (deq)
1559                                       + strlen (socket_name) + 1);
1560           strcpy (daemon_arg, deq);
1561           strcat (daemon_arg, socket_name);
1562           d_argv[1] = daemon_arg;
1563         }
1564       execvp ("emacs", d_argv);
1565       message (TRUE, "%s: error starting emacs daemon\n", progname);
1566     }
1567 #endif /* WINDOWSNT */
1568 }
1569
1570 int
1571 main (int argc, char **argv)
1572 {
1573   int rl = 0, needlf = 0;
1574   char *cwd, *str;
1575   char string[BUFSIZ+1];
1576   int null_socket_name IF_LINT ( = 0);
1577   int null_server_file IF_LINT ( = 0);
1578   int start_daemon_if_needed;
1579   int exit_status = EXIT_SUCCESS;
1580
1581   main_argv = argv;
1582   progname = argv[0];
1583
1584 #ifdef WINDOWSNT
1585   /* On Windows 7 and later, we need to explicitly associate emacsclient
1586      with emacs so the UI behaves sensibly.  */
1587   w32_set_user_model_id ();
1588 #endif
1589
1590   /* Process options.  */
1591   decode_options (argc, argv);
1592
1593   if ((argc - optind < 1) && !eval && current_frame)
1594     {
1595       message (TRUE, "%s: file name or argument required\n"
1596                "Try `%s --help' for more information\n",
1597                progname, progname);
1598       exit (EXIT_FAILURE);
1599     }
1600
1601   /* If alternate_editor is the empty string, start the emacs daemon
1602      in case of failure to connect.  */
1603   start_daemon_if_needed = (alternate_editor
1604                             && (alternate_editor[0] == '\0'));
1605   if (start_daemon_if_needed)
1606     {
1607       /* set_socket changes the values for socket_name and
1608          server_file, we need to reset them, if they were NULL before
1609          for the second call to set_socket.  */
1610       null_socket_name = (socket_name == NULL);
1611       null_server_file = (server_file == NULL);
1612     }
1613
1614   emacs_socket = set_socket (alternate_editor || start_daemon_if_needed);
1615   if (emacs_socket == INVALID_SOCKET)
1616     {
1617       if (! start_daemon_if_needed)
1618         fail ();
1619
1620       /* Reset socket_name and server_file if they were NULL
1621          before the set_socket call.  */
1622       if (null_socket_name)
1623         socket_name = NULL;
1624       if (null_server_file)
1625         server_file = NULL;
1626
1627       start_daemon_and_retry_set_socket ();
1628     }
1629
1630   cwd = get_current_dir_name ();
1631   if (cwd == 0)
1632     {
1633       /* getwd puts message in STRING if it fails.  */
1634       message (TRUE, "%s: %s\n", progname,
1635                "Cannot get current working directory");
1636       fail ();
1637     }
1638
1639 #ifdef WINDOWSNT
1640   w32_give_focus ();
1641 #endif
1642
1643   /* Send over our environment and current directory. */
1644   if (!current_frame)
1645     {
1646 #ifndef WINDOWSNT
1647       /* This is defined in stdlib.h on MS-Windows.  It's defined in
1648          unistd.h on some POSIX hosts, but not all (Bug#10155).  */
1649       extern char **environ;
1650 #endif
1651       int i;
1652       for (i = 0; environ[i]; i++)
1653         {
1654           send_to_emacs (emacs_socket, "-env ");
1655           quote_argument (emacs_socket, environ[i]);
1656           send_to_emacs (emacs_socket, " ");
1657         }
1658     }
1659   send_to_emacs (emacs_socket, "-dir ");
1660   quote_argument (emacs_socket, cwd);
1661   send_to_emacs (emacs_socket, "/");
1662   send_to_emacs (emacs_socket, " ");
1663
1664  retry:
1665   if (nowait)
1666     send_to_emacs (emacs_socket, "-nowait ");
1667
1668   if (current_frame)
1669     send_to_emacs (emacs_socket, "-current-frame ");
1670
1671   if (display)
1672     {
1673       send_to_emacs (emacs_socket, "-display ");
1674       quote_argument (emacs_socket, display);
1675       send_to_emacs (emacs_socket, " ");
1676     }
1677
1678   if (parent_id)
1679     {
1680       send_to_emacs (emacs_socket, "-parent-id ");
1681       quote_argument (emacs_socket, parent_id);
1682       send_to_emacs (emacs_socket, " ");
1683     }
1684
1685   if (frame_parameters && !current_frame)
1686     {
1687       send_to_emacs (emacs_socket, "-frame-parameters ");
1688       quote_argument (emacs_socket, frame_parameters);
1689       send_to_emacs (emacs_socket, " ");
1690     }
1691
1692   /* If using the current frame, send tty information to Emacs anyway.
1693      In daemon mode, Emacs may need to occupy this tty if no other
1694      frame is available.  */
1695   if (tty || (current_frame && !eval))
1696     {
1697       const char *tty_type, *tty_name;
1698
1699       if (find_tty (&tty_type, &tty_name, !tty))
1700         {
1701 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1702           init_signals ();
1703 #endif
1704           send_to_emacs (emacs_socket, "-tty ");
1705           quote_argument (emacs_socket, tty_name);
1706           send_to_emacs (emacs_socket, " ");
1707           quote_argument (emacs_socket, tty_type);
1708           send_to_emacs (emacs_socket, " ");
1709         }
1710     }
1711
1712   if (!current_frame && !tty)
1713     send_to_emacs (emacs_socket, "-window-system ");
1714
1715   if ((argc - optind > 0))
1716     {
1717       int i;
1718       for (i = optind; i < argc; i++)
1719         {
1720
1721           if (eval)
1722             {
1723               /* Don't prepend cwd or anything like that.  */
1724               send_to_emacs (emacs_socket, "-eval ");
1725               quote_argument (emacs_socket, argv[i]);
1726               send_to_emacs (emacs_socket, " ");
1727               continue;
1728             }
1729
1730           if (*argv[i] == '+')
1731             {
1732               char *p = argv[i] + 1;
1733               while (isdigit ((unsigned char) *p) || *p == ':') p++;
1734               if (*p == 0)
1735                 {
1736                   send_to_emacs (emacs_socket, "-position ");
1737                   quote_argument (emacs_socket, argv[i]);
1738                   send_to_emacs (emacs_socket, " ");
1739                   continue;
1740                 }
1741             }
1742 #ifdef WINDOWSNT
1743           else if (! file_name_absolute_p (argv[i])
1744                    && (isalpha (argv[i][0]) && argv[i][1] == ':'))
1745             /* Windows can have a different default directory for each
1746                drive, so the cwd passed via "-dir" is not sufficient
1747                to account for that.
1748                If the user uses <drive>:<relpath>, we hence need to be
1749                careful to expand <relpath> with the default directory
1750                corresponding to <drive>.  */
1751             {
1752               char *filename = (char *) xmalloc (MAX_PATH);
1753               DWORD size;
1754
1755               size = GetFullPathName (argv[i], MAX_PATH, filename, NULL);
1756               if (size > 0 && size < MAX_PATH)
1757                 argv[i] = filename;
1758               else
1759                 free (filename);
1760             }
1761 #endif
1762
1763           send_to_emacs (emacs_socket, "-file ");
1764           quote_argument (emacs_socket, argv[i]);
1765           send_to_emacs (emacs_socket, " ");
1766         }
1767     }
1768   else if (eval)
1769     {
1770       /* Read expressions interactively.  */
1771       while ((str = fgets (string, BUFSIZ, stdin)))
1772         {
1773           send_to_emacs (emacs_socket, "-eval ");
1774           quote_argument (emacs_socket, str);
1775         }
1776       send_to_emacs (emacs_socket, " ");
1777     }
1778
1779   send_to_emacs (emacs_socket, "\n");
1780
1781   /* Wait for an answer. */
1782   if (!eval && !tty && !nowait && !quiet)
1783     {
1784       printf ("Waiting for Emacs...");
1785       needlf = 2;
1786     }
1787   fflush (stdout);
1788   fsync (1);
1789
1790   /* Now, wait for an answer and print any messages.  */
1791   while (exit_status == EXIT_SUCCESS)
1792     {
1793       char *p;
1794       do
1795         {
1796           errno = 0;
1797           rl = recv (emacs_socket, string, BUFSIZ, 0);
1798         }
1799       /* If we receive a signal (e.g. SIGWINCH, which we pass
1800          through to Emacs), on some OSes we get EINTR and must retry. */
1801       while (rl < 0 && errno == EINTR);
1802
1803       if (rl <= 0)
1804         break;
1805
1806       string[rl] = '\0';
1807
1808       p = string + strlen (string) - 1;
1809       while (p > string && *p == '\n')
1810         *p-- = 0;
1811
1812       if (strprefix ("-emacs-pid ", string))
1813         {
1814           /* -emacs-pid PID: The process id of the Emacs process. */
1815           emacs_pid = strtol (string + strlen ("-emacs-pid"), NULL, 10);
1816         }
1817       else if (strprefix ("-window-system-unsupported ", string))
1818         {
1819           /* -window-system-unsupported: Emacs was compiled without X
1820               support.  Try again on the terminal. */
1821           nowait = 0;
1822           tty = 1;
1823           goto retry;
1824         }
1825       else if (strprefix ("-print ", string))
1826         {
1827           /* -print STRING: Print STRING on the terminal. */
1828           str = unquote_argument (string + strlen ("-print "));
1829           if (needlf)
1830             printf ("\n");
1831           printf ("%s", str);
1832           needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1833         }
1834       else if (strprefix ("-error ", string))
1835         {
1836           /* -error DESCRIPTION: Signal an error on the terminal. */
1837           str = unquote_argument (string + strlen ("-error "));
1838           if (needlf)
1839             printf ("\n");
1840           fprintf (stderr, "*ERROR*: %s", str);
1841           needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1842           exit_status = EXIT_FAILURE;
1843         }
1844 #ifdef SIGSTOP
1845       else if (strprefix ("-suspend ", string))
1846         {
1847           /* -suspend: Suspend this terminal, i.e., stop the process. */
1848           if (needlf)
1849             printf ("\n");
1850           needlf = 0;
1851           kill (0, SIGSTOP);
1852         }
1853 #endif
1854       else
1855         {
1856           /* Unknown command. */
1857           if (needlf)
1858             printf ("\n");
1859           printf ("*ERROR*: Unknown message: %s", string);
1860           needlf = string[0]
1861             == '\0' ? needlf : string[strlen (string) - 1] != '\n';
1862         }
1863     }
1864
1865   if (needlf)
1866     printf ("\n");
1867   fflush (stdout);
1868   fsync (1);
1869
1870   if (rl < 0)
1871     exit_status = EXIT_FAILURE;
1872
1873   CLOSE_SOCKET (emacs_socket);
1874   return exit_status;
1875 }
1876
1877 #endif /* HAVE_SOCKETS && HAVE_INET_SOCKETS */
1878
1879 \f
1880 #ifndef HAVE_STRERROR
1881 char *
1882 strerror (errnum)
1883      int errnum;
1884 {
1885   extern char *sys_errlist[];
1886   extern int sys_nerr;
1887
1888   if (errnum >= 0 && errnum < sys_nerr)
1889     return sys_errlist[errnum];
1890   return (char *) "Unknown error";
1891 }
1892
1893 #endif /* ! HAVE_STRERROR */
1894
1895
1896 /* emacsclient.c ends here */