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=DISPLAY\n\
 632                         Visit the file in the given display\n"
 633 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
 634 "-s SOCKET, --socket-name=SOCKET\n\
 635                         Set filename of the UNIX socket for communication\n"
 636 #endif
 637 "-f SERVER, --server-file=SERVER\n\
 638                         Set filename of the TCP authentication file\n\
 639 -a EDITOR, --alternate-editor=EDITOR\n\
 640                         Editor to fallback to if the server is not running\n"
 641 #ifndef WINDOWSNT
 642 "                       If EDITOR is the empty string, start Emacs in daemon\n\
 643                         mode and try connecting again\n"
 644 #endif /* not WINDOWSNT */
 645 "\n\
 646 Report bugs to bug-gnu-emacs@gnu.org.\n", progname);
 647   exit (EXIT_SUCCESS);
 648 }
 649
 650 /*
 651   Try to run a different command, or --if no alternate editor is
 652   defined-- exit with an errorcode.
 653   Uses argv, but gets it from the global variable main_argv.
 654 */
 655 void
 656 fail (void)
 657 {
 658   if (alternate_editor)
 659     {
 660       int i = optind - 1;
 661
 662       execvp (alternate_editor, main_argv + i);
 663       message (TRUE, "%s: error executing alternate editor \"%s\"\n",
 664                progname, alternate_editor);
 665     }
 666   exit (EXIT_FAILURE);
 667 }
 668
 669 \f
 670 #if !defined (HAVE_SOCKETS) || !defined (HAVE_INET_SOCKETS)
 671
 672 int
 673 main (argc, argv)
 674      int argc;
 675      char **argv;
 676 {
 677   main_argv = argv;
 678   progname = argv[0];
 679   message (TRUE, "%s: Sorry, the Emacs server is supported only\n"
 680            "on systems with Berkeley sockets.\n",
 681            argv[0]);
 682   fail ();
 683 }
 684
 685 #else /* HAVE_SOCKETS && HAVE_INET_SOCKETS */
 686
 687 #ifdef WINDOWSNT
 688 # include <winsock2.h>
 689 #else
 690 # include <sys/types.h>
 691 # include <sys/socket.h>
 692 # include <sys/un.h>
 693 #endif
 694
 695 #define AUTH_KEY_LENGTH      64
 696 #define SEND_BUFFER_SIZE   4096
 697
 698 extern char *strerror ();
 699 extern int errno;
 700
 701 /* Buffer to accumulate data to send in TCP connections.  */
 702 char send_buffer[SEND_BUFFER_SIZE + 1];
 703 int sblen = 0;  /* Fill pointer for the send buffer.  */
 704 /* Socket used to communicate with the Emacs server process.  */
 705 HSOCKET emacs_socket = 0;
 706
 707 /* On Windows, the socket library was historically separate from the standard
 708    C library, so errors are handled differently.  */
 709 void
 710 sock_err_message (function_name)
 711      char *function_name;
 712 {
 713 #ifdef WINDOWSNT
 714   char* msg = NULL;
 715
 716   FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
 717                  | FORMAT_MESSAGE_ALLOCATE_BUFFER
 718                  | FORMAT_MESSAGE_ARGUMENT_ARRAY,
 719                  NULL, WSAGetLastError (), 0, (LPTSTR)&msg, 0, NULL);
 720
 721   message (TRUE, "%s: %s: %s\n", progname, function_name, msg);
 722
 723   LocalFree (msg);
 724 #else
 725   message (TRUE, "%s: %s: %s\n", progname, function_name, strerror (errno));
 726 #endif
 727 }
 728
 729
 730 /* Let's send the data to Emacs when either
 731    - the data ends in "\n", or
 732    - the buffer is full (but this shouldn't happen)
 733    Otherwise, we just accumulate it.  */
 734 void
 735 send_to_emacs (s, data)
 736      HSOCKET s;
 737      char *data;
 738 {
 739   while (data)
 740     {
 741       int dlen = strlen (data);
 742       if (dlen + sblen >= SEND_BUFFER_SIZE)
 743         {
 744           int part = SEND_BUFFER_SIZE - sblen;
 745           strncpy (&send_buffer[sblen], data, part);
 746           data += part;
 747           sblen = SEND_BUFFER_SIZE;
 748         }
 749       else if (dlen)
 750         {
 751           strcpy (&send_buffer[sblen], data);
 752           data = NULL;
 753           sblen += dlen;
 754         }
 755       else
 756         break;
 757
 758       if (sblen == SEND_BUFFER_SIZE
 759           || (sblen > 0 && send_buffer[sblen-1] == '\n'))
 760         {
 761           int sent = send (s, send_buffer, sblen, 0);
 762           if (sent != sblen)
 763             strcpy (send_buffer, &send_buffer[sent]);
 764           sblen -= sent;
 765         }
 766     }
 767 }
 768
 769 \f
 770 /* In STR, insert a & before each &, each space, each newline, and
 771    any initial -.  Change spaces to underscores, too, so that the
 772    return value never contains a space.
 773
 774    Does not change the string.  Outputs the result to STREAM.  */
 775 void
 776 quote_argument (s, str)
 777      HSOCKET s;
 778      char *str;
 779 {
 780   char *copy = (char *) xmalloc (strlen (str) * 2 + 1);
 781   char *p, *q;
 782
 783   p = str;
 784   q = copy;
 785   while (*p)
 786     {
 787       if (*p == ' ')
 788         {
 789           *q++ = '&';
 790           *q++ = '_';
 791           p++;
 792         }
 793       else if (*p == '\n')
 794         {
 795           *q++ = '&';
 796           *q++ = 'n';
 797           p++;
 798         }
 799       else
 800         {
 801           if (*p == '&' || (*p == '-' && p == str))
 802             *q++ = '&';
 803           *q++ = *p++;
 804         }
 805     }
 806   *q++ = 0;
 807
 808   send_to_emacs (s, copy);
 809
 810   free (copy);
 811 }
 812
 813
 814 /* The inverse of quote_argument.  Removes quoting in string STR by
 815    modifying the string in place.   Returns STR. */
 816
 817 char *
 818 unquote_argument (str)
 819      char *str;
 820 {
 821   char *p, *q;
 822
 823   if (! str)
 824     return str;
 825
 826   p = str;
 827   q = str;
 828   while (*p)
 829     {
 830       if (*p == '&')
 831         {
 832           p++;
 833           if (*p == '&')
 834             *p = '&';
 835           else if (*p == '_')
 836             *p = ' ';
 837           else if (*p == 'n')
 838             *p = '\n';
 839           else if (*p == '-')
 840             *p = '-';
 841         }
 842       *q++ = *p++;
 843     }
 844   *q = 0;
 845   return str;
 846 }
 847
 848 \f
 849 int
 850 file_name_absolute_p (filename)
 851      const unsigned char *filename;
 852 {
 853   /* Sanity check, it shouldn't happen.  */
 854   if (! filename) return FALSE;
 855
 856   /* /xxx is always an absolute path.  */
 857   if (filename[0] == '/') return TRUE;
 858
 859   /* Empty filenames (which shouldn't happen) are relative.  */
 860   if (filename[0] == '\0') return FALSE;
 861
 862 #ifdef WINDOWSNT
 863   /* X:\xxx is always absolute.  */
 864   if (isalpha (filename[0])
 865       && filename[1] == ':' && (filename[2] == '\\' || filename[2] == '/'))
 866     return TRUE;
 867
 868   /* Both \xxx and \\xxx\yyy are absolute.  */
 869   if (filename[0] == '\\') return TRUE;
 870 #endif
 871
 872   return FALSE;
 873 }
 874
 875 #ifdef WINDOWSNT
 876 /* Wrapper to make WSACleanup a cdecl, as required by atexit.  */
 877 void
 878 __cdecl close_winsock ()
 879 {
 880   WSACleanup ();
 881 }
 882
 883 /* Initialize the WinSock2 library.  */
 884 void
 885 initialize_sockets ()
 886 {
 887   WSADATA wsaData;
 888
 889   if (WSAStartup (MAKEWORD (2, 0), &wsaData))
 890     {
 891       message (TRUE, "%s: error initializing WinSock2\n", progname);
 892       exit (EXIT_FAILURE);
 893     }
 894
 895   atexit (close_winsock);
 896 }
 897 #endif /* WINDOWSNT */
 898
 899 \f
 900 /*
 901  * Read the information needed to set up a TCP comm channel with
 902  * the Emacs server: host, port, pid and authentication string.
 903  */
 904 int
 905 get_server_config (server, authentication)
 906      struct sockaddr_in *server;
 907      char *authentication;
 908 {
 909   char dotted[32];
 910   char *port;
 911   char *pid;
 912   FILE *config = NULL;
 913
 914   if (file_name_absolute_p (server_file))
 915     config = fopen (server_file, "rb");
 916   else
 917     {
 918       char *home = egetenv ("HOME");
 919
 920       if (home)
 921         {
 922           char *path = alloca (strlen (home) + strlen (server_file)
 923                                + EXTRA_SPACE);
 924           sprintf (path, "%s/.emacs.d/server/%s", home, server_file);
 925           config = fopen (path, "rb");
 926         }
 927 #ifdef WINDOWSNT
 928       if (!config && (home = egetenv ("APPDATA")))
 929         {
 930           char *path = alloca (strlen (home) + strlen (server_file)
 931                                + EXTRA_SPACE);
 932           sprintf (path, "%s/.emacs.d/server/%s", home, server_file);
 933           config = fopen (path, "rb");
 934         }
 935 #endif
 936     }
 937
 938   if (! config)
 939     return FALSE;
 940
 941   if (fgets (dotted, sizeof dotted, config)
 942       && (port = strchr (dotted, ':'))
 943       && (pid = strchr (port, ' ')))
 944     {
 945       *port++ = '\0';
 946       *pid++  = '\0';
 947     }
 948   else
 949     {
 950       message (TRUE, "%s: invalid configuration info\n", progname);
 951       exit (EXIT_FAILURE);
 952     }
 953
 954   server->sin_family = AF_INET;
 955   server->sin_addr.s_addr = inet_addr (dotted);
 956   server->sin_port = htons (atoi (port));
 957
 958   if (! fread (authentication, AUTH_KEY_LENGTH, 1, config))
 959     {
 960       message (TRUE, "%s: cannot read authentication info\n", progname);
 961       exit (EXIT_FAILURE);
 962     }
 963
 964   fclose (config);
 965
 966   emacs_pid = atoi (pid);
 967
 968   return TRUE;
 969 }
 970
 971 HSOCKET
 972 set_tcp_socket ()
 973 {
 974   HSOCKET s;
 975   struct sockaddr_in server;
 976   struct linger l_arg = {1, 1};
 977   char auth_string[AUTH_KEY_LENGTH + 1];
 978
 979   if (! get_server_config (&server, auth_string))
 980     return INVALID_SOCKET;
 981
 982   if (server.sin_addr.s_addr != inet_addr ("127.0.0.1"))
 983     message (FALSE, "%s: connected to remote socket at %s\n",
 984              progname, inet_ntoa (server.sin_addr));
 985
 986   /*
 987    * Open up an AF_INET socket
 988    */
 989   if ((s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
 990     {
 991       sock_err_message ("socket");
 992       return INVALID_SOCKET;
 993     }
 994
 995   /*
 996    * Set up the socket
 997    */
 998   if (connect (s, (struct sockaddr *) &server, sizeof server) < 0)
 999     {
1000       sock_err_message ("connect");
1001       return INVALID_SOCKET;
1002     }
1003
1004   setsockopt (s, SOL_SOCKET, SO_LINGER, (char *) &l_arg, sizeof l_arg);
1005
1006   /*
1007    * Send the authentication
1008    */
1009   auth_string[AUTH_KEY_LENGTH] = '\0';
1010
1011   send_to_emacs (s, "-auth ");
1012   send_to_emacs (s, auth_string);
1013   send_to_emacs (s, " ");
1014
1015   return s;
1016 }
1017
1018
1019 /* Returns 1 if PREFIX is a prefix of STRING. */
1020 static int
1021 strprefix (char *prefix, char *string)
1022 {
1023   return !strncmp (prefix, string, strlen (prefix));
1024 }
1025
1026 /* Get tty name and type.  If successful, return the type in TTY_TYPE
1027    and the name in TTY_NAME, and return 1.  Otherwise, fail if NOABORT
1028    is zero, or return 0 if NOABORT is non-zero.  */
1029
1030 int
1031 find_tty (char **tty_type, char **tty_name, int noabort)
1032 {
1033   char *type = egetenv ("TERM");
1034   char *name = ttyname (fileno (stdout));
1035
1036   if (!name)
1037     {
1038       if (noabort)
1039         return 0;
1040       else
1041         {
1042           message (TRUE, "%s: could not get terminal name\n", progname);
1043           fail ();
1044         }
1045     }
1046
1047   if (!type)
1048     {
1049       if (noabort)
1050         return 0;
1051       else
1052         {
1053           message (TRUE, "%s: please set the TERM variable to your terminal type\n",
1054                    progname);
1055           fail ();
1056         }
1057     }
1058
1059   if (strcmp (type, "eterm") == 0)
1060     {
1061       if (noabort)
1062         return 0;
1063       else
1064         {
1065           /* This causes nasty, MULTI_KBOARD-related input lockouts. */
1066           message (TRUE, "%s: opening a frame in an Emacs term buffer"
1067                    " is not supported\n", progname);
1068           fail ();
1069         }
1070     }
1071
1072   *tty_name = name;
1073   *tty_type = type;
1074   return 1;
1075 }
1076
1077
1078 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1079
1080 /* Three possibilities:
1081    2 - can't be `stat'ed                (sets errno)
1082    1 - isn't owned by us
1083    0 - success: none of the above */
1084
1085 static int
1086 socket_status (socket_name)
1087      char *socket_name;
1088 {
1089   struct stat statbfr;
1090
1091   if (stat (socket_name, &statbfr) == -1)
1092     return 2;
1093
1094   if (statbfr.st_uid != geteuid ())
1095     return 1;
1096
1097   return 0;
1098 }
1099
1100 \f
1101 /* A signal handler that passes the signal to the Emacs process.
1102    Useful for SIGWINCH.  */
1103
1104 SIGTYPE
1105 pass_signal_to_emacs (int signalnum)
1106 {
1107   int old_errno = errno;
1108
1109   if (emacs_pid)
1110     kill (emacs_pid, signalnum);
1111
1112   signal (signalnum, pass_signal_to_emacs);
1113   errno = old_errno;
1114 }
1115
1116 /* Signal handler for SIGCONT; notify the Emacs process that it can
1117    now resume our tty frame.  */
1118
1119 SIGTYPE
1120 handle_sigcont (int signalnum)
1121 {
1122   int old_errno = errno;
1123
1124   if (tcgetpgrp (1) == getpgrp ())
1125     {
1126       /* We are in the foreground. */
1127       send_to_emacs (emacs_socket, "-resume \n");
1128     }
1129   else
1130     {
1131       /* We are in the background; cancel the continue. */
1132       kill (getpid (), SIGSTOP);
1133     }
1134
1135   signal (signalnum, handle_sigcont);
1136   errno = old_errno;
1137 }
1138
1139 /* Signal handler for SIGTSTP; notify the Emacs process that we are
1140    going to sleep.  Normally the suspend is initiated by Emacs via
1141    server-handle-suspend-tty, but if the server gets out of sync with
1142    reality, we may get a SIGTSTP on C-z.  Handling this signal and
1143    notifying Emacs about it should get things under control again. */
1144
1145 SIGTYPE
1146 handle_sigtstp (int signalnum)
1147 {
1148   int old_errno = errno;
1149   sigset_t set;
1150
1151   if (emacs_socket)
1152     send_to_emacs (emacs_socket, "-suspend \n");
1153
1154   /* Unblock this signal and call the default handler by temporarily
1155      changing the handler and resignalling. */
1156   sigprocmask (SIG_BLOCK, NULL, &set);
1157   sigdelset (&set, signalnum);
1158   signal (signalnum, SIG_DFL);
1159   kill (getpid (), signalnum);
1160   sigprocmask (SIG_SETMASK, &set, NULL); /* Let's the above signal through. */
1161   signal (signalnum, handle_sigtstp);
1162
1163   errno = old_errno;
1164 }
1165
1166
1167 /* Set up signal handlers before opening a frame on the current tty.  */
1168
1169 void
1170 init_signals (void)
1171 {
1172   /* Set up signal handlers. */
1173   signal (SIGWINCH, pass_signal_to_emacs);
1174
1175   /* Don't pass SIGINT and SIGQUIT to Emacs, because it has no way of
1176      deciding which terminal the signal came from.  C-g is now a
1177      normal input event on secondary terminals.  */
1178 #if 0
1179   signal (SIGINT, pass_signal_to_emacs);
1180   signal (SIGQUIT, pass_signal_to_emacs);
1181 #endif
1182
1183   signal (SIGCONT, handle_sigcont);
1184   signal (SIGTSTP, handle_sigtstp);
1185   signal (SIGTTOU, handle_sigtstp);
1186 }
1187
1188
1189 HSOCKET
1190 set_local_socket ()
1191 {
1192   HSOCKET s;
1193   struct sockaddr_un server;
1194
1195   /*
1196    * Open up an AF_UNIX socket in this person's home directory
1197    */
1198
1199   if ((s = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
1200     {
1201       message (TRUE, "%s: socket: %s\n", progname, strerror (errno));
1202       return INVALID_SOCKET;
1203     }
1204
1205   server.sun_family = AF_UNIX;
1206
1207   {
1208     int sock_status = 0;
1209     int default_sock = !socket_name;
1210     int saved_errno = 0;
1211     char *server_name = "server";
1212     char *tmpdir;
1213
1214     if (socket_name && !index (socket_name, '/') && !index (socket_name, '\\'))
1215       { /* socket_name is a file name component.  */
1216         server_name = socket_name;
1217         socket_name = NULL;
1218         default_sock = 1;       /* Try both UIDs.  */
1219       }
1220
1221     if (default_sock)
1222       {
1223         tmpdir = egetenv ("TMPDIR");
1224         if (!tmpdir)
1225           tmpdir = "/tmp";
1226         socket_name = alloca (strlen (tmpdir) + strlen (server_name)
1227                               + EXTRA_SPACE);
1228         sprintf (socket_name, "%s/emacs%d/%s",
1229                  tmpdir, (int) geteuid (), server_name);
1230       }
1231
1232     if (strlen (socket_name) < sizeof (server.sun_path))
1233       strcpy (server.sun_path, socket_name);
1234     else
1235       {
1236         message (TRUE, "%s: socket-name %s too long\n",
1237                  progname, socket_name);
1238         fail ();
1239       }
1240
1241     /* See if the socket exists, and if it's owned by us. */
1242     sock_status = socket_status (server.sun_path);
1243     saved_errno = errno;
1244     if (sock_status && default_sock)
1245       {
1246         /* Failing that, see if LOGNAME or USER exist and differ from
1247            our euid.  If so, look for a socket based on the UID
1248            associated with the name.  This is reminiscent of the logic
1249            that init_editfns uses to set the global Vuser_full_name.  */
1250
1251         char *user_name = (char *) egetenv ("LOGNAME");
1252
1253         if (!user_name)
1254           user_name = (char *) egetenv ("USER");
1255
1256         if (user_name)
1257           {
1258             struct passwd *pw = getpwnam (user_name);
1259
1260             if (pw && (pw->pw_uid != geteuid ()))
1261               {
1262                 /* We're running under su, apparently. */
1263                 socket_name = alloca (strlen (tmpdir) + strlen (server_name)
1264                                       + EXTRA_SPACE);
1265                 sprintf (socket_name, "%s/emacs%d/%s",
1266                          tmpdir, (int) pw->pw_uid, server_name);
1267
1268                 if (strlen (socket_name) < sizeof (server.sun_path))
1269                   strcpy (server.sun_path, socket_name);
1270                 else
1271                   {
1272                     message (TRUE, "%s: socket-name %s too long\n",
1273                              progname, socket_name);
1274                     exit (EXIT_FAILURE);
1275                   }
1276
1277                 sock_status = socket_status (server.sun_path);
1278                 saved_errno = errno;
1279               }
1280             else
1281               errno = saved_errno;
1282           }
1283       }
1284
1285     switch (sock_status)
1286       {
1287       case 1:
1288         /* There's a socket, but it isn't owned by us.  This is OK if
1289            we are root. */
1290         if (0 != geteuid ())
1291           {
1292             message (TRUE, "%s: Invalid socket owner\n", progname);
1293             return INVALID_SOCKET;
1294           }
1295         break;
1296
1297       case 2:
1298         /* `stat' failed */
1299         if (saved_errno == ENOENT)
1300           message (TRUE,
1301                    "%s: can't find socket; have you started the server?\n\
1302 To start the server in Emacs, type \"M-x server-start\".\n",
1303                    progname);
1304         else
1305           message (TRUE, "%s: can't stat %s: %s\n",
1306                    progname, server.sun_path, strerror (saved_errno));
1307         return INVALID_SOCKET;
1308       }
1309   }
1310
1311   if (connect (s, (struct sockaddr *) &server, strlen (server.sun_path) + 2)
1312       < 0)
1313     {
1314       message (TRUE, "%s: connect: %s\n", progname, strerror (errno));
1315       return INVALID_SOCKET;
1316     }
1317
1318   return s;
1319 }
1320 #endif /* ! NO_SOCKETS_IN_FILE_SYSTEM */
1321
1322 HSOCKET
1323 set_socket (int no_exit_if_error)
1324 {
1325   HSOCKET s;
1326
1327   INITIALIZE ();
1328
1329 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1330   /* Explicit --socket-name argument.  */
1331   if (socket_name)
1332     {
1333       s = set_local_socket ();
1334       if ((s != INVALID_SOCKET) || no_exit_if_error)
1335         return s;
1336       message (TRUE, "%s: error accessing socket \"%s\"\n",
1337                progname, socket_name);
1338       exit (EXIT_FAILURE);
1339     }
1340 #endif
1341
1342   /* Explicit --server-file arg or EMACS_SERVER_FILE variable.  */
1343   if (!server_file)
1344     server_file = egetenv ("EMACS_SERVER_FILE");
1345
1346   if (server_file)
1347     {
1348       s = set_tcp_socket ();
1349       if ((s != INVALID_SOCKET) || no_exit_if_error)
1350         return s;
1351
1352       message (TRUE, "%s: error accessing server file \"%s\"\n",
1353                progname, server_file);
1354       exit (EXIT_FAILURE);
1355     }
1356
1357 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1358   /* Implicit local socket.  */
1359   s = set_local_socket ();
1360   if (s != INVALID_SOCKET)
1361     return s;
1362 #endif
1363
1364   /* Implicit server file.  */
1365   server_file = "server";
1366   s = set_tcp_socket ();
1367   if ((s != INVALID_SOCKET) || no_exit_if_error)
1368     return s;
1369
1370   /* No implicit or explicit socket, and no alternate editor.  */
1371   message (TRUE, "%s: No socket or alternate editor.  Please use:\n\n"
1372 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1373 "\t--socket-name\n"
1374 #endif
1375 "\t--server-file      (or environment variable EMACS_SERVER_FILE)\n\
1376 \t--alternate-editor (or environment variable ALTERNATE_EDITOR)\n",
1377            progname);
1378   exit (EXIT_FAILURE);
1379 }
1380
1381 #ifdef WINDOWSNT
1382 FARPROC set_fg;  /* Pointer to AllowSetForegroundWindow.  */
1383 FARPROC get_wc;  /* Pointer to RealGetWindowClassA.  */
1384
1385 BOOL CALLBACK
1386 w32_find_emacs_process (hWnd, lParam)
1387      HWND hWnd;
1388      LPARAM lParam;
1389 {
1390   DWORD pid;
1391   char class[6];
1392
1393   /* Reject any window not of class "Emacs".  */
1394   if (! get_wc (hWnd, class, sizeof (class))
1395       || strcmp (class, "Emacs"))
1396     return TRUE;
1397
1398   /* We only need the process id, not the thread id.  */
1399   (void) GetWindowThreadProcessId (hWnd, &pid);
1400
1401   /* Not the one we're looking for.  */
1402   if (pid != (DWORD) emacs_pid) return TRUE;
1403
1404   /* OK, let's raise it.  */
1405   set_fg (emacs_pid);
1406
1407   /* Stop enumeration.  */
1408   return FALSE;
1409 }
1410
1411 /*
1412  * Search for a window of class "Emacs" and owned by a process with
1413  * process id = emacs_pid.  If found, allow it to grab the focus.
1414  */
1415 void
1416 w32_give_focus ()
1417 {
1418   HMODULE hUser32;
1419
1420   /* It shouldn't happen when dealing with TCP sockets.  */
1421   if (!emacs_pid) return;
1422
1423   if (!(hUser32 = LoadLibrary ("user32.dll"))) return;
1424
1425   /* Modern Windows restrict which processes can set the foreground window.
1426      emacsclient can allow Emacs to grab the focus by calling the function
1427      AllowSetForegroundWindow.  Unfortunately, older Windows (W95, W98 and
1428      NT) lack this function, so we have to check its availability.  */
1429   if ((set_fg = GetProcAddress (hUser32, "AllowSetForegroundWindow"))
1430       && (get_wc = GetProcAddress (hUser32, "RealGetWindowClassA")))
1431     EnumWindows (w32_find_emacs_process, (LPARAM) 0);
1432
1433   FreeLibrary (hUser32);
1434 }
1435 #endif
1436
1437 /* Start the emacs daemon and try to connect to it.  */
1438
1439 void
1440 start_daemon_and_retry_set_socket (void)
1441 {
1442 #ifndef WINDOWSNT
1443   pid_t dpid;
1444   int status;
1445
1446   dpid = fork ();
1447
1448   if (dpid > 0)
1449     {
1450       pid_t w;
1451       w = waitpid (dpid, &status, WUNTRACED | WCONTINUED);
1452
1453       if ((w == -1) || !WIFEXITED (status) || WEXITSTATUS(status))
1454         {
1455           message (TRUE, "Error: Could not start the Emacs daemon\n");
1456           exit (EXIT_FAILURE);
1457         }
1458
1459       /* Try connecting, the daemon should have started by now.  */
1460       message (TRUE, "Emacs daemon should have started, trying to connect again\n");
1461       if ((emacs_socket = set_socket (1)) == INVALID_SOCKET)
1462         {
1463           message (TRUE, "Error: Cannot connect even after starting the Emacs daemon\n");
1464           exit (EXIT_FAILURE);
1465         }
1466     }
1467   else if (dpid < 0)
1468     {
1469       fprintf (stderr, "Error: Cannot fork!\n");
1470       exit (1);
1471     }
1472   else
1473     {
1474       char *d_argv[] = {"emacs", "--daemon", 0 };
1475       if (socket_name != NULL)
1476         {
1477           /* Pass  --daemon=socket_name as argument.  */
1478           char *deq = "--daemon=";
1479           char *daemon_arg = alloca (strlen (deq)
1480                                      + strlen (socket_name) + 1);
1481           strcpy (daemon_arg, deq);
1482           strcat (daemon_arg, socket_name);
1483           d_argv[1] = daemon_arg;
1484         }
1485       execvp ("emacs", d_argv);
1486       message (TRUE, "%s: error starting emacs daemon\n", progname);
1487     }
1488 #endif /* WINDOWSNT */
1489 }
1490
1491 int
1492 main (argc, argv)
1493      int argc;
1494      char **argv;
1495 {
1496   int i, rl, needlf = 0;
1497   char *cwd, *str;
1498   char string[BUFSIZ+1];
1499   int null_socket_name, null_server_file, start_daemon_if_needed;
1500
1501   main_argv = argv;
1502   progname = argv[0];
1503
1504   /* Process options.  */
1505   decode_options (argc, argv);
1506
1507   if ((argc - optind < 1) && !eval && current_frame)
1508     {
1509       message (TRUE, "%s: file name or argument required\n"
1510                "Try `%s --help' for more information\n",
1511                progname, progname);
1512       exit (EXIT_FAILURE);
1513     }
1514
1515   /* If alternate_editor is the empty string, start the emacs daemon
1516      in case of failure to connect.  */
1517   start_daemon_if_needed = (alternate_editor
1518                             && (alternate_editor[0] == '\0'));
1519   if (start_daemon_if_needed)
1520     {
1521       /* set_socket changes the values for socket_name and
1522          server_file, we need to reset them, if they were NULL before
1523          for the second call to set_socket.  */
1524       null_socket_name = (socket_name == NULL);
1525       null_server_file = (server_file == NULL);
1526     }
1527
1528   if ((emacs_socket = set_socket (alternate_editor
1529                                   || start_daemon_if_needed)) == INVALID_SOCKET)
1530     if (start_daemon_if_needed)
1531       {
1532         /* Reset socket_name and server_file if they were NULL
1533            before the set_socket call.  */
1534         if (null_socket_name)
1535           socket_name = NULL;
1536         if (null_server_file)
1537           server_file = NULL;
1538
1539         start_daemon_and_retry_set_socket ();
1540       }
1541     else
1542       fail ();
1543
1544   cwd = get_current_dir_name ();
1545   if (cwd == 0)
1546     {
1547       /* getwd puts message in STRING if it fails.  */
1548       message (TRUE, "%s: %s\n", progname,
1549                "Cannot get current working directory");
1550       fail ();
1551     }
1552
1553 #ifdef WINDOWSNT
1554   w32_give_focus ();
1555 #endif
1556
1557   /* Send over our environment and current directory. */
1558   if (!current_frame)
1559     {
1560       extern char **environ;
1561       int i;
1562       for (i = 0; environ[i]; i++)
1563         {
1564           char *name = xstrdup (environ[i]);
1565           char *value = strchr (name, '=');
1566           send_to_emacs (emacs_socket, "-env ");
1567           quote_argument (emacs_socket, environ[i]);
1568           send_to_emacs (emacs_socket, " ");
1569         }
1570     }
1571   send_to_emacs (emacs_socket, "-dir ");
1572   quote_argument (emacs_socket, cwd);
1573   send_to_emacs (emacs_socket, "/");
1574   send_to_emacs (emacs_socket, " ");
1575
1576  retry:
1577   if (nowait)
1578     send_to_emacs (emacs_socket, "-nowait ");
1579
1580   if (current_frame)
1581     send_to_emacs (emacs_socket, "-current-frame ");
1582
1583   if (display)
1584     {
1585       send_to_emacs (emacs_socket, "-display ");
1586       quote_argument (emacs_socket, display);
1587       send_to_emacs (emacs_socket, " ");
1588     }
1589
1590   /* If using the current frame, send tty information to Emacs anyway.
1591      In daemon mode, Emacs may need to occupy this tty if no other
1592      frame is available.  */
1593   if (tty || (current_frame && !eval))
1594     {
1595       char *tty_type, *tty_name;
1596
1597       if (find_tty (&tty_type, &tty_name, !tty))
1598         {
1599 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1600           init_signals ();
1601 #endif
1602           send_to_emacs (emacs_socket, "-tty ");
1603           quote_argument (emacs_socket, tty_name);
1604           send_to_emacs (emacs_socket, " ");
1605           quote_argument (emacs_socket, tty_type);
1606           send_to_emacs (emacs_socket, " ");
1607         }
1608     }
1609
1610   if (!current_frame && !tty)
1611     send_to_emacs (emacs_socket, "-window-system ");
1612
1613   if ((argc - optind > 0))
1614     {
1615       for (i = optind; i < argc; i++)
1616         {
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             }
1639 #ifdef WINDOWSNT
1640           else if (! file_name_absolute_p (argv[i])
1641                    && (isalpha (argv[i][0]) && argv[i][1] == ':'))
1642             /* Windows can have a different default directory for each
1643                drive, so the cwd passed via "-dir" is not sufficient
1644                to account for that.
1645                If the user uses <drive>:<relpath>, we hence need to be
1646                careful to expand <relpath> with the default directory
1647                corresponding to <drive>.  */
1648             {
1649               char *filename = (char *) xmalloc (MAX_PATH);
1650               DWORD size;
1651
1652               size = GetFullPathName (argv[i], MAX_PATH, filename, NULL);
1653               if (size > 0 && size < MAX_PATH)
1654                 argv[i] = filename;
1655               else
1656                 free (filename);
1657             }
1658 #endif
1659
1660           send_to_emacs (emacs_socket, "-file ");
1661           quote_argument (emacs_socket, argv[i]);
1662           send_to_emacs (emacs_socket, " ");
1663         }
1664     }
1665   else if (eval)
1666     {
1667       /* Read expressions interactively.  */
1668       while ((str = fgets (string, BUFSIZ, stdin)))
1669         {
1670           send_to_emacs (emacs_socket, "-eval ");
1671           quote_argument (emacs_socket, str);
1672         }
1673       send_to_emacs (emacs_socket, " ");
1674     }
1675
1676   send_to_emacs (emacs_socket, "\n");
1677
1678   /* Wait for an answer. */
1679   if (!eval && !tty && !nowait)
1680     {
1681       printf ("Waiting for Emacs...");
1682       needlf = 2;
1683     }
1684   fflush (stdout);
1685   fsync (1);
1686
1687   /* Now, wait for an answer and print any messages.  */
1688   while ((rl = recv (emacs_socket, string, BUFSIZ, 0)) > 0)
1689     {
1690       char *p;
1691       string[rl] = '\0';
1692
1693       p = string + strlen (string) - 1;
1694       while (p > string && *p == '\n')
1695         *p-- = 0;
1696
1697       if (strprefix ("-emacs-pid ", string))
1698         {
1699           /* -emacs-pid PID: The process id of the Emacs process. */
1700           emacs_pid = strtol (string + strlen ("-emacs-pid"), NULL, 10);
1701         }
1702       else if (strprefix ("-window-system-unsupported ", string))
1703         {
1704           /* -window-system-unsupported: Emacs was compiled without X
1705               support.  Try again on the terminal. */
1706           nowait = 0;
1707           tty = 1;
1708           goto retry;
1709         }
1710       else if (strprefix ("-print ", string))
1711         {
1712           /* -print STRING: Print STRING on the terminal. */
1713           str = unquote_argument (string + strlen ("-print "));
1714           if (needlf)
1715             printf ("\n");
1716           printf ("%s", str);
1717           needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1718         }
1719       else if (strprefix ("-error ", string))
1720         {
1721           /* -error DESCRIPTION: Signal an error on the terminal. */
1722           str = unquote_argument (string + strlen ("-error "));
1723           if (needlf)
1724             printf ("\n");
1725           fprintf (stderr, "*ERROR*: %s", str);
1726           needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1727         }
1728 #ifdef SIGSTOP
1729       else if (strprefix ("-suspend ", string))
1730         {
1731           /* -suspend: Suspend this terminal, i.e., stop the process. */
1732           if (needlf)
1733             printf ("\n");
1734           needlf = 0;
1735           kill (0, SIGSTOP);
1736         }
1737 #endif
1738       else
1739         {
1740           /* Unknown command. */
1741           if (needlf)
1742             printf ("\n");
1743           printf ("*ERROR*: Unknown message: %s", string);
1744           needlf = string[0] == '\0' ? needlf : string[strlen (string) - 1] != '\n';
1745         }
1746     }
1747
1748   if (needlf)
1749     printf ("\n");
1750   fflush (stdout);
1751   fsync (1);
1752
1753   CLOSE_SOCKET (emacs_socket);
1754   return EXIT_SUCCESS;
1755 }
1756
1757 #endif /* HAVE_SOCKETS && HAVE_INET_SOCKETS */
1758
1759 \f
1760 #ifndef HAVE_STRERROR
1761 char *
1762 strerror (errnum)
1763      int errnum;
1764 {
1765   extern char *sys_errlist[];
1766   extern int sys_nerr;
1767
1768   if (errnum >= 0 && errnum < sys_nerr)
1769     return sys_errlist[errnum];
1770   return (char *) "Unknown error";
1771 }
1772
1773 #endif /* ! HAVE_STRERROR */
1774
1775 /* arch-tag: f39bb9c4-73eb-477e-896d-50832e2ca9a7
1776    (do not change this comment) */
1777
1778 /* emacsclient.c ends here */