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