lib-src/emacsclient.c

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