lib-src/emacsclient.c

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