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