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