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