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