/* Client process that communicates with GNU Emacs acting as server.

Copyright (C) 1986-2025 Free Software Foundation, Inc.

This file is part of GNU Emacs.

GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or (at
your option) any later version.

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */


#include <config.h>

#ifdef WINDOWSNT

/* ms-w32.h defines these, which disables sockets altogether!  */
# undef _WINSOCKAPI_
# undef _WINSOCK_H

# include <malloc.h>
# include <windows.h>
# include <commctrl.h>
# include <io.h>
# include <winsock2.h>

# define HSOCKET SOCKET
# define CLOSE_SOCKET closesocket
# define INITIALIZE() initialize_sockets ()

char *w32_getenv (const char *);
# define egetenv(VAR) w32_getenv (VAR)

# undef signal

#else /* !WINDOWSNT */

# ifdef HAVE_NTGUI
#  include <windows.h>
# endif

# include "syswait.h"

# include <arpa/inet.h>
# include <fcntl.h>
# include <netinet/in.h>
# include <sys/socket.h>
# include <sys/un.h>

# define SOCKETS_IN_FILE_SYSTEM

# define INVALID_SOCKET (-1)
# define HSOCKET int
# define CLOSE_SOCKET close
# define INITIALIZE()

# define egetenv(VAR) getenv (VAR)

#endif /* !WINDOWSNT */

#define DEFAULT_TIMEOUT (30)

#include <ctype.h>
#include <errno.h>
#include <getopt.h>
#include <inttypes.h>
#include <pwd.h>
#include <signal.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

#include <attribute.h>
#include <filename.h>
#include <intprops.h>
#include <min-max.h>
#include <pathmax.h>
#include <unlocked-io.h>

/* Work around GCC bug 88251.  */
#if GNUC_PREREQ (7, 0, 0)
# pragma GCC diagnostic ignored "-Wformat-truncation=2"
#endif


/* Name used to invoke this program.  */
static char const *progname;

/* The first argument to main.  */
static int main_argc;

/* The second argument to main.  */
static char *const *main_argv;

/* True means don't wait for a response from Emacs.  --no-wait.  */
static bool nowait;

/* True means don't print messages for successful operations.  --quiet.  */
static bool quiet;

/* True means don't print values returned from emacs. --suppress-output.  */
static bool suppress_output;

/* True means args are expressions to be evaluated.  --eval.  */
static bool eval;

/* True means open a new frame.  --create-frame etc.  */
static bool create_frame;

/* True means reuse a frame if it already exists.  */
static bool reuse_frame;

/* The display on which Emacs should work.  --display.  */
static char const *display;

/* The alternate display we should try if Emacs does not support display.  */
static char const *alt_display;

/* The parent window ID, if we are opening a frame via XEmbed.  */
static char *parent_id;

/* True means open a new Emacs frame on the current terminal.  */
static bool tty;

/* If non-NULL, the name of an editor to fallback to if the server
   is not running.  --alternate-editor.   */
static char *alternate_editor;

#ifdef SOCKETS_IN_FILE_SYSTEM
/* If non-NULL, the filename of the UNIX socket.  */
static char const *socket_name;
#endif

/* If non-NULL, the filename of the authentication file.  */
static char const *server_file;

/* Seconds to wait before timing out (0 means wait forever).  */
static uintmax_t timeout;

/* If non-NULL, the tramp prefix emacs must use to find the files.  */
static char const *tramp_prefix;

/* If nonzero, PID of the Emacs server process.  */
static pid_t emacs_pid;

/* If non-NULL, a string that should form a frame parameter alist to
   be used for the new frame.  */
static char const *frame_parameters;

static _Noreturn void print_help_and_exit (void);

/* Long command-line options.  */

static struct option const longopts[] =
{
  { "no-wait",	no_argument,	   NULL, 'n' },
  { "quiet",	no_argument,	   NULL, 'q' },
  { "suppress-output", no_argument, NULL, 'u' },
  { "eval",	no_argument,	   NULL, 'e' },
  { "help",	no_argument,	   NULL, 'H' },
  { "version",	no_argument,	   NULL, 'V' },
  { "tty",	no_argument,       NULL, 't' },
  { "nw",	no_argument,       NULL, 't' },
  { "no-window-system",	no_argument, NULL, 't' },
  { "create-frame", no_argument,   NULL, 'c' },
  { "reuse-frame", no_argument,   NULL, 'r' },
  { "alternate-editor", required_argument, NULL, 'a' },
  { "frame-parameters", required_argument, NULL, 'F' },
#ifdef SOCKETS_IN_FILE_SYSTEM
  { "socket-name",	required_argument, NULL, 's' },
#endif
  { "server-file",	required_argument, NULL, 'f' },
  { "display",	required_argument, NULL, 'd' },
  { "parent-id", required_argument, NULL, 'p' },
  { "timeout",	required_argument, NULL, 'w' },
  { "tramp",	required_argument, NULL, 'T' },
  { 0, 0, 0, 0 }
};

/* Short options, in the same order as the corresponding long options.
   There is no '-p' short option.  */
static char const shortopts[] =
  "nqueHVtca:F:w:"
#ifdef SOCKETS_IN_FILE_SYSTEM
  "s:"
#endif
  "f:d:T:";


/* Like malloc but get fatal error if memory is exhausted.  */

static void * ATTRIBUTE_MALLOC
xmalloc (size_t size)
{
  void *result = malloc (size);
  if (result == NULL)
    {
      perror ("malloc");
      exit (EXIT_FAILURE);
    }
  return result;
}

/* Like realloc but get fatal error if memory is exhausted.  */

static void *
xrealloc (void *ptr, size_t size)
{
  void *result = realloc (ptr, size);
  if (result == NULL)
    {
      perror ("realloc");
      exit (EXIT_FAILURE);
    }
  return result;
}

/* Like strdup but get a fatal error if memory is exhausted. */

static char * ATTRIBUTE_MALLOC
xstrdup (const char *s)
{
  char *result = strdup (s);
  if (result == NULL)
    {
      perror ("strdup");
      exit (EXIT_FAILURE);
    }
  return result;
}

/* From sysdep.c */
#if !defined HAVE_GET_CURRENT_DIR_NAME || defined BROKEN_GET_CURRENT_DIR_NAME

char *get_current_dir_name (void);

/* Return the current working directory.  Returns NULL on errors.
   Any other returned value must be freed with free.  This is used
   only when get_current_dir_name is not defined on the system.  */
char *
get_current_dir_name (void)
{
  /* The maximum size of a directory name, including the terminating NUL.
     Leave room so that the caller can append a trailing slash.  */
  ptrdiff_t dirsize_max = min (PTRDIFF_MAX, SIZE_MAX) - 1;

  /* The maximum size of a buffer for a file name, including the
     terminating NUL.  This is bounded by PATH_MAX, if available.  */
  ptrdiff_t bufsize_max = dirsize_max;
#ifdef PATH_MAX
  bufsize_max = min (bufsize_max, PATH_MAX);
#endif

  struct stat dotstat, pwdstat;
  size_t pwdlen;
  /* If PWD is accurate, use it instead of calling getcwd.  PWD is
     sometimes a nicer name, and using it may avoid a fatal error if a
     parent directory is searchable but not readable.  */
  char const *pwd = egetenv ("PWD");
  if (pwd
      && (pwdlen = strnlen (pwd, bufsize_max)) < bufsize_max
      && IS_DIRECTORY_SEP (pwd[pwdlen && IS_DEVICE_SEP (pwd[1]) ? 2 : 0])
      && stat (pwd, &pwdstat) == 0
      && stat (".", &dotstat) == 0
      && dotstat.st_ino == pwdstat.st_ino
      && dotstat.st_dev == pwdstat.st_dev)
    return strdup (pwd);
  else
    {
      ptrdiff_t buf_size = min (bufsize_max, 1024);
      for (;;)
	{
	  char *buf = malloc (buf_size);
	  if (!buf)
	    return NULL;
	  if (getcwd (buf, buf_size) == buf)
	    return buf;
	  free (buf);
	  if (errno != ERANGE || buf_size == bufsize_max)
	    return NULL;
	  buf_size = buf_size <= bufsize_max / 2 ? 2 * buf_size : bufsize_max;
	}
    }
}
#endif

#ifdef WINDOWSNT

# define REG_ROOT "SOFTWARE\\GNU\\Emacs"

char *w32_get_resource (HKEY, const char *, LPDWORD);

/* Retrieve an environment variable from the Emacs subkeys of the registry.
   Return NULL if the variable was not found, or it was empty.
   This code is based on w32_get_resource (w32.c).  */
