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