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