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