char *
w32_get_resource (HKEY predefined, const char *key, LPDWORD type)
{
  HKEY hrootkey = NULL;
  char *result = NULL;
  DWORD cbData;

  if (RegOpenKeyEx (predefined, REG_ROOT, 0, KEY_READ, &hrootkey)
      == ERROR_SUCCESS)
    {
      if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData)
	  == ERROR_SUCCESS)
	{
	  result = xmalloc (cbData);

	  if ((RegQueryValueEx (hrootkey, key, NULL, type, (LPBYTE) result,
				&cbData)
	       != ERROR_SUCCESS)
	      || *result == 0)
	    {
	      free (result);
	      result = NULL;
	    }
	}

      RegCloseKey (hrootkey);
    }

  return result;
}

/*
  getenv wrapper for Windows

  Value is allocated on the heap, and can be free'd.

  This is needed to duplicate Emacs's behavior, which is to look for
  environment variables in the registry if they don't appear in the
  environment.  */
char *
w32_getenv (const char *envvar)
{
  char *value;
  DWORD dwType;

  if ((value = getenv (envvar)))
    /* Found in the environment.  strdup it, because values returned
       by getenv cannot be free'd.  */
    return xstrdup (value);

  if (! (value = w32_get_resource (HKEY_CURRENT_USER, envvar, &dwType)) &&
      ! (value = w32_get_resource (HKEY_LOCAL_MACHINE, envvar, &dwType)))
    {
      /* "w32console" is what Emacs on Windows uses for tty-type under -nw.  */
      if (strcmp (envvar, "TERM") == 0)
	return xstrdup ("w32console");
      /* Found neither in the environment nor in the registry.  */
      return NULL;
    }

  if (dwType == REG_SZ)
    /* Registry; no need to expand.  */
    return value;

  if (dwType == REG_EXPAND_SZ)
    {
      DWORD size;

      if ((size = ExpandEnvironmentStrings (value, NULL, 0)))
	{
	  char *buffer = xmalloc (size);
	  if (ExpandEnvironmentStrings (value, buffer, size))
	    {
	      /* Found and expanded.  */
	      free (value);
	      return buffer;
	    }

	  /* Error expanding.  */
	  free (buffer);
	}
    }

  /* Not the right type, or not correctly expanded.  */
  free (value);
  return NULL;
}

int w32_window_app (void);

int
w32_window_app (void)
{
  static int window_app = -1;
  char szTitle[MAX_PATH];

  if (window_app < 0)
    {
      /* Checking for STDOUT does not work; it's a valid handle also in
         nonconsole apps.  Testing for the console title seems to work. */
      window_app = (GetConsoleTitleA (szTitle, MAX_PATH) == 0);
      if (window_app)
        InitCommonControls ();
    }

  return window_app;
}

/* execvp wrapper for Windows.  Quotes arguments with embedded spaces.

  This is necessary due to the broken implementation of exec* routines in
  the Microsoft libraries: they concatenate the arguments together without
  quoting special characters, and pass the result to CreateProcess, with
  predictably bad results.  By contrast, POSIX execvp passes the arguments
  directly into the argv array of the child process.  */

int w32_execvp (const char *, char **);

int
w32_execvp (const char *path, char **argv)
{
  int i;

  /* Required to allow a .BAT script as alternate editor.  */
  argv[0] = (char *) alternate_editor;

  for (i = 0; argv[i]; i++)
    if (strchr (argv[i], ' '))
      {
	char *quoted = alloca (strlen (argv[i]) + 3);
	sprintf (quoted, "\"%s\"", argv[i]);
	argv[i] = quoted;
      }

  return execvp (path, argv);
}

# undef execvp
# define execvp w32_execvp

/* Emulation of ttyname for Windows.  */
const char *ttyname (int);
const char *
ttyname (int fd)
{
  return "CONOUT$";
}

#endif /* WINDOWSNT */

/* Display a normal or error message.
   On Windows, use a message box if compiled as a Windows app.  */
static void message (bool, const char *, ...) ATTRIBUTE_FORMAT_PRINTF (2, 3);
static void
message (bool is_error, const char *format, ...)
{
  va_list args;

  va_start (args, format);

#ifdef WINDOWSNT
  if (w32_window_app ())
    {
      char msg[2048];
      vsnprintf (msg, sizeof msg, format, args);
      msg[sizeof msg - 1] = '\0';

      if (is_error)
	MessageBox (NULL, msg, "Emacsclient ERROR", MB_ICONERROR);
      else
	MessageBox (NULL, msg, "Emacsclient", MB_ICONINFORMATION);
    }
  else
#endif
    {
      FILE *f = is_error ? stderr : stdout;

      vfprintf (f, format, args);
      fflush (f);
    }

  va_end (args);
}

/* Decode the options from argv and argc.
   The global variable 'optind' will say how many arguments we used up.  */

static void
decode_options (int argc, char **argv)
{
  alternate_editor = egetenv ("ALTERNATE_EDITOR");
  tramp_prefix = egetenv ("EMACSCLIENT_TRAMP");

  while (true)
    {
      int opt = getopt_long_only (argc, argv, shortopts, longopts, NULL);
      if (opt < 0)
	break;

      char* endptr;
      switch (opt)
	{
	case 0:
	  /* If getopt returns 0, then it has already processed a
	     long-named option.  We should do nothing.  */
	  break;

	case 'a':
	  alternate_editor = optarg;
	  break;

#ifdef SOCKETS_IN_FILE_SYSTEM
	case 's':
	  socket_name = optarg;
	  break;
#endif

	case 'f':
	  server_file = optarg;
	  break;

	  /* We used to disallow this argument in w32, but it seems better
	     to allow it, for the occasional case where the user is
	     connecting with a w32 client to a server compiled with X11
	     support.  */
	case 'd':
	  display = optarg;
	  break;

	case 'n':
	  nowait = true;
	  break;

	case 'w':
	  timeout = strtoumax (optarg, &endptr, 10);
	  if (timeout <= 0 ||
	      ((timeout == INTMAX_MAX || timeout == INTMAX_MIN)
	       && errno == ERANGE))
	    {
	      fprintf (stderr, "Invalid timeout: \"%s\"\n", optarg);
	      exit (EXIT_FAILURE);
	    }
	  break;

	case 'e':
	  eval = true;
	  break;

	case 'q':
	  quiet = true;
	  break;

	case 'u':
	  suppress_output = true;
	  break;

	case 'V':
	  message (false, "emacsclient %s\n", PACKAGE_VERSION);
	  exit (EXIT_SUCCESS);
	  break;

        case 't':
	  tty = true;
	  create_frame = true;
	  reuse_frame = false;
          break;

        case 'c':
	  create_frame = true;
          break;

	case 'r':
	  create_frame = true;
	  if (!tty)
	    reuse_frame = true;
	  break;

	case 'p':
	  parent_id = optarg;
	  create_frame = true;
	  break;

	case 'H':
	  print_help_and_exit ();
	  break;

        case 'F':
          frame_parameters = optarg;
          break;

        case 'T':
          tramp_prefix = optarg;
          break;

	default:
	  message (true, "Try '%s --help' for more information\n", progname);
	  exit (EXIT_FAILURE);
	  break;
	}
    }

  /* If the -c option is used (without -t) and no --display argument
     is provided, try $DISPLAY.
     Without the -c option, we used to set 'display' to $DISPLAY by
     default, but this changed the default behavior and is sometimes
     inconvenient.  So we force users to use "--display $DISPLAY" if
     they want Emacs to connect to their current display.

     Some window systems have a notion of default display not
     reflected in the DISPLAY variable.  If the user didn't give us an
     explicit display, try this platform-specific after trying the
     display in DISPLAY (if any).  */
  if (create_frame && !tty && !display)
    {
#ifndef HAVE_ANDROID
      /* Set these here so we use a default_display only when the user
         didn't give us an explicit display.  */
#if defined (NS_IMPL_COCOA)
      alt_display = "ns";
#elif defined (HAVE_NTGUI)
      alt_display = "w32";
#elif defined (HAVE_HAIKU)
      alt_display = "be";
#endif /* NS_IMPL_COCOA */

#ifdef HAVE_PGTK
      display = egetenv ("WAYLAND_DISPLAY");
      alt_display = egetenv ("DISPLAY");
#else /* !HAVE_PGTK */
      display = egetenv ("DISPLAY");
#endif /* HAVE_PGTK */
#else /* HAVE_ANDROID */
      /* Disregard the DISPLAY environment variable under Android.
         Several terminal emulator programs furnish their own X
         servers and set DISPLAY, but an Android build is incapable of
         displaying X frames.  */
      alt_display = NULL;
      display = "android";
#endif /* !HAVE_ANDROID */
    }

  if (!display)
    {
      display = alt_display;
      alt_display = NULL;
    }

  /* A null-string display is invalid.  */
  if (display && !display[0])
    display = NULL;

  /* If no display is available, new frames are tty frames.  */
  if (create_frame && !display)
    tty = true;

#ifdef WINDOWSNT
  /* Emacs on Windows does not support graphical and text terminal
     frames in the same instance.  So, treat the -t and -c options as
     equivalent, and open a new frame on the server's terminal.
     Ideally, we would set tty = true only if the server is running in a
     console, but alas we don't know that.  As a workaround, always
     ask for a tty frame, and let server.el figure it out.  */
  if (create_frame)
    {
      display = NULL;
      tty = true;
    }
#endif /* WINDOWSNT */
}


