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