code.delx.au - gnu-emacs/blob - 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 #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             size_t n = confstr (_CS_DARWIN_USER_TEMP_DIR, NULL, (size_t) 0);
1229             if (n > 0)
1230               {
1231                 tmpdir = alloca (n);
1232                 confstr (_CS_DARWIN_USER_TEMP_DIR, tmpdir, n);
1233               }
1234             else
1235 #endif
1236               tmpdir = "/tmp";
1237           }
1238         socket_name = alloca (strlen (tmpdir) + strlen (server_name)
1239                               + EXTRA_SPACE);
1240         sprintf (socket_name, "%s/emacs%d/%s",
1241                  tmpdir, (int) geteuid (), server_name);
1242       }
1243
1244     if (strlen (socket_name) < sizeof (server.sun_path))
1245       strcpy (server.sun_path, socket_name);
1246     else
1247       {
1248         message (TRUE, "%s: socket-name %s too long\n",
1249                  progname, socket_name);
1250         fail ();
1251       }
1252
1253     /* See if the socket exists, and if it's owned by us. */
1254     sock_status = socket_status (server.sun_path);
1255     saved_errno = errno;
1256     if (sock_status && default_sock)
1257       {
1258         /* Failing that, see if LOGNAME or USER exist and differ from
1259            our euid.  If so, look for a socket based on the UID
1260            associated with the name.  This is reminiscent of the logic
1261            that init_editfns uses to set the global Vuser_full_name.  */
1262
1263         char *user_name = (char *) egetenv ("LOGNAME");
1264
1265         if (!user_name)
1266           user_name = (char *) egetenv ("USER");
1267
1268         if (user_name)
1269           {
1270             struct passwd *pw = getpwnam (user_name);
1271
1272             if (pw && (pw->pw_uid != geteuid ()))
1273               {
1274                 /* We're running under su, apparently. */
1275                 socket_name = alloca (strlen (tmpdir) + strlen (server_name)
1276                                       + EXTRA_SPACE);
1277                 sprintf (socket_name, "%s/emacs%d/%s",
1278                          tmpdir, (int) pw->pw_uid, server_name);
1279
1280                 if (strlen (socket_name) < sizeof (server.sun_path))
1281                   strcpy (server.sun_path, socket_name);
1282                 else
1283                   {
1284                     message (TRUE, "%s: socket-name %s too long\n",
1285                              progname, socket_name);
1286                     exit (EXIT_FAILURE);
1287                   }
1288
1289                 sock_status = socket_status (server.sun_path);
1290                 saved_errno = errno;
1291               }
1292             else
1293               errno = saved_errno;
1294           }
1295       }
1296
1297     switch (sock_status)
1298       {
1299       case 1:
1300         /* There's a socket, but it isn't owned by us.  This is OK if
1301            we are root. */
1302         if (0 != geteuid ())
1303           {
1304             message (TRUE, "%s: Invalid socket owner\n", progname);
1305             return INVALID_SOCKET;
1306           }
1307         break;
1308
1309       case 2:
1310         /* `stat' failed */
1311         if (saved_errno == ENOENT)
1312           message (TRUE,
1313                    "%s: can't find socket; have you started the server?\n\
1314 To start the server in Emacs, type \"M-x server-start\".\n",
1315                    progname);
1316         else
1317           message (TRUE, "%s: can't stat %s: %s\n",
1318                    progname, server.sun_path, strerror (saved_errno));
1319         return INVALID_SOCKET;
1320       }
1321   }
1322
1323   if (connect (s, (struct sockaddr *) &server, strlen (server.sun_path) + 2)
1324       < 0)
1325     {
1326       message (TRUE, "%s: connect: %s\n", progname, strerror (errno));
1327       return INVALID_SOCKET;
1328     }
1329
1330   return s;
1331 }
1332 #endif /* ! NO_SOCKETS_IN_FILE_SYSTEM */
1333
1334 HSOCKET
1335 set_socket (int no_exit_if_error)
1336 {
1337   HSOCKET s;
1338
1339   INITIALIZE ();
1340
1341 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1342   /* Explicit --socket-name argument.  */
1343   if (socket_name)
1344     {
1345       s = set_local_socket ();
1346       if ((s != INVALID_SOCKET) || no_exit_if_error)
1347         return s;
1348       message (TRUE, "%s: error accessing socket \"%s\"\n",
1349                progname, socket_name);
1350       exit (EXIT_FAILURE);
1351     }
1352 #endif
1353
1354   /* Explicit --server-file arg or EMACS_SERVER_FILE variable.  */
1355   if (!server_file)
1356     server_file = egetenv ("EMACS_SERVER_FILE");
1357
1358   if (server_file)
1359     {
1360       s = set_tcp_socket ();
1361       if ((s != INVALID_SOCKET) || no_exit_if_error)
1362         return s;
1363
1364       message (TRUE, "%s: error accessing server file \"%s\"\n",
1365                progname, server_file);
1366       exit (EXIT_FAILURE);
1367     }
1368
1369 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1370   /* Implicit local socket.  */
1371   s = set_local_socket ();
1372   if (s != INVALID_SOCKET)
1373     return s;
1374 #endif
1375
1376   /* Implicit server file.  */
1377   server_file = "server";
1378   s = set_tcp_socket ();
1379   if ((s != INVALID_SOCKET) || no_exit_if_error)
1380     return s;
1381
1382   /* No implicit or explicit socket, and no alternate editor.  */
1383   message (TRUE, "%s: No socket or alternate editor.  Please use:\n\n"
1384 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1385 "\t--socket-name\n"
1386 #endif
1387 "\t--server-file      (or environment variable EMACS_SERVER_FILE)\n\
1388 \t--alternate-editor (or environment variable ALTERNATE_EDITOR)\n",
1389            progname);
1390   exit (EXIT_FAILURE);
1391 }
1392
1393 #ifdef WINDOWSNT
1394 FARPROC set_fg;  /* Pointer to AllowSetForegroundWindow.  */
1395 FARPROC get_wc;  /* Pointer to RealGetWindowClassA.  */
1396
1397 BOOL CALLBACK
1398 w32_find_emacs_process (HWND hWnd, LPARAM lParam)
1399 {
1400   DWORD pid;
1401   char class[6];
1402
1403   /* Reject any window not of class "Emacs".  */
1404   if (! get_wc (hWnd, class, sizeof (class))
1405       || strcmp (class, "Emacs"))
1406     return TRUE;
1407
1408   /* We only need the process id, not the thread id.  */
1409   (void) GetWindowThreadProcessId (hWnd, &pid);
1410
1411   /* Not the one we're looking for.  */
1412   if (pid != (DWORD) emacs_pid) return TRUE;
1413
1414   /* OK, let's raise it.  */
1415   set_fg (emacs_pid);
1416
1417   /* Stop enumeration.  */
1418   return FALSE;
1419 }
1420
1421 /*
1422  * Search for a window of class "Emacs" and owned by a process with
1423  * process id = emacs_pid.  If found, allow it to grab the focus.
1424  */
1425 void
1426 w32_give_focus (void)
1427 {
1428   HANDLE user32;
1429
1430   /* It shouldn't happen when dealing with TCP sockets.  */
1431   if (!emacs_pid) return;
1432
1433   user32 = GetModuleHandle ("user32.dll");
1434
1435   if (!user32)
1436     return;
1437
1438   /* Modern Windows restrict which processes can set the foreground window.
1439      emacsclient can allow Emacs to grab the focus by calling the function
1440      AllowSetForegroundWindow.  Unfortunately, older Windows (W95, W98 and
1441      NT) lack this function, so we have to check its availability.  */
1442   if ((set_fg = GetProcAddress (user32, "AllowSetForegroundWindow"))
1443       && (get_wc = GetProcAddress (user32, "RealGetWindowClassA")))
1444     EnumWindows (w32_find_emacs_process, (LPARAM) 0);
1445 }
1446 #endif
1447
1448 /* Start the emacs daemon and try to connect to it.  */
1449
1450 void
1451 start_daemon_and_retry_set_socket (void)
1452 {
1453 #ifndef WINDOWSNT
1454   pid_t dpid;
1455   int status;
1456
1457   dpid = fork ();
1458
1459   if (dpid > 0)
1460     {
1461       pid_t w;
1462       w = waitpid (dpid, &status, WUNTRACED | WCONTINUED);
1463
1464       if ((w == -1) || !WIFEXITED (status) || WEXITSTATUS (status))
1465         {
1466           message (TRUE, "Error: Could not start the Emacs daemon\n");
1467           exit (EXIT_FAILURE);
1468         }
1469
1470       /* Try connecting, the daemon should have started by now.  */
1471       message (TRUE, "Emacs daemon should have started, trying to connect again\n");
1472       if ((emacs_socket = set_socket (1)) == INVALID_SOCKET)
1473         {
1474           message (TRUE, "Error: Cannot connect even after starting the Emacs daemon\n");
1475           exit (EXIT_FAILURE);
1476         }
1477     }
1478   else if (dpid < 0)
1479     {
1480       fprintf (stderr, "Error: Cannot fork!\n");
1481       exit (EXIT_FAILURE);
1482     }
1483   else
1484     {
1485       char emacs[] = "emacs";
1486       char daemon[] = "--daemon";
1487       char *d_argv[] = {emacs, daemon, 0 };
1488       if (socket_name != NULL)
1489         {
1490           /* Pass  --daemon=socket_name as argument.  */
1491           const char *deq = "--daemon=";
1492           char *daemon_arg = alloca (strlen (deq)
1493                                      + strlen (socket_name) + 1);
1494           strcpy (daemon_arg, deq);
1495           strcat (daemon_arg, socket_name);
1496           d_argv[1] = daemon_arg;
1497         }
1498       execvp ("emacs", d_argv);
1499       message (TRUE, "%s: error starting emacs daemon\n", progname);
1500     }
1501 #endif /* WINDOWSNT */
1502 }
1503
1504 int
1505 main (int argc, char **argv)
1506 {
1507   int i, rl, needlf = 0;
1508   char *cwd, *str;
1509   char string[BUFSIZ+1];
1510   int null_socket_name, null_server_file, start_daemon_if_needed;
1511   int exit_status = EXIT_SUCCESS;
1512
1513   main_argv = argv;
1514   progname = argv[0];
1515
1516 #ifdef WINDOWSNT
1517   /* On Windows 7 and later, we need to explicitly associate emacsclient
1518      with emacs so the UI behaves sensibly.  */
1519   w32_set_user_model_id ();
1520 #endif
1521
1522   /* Process options.  */
1523   decode_options (argc, argv);
1524
1525   if ((argc - optind < 1) && !eval && current_frame)
1526     {
1527       message (TRUE, "%s: file name or argument required\n"
1528                "Try `%s --help' for more information\n",
1529                progname, progname);
1530       exit (EXIT_FAILURE);
1531     }
1532
1533   /* If alternate_editor is the empty string, start the emacs daemon
1534      in case of failure to connect.  */
1535   start_daemon_if_needed = (alternate_editor
1536                             && (alternate_editor[0] == '\0'));
1537   if (start_daemon_if_needed)
1538     {
1539       /* set_socket changes the values for socket_name and
1540          server_file, we need to reset them, if they were NULL before
1541          for the second call to set_socket.  */
1542       null_socket_name = (socket_name == NULL);
1543       null_server_file = (server_file == NULL);
1544     }
1545
1546   if ((emacs_socket = set_socket (alternate_editor
1547                                   || start_daemon_if_needed)) == INVALID_SOCKET)
1548     if (start_daemon_if_needed)
1549       {
1550         /* Reset socket_name and server_file if they were NULL
1551            before the set_socket call.  */
1552         if (null_socket_name)
1553           socket_name = NULL;
1554         if (null_server_file)
1555           server_file = NULL;
1556
1557         start_daemon_and_retry_set_socket ();
1558       }
1559     else
1560       fail ();
1561
1562   cwd = get_current_dir_name ();
1563   if (cwd == 0)
1564     {
1565       /* getwd puts message in STRING if it fails.  */
1566       message (TRUE, "%s: %s\n", progname,
1567                "Cannot get current working directory");
1568       fail ();
1569     }
1570
1571 #ifdef WINDOWSNT
1572   w32_give_focus ();
1573 #endif
1574
1575   /* Send over our environment and current directory. */
1576   if (!current_frame)
1577     {
1578       extern char **environ;
1579       int i;
1580       for (i = 0; environ[i]; i++)
1581         {
1582           send_to_emacs (emacs_socket, "-env ");
1583           quote_argument (emacs_socket, environ[i]);
1584           send_to_emacs (emacs_socket, " ");
1585         }
1586     }
1587   send_to_emacs (emacs_socket, "-dir ");
1588   quote_argument (emacs_socket, cwd);
1589   send_to_emacs (emacs_socket, "/");
1590   send_to_emacs (emacs_socket, " ");
1591
1592  retry:
1593   if (nowait)
1594     send_to_emacs (emacs_socket, "-nowait ");
1595
1596   if (current_frame)
1597     send_to_emacs (emacs_socket, "-current-frame ");
1598
1599   if (display)
1600     {
1601       send_to_emacs (emacs_socket, "-display ");
1602       quote_argument (emacs_socket, display);
1603       send_to_emacs (emacs_socket, " ");
1604     }
1605
1606   if (parent_id)
1607     {
1608       send_to_emacs (emacs_socket, "-parent-id ");
1609       quote_argument (emacs_socket, parent_id);
1610       send_to_emacs (emacs_socket, " ");
1611     }
1612
1613   /* If using the current frame, send tty information to Emacs anyway.
1614      In daemon mode, Emacs may need to occupy this tty if no other
1615      frame is available.  */
1616   if (tty || (current_frame && !eval))
1617     {
1618       char *tty_type, *tty_name;
1619
1620       if (find_tty (&tty_type, &tty_name, !tty))
1621         {
1622 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1623           init_signals ();
1624 #endif
1625           send_to_emacs (emacs_socket, "-tty ");
1626           quote_argument (emacs_socket, tty_name);
1627           send_to_emacs (emacs_socket, " ");
1628           quote_argument (emacs_socket, tty_type);
1629           send_to_emacs (emacs_socket, " ");
1630         }
1631     }
1632
1633   if (!current_frame && !tty)
1634     send_to_emacs (emacs_socket, "-window-system ");
1635
1636   if ((argc - optind > 0))
1637     {
1638       for (i = optind; i < argc; i++)
1639         {
1640
1641           if (eval)
1642             {
1643               /* Don't prepend cwd or anything like that.  */
1644               send_to_emacs (emacs_socket, "-eval ");
1645               quote_argument (emacs_socket, argv[i]);
1646               send_to_emacs (emacs_socket, " ");
1647               continue;
1648             }
1649
1650           if (*argv[i] == '+')
1651             {
1652               char *p = argv[i] + 1;
1653               while (isdigit ((unsigned char) *p) || *p == ':') p++;
1654               if (*p == 0)
1655                 {
1656                   send_to_emacs (emacs_socket, "-position ");
1657                   quote_argument (emacs_socket, argv[i]);
1658                   send_to_emacs (emacs_socket, " ");
1659                   continue;
1660                 }
1661             }
1662 #ifdef WINDOWSNT
1663           else if (! file_name_absolute_p (argv[i])
1664                    && (isalpha (argv[i][0]) && argv[i][1] == ':'))
1665             /* Windows can have a different default directory for each
1666                drive, so the cwd passed via "-dir" is not sufficient
1667                to account for that.
1668                If the user uses <drive>:<relpath>, we hence need to be
1669                careful to expand <relpath> with the default directory
1670                corresponding to <drive>.  */
1671             {
1672               char *filename = (char *) xmalloc (MAX_PATH);
1673               DWORD size;
1674
1675               size = GetFullPathName (argv[i], MAX_PATH, filename, NULL);
1676               if (size > 0 && size < MAX_PATH)
1677                 argv[i] = filename;
1678               else
1679                 free (filename);
1680             }
1681 #endif
1682
1683           send_to_emacs (emacs_socket, "-file ");
1684           quote_argument (emacs_socket, argv[i]);
1685           send_to_emacs (emacs_socket, " ");
1686         }
1687     }
1688   else if (eval)
1689     {
1690       /* Read expressions interactively.  */
1691       while ((str = fgets (string, BUFSIZ, stdin)))
1692         {
1693           send_to_emacs (emacs_socket, "-eval ");
1694           quote_argument (emacs_socket, str);
1695         }
1696       send_to_emacs (emacs_socket, " ");
1697     }
1698
1699   send_to_emacs (emacs_socket, "\n");
1700
1701   /* Wait for an answer. */
1702   if (!eval && !tty && !nowait)
1703     {
1704       printf ("Waiting for Emacs...");
1705       needlf = 2;
1706     }
1707   fflush (stdout);
1708   fsync (1);
1709
1710   /* Now, wait for an answer and print any messages.  */
1711   while (exit_status == EXIT_SUCCESS
1712          && (rl = recv (emacs_socket, string, BUFSIZ, 0)) > 0)
1713     {
1714       char *p;
1715       string[rl] = '\0';
1716
1717       p = string + strlen (string) - 1;
1718       while (p > string && *p == '\n')
1719         *p-- = 0;
1720
1721       if (strprefix ("-emacs-pid ", string))
1722         {
1723           /* -emacs-pid PID: The process id of the Emacs process. */
1724           emacs_pid = strtol (string + strlen ("-emacs-pid"), NULL, 10);
1725         }
1726       else if (strprefix ("-window-system-unsupported ", string))
1727         {
1728           /* -window-system-unsupported: Emacs was compiled without X
1729               support.  Try again on the terminal. */
1730           nowait = 0;
1731           tty = 1;
1732           goto retry;
1733         }
1734       else if (strprefix ("-print ", string))
1735         {
1736           /* -print STRING: Print STRING on the terminal. */
1737           str = unquote_argument (string + strlen ("-print "));
1738           if (needlf)
1739             printf ("\n");
1740           printf ("%s", str);
1741           needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1742         }
1743       else if (strprefix ("-error ", string))
1744         {
1745           /* -error DESCRIPTION: Signal an error on the terminal. */
1746           str = unquote_argument (string + strlen ("-error "));
1747           if (needlf)
1748             printf ("\n");
1749           fprintf (stderr, "*ERROR*: %s", str);
1750           needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1751           exit_status = EXIT_FAILURE;
1752         }
1753 #ifdef SIGSTOP
1754       else if (strprefix ("-suspend ", string))
1755         {
1756           /* -suspend: Suspend this terminal, i.e., stop the process. */
1757           if (needlf)
1758             printf ("\n");
1759           needlf = 0;
1760           kill (0, SIGSTOP);
1761         }
1762 #endif
1763       else
1764         {
1765           /* Unknown command. */
1766           if (needlf)
1767             printf ("\n");
1768           printf ("*ERROR*: Unknown message: %s", string);
1769           needlf = string[0]
1770             == '\0' ? needlf : string[strlen (string) - 1] != '\n';
1771         }
1772     }
1773
1774   if (needlf)
1775     printf ("\n");
1776   fflush (stdout);
1777   fsync (1);
1778
1779   if (rl < 0)
1780     exit_status = EXIT_FAILURE;
1781
1782   CLOSE_SOCKET (emacs_socket);
1783   return exit_status;
1784 }
1785
1786 #endif /* HAVE_SOCKETS && HAVE_INET_SOCKETS */
1787
1788 \f
1789 #ifndef HAVE_STRERROR
1790 char *
1791 strerror (errnum)
1792      int errnum;
1793 {
1794   extern char *sys_errlist[];
1795   extern int sys_nerr;
1796
1797   if (errnum >= 0 && errnum < sys_nerr)
1798     return sys_errlist[errnum];
1799   return (char *) "Unknown error";
1800 }
1801
1802 #endif /* ! HAVE_STRERROR */
1803
1804 /* arch-tag: f39bb9c4-73eb-477e-896d-50832e2ca9a7
1805    (do not change this comment) */
1806
1807 /* emacsclient.c ends here */