lib-src/emacsclient.c

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