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