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 #ifndef WINDOWSNT
1523   else
1524     fail ();
1525 #endif
1526
1527   cwd = get_current_dir_name ();
1528   if (cwd == 0)
1529     {
1530       /* getwd puts message in STRING if it fails.  */
1531       message (TRUE, "%s: %s\n", progname,
1532                "Cannot get current working directory");
1533       fail ();
1534     }
1535
1536 #ifdef WINDOWSNT
1537   w32_give_focus ();
1538 #endif
1539
1540   /* Send over our environment and current directory. */
1541   if (!current_frame)
1542     {
1543       extern char **environ;
1544       int i;
1545       for (i = 0; environ[i]; i++)
1546         {
1547           char *name = xstrdup (environ[i]);
1548           char *value = strchr (name, '=');
1549           send_to_emacs (emacs_socket, "-env ");
1550           quote_argument (emacs_socket, environ[i]);
1551           send_to_emacs (emacs_socket, " ");
1552         }
1553       send_to_emacs (emacs_socket, "-dir ");
1554       quote_argument (emacs_socket, cwd);
1555       send_to_emacs (emacs_socket, "/");
1556       send_to_emacs (emacs_socket, " ");
1557     }
1558
1559  retry:
1560   if (nowait)
1561     send_to_emacs (emacs_socket, "-nowait ");
1562
1563   if (current_frame)
1564     send_to_emacs (emacs_socket, "-current-frame ");
1565
1566   if (display)
1567     {
1568       send_to_emacs (emacs_socket, "-display ");
1569       quote_argument (emacs_socket, display);
1570       send_to_emacs (emacs_socket, " ");
1571     }
1572
1573   /* If using the current frame, send tty information to Emacs anyway.
1574      In daemon mode, Emacs may need to occupy this tty if no other
1575      frame is available.  */
1576   if (tty || (current_frame && !eval))
1577     {
1578       char *tty_type, *tty_name;
1579
1580       if (find_tty (&tty_type, &tty_name, !tty))
1581         {
1582 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1583           init_signals ();
1584 #endif
1585           send_to_emacs (emacs_socket, "-tty ");
1586           quote_argument (emacs_socket, tty_name);
1587           send_to_emacs (emacs_socket, " ");
1588           quote_argument (emacs_socket, tty_type);
1589           send_to_emacs (emacs_socket, " ");
1590         }
1591     }
1592
1593   if (!current_frame && !tty)
1594     send_to_emacs (emacs_socket, "-window-system ");
1595
1596   if ((argc - optind > 0))
1597     {
1598       for (i = optind; i < argc; i++)
1599         {
1600           int relative = 0;
1601
1602           if (eval)
1603             {
1604               /* Don't prepend cwd or anything like that.  */
1605               send_to_emacs (emacs_socket, "-eval ");
1606               quote_argument (emacs_socket, argv[i]);
1607               send_to_emacs (emacs_socket, " ");
1608               continue;
1609             }
1610
1611           if (*argv[i] == '+')
1612             {
1613               char *p = argv[i] + 1;
1614               while (isdigit ((unsigned char) *p) || *p == ':') p++;
1615               if (*p == 0)
1616                 {
1617                   send_to_emacs (emacs_socket, "-position ");
1618                   quote_argument (emacs_socket, argv[i]);
1619                   send_to_emacs (emacs_socket, " ");
1620                   continue;
1621                 }
1622               else
1623                 relative = 1;
1624             }
1625           else if (! file_name_absolute_p (argv[i]))
1626 #ifndef WINDOWSNT
1627             relative = 1;
1628 #else
1629             /* Call GetFullPathName so filenames of the form X:Y, where X is
1630                a valid drive designator, are interpreted as drive:path, not
1631                file:stream, and treated as absolute.
1632                The user can still pass a file:stream if desired (for example,
1633                .\X:Y), but it is not very useful, as Emacs currently does a
1634                very bad job of dealing with NTFS streams. */
1635             {
1636               char *filename = (char *) xmalloc (MAX_PATH);
1637               DWORD size;
1638
1639               size = GetFullPathName (argv[i], MAX_PATH, filename, NULL);
1640               if (size > 0 && size < MAX_PATH)
1641                 argv[i] = filename;
1642               else
1643                 {
1644                   relative = 1;
1645                   free (filename);
1646                 }
1647             }
1648 #endif
1649
1650           send_to_emacs (emacs_socket, "-file ");
1651           if (relative)
1652             {
1653               quote_argument (emacs_socket, cwd);
1654               send_to_emacs (emacs_socket, "/");
1655             }
1656           quote_argument (emacs_socket, argv[i]);
1657           send_to_emacs (emacs_socket, " ");
1658         }
1659     }
1660   else if (eval)
1661     {
1662       /* Read expressions interactively.  */
1663       while ((str = fgets (string, BUFSIZ, stdin)))
1664         {
1665           send_to_emacs (emacs_socket, "-eval ");
1666           quote_argument (emacs_socket, str);
1667         }
1668       send_to_emacs (emacs_socket, " ");
1669     }
1670
1671   send_to_emacs (emacs_socket, "\n");
1672
1673   /* Wait for an answer. */
1674   if (!eval && !tty && !nowait)
1675     {
1676       printf ("Waiting for Emacs...");
1677       needlf = 2;
1678     }
1679   fflush (stdout);
1680   fsync (1);
1681
1682   /* Now, wait for an answer and print any messages.  */
1683   while ((rl = recv (emacs_socket, string, BUFSIZ, 0)) > 0)
1684     {
1685       char *p;
1686       string[rl] = '\0';
1687
1688       p = string + strlen (string) - 1;
1689       while (p > string && *p == '\n')
1690         *p-- = 0;
1691
1692       if (strprefix ("-emacs-pid ", string))
1693         {
1694           /* -emacs-pid PID: The process id of the Emacs process. */
1695           emacs_pid = strtol (string + strlen ("-emacs-pid"), NULL, 10);
1696         }
1697       else if (strprefix ("-window-system-unsupported ", string))
1698         {
1699           /* -window-system-unsupported: Emacs was compiled without X
1700               support.  Try again on the terminal. */
1701           nowait = 0;
1702           tty = 1;
1703           goto retry;
1704         }
1705       else if (strprefix ("-print ", string))
1706         {
1707           /* -print STRING: Print STRING on the terminal. */
1708           str = unquote_argument (string + strlen ("-print "));
1709           if (needlf)
1710             printf ("\n");
1711           printf ("%s", str);
1712           needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1713         }
1714       else if (strprefix ("-error ", string))
1715         {
1716           /* -error DESCRIPTION: Signal an error on the terminal. */
1717           str = unquote_argument (string + strlen ("-error "));
1718           if (needlf)
1719             printf ("\n");
1720           fprintf (stderr, "*ERROR*: %s", str);
1721           needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1722         }
1723 #ifdef SIGSTOP
1724       else if (strprefix ("-suspend ", string))
1725         {
1726           /* -suspend: Suspend this terminal, i.e., stop the process. */
1727           if (needlf)
1728             printf ("\n");
1729           needlf = 0;
1730           kill (0, SIGSTOP);
1731         }
1732 #endif
1733       else
1734         {
1735           /* Unknown command. */
1736           if (needlf)
1737             printf ("\n");
1738           printf ("*ERROR*: Unknown message: %s", string);
1739           needlf = string[0] == '\0' ? needlf : string[strlen (string) - 1] != '\n';
1740         }
1741     }
1742
1743   if (needlf)
1744     printf ("\n");
1745   fflush (stdout);
1746   fsync (1);
1747
1748   CLOSE_SOCKET (emacs_socket);
1749   return EXIT_SUCCESS;
1750 }
1751
1752 #endif /* HAVE_SOCKETS && HAVE_INET_SOCKETS */
1753
1754 \f
1755 #ifndef HAVE_STRERROR
1756 char *
1757 strerror (errnum)
1758      int errnum;
1759 {
1760   extern char *sys_errlist[];
1761   extern int sys_nerr;
1762
1763   if (errnum >= 0 && errnum < sys_nerr)
1764     return sys_errlist[errnum];
1765   return (char *) "Unknown error";
1766 }
1767
1768 #endif /* ! HAVE_STRERROR */
1769
1770 /* arch-tag: f39bb9c4-73eb-477e-896d-50832e2ca9a7
1771    (do not change this comment) */
1772
1773 /* emacsclient.c ends here */