static _Noreturn void
print_help_and_exit (void)
{
  /* Spaces and tabs are significant in this message; they're chosen so the
     message aligns properly both in a tty and in a Windows message box.
     Please try to preserve them; otherwise the output is very hard to read
     when using emacsclientw.  */
  message (false,
	   "Usage: %s [OPTIONS] FILE...\n%s%s%s", progname, "\
Tell the Emacs server to visit the specified files.\n\
Every FILE can be either just a FILENAME or [+LINE[:COLUMN]] FILENAME.\n\
\n\
The following OPTIONS are accepted:\n\
-V, --version		Just print version info and return\n\
-H, --help    		Print this usage information message\n\
-nw, -t, --tty, --no-window-system\n\
			Open a new Emacs frame on the current terminal\n\
-c, --create-frame    	Create a new frame instead of trying to\n\
			use the current Emacs frame\n\
-r, --reuse-frame	Create a new frame if none exists, otherwise\n\
			use the current Emacs frame\n\
", "\
-F ALIST, --frame-parameters=ALIST\n\
			Set the parameters of a new frame\n\
-e, --eval    		Evaluate the FILE arguments as ELisp expressions\n\
-n, --no-wait		Don't wait for the server to return\n\
-w, --timeout=SECONDS	Seconds to wait before timing out\n\
-q, --quiet		Don't display messages on success\n\
-u, --suppress-output   Don't display return values from the server\n\
-d DISPLAY, --display=DISPLAY\n\
			Visit the file in the given display\n\
", "\
--parent-id=ID          Open in parent window ID, via XEmbed\n"
#ifdef SOCKETS_IN_FILE_SYSTEM
"-s SOCKET, --socket-name=SOCKET\n\
			Set filename of the UNIX socket for communication\n"
#endif
"-f SERVER, --server-file=SERVER\n\
			Set filename of the TCP authentication file\n\
-a EDITOR, --alternate-editor=EDITOR\n\
			Editor to fallback to if the server is not running\n"
"			If EDITOR is the empty string, start Emacs in daemon\n\
			mode and try connecting again\n"
"-T PREFIX, --tramp=PREFIX\n\
                        PREFIX to prepend to filenames sent by emacsclient\n\
                        for locating files remotely via Tramp\n"
"\n\
Report bugs with M-x report-emacs-bug.\n");
  exit (EXIT_SUCCESS);
}

/* Try to run a different command, or --if no alternate editor is
   defined-- exit with an error code.
   Uses argv, but gets it from the global variable main_argv.  */

static _Noreturn void
fail (void)
{
  if (alternate_editor)
    {
      size_t extra_args_size = (main_argc - optind + 1) * sizeof (char *);
      size_t new_argv_size = extra_args_size;
      char **new_argv = xmalloc (new_argv_size);
      char *s = xstrdup (alternate_editor);
      ptrdiff_t toks = 0;

      /* Unpack alternate_editor's space-separated tokens into new_argv.  */
      for (char *tok = s; tok != NULL && *tok != '\0';)
        {
          /* Allocate new token.  */
          ++toks;
          new_argv = xrealloc (new_argv,
			       new_argv_size + toks * sizeof (char *));

          /* Skip leading delimiters, and set separator, skipping any
             opening quote.  */
          size_t skip = strspn (tok, " \"");
          tok += skip;
          char sep = (skip > 0 && tok[-1] == '"') ? '"' : ' ';

          /* Record start of token.  */
          new_argv[toks - 1] = tok;

          /* Find end of token and overwrite it with NUL.  */
          tok = strchr (tok, sep);
          if (tok != NULL)
            *tok++ = '\0';
        }

      /* Append main_argv arguments to new_argv.  */
      memcpy (&new_argv[toks], main_argv + optind, extra_args_size);

      execvp (*new_argv, new_argv);
      message (true, "%s: error executing alternate editor \"%s\"\n",
	       progname, alternate_editor);
    }
  exit (EXIT_FAILURE);
}


#ifdef SOCKETS_IN_FILE_SYSTEM
static void act_on_signals (HSOCKET);
#else
static void act_on_signals (HSOCKET s) {}
static void init_signals (void) {}
#endif

enum { AUTH_KEY_LENGTH = 64 };

static void
sock_err_message (const char *function_name)
{
#ifdef WINDOWSNT
  /* On Windows, the socket library was historically separate from the
     standard C library, so errors are handled differently.  */

  if (w32_window_app () && alternate_editor)
    return;

  char *msg = NULL;

  FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
                 | FORMAT_MESSAGE_ALLOCATE_BUFFER
                 | FORMAT_MESSAGE_ARGUMENT_ARRAY,
                 NULL, WSAGetLastError (), 0, (LPTSTR)&msg, 0, NULL);

  message (true, "%s: %s: %s\n", progname, function_name, msg);

  LocalFree (msg);
#else
  message (true, "%s: %s: %s\n", progname, function_name, strerror (errno));
#endif
}


/* Send to S the data in *DATA when either
   - the data's last byte is '\n', or
   - the buffer is full (but this shouldn't happen)
   Otherwise, just accumulate the data.  */
static void
send_to_emacs (HSOCKET s, const char *data)
{
  enum { SEND_BUFFER_SIZE = 4096 };

  /* Buffer to accumulate data to send in TCP connections.  */
  static char send_buffer[SEND_BUFFER_SIZE + 1];

  /* Fill pointer for the send buffer.  */
  static int sblen;

  for (ptrdiff_t dlen = strlen (data); dlen != 0; )
    {
      int part = min (dlen, SEND_BUFFER_SIZE - sblen);
      memcpy (&send_buffer[sblen], data, part);
      data += part;
      sblen += part;

      if (sblen == SEND_BUFFER_SIZE
	  || (0 < sblen && send_buffer[sblen - 1] == '\n'))
	{
	  int sent;
	  while ((sent = send (s, send_buffer, sblen, 0)) < 0)
	    {
	      if (errno != EINTR)
		{
		  message (true, "%s: failed to send %d bytes to socket: %s\n",
			   progname, sblen, strerror (errno));
		  fail ();
		}
	      /* Act on signals not requiring communication to Emacs,
		 but defer action on the others to avoid confusing the
		 communication currently in progress.  */
	      act_on_signals (INVALID_SOCKET);
	    }
	  sblen -= sent;
	  memmove (send_buffer, &send_buffer[sent], sblen);
	}

      dlen -= part;
    }
}


/* In STR, insert a & before each &, each space, each newline, and
   any initial -.  Change spaces to underscores, too, so that the
   return value never contains a space.

   Does not change the string.  Outputs the result to S.  */
static void
quote_argument (HSOCKET s, const char *str)
{
  char *copy = xmalloc (strlen (str) * 2 + 1);
  char *q = copy;
  if (*str == '-')
    *q++ = '&', *q++ = *str++;
  for (; *str; str++)
    {
      char c = *str;
      if (c == ' ')
	*q++ = '&', c = '_';
      else if (c == '\n')
	*q++ = '&', c = 'n';
      else if (c == '&')
	*q++ = '&';
      *q++ = c;
    }
  *q = 0;

  send_to_emacs (s, copy);

  free (copy);
}


/* The inverse of quote_argument.  Remove quoting in string STR by
   modifying the addressed string in place.  Return STR.  */

static char *
unquote_argument (char *str)
{
  char const *p = str;
  char *q = str;
  char c;

  do
    {
      c = *p++;
      if (c == '&')
	{
	  c = *p++;
	  if (c == '_')
	    c = ' ';
	  else if (c == 'n')
	    c = '\n';
	}
      *q++ = c;
    }
  while (c);

  return str;
}


#ifdef WINDOWSNT
/* Wrapper to make WSACleanup a cdecl, as required by atexit.  */
void __cdecl close_winsock (void);
void __cdecl
close_winsock (void)
{
  WSACleanup ();
}

/* Initialize the WinSock2 library.  */
void initialize_sockets (void);
void
initialize_sockets (void)
{
  WSADATA wsaData;

  if (WSAStartup (MAKEWORD (2, 0), &wsaData))
    {
      message (true, "%s: error initializing WinSock2\n", progname);
      exit (EXIT_FAILURE);
    }

  atexit (close_winsock);
}
#endif /* WINDOWSNT */


