lib-src/emacsclient.c

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