lib-src/emacsclient.c

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