/* If the home directory is HOME, and XDG_CONFIG_HOME's value is XDG,
   return the configuration file with basename CONFIG_FILE.  Fail if
   the configuration file could not be opened.  */

static FILE *
open_config (char const *home, char const *xdg, char const *config_file)
{
  ptrdiff_t xdgsubdirsize = xdg ? strlen (xdg) + sizeof "/emacs/server/" : 0;
  ptrdiff_t homesuffixsizemax = max (sizeof "/.config/emacs/server/",
				     sizeof "/.emacs.d/server/");
  ptrdiff_t homesubdirsizemax = home ? strlen (home) + homesuffixsizemax : 0;
  char *configname = xmalloc (max (xdgsubdirsize, homesubdirsizemax)
			      + strlen (config_file));
  FILE *config;

  if (home)
    {
      strcpy (stpcpy (stpcpy (configname, home), "/.emacs.d/server/"),
              config_file);
      config = fopen (configname, "rb");
    }
  else
    config = NULL;

  if (! config && (xdg || home))
    {
      strcpy ((xdg
               ? stpcpy (stpcpy (configname, xdg), "/emacs/server/")
               : stpcpy (stpcpy (configname, home), "/.config/emacs/server/")),
              config_file);
      config = fopen (configname, "rb");
    }

  free (configname);
  return config;
}

/* Read the information needed to set up a TCP comm channel with
   the Emacs server: host, port, and authentication string.  */

static bool
get_server_config (const char *config_file, struct sockaddr_in *server,
		   char *authentication)
{
  char dotted[32];
  char *port;
  FILE *config;

  if (IS_ABSOLUTE_FILE_NAME (config_file))
    config = fopen (config_file, "rb");
  else
    {
      char const *xdg = egetenv ("XDG_CONFIG_HOME");
      config = open_config (egetenv ("HOME"), xdg, config_file);
#ifdef WINDOWSNT
      if (!config)
	config = open_config (egetenv ("APPDATA"), xdg, config_file);
#endif
    }

  if (! config)
    return false;

  if (fgets (dotted, sizeof dotted, config)
      && (port = strchr (dotted, ':')))
    *port++ = '\0';
  else
    {
      message (true, "%s: invalid configuration info\n", progname);
      exit (EXIT_FAILURE);
    }

  memset (server, 0, sizeof *server);
  server->sin_family = AF_INET;
  server->sin_addr.s_addr = inet_addr (dotted);
  server->sin_port = htons (atoi (port));

  if (! fread (authentication, AUTH_KEY_LENGTH, 1, config))
    {
      message (true, "%s: cannot read authentication info\n", progname);
      exit (EXIT_FAILURE);
    }

  fclose (config);

  return true;
}

/* Like socket (DOMAIN, TYPE, PROTOCOL), except arrange for the
   resulting file descriptor to be close-on-exec.  */

static HSOCKET
cloexec_socket (int domain, int type, int protocol)
{
#ifdef SOCK_CLOEXEC
  return socket (domain, type | SOCK_CLOEXEC, protocol);
#else
  HSOCKET s = socket (domain, type, protocol);
# ifndef WINDOWSNT
  if (0 <= s)
    fcntl (s, F_SETFD, FD_CLOEXEC);
# endif
  return s;
#endif
}

static HSOCKET
set_tcp_socket (const char *local_server_file)
{
  union {
    struct sockaddr_in in;
    struct sockaddr sa;
  } server;
  struct linger l_arg = { .l_onoff = 1, .l_linger = 1 };
  char auth_string[AUTH_KEY_LENGTH + 1];

  if (! get_server_config (local_server_file, &server.in, auth_string))
    return INVALID_SOCKET;

  if (server.in.sin_addr.s_addr != inet_addr ("127.0.0.1") && !quiet)
    message (false, "%s: connected to remote socket at %s\n",
	     progname, inet_ntoa (server.in.sin_addr));

  /* Open up an AF_INET socket.  */
  HSOCKET s = cloexec_socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
  if (s < 0)
    {
      /* Since we have an alternate to try out, this is not an error
	 yet; popping out a modal dialog at this stage would make -a
	 option totally useless for emacsclientw -- the user will
	 still get an error message if the alternate editor fails.  */
      sock_err_message ("socket");
      return INVALID_SOCKET;
    }

  /* Set up the socket.  */
  if (connect (s, &server.sa, sizeof server.in) != 0)
    {
      sock_err_message ("connect");
      CLOSE_SOCKET (s);
      return INVALID_SOCKET;
    }

  /* The cast to 'const char *' is to avoid a compiler warning when
     compiling for MS-Windows sockets.  */
  int ret = setsockopt (s, SOL_SOCKET, SO_LINGER, (const char *) &l_arg, sizeof l_arg);
  if (ret < 0)
    sock_err_message ("setsockopt");

  /* Send the authentication.  */
  auth_string[AUTH_KEY_LENGTH] = '\0';

  send_to_emacs (s, "-auth ");
  send_to_emacs (s, auth_string);
  send_to_emacs (s, " ");

  return s;
}


/* Return true if PREFIX is a prefix of STRING. */
static bool
strprefix (const char *prefix, const char *string)
{
  return !strncmp (prefix, string, strlen (prefix));
}

/* Get tty name and type.  If successful, store the type into
   *TTY_TYPE and the name into *TTY_NAME, and return true.
   Otherwise, fail if NOABORT is zero, or return false if NOABORT.  */

static bool
find_tty (const char **tty_type, const char **tty_name, bool noabort)
{
  const char *type = egetenv ("TERM");
  const char *name = ttyname (STDOUT_FILENO);

  if (!name)
    {
      if (noabort)
	return false;
      message (true, "%s: could not get terminal name\n", progname);
      fail ();
    }

  if (!type)
    {
      if (noabort)
	return false;
      message (true, "%s: please set the TERM variable to your terminal type\n",
	       progname);
      fail ();
    }

  const char *inside_emacs = egetenv ("INSIDE_EMACS");
  if (inside_emacs && strstr (inside_emacs, ",term:")
      && strprefix ("eterm", type))
    {
      if (noabort)
	return false;
      /* This causes nasty, MULTI_KBOARD-related input lockouts. */
      message (true, ("%s: opening a frame in an Emacs term buffer"
		      " is not supported\n"),
	       progname);
      fail ();
    }

  *tty_name = name;
  *tty_type = type;
  return true;
}

/* Return the process group if in the foreground, the negative of the
   process group if in the background, and zero if there is no
   foreground process group for the controlling terminal.
   Unfortunately, use of this function introduces an unavoidable race,
   since whether the process is in the foreground or background can
   change at any time.  */

static pid_t
process_grouping (void)
{
#ifdef SOCKETS_IN_FILE_SYSTEM
  pid_t tcpgrp = tcgetpgrp (STDOUT_FILENO);
  if (0 <= tcpgrp)
    {
      pid_t pgrp = getpgrp ();
      return tcpgrp == pgrp ? pgrp : -pgrp;
    }
#endif
  return 0;
}

#ifdef SOCKETS_IN_FILE_SYSTEM

# include <acl.h>

# ifndef O_PATH
#  define O_PATH O_SEARCH
# endif

/* A local socket address.  The union avoids the need to cast.  */
union local_sockaddr
{
  struct sockaddr_un un;
  struct sockaddr sa;
};

/* Relative to the directory DIRFD, connect the socket file named ADDR
   to the socket S.  Return 0 if successful, -1 if DIRFD is not
   AT_FDCWD and DIRFD's permissions would allow a symlink attack, an
   errno otherwise.  */

static int
connect_socket (int dirfd, char const *addr, int s, uid_t uid)
{
  int sock_status = 0;

  union local_sockaddr server;
  if (sizeof server.un.sun_path <= strlen (addr))
    return ENAMETOOLONG;
  server.un.sun_family = AF_UNIX;
  strcpy (server.un.sun_path, addr);

  /* If -1, WDFD is not set yet.  If nonnegative, WDFD is a file
     descriptor for the initial working directory.  Otherwise -1 - WDFD is
     the error number for the initial working directory.  */
  static int wdfd = -1;

  if (dirfd != AT_FDCWD)
    {
      /* Fail if DIRFD's permissions are bogus.  */
      struct stat st;
      if (fstat (dirfd, &st) != 0)
	return errno;
      if (st.st_uid != uid || (st.st_mode & (S_IWGRP | S_IWOTH)))
	return -1;

      if (wdfd == -1)
	{
	  /* Save the initial working directory.  */
	  wdfd = open (".", O_PATH | O_CLOEXEC);
	  if (wdfd < 0)
	    wdfd = -1 - errno;
	}
      if (wdfd < 0)
	return -1 - wdfd;
      if (fchdir (dirfd) != 0)
	return errno;

      /* Fail if DIRFD has an ACL, which means its permissions are
	 almost surely bogus.  */
      int has_acl = file_has_acl (".", &st);
      if (has_acl)
	sock_status = has_acl < 0 ? errno : -1;
    }

  if (!sock_status)
    sock_status = connect (s, &server.sa, sizeof server.un) == 0 ? 0 : errno;

  /* Fail immediately if we cannot change back to the initial working
     directory, as that can mess up the rest of execution.  */
  if (dirfd != AT_FDCWD && fchdir (wdfd) != 0)
    {
      message (true, "%s: .: %s\n", progname, strerror (errno));
      exit (EXIT_FAILURE);
    }

  return sock_status;
}


