lib-src/emacsclient.c

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