lib-src/emacsclient.c

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