/* Signal handlers merely set a flag, to avoid race conditions on
   POSIXish systems.  Non-POSIX platforms lacking sigaction make do
   with traditional calls to 'signal'; races are rare so this usually
   works.  Although this approach may treat multiple deliveries of SIG
   as a single delivery and may act on signals in a different order
   than received, that is OK for emacsclient.  Also, this approach may
   omit output if a printf call is interrupted by a signal, but printf
   output is not that important (emacsclient does not check for printf
   errors, after all) so this is also OK for emacsclient.  */

/* Reinstall for SIG the signal handler HANDLER if needed.  It is
   needed on a non-POSIX or traditional platform where an interrupt
   resets the signal handler to SIG_DFL.  */
static void
reinstall_handler_if_needed (int sig, void (*handler) (int))
{
# ifndef SA_RESETHAND
  /* This is a platform without POSIX's sigaction.  */
  signal (sig, handler);
# endif
}

/* Flags for each signal, and handlers that set the flags.  */

static sig_atomic_t volatile
  got_sigcont, got_sigtstp, got_sigttou, got_sigwinch;

static void
handle_sigcont (int sig)
{
  got_sigcont = 1;
  reinstall_handler_if_needed (sig, handle_sigcont);
}
static void
handle_sigtstp (int sig)
{
  got_sigtstp = 1;
  reinstall_handler_if_needed (sig, handle_sigtstp);
}
static void
handle_sigttou (int sig)
{
  got_sigttou = 1;
  reinstall_handler_if_needed (sig, handle_sigttou);
}
static void
handle_sigwinch (int sig)
{
  got_sigwinch = 1;
  reinstall_handler_if_needed (sig, handle_sigwinch);
}

/* Install for signal SIG the handler HANDLER.  However, if FLAG is
   non-null and if the signal is currently being ignored, do not
   install the handler and keep *FLAG zero.  */

static void
install_handler (int sig, void (*handler) (int), sig_atomic_t volatile *flag)
{
# ifdef SA_RESETHAND
  if (flag)
    {
      struct sigaction oact;
      if (sigaction (sig, NULL, &oact) == 0 && oact.sa_handler == SIG_IGN)
	return;
    }
  struct sigaction act = { .sa_handler = handler };
  sigemptyset (&act.sa_mask);
  sigaction (sig, &act, NULL);
# else
  void (*ohandler) (int) = signal (sig, handler);
  if (flag)
    {
      if (ohandler == SIG_IGN)
	{
	  signal (sig, SIG_IGN);
	  /* While HANDLER was mistakenly installed a signal may have
	     arrived and set *FLAG, so clear *FLAG now.  */
	  *flag = 0;
	}
    }
# endif
}

/* Initial installation of signal handlers.  */

static void
init_signals (void)
{
  install_handler (SIGCONT, handle_sigcont, &got_sigcont);
  install_handler (SIGTSTP, handle_sigtstp, &got_sigtstp);
  install_handler (SIGTTOU, handle_sigttou, &got_sigttou);
  install_handler (SIGWINCH, handle_sigwinch, &got_sigwinch);
  /* Don't mess with SIGINT and SIGQUIT, as Emacs has no way to
     determine which terminal the signal came from.  C-g is a normal
     input event on secondary terminals.  */
}

/* Act on delivered tty-related signal SIG that normally has handler
   HANDLER.  EMACS_SOCKET connects to Emacs.  */

static void
act_on_tty_signal (int sig, void (*handler) (int), HSOCKET emacs_socket)
{
  /* Notify Emacs that we are going to sleep.  Normally the suspend is
     initiated by Emacs via server-handle-suspend-tty, but if the
     server gets out of sync with reality, we may get a SIGTSTP on
     C-z.  Handling this signal and notifying Emacs about it should
     get things under control again.  */
  send_to_emacs (emacs_socket, "-suspend \n");

  /* Execute the default action by temporarily changing handling to
     the default and resignaling.  */
  install_handler (sig, SIG_DFL, NULL);
  raise (sig);
  install_handler (sig, handler, NULL);
}

/* Act on delivered signals if possible.  If EMACS_SOCKET is valid,
   use it to communicate to Emacs.  */

static void
act_on_signals (HSOCKET emacs_socket)
{
  while (true)
    {
      bool took_action = false;

      if (emacs_socket != INVALID_SOCKET)
	{
	  if (got_sigcont)
	    {
	      got_sigcont = 0;
	      took_action = true;
	      pid_t grouping = process_grouping ();
	      if (grouping < 0)
		{
		  if (tty)
		    {
		      /* Cancel the continue.  */
		      kill (grouping, SIGTTIN);
		    }
		}
	      else
		send_to_emacs (emacs_socket, "-resume \n");
	    }

	  if (got_sigtstp)
	    {
	      got_sigtstp = 0;
	      took_action = true;
	      act_on_tty_signal (SIGTSTP, handle_sigtstp, emacs_socket);
	    }
	  if (got_sigttou)
	    {
	      got_sigttou = 0;
	      took_action = true;
	      act_on_tty_signal (SIGTTOU, handle_sigttou, emacs_socket);
	    }
	}

      if (emacs_pid && got_sigwinch)
	{
	  got_sigwinch = 0;
	  took_action = true;
	  kill (emacs_pid, SIGWINCH);
	}

      if (!took_action)
	break;
    }
}

enum { socknamesize = sizeof ((struct sockaddr_un *) NULL)->sun_path };

/* Given a local socket S, create in *SOCKNAME a name for a local socket
   and connect to that socket.  The first TMPDIRLEN bytes of *SOCKNAME are
   already initialized to be the name of a temporary directory.
   Use UID and SERVER_NAME to concoct the name.  Return 0 if
   successful, -1 if the socket's parent directory is not safe, and an
   errno if there is some other problem.  */

static int
local_sockname (int s, char sockname[socknamesize], int tmpdirlen,
		uid_t uid, char const *server_name)
{
  /* If ! (0 <= TMPDIRLEN && TMPDIRLEN < SOCKNAMESIZE) the truncated
     temporary directory name is already in SOCKNAME, so nothing more
     need be stored.  */
  if (! (0 <= tmpdirlen && tmpdirlen < socknamesize))
    return ENAMETOOLONG;

  /* Put the full address name into the buffer, since the caller might
     need it for diagnostics.  But don't overrun the buffer.  */
  uintmax_t uidmax = uid;
  int suffixlen = snprintf (sockname + tmpdirlen, socknamesize - tmpdirlen,
			    "/emacs%"PRIuMAX"/%s", uidmax, server_name);
  if (! (0 <= suffixlen && suffixlen < socknamesize - tmpdirlen))
    return ENAMETOOLONG;

  /* Make sure the address's parent directory is not a symlink and is
     this user's directory and does not let others write to it; this
     fends off some symlink attacks.  To avoid races, keep the parent
     directory open while checking.  */
  char *emacsdirend = (sockname + tmpdirlen + suffixlen
		       - strlen (server_name) - 1);
  *emacsdirend = '\0';
  int dir = open (sockname, O_PATH | O_DIRECTORY | O_NOFOLLOW | O_CLOEXEC);
  *emacsdirend = '/';
  if (dir < 0)
    return errno;
  int sock_status = connect_socket (dir, server_name, s, uid);
  close (dir);
  return sock_status;
}

/* Create a local socket for SERVER_NAME and connect it to Emacs.  If
   SERVER_NAME is a file name component, the local socket name
   relative to a well-known location in a temporary directory.
   Otherwise, the local socket name is SERVER_NAME.  */

