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 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           {
1253 #ifdef DARWIN_OS
1254             size_t n = confstr (_CS_DARWIN_USER_TEMP_DIR, NULL, (size_t) 0);
1255             if (n > 0)
1256               {
1257                 tmpdir = alloca (n);
1258                 confstr (_CS_DARWIN_USER_TEMP_DIR, tmpdir, n);
1259               }
1260             else
1261 #endif
1262               tmpdir = "/tmp";
1263           }
1264         socket_name = alloca (strlen (tmpdir) + strlen (server_name)
1265                               + EXTRA_SPACE);
1266         sprintf (socket_name, "%s/emacs%d/%s",
1267                  tmpdir, (int) geteuid (), server_name);
1268       }
1269
1270     if (strlen (socket_name) < sizeof (server.sun_path))
1271       strcpy (server.sun_path, socket_name);
1272     else
1273       {
1274         message (TRUE, "%s: socket-name %s too long\n",
1275                  progname, socket_name);
1276         fail ();
1277       }
1278
1279     /* See if the socket exists, and if it's owned by us. */
1280     sock_status = socket_status (server.sun_path);
1281     saved_errno = errno;
1282     if (sock_status && default_sock)
1283       {
1284         /* Failing that, see if LOGNAME or USER exist and differ from
1285            our euid.  If so, look for a socket based on the UID
1286            associated with the name.  This is reminiscent of the logic
1287            that init_editfns uses to set the global Vuser_full_name.  */
1288
1289         char *user_name = (char *) egetenv ("LOGNAME");
1290
1291         if (!user_name)
1292           user_name = (char *) egetenv ("USER");
1293
1294         if (user_name)
1295           {
1296             struct passwd *pw = getpwnam (user_name);
1297
1298             if (pw && (pw->pw_uid != geteuid ()))
1299               {
1300                 /* We're running under su, apparently. */
1301                 socket_name = alloca (strlen (tmpdir) + strlen (server_name)
1302                                       + EXTRA_SPACE);
1303                 sprintf (socket_name, "%s/emacs%d/%s",
1304                          tmpdir, (int) pw->pw_uid, server_name);
1305
1306                 if (strlen (socket_name) < sizeof (server.sun_path))
1307                   strcpy (server.sun_path, socket_name);
1308                 else
1309                   {
1310                     message (TRUE, "%s: socket-name %s too long\n",
1311                              progname, socket_name);
1312                     exit (EXIT_FAILURE);
1313                   }
1314
1315                 sock_status = socket_status (server.sun_path);
1316                 saved_errno = errno;
1317               }
1318             else
1319               errno = saved_errno;
1320           }
1321       }
1322
1323     switch (sock_status)
1324       {
1325       case 1:
1326         /* There's a socket, but it isn't owned by us.  This is OK if
1327            we are root. */
1328         if (0 != geteuid ())
1329           {
1330             message (TRUE, "%s: Invalid socket owner\n", progname);
1331             return INVALID_SOCKET;
1332           }
1333         break;
1334
1335       case 2:
1336         /* `stat' failed */
1337         if (saved_errno == ENOENT)
1338           message (TRUE,
1339                    "%s: can't find socket; have you started the server?\n\
1340 To start the server in Emacs, type \"M-x server-start\".\n",
1341                    progname);
1342         else
1343           message (TRUE, "%s: can't stat %s: %s\n",
1344                    progname, server.sun_path, strerror (saved_errno));
1345         return INVALID_SOCKET;
1346       }
1347   }
1348
1349   if (connect (s, (struct sockaddr *) &server, strlen (server.sun_path) + 2)
1350       < 0)
1351     {
1352       message (TRUE, "%s: connect: %s\n", progname, strerror (errno));
1353       return INVALID_SOCKET;
1354     }
1355
1356   return s;
1357 }
1358 #endif /* ! NO_SOCKETS_IN_FILE_SYSTEM */
1359
1360 HSOCKET
1361 set_socket (int no_exit_if_error)
1362 {
1363   HSOCKET s;
1364
1365   INITIALIZE ();
1366
1367 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1368   /* Explicit --socket-name argument.  */
1369   if (socket_name)
1370     {
1371       s = set_local_socket ();
1372       if ((s != INVALID_SOCKET) || no_exit_if_error)
1373         return s;
1374       message (TRUE, "%s: error accessing socket \"%s\"\n",
1375                progname, socket_name);
1376       exit (EXIT_FAILURE);
1377     }
1378 #endif
1379
1380   /* Explicit --server-file arg or EMACS_SERVER_FILE variable.  */
1381   if (!server_file)
1382     server_file = egetenv ("EMACS_SERVER_FILE");
1383
1384   if (server_file)
1385     {
1386       s = set_tcp_socket ();
1387       if ((s != INVALID_SOCKET) || no_exit_if_error)
1388         return s;
1389
1390       message (TRUE, "%s: error accessing server file \"%s\"\n",
1391                progname, server_file);
1392       exit (EXIT_FAILURE);
1393     }
1394
1395 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1396   /* Implicit local socket.  */
1397   s = set_local_socket ();
1398   if (s != INVALID_SOCKET)
1399     return s;
1400 #endif
1401
1402   /* Implicit server file.  */
1403   server_file = "server";
1404   s = set_tcp_socket ();
1405   if ((s != INVALID_SOCKET) || no_exit_if_error)
1406     return s;
1407
1408   /* No implicit or explicit socket, and no alternate editor.  */
1409   message (TRUE, "%s: No socket or alternate editor.  Please use:\n\n"
1410 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1411 "\t--socket-name\n"
1412 #endif
1413 "\t--server-file      (or environment variable EMACS_SERVER_FILE)\n\
1414 \t--alternate-editor (or environment variable ALTERNATE_EDITOR)\n",
1415            progname);
1416   exit (EXIT_FAILURE);
1417 }
1418
1419 #ifdef WINDOWSNT
1420 FARPROC set_fg;  /* Pointer to AllowSetForegroundWindow.  */
1421 FARPROC get_wc;  /* Pointer to RealGetWindowClassA.  */
1422
1423 BOOL CALLBACK
1424 w32_find_emacs_process (hWnd, lParam)
1425      HWND hWnd;
1426      LPARAM lParam;
1427 {
1428   DWORD pid;
1429   char class[6];
1430
1431   /* Reject any window not of class "Emacs".  */
1432   if (! get_wc (hWnd, class, sizeof (class))
1433       || strcmp (class, "Emacs"))
1434     return TRUE;
1435
1436   /* We only need the process id, not the thread id.  */
1437   (void) GetWindowThreadProcessId (hWnd, &pid);
1438
1439   /* Not the one we're looking for.  */
1440   if (pid != (DWORD) emacs_pid) return TRUE;
1441
1442   /* OK, let's raise it.  */
1443   set_fg (emacs_pid);
1444
1445   /* Stop enumeration.  */
1446   return FALSE;
1447 }
1448
1449 /*
1450  * Search for a window of class "Emacs" and owned by a process with
1451  * process id = emacs_pid.  If found, allow it to grab the focus.
1452  */
1453 void
1454 w32_give_focus ()
1455 {
1456   HANDLE user32;
1457
1458   /* It shouldn't happen when dealing with TCP sockets.  */
1459   if (!emacs_pid) return;
1460
1461   user32 = GetModuleHandle ("user32.dll");
1462
1463   if (!user32)
1464     return;
1465
1466   /* Modern Windows restrict which processes can set the foreground window.
1467      emacsclient can allow Emacs to grab the focus by calling the function
1468      AllowSetForegroundWindow.  Unfortunately, older Windows (W95, W98 and
1469      NT) lack this function, so we have to check its availability.  */
1470   if ((set_fg = GetProcAddress (user32, "AllowSetForegroundWindow"))
1471       && (get_wc = GetProcAddress (user32, "RealGetWindowClassA")))
1472     EnumWindows (w32_find_emacs_process, (LPARAM) 0);
1473 }
1474 #endif
1475
1476 /* Start the emacs daemon and try to connect to it.  */
1477
1478 void
1479 start_daemon_and_retry_set_socket (void)
1480 {
1481 #ifndef WINDOWSNT
1482   pid_t dpid;
1483   int status;
1484
1485   dpid = fork ();
1486
1487   if (dpid > 0)
1488     {
1489       pid_t w;
1490       w = waitpid (dpid, &status, WUNTRACED | WCONTINUED);
1491
1492       if ((w == -1) || !WIFEXITED (status) || WEXITSTATUS(status))
1493         {
1494           message (TRUE, "Error: Could not start the Emacs daemon\n");
1495           exit (EXIT_FAILURE);
1496         }
1497
1498       /* Try connecting, the daemon should have started by now.  */
1499       message (TRUE, "Emacs daemon should have started, trying to connect again\n");
1500       if ((emacs_socket = set_socket (1)) == INVALID_SOCKET)
1501         {
1502           message (TRUE, "Error: Cannot connect even after starting the Emacs daemon\n");
1503           exit (EXIT_FAILURE);
1504         }
1505     }
1506   else if (dpid < 0)
1507     {
1508       fprintf (stderr, "Error: Cannot fork!\n");
1509       exit (1);
1510     }
1511   else
1512     {
1513       char *d_argv[] = {"emacs", "--daemon", 0 };
1514       if (socket_name != NULL)
1515         {
1516           /* Pass  --daemon=socket_name as argument.  */
1517           char *deq = "--daemon=";
1518           char *daemon_arg = alloca (strlen (deq)
1519                                      + strlen (socket_name) + 1);
1520           strcpy (daemon_arg, deq);
1521           strcat (daemon_arg, socket_name);
1522           d_argv[1] = daemon_arg;
1523         }
1524       execvp ("emacs", d_argv);
1525       message (TRUE, "%s: error starting emacs daemon\n", progname);
1526     }
1527 #endif /* WINDOWSNT */
1528 }
1529
1530 int
1531 main (argc, argv)
1532      int argc;
1533      char **argv;
1534 {
1535   int i, rl, needlf = 0;
1536   char *cwd, *str;
1537   char string[BUFSIZ+1];
1538   int null_socket_name, null_server_file, start_daemon_if_needed;
1539
1540   main_argv = argv;
1541   progname = argv[0];
1542
1543 #ifdef WINDOWSNT
1544   /* On Windows 7 and later, we need to explicitly associate emacsclient
1545      with emacs so the UI behaves sensibly.  */
1546   w32_set_user_model_id ();
1547 #endif
1548
1549   /* Process options.  */
1550   decode_options (argc, argv);
1551
1552   if ((argc - optind < 1) && !eval && current_frame)
1553     {
1554       message (TRUE, "%s: file name or argument required\n"
1555                "Try `%s --help' for more information\n",
1556                progname, progname);
1557       exit (EXIT_FAILURE);
1558     }
1559
1560   /* If alternate_editor is the empty string, start the emacs daemon
1561      in case of failure to connect.  */
1562   start_daemon_if_needed = (alternate_editor
1563                             && (alternate_editor[0] == '\0'));
1564   if (start_daemon_if_needed)
1565     {
1566       /* set_socket changes the values for socket_name and
1567          server_file, we need to reset them, if they were NULL before
1568          for the second call to set_socket.  */
1569       null_socket_name = (socket_name == NULL);
1570       null_server_file = (server_file == NULL);
1571     }
1572
1573   if ((emacs_socket = set_socket (alternate_editor
1574                                   || start_daemon_if_needed)) == INVALID_SOCKET)
1575     if (start_daemon_if_needed)
1576       {
1577         /* Reset socket_name and server_file if they were NULL
1578            before the set_socket call.  */
1579         if (null_socket_name)
1580           socket_name = NULL;
1581         if (null_server_file)
1582           server_file = NULL;
1583
1584         start_daemon_and_retry_set_socket ();
1585       }
1586     else
1587       fail ();
1588
1589   cwd = get_current_dir_name ();
1590   if (cwd == 0)
1591     {
1592       /* getwd puts message in STRING if it fails.  */
1593       message (TRUE, "%s: %s\n", progname,
1594                "Cannot get current working directory");
1595       fail ();
1596     }
1597
1598 #ifdef WINDOWSNT
1599   w32_give_focus ();
1600 #endif
1601
1602   /* Send over our environment and current directory. */
1603   if (!current_frame)
1604     {
1605       extern char **environ;
1606       int i;
1607       for (i = 0; environ[i]; i++)
1608         {
1609           char *name = xstrdup (environ[i]);
1610           char *value = strchr (name, '=');
1611           send_to_emacs (emacs_socket, "-env ");
1612           quote_argument (emacs_socket, environ[i]);
1613           send_to_emacs (emacs_socket, " ");
1614         }
1615     }
1616   send_to_emacs (emacs_socket, "-dir ");
1617   quote_argument (emacs_socket, cwd);
1618   send_to_emacs (emacs_socket, "/");
1619   send_to_emacs (emacs_socket, " ");
1620
1621  retry:
1622   if (nowait)
1623     send_to_emacs (emacs_socket, "-nowait ");
1624
1625   if (current_frame)
1626     send_to_emacs (emacs_socket, "-current-frame ");
1627
1628   if (display)
1629     {
1630       send_to_emacs (emacs_socket, "-display ");
1631       quote_argument (emacs_socket, display);
1632       send_to_emacs (emacs_socket, " ");
1633     }
1634
1635   /* If using the current frame, send tty information to Emacs anyway.
1636      In daemon mode, Emacs may need to occupy this tty if no other
1637      frame is available.  */
1638   if (tty || (current_frame && !eval))
1639     {
1640       char *tty_type, *tty_name;
1641
1642       if (find_tty (&tty_type, &tty_name, !tty))
1643         {
1644 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1645           init_signals ();
1646 #endif
1647           send_to_emacs (emacs_socket, "-tty ");
1648           quote_argument (emacs_socket, tty_name);
1649           send_to_emacs (emacs_socket, " ");
1650           quote_argument (emacs_socket, tty_type);
1651           send_to_emacs (emacs_socket, " ");
1652         }
1653     }
1654
1655   if (!current_frame && !tty)
1656     send_to_emacs (emacs_socket, "-window-system ");
1657
1658   if ((argc - optind > 0))
1659     {
1660       for (i = optind; i < argc; i++)
1661         {
1662
1663           if (eval)
1664             {
1665               /* Don't prepend cwd or anything like that.  */
1666               send_to_emacs (emacs_socket, "-eval ");
1667               quote_argument (emacs_socket, argv[i]);
1668               send_to_emacs (emacs_socket, " ");
1669               continue;
1670             }
1671
1672           if (*argv[i] == '+')
1673             {
1674               char *p = argv[i] + 1;
1675               while (isdigit ((unsigned char) *p) || *p == ':') p++;
1676               if (*p == 0)
1677                 {
1678                   send_to_emacs (emacs_socket, "-position ");
1679                   quote_argument (emacs_socket, argv[i]);
1680                   send_to_emacs (emacs_socket, " ");
1681                   continue;
1682                 }
1683             }
1684 #ifdef WINDOWSNT
1685           else if (! file_name_absolute_p (argv[i])
1686                    && (isalpha (argv[i][0]) && argv[i][1] == ':'))
1687             /* Windows can have a different default directory for each
1688                drive, so the cwd passed via "-dir" is not sufficient
1689                to account for that.
1690                If the user uses <drive>:<relpath>, we hence need to be
1691                careful to expand <relpath> with the default directory
1692                corresponding to <drive>.  */
1693             {
1694               char *filename = (char *) xmalloc (MAX_PATH);
1695               DWORD size;
1696
1697               size = GetFullPathName (argv[i], MAX_PATH, filename, NULL);
1698               if (size > 0 && size < MAX_PATH)
1699                 argv[i] = filename;
1700               else
1701                 free (filename);
1702             }
1703 #endif
1704
1705           send_to_emacs (emacs_socket, "-file ");
1706           quote_argument (emacs_socket, argv[i]);
1707           send_to_emacs (emacs_socket, " ");
1708         }
1709     }
1710   else if (eval)
1711     {
1712       /* Read expressions interactively.  */
1713       while ((str = fgets (string, BUFSIZ, stdin)))
1714         {
1715           send_to_emacs (emacs_socket, "-eval ");
1716           quote_argument (emacs_socket, str);
1717         }
1718       send_to_emacs (emacs_socket, " ");
1719     }
1720
1721   send_to_emacs (emacs_socket, "\n");
1722
1723   /* Wait for an answer. */
1724   if (!eval && !tty && !nowait)
1725     {
1726       printf ("Waiting for Emacs...");
1727       needlf = 2;
1728     }
1729   fflush (stdout);
1730   fsync (1);
1731
1732   /* Now, wait for an answer and print any messages.  */
1733   while ((rl = recv (emacs_socket, string, BUFSIZ, 0)) > 0)
1734     {
1735       char *p;
1736       string[rl] = '\0';
1737
1738       p = string + strlen (string) - 1;
1739       while (p > string && *p == '\n')
1740         *p-- = 0;
1741
1742       if (strprefix ("-emacs-pid ", string))
1743         {
1744           /* -emacs-pid PID: The process id of the Emacs process. */
1745           emacs_pid = strtol (string + strlen ("-emacs-pid"), NULL, 10);
1746         }
1747       else if (strprefix ("-window-system-unsupported ", string))
1748         {
1749           /* -window-system-unsupported: Emacs was compiled without X
1750               support.  Try again on the terminal. */
1751           nowait = 0;
1752           tty = 1;
1753           goto retry;
1754         }
1755       else if (strprefix ("-print ", string))
1756         {
1757           /* -print STRING: Print STRING on the terminal. */
1758           str = unquote_argument (string + strlen ("-print "));
1759           if (needlf)
1760             printf ("\n");
1761           printf ("%s", str);
1762           needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1763         }
1764       else if (strprefix ("-error ", string))
1765         {
1766           /* -error DESCRIPTION: Signal an error on the terminal. */
1767           str = unquote_argument (string + strlen ("-error "));
1768           if (needlf)
1769             printf ("\n");
1770           fprintf (stderr, "*ERROR*: %s", str);
1771           needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1772         }
1773 #ifdef SIGSTOP
1774       else if (strprefix ("-suspend ", string))
1775         {
1776           /* -suspend: Suspend this terminal, i.e., stop the process. */
1777           if (needlf)
1778             printf ("\n");
1779           needlf = 0;
1780           kill (0, SIGSTOP);
1781         }
1782 #endif
1783       else
1784         {
1785           /* Unknown command. */
1786           if (needlf)
1787             printf ("\n");
1788           printf ("*ERROR*: Unknown message: %s", string);
1789           needlf = string[0] == '\0' ? needlf : string[strlen (string) - 1] != '\n';
1790         }
1791     }
1792
1793   if (needlf)
1794     printf ("\n");
1795   fflush (stdout);
1796   fsync (1);
1797
1798   CLOSE_SOCKET (emacs_socket);
1799   return EXIT_SUCCESS;
1800 }
1801
1802 #endif /* HAVE_SOCKETS && HAVE_INET_SOCKETS */
1803
1804 \f
1805 #ifndef HAVE_STRERROR
1806 char *
1807 strerror (errnum)
1808      int errnum;
1809 {
1810   extern char *sys_errlist[];
1811   extern int sys_nerr;
1812
1813   if (errnum >= 0 && errnum < sys_nerr)
1814     return sys_errlist[errnum];
1815   return (char *) "Unknown error";
1816 }
1817
1818 #endif /* ! HAVE_STRERROR */
1819
1820 /* arch-tag: f39bb9c4-73eb-477e-896d-50832e2ca9a7
1821    (do not change this comment) */
1822
1823 /* emacsclient.c ends here */