lib-src/emacsclient.c

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