static HSOCKET
set_local_socket (char const *server_name)
{
  union local_sockaddr server;
  int sock_status;
  char *sockname = server.un.sun_path;
  int tmpdirlen = -1;
  int socknamelen = -1;
  uid_t uid = geteuid ();
  bool tmpdir_used = false;
  int s = cloexec_socket (AF_UNIX, SOCK_STREAM, 0);
  if (s < 0)
    {
      message (true, "%s: can't create socket: %s\n",
	       progname, strerror (errno));
      fail ();
    }

  if (strchr (server_name, '/')
      || (ISSLASH ('\\') && strchr (server_name, '\\')))
    {
      socknamelen = snprintf (sockname, socknamesize, "%s", server_name);
      sock_status = (0 <= socknamelen && socknamelen < socknamesize
		     ? connect_socket (AT_FDCWD, sockname, s, 0)
		     : ENAMETOOLONG);
    }
  else
    {
#ifndef HAVE_ANDROID
      /* socket_name is a file name component.  */
      char const *xdg_runtime_dir = egetenv ("XDG_RUNTIME_DIR");
      if (xdg_runtime_dir)
	{
	  socknamelen = snprintf (sockname, socknamesize, "%s/emacs/%s",
				  xdg_runtime_dir, server_name);
	  sock_status = (0 <= socknamelen && socknamelen < socknamesize
			 ? connect_socket (AT_FDCWD, sockname, s, 0)
			 : ENAMETOOLONG);
	}
      else
	{
	  char const *tmpdir = egetenv ("TMPDIR");
	  if (tmpdir)
	    tmpdirlen = snprintf (sockname, socknamesize, "%s", tmpdir);
	  else
	    {
# ifdef DARWIN_OS
#  ifndef _CS_DARWIN_USER_TEMP_DIR
#   define _CS_DARWIN_USER_TEMP_DIR 65537
#  endif
	      size_t n = confstr (_CS_DARWIN_USER_TEMP_DIR,
				  sockname, socknamesize);
	      if (0 < n && n < (size_t) -1)
	        tmpdirlen = min (n - 1, socknamesize);
# endif
	      if (tmpdirlen < 0)
		tmpdirlen = snprintf (sockname, socknamesize, "/tmp");
	    }

	  sock_status = local_sockname (s, sockname, tmpdirlen,
					uid, server_name);
	  tmpdir_used = true;
	}
#else /* HAVE_ANDROID */
      char const *tmpdir;
      int socknamelen;
      uintmax_t uidmax;

      /* The TMPDIR of any process to which this binary is
	 accessible must be reserved for Emacs, so the checks in
	 local_sockname and the like are redundant.  */
      tmpdir = egetenv ("TMPDIR");

      /* Resort to the usual location of the cache directory, though
	 this location is not guaranteed to remain stable over
	 future releases of Android.  */
      if (!tmpdir)
	tmpdir = "/data/data/org.gnu.emacs/cache";

      uidmax = uid;
      socknamelen = snprintf (sockname, socknamesize,
			      "%s/emacs%"PRIuMAX"/%s",
			      tmpdir, uidmax, server_name);
      sock_status = (0 <= socknamelen && socknamelen < socknamesize
		     ? connect_socket (AT_FDCWD, sockname, s, 0)
		     : ENAMETOOLONG);
#endif /* !HAVE_ANDROID */
    }

  if (sock_status == 0)
    return s;

  if (sock_status == ENAMETOOLONG)
    {
      message (true, "%s: socket-name %s... too long\n", progname, sockname);
      fail ();
    }

  if (tmpdir_used)
    {
      /* See whether LOGNAME or USER exist and differ from
	 our euid.  If so, look for a socket based on the UID
	 associated with the name.  This is reminiscent of the logic
	 that init_editfns uses to set the global Vuser_full_name.  */

      char const *user_name = egetenv ("LOGNAME");

      if (!user_name)
	user_name = egetenv ("USER");

      if (user_name)
	{
	  struct passwd *pw = getpwnam (user_name);

	  if (pw && pw->pw_uid != uid)
	    {
	      /* We're running under su, apparently. */
	      sock_status = local_sockname (s, sockname, tmpdirlen,
					    pw->pw_uid, server_name);
	      if (sock_status == 0)
		return s;
	      if (sock_status == ENAMETOOLONG)
		{
		  message (true, "%s: socket-name %s... too long\n",
			   progname, sockname);
		  exit (EXIT_FAILURE);
		}
	    }
	}
    }

  close (s);

  if (sock_status == -1)
    message (true,
	     "%s: Invalid permissions on parent directory of socket: %s\n",
	     progname, sockname);
  else if (sock_status == ENOENT)
    {
      if (tmpdir_used)
	{
	  uintmax_t id = uid;
	  char sockdirname[socknamesize];
	  int sockdirnamelen = snprintf (sockdirname, sizeof sockdirname,
					 "/run/user/%"PRIuMAX, id);
	  if (0 <= sockdirnamelen && sockdirnamelen < sizeof sockdirname
	      && faccessat (AT_FDCWD, sockdirname, X_OK, AT_EACCESS) == 0)
	    message
	      (true,
	       ("%s: Should XDG_RUNTIME_DIR='%s' be in the environment?\n"
		"%s: (Be careful: XDG_RUNTIME_DIR is security-related.)\n"),
	       progname, sockdirname, progname);
	}

      /* If there's an alternate editor and the user has requested
	 --quiet, don't output the warning. */
      if (!quiet || !alternate_editor)
	{
	  message (true,
		   ("%s: can't find socket; have you started the server?\n"
		    "%s: To start the server in Emacs,"
		    " type \"M-x server-start\".\n"),
		   progname, progname);
	}
    }
  else
    message (true, "%s: can't connect to %s: %s\n",
	     progname, sockname, strerror (sock_status));

  return INVALID_SOCKET;
}
#endif /* SOCKETS_IN_FILE_SYSTEM */

static HSOCKET
set_socket (bool no_exit_if_error)
{
  HSOCKET s;
  const char *local_server_file = server_file;

  INITIALIZE ();

#ifdef SOCKETS_IN_FILE_SYSTEM
  if (!socket_name)
    socket_name = egetenv ("EMACS_SOCKET_NAME");

  if (socket_name)
    {
      /* Explicit --socket-name argument, or environment variable.  */
      s = set_local_socket (socket_name);
      if (s != INVALID_SOCKET || no_exit_if_error)
	return s;
      message (true, "%s: error accessing socket \"%s\"\n",
	       progname, socket_name);
      exit (EXIT_FAILURE);
    }
#endif

  /* Explicit --server-file arg or EMACS_SERVER_FILE variable.  */
  if (!local_server_file)
    local_server_file = egetenv ("EMACS_SERVER_FILE");

  if (local_server_file)
    {
      s = set_tcp_socket (local_server_file);
      if (s != INVALID_SOCKET || no_exit_if_error)
	return s;

      message (true, "%s: error accessing server file \"%s\"\n",
	       progname, local_server_file);
      exit (EXIT_FAILURE);
    }

#ifdef SOCKETS_IN_FILE_SYSTEM
  /* Implicit local socket.  */
  s = set_local_socket ("server");
  if (s != INVALID_SOCKET)
    return s;
#endif

  /* Implicit server file.  */
  s = set_tcp_socket ("server");
  if (s != INVALID_SOCKET || no_exit_if_error)
    return s;

  /* No implicit or explicit socket, and no alternate editor.  */
  message (true, "%s: No socket or alternate editor.  Please use:\n\n"
#ifdef SOCKETS_IN_FILE_SYSTEM
"\t--socket-name\n"
#endif
"\t--server-file      (or environment variable EMACS_SERVER_FILE)\n\
\t--alternate-editor (or environment variable ALTERNATE_EDITOR)\n",
           progname);
  exit (EXIT_FAILURE);
}

#ifdef HAVE_NTGUI
typedef void (* VOIDFNPTR) (void);
typedef BOOL (WINAPI *AllowSetForegroundWindow_proc) (DWORD);
/* Pointer to AllowSetForegroundWindow.  */
static AllowSetForegroundWindow_proc set_fg;
typedef UINT (WINAPI *RealGetWindowClassA_proc) (HWND, LPSTR, UINT);
/* Pointer to RealGetWindowClassA.  */
static RealGetWindowClassA_proc get_wc;

void w32_set_user_model_id (void);

void
w32_set_user_model_id (void)
{
  HMODULE shell;
  HRESULT (WINAPI * set_user_model) (const wchar_t * id);

  /* On Windows 7 and later, we need to set the user model ID
     to associate emacsclient launched files with Emacs frames
     in the UI.  */
  shell = LoadLibrary ("shell32.dll");
  if (shell)
    {
      set_user_model
	= (void *) GetProcAddress (shell,
				   "SetCurrentProcessExplicitAppUserModelID");
      /* If the function is defined, then we are running on Windows 7
	 or newer, and the UI uses this to group related windows
	 together.  Since emacs, runemacs, emacsclient are related, we
	 want them grouped even though the executables are different,
	 so we need to set a consistent ID between them.  */
      if (set_user_model)
	set_user_model (L"GNU.Emacs");

      FreeLibrary (shell);
    }
}

