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