BOOL CALLBACK w32_find_emacs_process (HWND, LPARAM);

BOOL CALLBACK
w32_find_emacs_process (HWND hWnd, LPARAM lParam)
{
  DWORD pid;
  char class[6];

  /* Reject any window not of class "Emacs".  */
  if (! get_wc (hWnd, class, sizeof (class))
      || strcmp (class, "Emacs"))
    return TRUE;

  /* We only need the process id, not the thread id.  */
  (void) GetWindowThreadProcessId (hWnd, &pid);

  /* Not the one we're looking for.  */
  if (pid != (DWORD) emacs_pid) return TRUE;

  /* OK, let's raise it.  */
  set_fg (emacs_pid);

  /* Stop enumeration.  */
  return FALSE;
}

/* Search for a window of class "Emacs" and owned by a process with
   process id = emacs_pid.  If found, allow it to grab the focus.  */
void w32_give_focus (void);

void
w32_give_focus (void)
{
  HANDLE user32;

  /* It shouldn't happen when dealing with TCP sockets.  */
  if (!emacs_pid) return;

  user32 = GetModuleHandle ("user32.dll");

  if (!user32)
    return;

  /* Modern Windows restrict which processes can set the foreground window.
     emacsclient can allow Emacs to grab the focus by calling the function
     AllowSetForegroundWindow.  Unfortunately, older Windows (W95, W98 and
     NT) lack this function, so we have to check its availability.  */
  if ((set_fg = (AllowSetForegroundWindow_proc) (VOIDFNPTR) GetProcAddress (user32, "AllowSetForegroundWindow"))
      && (get_wc = (RealGetWindowClassA_proc) (VOIDFNPTR) GetProcAddress (user32, "RealGetWindowClassA")))
    EnumWindows (w32_find_emacs_process, (LPARAM) 0);
}
#endif /* HAVE_NTGUI */

/* Start the emacs daemon and try to connect to it.  */

static HSOCKET
start_daemon_and_retry_set_socket (void)
{
#ifndef WINDOWSNT
  pid_t dpid;
  int status;

  dpid = fork ();

  if (dpid > 0)
    {
      pid_t w = waitpid (dpid, &status, WUNTRACED | WCONTINUED);

      if (w < 0 || !WIFEXITED (status) || WEXITSTATUS (status))
	{
	  message (true, "Error: Could not start the Emacs daemon\n");
	  exit (EXIT_FAILURE);
	}

      /* Try connecting, the daemon should have started by now.  */
      if (!quiet)
        message (true,
                 "Emacs daemon should have started, trying to connect again\n");
    }
  else if (dpid < 0)
    {
      fprintf (stderr, "Error: Cannot fork!\n");
      exit (EXIT_FAILURE);
    }
  else
    {
      char emacs[] = "emacs";
      char daemon_option[] = "--daemon";
      char *d_argv[3];
      d_argv[0] = emacs;
      d_argv[1] = daemon_option;
      d_argv[2] = 0;
# ifdef SOCKETS_IN_FILE_SYSTEM
      if (socket_name != NULL)
	{
	  /* Pass  --daemon=socket_name as argument.  */
	  const char *deq = "--daemon=";
	  char *daemon_arg = xmalloc (strlen (deq)
				      + strlen (socket_name) + 1);
	  strcpy (stpcpy (daemon_arg, deq), socket_name);
	  d_argv[1] = daemon_arg;
	}
# endif
      execvp ("emacs", d_argv);
      message (true, "%s: error starting emacs daemon\n", progname);
      exit (EXIT_FAILURE);
    }
#else  /* WINDOWSNT */
  DWORD wait_result;
  HANDLE w32_daemon_event;
  STARTUPINFO si;
  PROCESS_INFORMATION pi;

  ZeroMemory (&si, sizeof si);
  si.cb = sizeof si;
  ZeroMemory (&pi, sizeof pi);

  /* We start Emacs in daemon mode, and then wait for it to signal us
     it is ready to accept client connections, by asserting an event
     whose name is known to the daemon (defined by nt/inc/ms-w32.h).  */

  if (!CreateProcess (NULL, (LPSTR)"emacs --daemon", NULL, NULL, FALSE,
                      CREATE_NO_WINDOW, NULL, NULL, &si, &pi))
    {
      char* msg = NULL;

      FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
		     | FORMAT_MESSAGE_ALLOCATE_BUFFER
		     | FORMAT_MESSAGE_ARGUMENT_ARRAY,
		     NULL, GetLastError (), 0, (LPTSTR)&msg, 0, NULL);
      message (true, "%s: error starting emacs daemon (%s)\n", progname, msg);
      exit (EXIT_FAILURE);
    }

  w32_daemon_event = CreateEvent (NULL, TRUE, FALSE, W32_DAEMON_EVENT);
  if (w32_daemon_event == NULL)
    {
      message (true, "Couldn't create Windows daemon event");
      exit (EXIT_FAILURE);
    }
  if ((wait_result = WaitForSingleObject (w32_daemon_event, INFINITE))
      != WAIT_OBJECT_0)
    {
      const char *msg = NULL;

      switch (wait_result)
	{
	case WAIT_ABANDONED:
	  msg = "The daemon exited unexpectedly";
	  break;
	case WAIT_TIMEOUT:
	  /* Can't happen due to INFINITE.  */
	default:
	case WAIT_FAILED:
	  FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
			 | FORMAT_MESSAGE_ALLOCATE_BUFFER
			 | FORMAT_MESSAGE_ARGUMENT_ARRAY,
			 NULL, GetLastError (), 0, (LPTSTR)&msg, 0, NULL);
	  break;
	}
      message (true, "Error: Could not start the Emacs daemon: %s\n", msg);
      exit (EXIT_FAILURE);
    }
  CloseHandle (w32_daemon_event);

  /* Try connecting, the daemon should have started by now.  */
  /* It's just a progress message, so don't pop a dialog if this is
     emacsclientw.  */
  if (!quiet && !w32_window_app ())
    message (true,
	     "Emacs daemon should have started, trying to connect again\n");
#endif /* WINDOWSNT */

  HSOCKET emacs_socket = set_socket (true);
  if (emacs_socket == INVALID_SOCKET)
    {
      message (true,
	       "Error: Cannot connect even after starting the Emacs daemon\n");
      exit (EXIT_FAILURE);
    }
  return emacs_socket;
}

static void
set_socket_timeout (HSOCKET socket, int seconds)
{
  int ret;

#ifndef WINDOWSNT
  struct timeval timeout;
  timeout.tv_sec = seconds;
  timeout.tv_usec = 0;
  ret = setsockopt (socket, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof timeout);
#else
  DWORD timeout;

  if (seconds > INT_MAX / 1000)
    timeout = INT_MAX;
  else
    timeout = seconds * 1000;
  ret = setsockopt (socket, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, sizeof timeout);
#endif

  if (ret < 0)
    sock_err_message ("setsockopt");
}

static bool
check_socket_timeout (int rl)
{
#ifndef WINDOWSNT
  return (rl == -1)
    && (errno == EAGAIN)
    && (errno == EWOULDBLOCK);
#else
  return (rl == SOCKET_ERROR)
    && (WSAGetLastError() == WSAETIMEDOUT);
#endif
}

int
main (int argc, char **argv)
{
  main_argc = argc;
  main_argv = argv;
  progname = argv[0] ? argv[0] : "emacsclient";

  int rl = 0;
  bool skiplf = true;
  char string[BUFSIZ + 1];
  int exit_status = EXIT_SUCCESS;

#ifdef HAVE_NTGUI
  /* On Windows 7 and later, we need to explicitly associate
     emacsclient with emacs so the UI behaves sensibly.  This
     association does no harm if we're not actually connecting to an
     Emacs using a window display.  */
  w32_set_user_model_id ();
#endif

  /* Process options.  */
  decode_options (argc, argv);

  if (! (optind < argc || eval || create_frame))
    {
      message (true, ("%s: file name or argument required\n"
		      "Try '%s --help' for more information\n"),
	       progname, progname);
      exit (EXIT_FAILURE);
    }

#ifdef SOCKETS_IN_FILE_SYSTEM
  if (tty)
    {
      pid_t grouping = process_grouping ();
      if (grouping < 0)
	kill (grouping, SIGTTIN);
    }
#endif

  /* If alternate_editor is the empty string, start the emacs daemon
     in case of failure to connect.  */
  bool start_daemon_if_needed = alternate_editor && !alternate_editor[0];

  HSOCKET emacs_socket = set_socket (alternate_editor
				     || start_daemon_if_needed);
  if (emacs_socket == INVALID_SOCKET)
    {
      if (! start_daemon_if_needed)
	fail ();

      emacs_socket = start_daemon_and_retry_set_socket ();
    }

  char *cwd = get_current_dir_name ();
  if (cwd == 0)
    {
      message (true, "%s: %s\n", progname,
	       "Cannot get current working directory");
      fail ();
    }

#ifdef HAVE_NTGUI
  if (display && !strcmp (display, "w32"))
  w32_give_focus ();
#endif

  /* Send over our environment and current directory. */
  if (create_frame)
    {
      for (char *const *e = environ; *e; e++)
        {
          send_to_emacs (emacs_socket, "-env ");
          quote_argument (emacs_socket, *e);
          send_to_emacs (emacs_socket, " ");
        }
    }
  send_to_emacs (emacs_socket, "-dir ");
  if (tramp_prefix)
    quote_argument (emacs_socket, tramp_prefix);
  quote_argument (emacs_socket, cwd);
  free (cwd);
  send_to_emacs (emacs_socket, "/");
  send_to_emacs (emacs_socket, " ");

 retry:
  if (nowait)
    send_to_emacs (emacs_socket, "-nowait ");

  if (!create_frame || reuse_frame)
    send_to_emacs (emacs_socket, "-current-frame ");

  if (display)
    {
      send_to_emacs (emacs_socket, "-display ");
      quote_argument (emacs_socket, display);
      send_to_emacs (emacs_socket, " ");
    }

  if (parent_id)
    {
      send_to_emacs (emacs_socket, "-parent-id ");
      quote_argument (emacs_socket, parent_id);
      send_to_emacs (emacs_socket, " ");
    }

  if (frame_parameters && create_frame)
    {
      send_to_emacs (emacs_socket, "-frame-parameters ");
      quote_argument (emacs_socket, frame_parameters);
      send_to_emacs (emacs_socket, " ");
    }

  /* Unless we are certain we don't want to occupy the tty, send our
     tty information to Emacs.  For example, in daemon mode Emacs may
     need to occupy this tty if no other frame is available.  */
  if (create_frame || !eval)
    {
      const char *tty_type, *tty_name;

      if (find_tty (&tty_type, &tty_name, !tty))
	{
	  /* Install signal handlers before opening a frame on the
	     current tty.  */
	  init_signals ();

	  send_to_emacs (emacs_socket, "-tty ");
	  quote_argument (emacs_socket, tty_name);
	  send_to_emacs (emacs_socket, " ");
	  quote_argument (emacs_socket, tty_type);
	  send_to_emacs (emacs_socket, " ");
	}
    }

  if (create_frame && !tty)
    send_to_emacs (emacs_socket, "-window-system ");

  if (optind < argc)
    {
      for (int i = optind; i < argc; i++)
	{

	  if (eval)
            {
              /* Don't prepend cwd or anything like that.  */
              send_to_emacs (emacs_socket, "-eval ");
              quote_argument (emacs_socket, argv[i]);
              send_to_emacs (emacs_socket, " ");
              continue;
            }

	  char *p = argv[i];
	  if (*p == '+')
            {
	      unsigned char c;
	      do
		c = *++p;
	      while (isdigit (c) || c == ':');

	      if (c == 0)
                {
                  send_to_emacs (emacs_socket, "-position ");
                  quote_argument (emacs_socket, argv[i]);
                  send_to_emacs (emacs_socket, " ");
                  continue;
                }
            }
#ifdef WINDOWSNT
	  else if (! IS_ABSOLUTE_FILE_NAME (argv[i])
		   && (isalpha (argv[i][0]) && argv[i][1] == ':'))
	    /* Windows can have a different default directory for each
	       drive, so the cwd passed via "-dir" is not sufficient
	       to account for that.
	       If the user uses <drive>:<relpath>, we hence need to be
	       careful to expand <relpath> with the default directory
	       corresponding to <drive>.  */
	    {
	      char *filename = xmalloc (MAX_PATH);
	      DWORD size;

	      size = GetFullPathName (argv[i], MAX_PATH, filename, NULL);
	      if (size > 0 && size < MAX_PATH)
		argv[i] = filename;
	      else
		free (filename);
	    }
#endif

          send_to_emacs (emacs_socket, "-file ");
	  if (tramp_prefix && IS_ABSOLUTE_FILE_NAME (argv[i]))
	    quote_argument (emacs_socket, tramp_prefix);
          quote_argument (emacs_socket, argv[i]);
          send_to_emacs (emacs_socket, " ");
        }
    }
  else if (eval)
    {
      /* Read expressions interactively.  */
      while (fgets (string, BUFSIZ, stdin))
	{
	  send_to_emacs (emacs_socket, "-eval ");
	  quote_argument (emacs_socket, string);
	}
      send_to_emacs (emacs_socket, " ");
    }

  send_to_emacs (emacs_socket, "\n");

  /* Wait for an answer. */
  if (!eval && !tty && !nowait && !quiet && 0 <= process_grouping ())
    {
      printf ("Waiting for Emacs...");
      skiplf = false;
    }
  fflush (stdout);

  set_socket_timeout (emacs_socket, timeout > 0 ? timeout : DEFAULT_TIMEOUT);
  bool saw_response = false;
  /* Now, wait for an answer and print any messages.  */
  while (exit_status == EXIT_SUCCESS)
    {
      bool retry = true;
      bool msg_showed = quiet;
      do
	{
	  act_on_signals (emacs_socket);
	  rl = recv (emacs_socket, string, BUFSIZ, 0);
	  retry = check_socket_timeout (rl);
	  if (retry && !saw_response)
	    {
	      if (timeout > 0)
		{
		  /* Don't retry if we were given a --timeout flag.  */
		  fprintf (stderr, "\nServer not responding; timed out after %ju seconds",
			   timeout);
		  retry = false;
		}
	      else if (!msg_showed)
		{
		  msg_showed = true;
		  fprintf (stderr, "\nServer not responding; use Ctrl+C to break");
		}
	    }
	}
      while ((rl < 0 && errno == EINTR) || retry);

      if (rl <= 0)
        break;

      saw_response = true;
      string[rl] = '\0';

      /* Loop over all NL-terminated messages.  */
      char *p = string;
      for (char *end_p = p; end_p && *end_p != '\0'; p = end_p)
	{
	  end_p = strchr (p, '\n');
	  if (end_p != NULL)
	    *end_p++ = '\0';

          if (strprefix ("-emacs-pid ", p))
            {
              /* -emacs-pid PID: The process id of the Emacs process. */
	      emacs_pid = strtoumax (p + strlen ("-emacs-pid"), NULL, 10);
            }
          else if (strprefix ("-window-system-unsupported ", p))
            {
              /* -window-system-unsupported: Emacs was compiled without support
                 for whatever window system we tried.  Try the alternate
                 display, or, failing that, try the terminal.  */
              if (alt_display)
                {
                  display = alt_display;
                  alt_display = NULL;
                }
              else
                {
                  nowait = false;
                  tty = true;
                }

              goto retry;
            }
          else if (strprefix ("-print ", p))
            {
              /* -print STRING: Print STRING on the terminal. */
	      if (!suppress_output)
		{
		  char *str = unquote_argument (p + strlen ("-print "));
		  printf (&"\n%s"[skiplf], str);
		  if (str[0])
		    skiplf = str[strlen (str) - 1] == '\n';
		}
	    }
          else if (strprefix ("-print-nonl ", p))
            {
              /* -print-nonl STRING: Print STRING on the terminal.
                 Used to continue a preceding -print command.  */
	      if (!suppress_output)
		{
		  char *str = unquote_argument (p + strlen ("-print-nonl "));
		  printf ("%s", str);
		  if (str[0])
		    skiplf = str[strlen (str) - 1] == '\n';
		}
            }
          else if (strprefix ("-error ", p))
            {
              /* -error DESCRIPTION: Signal an error on the terminal. */
              char *str = unquote_argument (p + strlen ("-error "));
              if (!skiplf)
                printf ("\n");
	      message (true, "*ERROR*: %s", str);
              if (str[0])
	        skiplf = str[strlen (str) - 1] == '\n';
              exit_status = EXIT_FAILURE;
            }
#ifndef WINDOWSNT
	  else if (strprefix ("-suspend ", p))
	    {
	      /* -suspend: Suspend this terminal, i.e., stop the process. */
	      if (!skiplf)
		printf ("\n");
	      skiplf = true;
	      kill (0, SIGSTOP);
	    }
#endif
	  else
	    {
	      /* Unknown command. */
	      printf (&"\n*ERROR*: Unknown message: %s\n"[skiplf], p);
	      skiplf = true;
	    }
	}
    }

  if (!skiplf && 0 <= process_grouping ())
    printf ("\n");

  if (rl < 0)
    exit_status = EXIT_FAILURE;

  CLOSE_SOCKET (emacs_socket);
  return exit_status;
}
