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 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 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, 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 (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, 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, char *str)
 791 {
 792   char *copy = (char *) xmalloc (strlen (str) * 2 + 1);
 793   char *p, *q;
 794
 795   p = str;
 796   q = copy;
 797   while (*p)
 798     {
 799       if (*p == ' ')
 800         {
 801           *q++ = '&';
 802           *q++ = '_';
 803           p++;
 804         }
 805       else if (*p == '\n')
 806         {
 807           *q++ = '&';
 808           *q++ = 'n';
 809           p++;
 810         }
 811       else
 812         {
 813           if (*p == '&' || (*p == '-' && p == str))
 814             *q++ = '&';
 815           *q++ = *p++;
 816         }
 817     }
 818   *q++ = 0;
 819
 820   send_to_emacs (s, copy);
 821
 822   free (copy);
 823 }
 824
 825
 826 /* The inverse of quote_argument.  Removes quoting in string STR by
 827    modifying the string in place.   Returns STR. */
 828
 829 char *
 830 unquote_argument (char *str)
 831 {
 832   char *p, *q;
 833
 834   if (! str)
 835     return str;
 836
 837   p = str;
 838   q = str;
 839   while (*p)
 840     {
 841       if (*p == '&')
 842         {
 843           p++;
 844           if (*p == '&')
 845             *p = '&';
 846           else if (*p == '_')
 847             *p = ' ';
 848           else if (*p == 'n')
 849             *p = '\n';
 850           else if (*p == '-')
 851             *p = '-';
 852         }
 853       *q++ = *p++;
 854     }
 855   *q = 0;
 856   return str;
 857 }
 858
 859 \f
 860 int
 861 file_name_absolute_p (const unsigned char *filename)
 862 {
 863   /* Sanity check, it shouldn't happen.  */
 864   if (! filename) return FALSE;
 865
 866   /* /xxx is always an absolute path.  */
 867   if (filename[0] == '/') return TRUE;
 868
 869   /* Empty filenames (which shouldn't happen) are relative.  */
 870   if (filename[0] == '\0') return FALSE;
 871
 872 #ifdef WINDOWSNT
 873   /* X:\xxx is always absolute.  */
 874   if (isalpha (filename[0])
 875       && filename[1] == ':' && (filename[2] == '\\' || filename[2] == '/'))
 876     return TRUE;
 877
 878   /* Both \xxx and \\xxx\yyy are absolute.  */
 879   if (filename[0] == '\\') return TRUE;
 880 #endif
 881
 882   return FALSE;
 883 }
 884
 885 #ifdef WINDOWSNT
 886 /* Wrapper to make WSACleanup a cdecl, as required by atexit.  */
 887 void __cdecl
 888 close_winsock (void)
 889 {
 890   WSACleanup ();
 891 }
 892
 893 /* Initialize the WinSock2 library.  */
 894 void
 895 initialize_sockets (void)
 896 {
 897   WSADATA wsaData;
 898
 899   if (WSAStartup (MAKEWORD (2, 0), &wsaData))
 900     {
 901       message (TRUE, "%s: error initializing WinSock2\n", progname);
 902       exit (EXIT_FAILURE);
 903     }
 904
 905   atexit (close_winsock);
 906 }
 907 #endif /* WINDOWSNT */
 908
 909 \f
 910 /*
 911  * Read the information needed to set up a TCP comm channel with
 912  * the Emacs server: host, port, pid and authentication string.
 913  */
 914 int
 915 get_server_config (struct sockaddr_in *server, char *authentication)
 916 {
 917   char dotted[32];
 918   char *port;
 919   char *pid;
 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       && (pid = strchr (port, ' ')))
 952     {
 953       *port++ = '\0';
 954       *pid++  = '\0';
 955     }
 956   else
 957     {
 958       message (TRUE, "%s: invalid configuration info\n", progname);
 959       exit (EXIT_FAILURE);
 960     }
 961
 962   server->sin_family = AF_INET;
 963   server->sin_addr.s_addr = inet_addr (dotted);
 964   server->sin_port = htons (atoi (port));
 965
 966   if (! fread (authentication, AUTH_KEY_LENGTH, 1, config))
 967     {
 968       message (TRUE, "%s: cannot read authentication info\n", progname);
 969       exit (EXIT_FAILURE);
 970     }
 971
 972   fclose (config);
 973
 974   emacs_pid = atoi (pid);
 975
 976   return TRUE;
 977 }
 978
 979 HSOCKET
 980 set_tcp_socket (void)
 981 {
 982   HSOCKET s;
 983   struct sockaddr_in server;
 984   struct linger l_arg = {1, 1};
 985   char auth_string[AUTH_KEY_LENGTH + 1];
 986
 987   if (! get_server_config (&server, auth_string))
 988     return INVALID_SOCKET;
 989
 990   if (server.sin_addr.s_addr != inet_addr ("127.0.0.1"))
 991     message (FALSE, "%s: connected to remote socket at %s\n",
 992              progname, inet_ntoa (server.sin_addr));
 993
 994   /*
 995    * Open up an AF_INET socket
 996    */
 997   if ((s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
 998     {
 999       sock_err_message ("socket");
1000       return INVALID_SOCKET;
1001     }
1002
1003   /*
1004    * Set up the socket
1005    */
1006   if (connect (s, (struct sockaddr *) &server, sizeof server) < 0)
1007     {
1008       sock_err_message ("connect");
1009       return INVALID_SOCKET;
1010     }
1011
1012   setsockopt (s, SOL_SOCKET, SO_LINGER, (char *) &l_arg, sizeof l_arg);
1013
1014   /*
1015    * Send the authentication
1016    */
1017   auth_string[AUTH_KEY_LENGTH] = '\0';
1018
1019   send_to_emacs (s, "-auth ");
1020   send_to_emacs (s, auth_string);
1021   send_to_emacs (s, " ");
1022
1023   return s;
1024 }
1025
1026
1027 /* Returns 1 if PREFIX is a prefix of STRING. */
1028 static int
1029 strprefix (char *prefix, char *string)
1030 {
1031   return !strncmp (prefix, string, strlen (prefix));
1032 }
1033
1034 /* Get tty name and type.  If successful, return the type in TTY_TYPE
1035    and the name in TTY_NAME, and return 1.  Otherwise, fail if NOABORT
1036    is zero, or return 0 if NOABORT is non-zero.  */
1037
1038 int
1039 find_tty (char **tty_type, char **tty_name, int noabort)
1040 {
1041   char *type = egetenv ("TERM");
1042   char *name = ttyname (fileno (stdout));
1043
1044   if (!name)
1045     {
1046       if (noabort)
1047         return 0;
1048       else
1049         {
1050           message (TRUE, "%s: could not get terminal name\n", progname);
1051           fail ();
1052         }
1053     }
1054
1055   if (!type)
1056     {
1057       if (noabort)
1058         return 0;
1059       else
1060         {
1061           message (TRUE, "%s: please set the TERM variable to your terminal type\n",
1062                    progname);
1063           fail ();
1064         }
1065     }
1066
1067   if (strcmp (type, "eterm") == 0)
1068     {
1069       if (noabort)
1070         return 0;
1071       else
1072         {
1073           /* This causes nasty, MULTI_KBOARD-related input lockouts. */
1074           message (TRUE, "%s: opening a frame in an Emacs term buffer"
1075                    " is not supported\n", progname);
1076           fail ();
1077         }
1078     }
1079
1080   *tty_name = name;
1081   *tty_type = type;
1082   return 1;
1083 }
1084
1085
1086 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1087
1088 /* Three possibilities:
1089    2 - can't be `stat'ed                (sets errno)
1090    1 - isn't owned by us
1091    0 - success: none of the above */
1092
1093 static int
1094 socket_status (char *socket_name)
1095 {
1096   struct stat statbfr;
1097
1098   if (stat (socket_name, &statbfr) == -1)
1099     return 2;
1100
1101   if (statbfr.st_uid != geteuid ())
1102     return 1;
1103
1104   return 0;
1105 }
1106
1107 \f
1108 /* A signal handler that passes the signal to the Emacs process.
1109    Useful for SIGWINCH.  */
1110
1111 SIGTYPE
1112 pass_signal_to_emacs (int signalnum)
1113 {
1114   int old_errno = errno;
1115
1116   if (emacs_pid)
1117     kill (emacs_pid, signalnum);
1118
1119   signal (signalnum, pass_signal_to_emacs);
1120   errno = old_errno;
1121 }
1122
1123 /* Signal handler for SIGCONT; notify the Emacs process that it can
1124    now resume our tty frame.  */
1125
1126 SIGTYPE
1127 handle_sigcont (int signalnum)
1128 {
1129   int old_errno = errno;
1130
1131   if (tcgetpgrp (1) == getpgrp ())
1132     {
1133       /* We are in the foreground. */
1134       send_to_emacs (emacs_socket, "-resume \n");
1135     }
1136   else
1137     {
1138       /* We are in the background; cancel the continue. */
1139       kill (getpid (), SIGSTOP);
1140     }
1141
1142   signal (signalnum, handle_sigcont);
1143   errno = old_errno;
1144 }
1145
1146 /* Signal handler for SIGTSTP; notify the Emacs process that we are
1147    going to sleep.  Normally the suspend is initiated by Emacs via
1148    server-handle-suspend-tty, but if the server gets out of sync with
1149    reality, we may get a SIGTSTP on C-z.  Handling this signal and
1150    notifying Emacs about it should get things under control again. */
1151
1152 SIGTYPE
1153 handle_sigtstp (int signalnum)
1154 {
1155   int old_errno = errno;
1156   sigset_t set;
1157
1158   if (emacs_socket)
1159     send_to_emacs (emacs_socket, "-suspend \n");
1160
1161   /* Unblock this signal and call the default handler by temporarily
1162      changing the handler and resignalling. */
1163   sigprocmask (SIG_BLOCK, NULL, &set);
1164   sigdelset (&set, signalnum);
1165   signal (signalnum, SIG_DFL);
1166   kill (getpid (), signalnum);
1167   sigprocmask (SIG_SETMASK, &set, NULL); /* Let's the above signal through. */
1168   signal (signalnum, handle_sigtstp);
1169
1170   errno = old_errno;
1171 }
1172
1173
1174 /* Set up signal handlers before opening a frame on the current tty.  */
1175
1176 void
1177 init_signals (void)
1178 {
1179   /* Set up signal handlers. */
1180   signal (SIGWINCH, pass_signal_to_emacs);
1181
1182   /* Don't pass SIGINT and SIGQUIT to Emacs, because it has no way of
1183      deciding which terminal the signal came from.  C-g is now a
1184      normal input event on secondary terminals.  */
1185 #if 0
1186   signal (SIGINT, pass_signal_to_emacs);
1187   signal (SIGQUIT, pass_signal_to_emacs);
1188 #endif
1189
1190   signal (SIGCONT, handle_sigcont);
1191   signal (SIGTSTP, handle_sigtstp);
1192   signal (SIGTTOU, handle_sigtstp);
1193 }
1194
1195
1196 HSOCKET
1197 set_local_socket (void)
1198 {
1199   HSOCKET s;
1200   struct sockaddr_un server;
1201
1202   /*
1203    * Open up an AF_UNIX socket in this person's home directory
1204    */
1205
1206   if ((s = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
1207     {
1208       message (TRUE, "%s: socket: %s\n", progname, strerror (errno));
1209       return INVALID_SOCKET;
1210     }
1211
1212   server.sun_family = AF_UNIX;
1213
1214   {
1215     int sock_status = 0;
1216     int default_sock = !socket_name;
1217     int saved_errno = 0;
1218     char *server_name = "server";
1219     char *tmpdir;
1220
1221     if (socket_name && !strchr (socket_name, '/')
1222         && !strchr (socket_name, '\\'))
1223       {
1224         /* socket_name is a file name component.  */
1225         server_name = socket_name;
1226         socket_name = NULL;
1227         default_sock = 1;       /* Try both UIDs.  */
1228       }
1229
1230     if (default_sock)
1231       {
1232         tmpdir = egetenv ("TMPDIR");
1233         if (!tmpdir)
1234           tmpdir = "/tmp";
1235         socket_name = alloca (strlen (tmpdir) + strlen (server_name)
1236                               + EXTRA_SPACE);
1237         sprintf (socket_name, "%s/emacs%d/%s",
1238                  tmpdir, (int) geteuid (), server_name);
1239       }
1240
1241     if (strlen (socket_name) < sizeof (server.sun_path))
1242       strcpy (server.sun_path, socket_name);
1243     else
1244       {
1245         message (TRUE, "%s: socket-name %s too long\n",
1246                  progname, socket_name);
1247         fail ();
1248       }
1249
1250     /* See if the socket exists, and if it's owned by us. */
1251     sock_status = socket_status (server.sun_path);
1252     saved_errno = errno;
1253     if (sock_status && default_sock)
1254       {
1255         /* Failing that, see if LOGNAME or USER exist and differ from
1256            our euid.  If so, look for a socket based on the UID
1257            associated with the name.  This is reminiscent of the logic
1258            that init_editfns uses to set the global Vuser_full_name.  */
1259
1260         char *user_name = (char *) egetenv ("LOGNAME");
1261
1262         if (!user_name)
1263           user_name = (char *) egetenv ("USER");
1264
1265         if (user_name)
1266           {
1267             struct passwd *pw = getpwnam (user_name);
1268
1269             if (pw && (pw->pw_uid != geteuid ()))
1270               {
1271                 /* We're running under su, apparently. */
1272                 socket_name = alloca (strlen (tmpdir) + strlen (server_name)
1273                                       + EXTRA_SPACE);
1274                 sprintf (socket_name, "%s/emacs%d/%s",
1275                          tmpdir, (int) pw->pw_uid, server_name);
1276
1277                 if (strlen (socket_name) < sizeof (server.sun_path))
1278                   strcpy (server.sun_path, socket_name);
1279                 else
1280                   {
1281                     message (TRUE, "%s: socket-name %s too long\n",
1282                              progname, socket_name);
1283                     exit (EXIT_FAILURE);
1284                   }
1285
1286                 sock_status = socket_status (server.sun_path);
1287                 saved_errno = errno;
1288               }
1289             else
1290               errno = saved_errno;
1291           }
1292       }
1293
1294     switch (sock_status)
1295       {
1296       case 1:
1297         /* There's a socket, but it isn't owned by us.  This is OK if
1298            we are root. */
1299         if (0 != geteuid ())
1300           {
1301             message (TRUE, "%s: Invalid socket owner\n", progname);
1302             return INVALID_SOCKET;
1303           }
1304         break;
1305
1306       case 2:
1307         /* `stat' failed */
1308         if (saved_errno == ENOENT)
1309           message (TRUE,
1310                    "%s: can't find socket; have you started the server?\n\
1311 To start the server in Emacs, type \"M-x server-start\".\n",
1312                    progname);
1313         else
1314           message (TRUE, "%s: can't stat %s: %s\n",
1315                    progname, server.sun_path, strerror (saved_errno));
1316         return INVALID_SOCKET;
1317       }
1318   }
1319
1320   if (connect (s, (struct sockaddr *) &server, strlen (server.sun_path) + 2)
1321       < 0)
1322     {
1323       message (TRUE, "%s: connect: %s\n", progname, strerror (errno));
1324       return INVALID_SOCKET;
1325     }
1326
1327   return s;
1328 }
1329 #endif /* ! NO_SOCKETS_IN_FILE_SYSTEM */
1330
1331 HSOCKET
1332 set_socket (int no_exit_if_error)
1333 {
1334   HSOCKET s;
1335
1336   INITIALIZE ();
1337
1338 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1339   /* Explicit --socket-name argument.  */
1340   if (socket_name)
1341     {
1342       s = set_local_socket ();
1343       if ((s != INVALID_SOCKET) || no_exit_if_error)
1344         return s;
1345       message (TRUE, "%s: error accessing socket \"%s\"\n",
1346                progname, socket_name);
1347       exit (EXIT_FAILURE);
1348     }
1349 #endif
1350
1351   /* Explicit --server-file arg or EMACS_SERVER_FILE variable.  */
1352   if (!server_file)
1353     server_file = egetenv ("EMACS_SERVER_FILE");
1354
1355   if (server_file)
1356     {
1357       s = set_tcp_socket ();
1358       if ((s != INVALID_SOCKET) || no_exit_if_error)
1359         return s;
1360
1361       message (TRUE, "%s: error accessing server file \"%s\"\n",
1362                progname, server_file);
1363       exit (EXIT_FAILURE);
1364     }
1365
1366 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1367   /* Implicit local socket.  */
1368   s = set_local_socket ();
1369   if (s != INVALID_SOCKET)
1370     return s;
1371 #endif
1372
1373   /* Implicit server file.  */
1374   server_file = "server";
1375   s = set_tcp_socket ();
1376   if ((s != INVALID_SOCKET) || no_exit_if_error)
1377     return s;
1378
1379   /* No implicit or explicit socket, and no alternate editor.  */
1380   message (TRUE, "%s: No socket or alternate editor.  Please use:\n\n"
1381 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1382 "\t--socket-name\n"
1383 #endif
1384 "\t--server-file      (or environment variable EMACS_SERVER_FILE)\n\
1385 \t--alternate-editor (or environment variable ALTERNATE_EDITOR)\n",
1386            progname);
1387   exit (EXIT_FAILURE);
1388 }
1389
1390 #ifdef WINDOWSNT
1391 FARPROC set_fg;  /* Pointer to AllowSetForegroundWindow.  */
1392 FARPROC get_wc;  /* Pointer to RealGetWindowClassA.  */
1393
1394 BOOL CALLBACK
1395 w32_find_emacs_process (HWND hWnd, LPARAM lParam)
1396 {
1397   DWORD pid;
1398   char class[6];
1399
1400   /* Reject any window not of class "Emacs".  */
1401   if (! get_wc (hWnd, class, sizeof (class))
1402       || strcmp (class, "Emacs"))
1403     return TRUE;
1404
1405   /* We only need the process id, not the thread id.  */
1406   (void) GetWindowThreadProcessId (hWnd, &pid);
1407
1408   /* Not the one we're looking for.  */
1409   if (pid != (DWORD) emacs_pid) return TRUE;
1410
1411   /* OK, let's raise it.  */
1412   set_fg (emacs_pid);
1413
1414   /* Stop enumeration.  */
1415   return FALSE;
1416 }
1417
1418 /*
1419  * Search for a window of class "Emacs" and owned by a process with
1420  * process id = emacs_pid.  If found, allow it to grab the focus.
1421  */
1422 void
1423 w32_give_focus (void)
1424 {
1425   HANDLE user32;
1426
1427   /* It shouldn't happen when dealing with TCP sockets.  */
1428   if (!emacs_pid) return;
1429
1430   user32 = GetModuleHandle ("user32.dll");
1431
1432   if (!user32)
1433     return;
1434
1435   /* Modern Windows restrict which processes can set the foreground window.
1436      emacsclient can allow Emacs to grab the focus by calling the function
1437      AllowSetForegroundWindow.  Unfortunately, older Windows (W95, W98 and
1438      NT) lack this function, so we have to check its availability.  */
1439   if ((set_fg = GetProcAddress (user32, "AllowSetForegroundWindow"))
1440       && (get_wc = GetProcAddress (user32, "RealGetWindowClassA")))
1441     EnumWindows (w32_find_emacs_process, (LPARAM) 0);
1442 }
1443 #endif
1444
1445 /* Start the emacs daemon and try to connect to it.  */
1446
1447 void
1448 start_daemon_and_retry_set_socket (void)
1449 {
1450 #ifndef WINDOWSNT
1451   pid_t dpid;
1452   int status;
1453
1454   dpid = fork ();
1455
1456   if (dpid > 0)
1457     {
1458       pid_t w;
1459       w = waitpid (dpid, &status, WUNTRACED | WCONTINUED);
1460
1461       if ((w == -1) || !WIFEXITED (status) || WEXITSTATUS (status))
1462         {
1463           message (TRUE, "Error: Could not start the Emacs daemon\n");
1464           exit (EXIT_FAILURE);
1465         }
1466
1467       /* Try connecting, the daemon should have started by now.  */
1468       message (TRUE, "Emacs daemon should have started, trying to connect again\n");
1469       if ((emacs_socket = set_socket (1)) == INVALID_SOCKET)
1470         {
1471           message (TRUE, "Error: Cannot connect even after starting the Emacs daemon\n");
1472           exit (EXIT_FAILURE);
1473         }
1474     }
1475   else if (dpid < 0)
1476     {
1477       fprintf (stderr, "Error: Cannot fork!\n");
1478       exit (1);
1479     }
1480   else
1481     {
1482       char *d_argv[] = {"emacs", "--daemon", 0 };
1483       if (socket_name != NULL)
1484         {
1485           /* Pass  --daemon=socket_name as argument.  */
1486           char *deq = "--daemon=";
1487           char *daemon_arg = alloca (strlen (deq)
1488                                      + strlen (socket_name) + 1);
1489           strcpy (daemon_arg, deq);
1490           strcat (daemon_arg, socket_name);
1491           d_argv[1] = daemon_arg;
1492         }
1493       execvp ("emacs", d_argv);
1494       message (TRUE, "%s: error starting emacs daemon\n", progname);
1495     }
1496 #endif /* WINDOWSNT */
1497 }
1498
1499 int
1500 main (int argc, char **argv)
1501 {
1502   int i, rl, needlf = 0;
1503   char *cwd, *str;
1504   char string[BUFSIZ+1];
1505   int null_socket_name, null_server_file, start_daemon_if_needed;
1506
1507   main_argv = argv;
1508   progname = argv[0];
1509
1510 #ifdef WINDOWSNT
1511   /* On Windows 7 and later, we need to explicitly associate emacsclient
1512      with emacs so the UI behaves sensibly.  */
1513   w32_set_user_model_id ();
1514 #endif
1515
1516   /* Process options.  */
1517   decode_options (argc, argv);
1518
1519   if ((argc - optind < 1) && !eval && current_frame)
1520     {
1521       message (TRUE, "%s: file name or argument required\n"
1522                "Try `%s --help' for more information\n",
1523                progname, progname);
1524       exit (EXIT_FAILURE);
1525     }
1526
1527   /* If alternate_editor is the empty string, start the emacs daemon
1528      in case of failure to connect.  */
1529   start_daemon_if_needed = (alternate_editor
1530                             && (alternate_editor[0] == '\0'));
1531   if (start_daemon_if_needed)
1532     {
1533       /* set_socket changes the values for socket_name and
1534          server_file, we need to reset them, if they were NULL before
1535          for the second call to set_socket.  */
1536       null_socket_name = (socket_name == NULL);
1537       null_server_file = (server_file == NULL);
1538     }
1539
1540   if ((emacs_socket = set_socket (alternate_editor
1541                                   || start_daemon_if_needed)) == INVALID_SOCKET)
1542     if (start_daemon_if_needed)
1543       {
1544         /* Reset socket_name and server_file if they were NULL
1545            before the set_socket call.  */
1546         if (null_socket_name)
1547           socket_name = NULL;
1548         if (null_server_file)
1549           server_file = NULL;
1550
1551         start_daemon_and_retry_set_socket ();
1552       }
1553     else
1554       fail ();
1555
1556   cwd = get_current_dir_name ();
1557   if (cwd == 0)
1558     {
1559       /* getwd puts message in STRING if it fails.  */
1560       message (TRUE, "%s: %s\n", progname,
1561                "Cannot get current working directory");
1562       fail ();
1563     }
1564
1565 #ifdef WINDOWSNT
1566   w32_give_focus ();
1567 #endif
1568
1569   /* Send over our environment and current directory. */
1570   if (!current_frame)
1571     {
1572       extern char **environ;
1573       int i;
1574       for (i = 0; environ[i]; i++)
1575         {
1576           char *name = xstrdup (environ[i]);
1577           char *value = strchr (name, '=');
1578           send_to_emacs (emacs_socket, "-env ");
1579           quote_argument (emacs_socket, environ[i]);
1580           send_to_emacs (emacs_socket, " ");
1581         }
1582     }
1583   send_to_emacs (emacs_socket, "-dir ");
1584   quote_argument (emacs_socket, cwd);
1585   send_to_emacs (emacs_socket, "/");
1586   send_to_emacs (emacs_socket, " ");
1587
1588  retry:
1589   if (nowait)
1590     send_to_emacs (emacs_socket, "-nowait ");
1591
1592   if (current_frame)
1593     send_to_emacs (emacs_socket, "-current-frame ");
1594
1595   if (display)
1596     {
1597       send_to_emacs (emacs_socket, "-display ");
1598       quote_argument (emacs_socket, display);
1599       send_to_emacs (emacs_socket, " ");
1600     }
1601
1602   if (parent_id)
1603     {
1604       send_to_emacs (emacs_socket, "-parent-id ");
1605       quote_argument (emacs_socket, parent_id);
1606       send_to_emacs (emacs_socket, " ");
1607     }
1608
1609   /* If using the current frame, send tty information to Emacs anyway.
1610      In daemon mode, Emacs may need to occupy this tty if no other
1611      frame is available.  */
1612   if (tty || (current_frame && !eval))
1613     {
1614       char *tty_type, *tty_name;
1615
1616       if (find_tty (&tty_type, &tty_name, !tty))
1617         {
1618 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1619           init_signals ();
1620 #endif
1621           send_to_emacs (emacs_socket, "-tty ");
1622           quote_argument (emacs_socket, tty_name);
1623           send_to_emacs (emacs_socket, " ");
1624           quote_argument (emacs_socket, tty_type);
1625           send_to_emacs (emacs_socket, " ");
1626         }
1627     }
1628
1629   if (!current_frame && !tty)
1630     send_to_emacs (emacs_socket, "-window-system ");
1631
1632   if ((argc - optind > 0))
1633     {
1634       for (i = optind; i < argc; i++)
1635         {
1636
1637           if (eval)
1638             {
1639               /* Don't prepend cwd or anything like that.  */
1640               send_to_emacs (emacs_socket, "-eval ");
1641               quote_argument (emacs_socket, argv[i]);
1642               send_to_emacs (emacs_socket, " ");
1643               continue;
1644             }
1645
1646           if (*argv[i] == '+')
1647             {
1648               char *p = argv[i] + 1;
1649               while (isdigit ((unsigned char) *p) || *p == ':') p++;
1650               if (*p == 0)
1651                 {
1652                   send_to_emacs (emacs_socket, "-position ");
1653                   quote_argument (emacs_socket, argv[i]);
1654                   send_to_emacs (emacs_socket, " ");
1655                   continue;
1656                 }
1657             }
1658 #ifdef WINDOWSNT
1659           else if (! file_name_absolute_p (argv[i])
1660                    && (isalpha (argv[i][0]) && argv[i][1] == ':'))
1661             /* Windows can have a different default directory for each
1662                drive, so the cwd passed via "-dir" is not sufficient
1663                to account for that.
1664                If the user uses <drive>:<relpath>, we hence need to be
1665                careful to expand <relpath> with the default directory
1666                corresponding to <drive>.  */
1667             {
1668               char *filename = (char *) xmalloc (MAX_PATH);
1669               DWORD size;
1670
1671               size = GetFullPathName (argv[i], MAX_PATH, filename, NULL);
1672               if (size > 0 && size < MAX_PATH)
1673                 argv[i] = filename;
1674               else
1675                 free (filename);
1676             }
1677 #endif
1678
1679           send_to_emacs (emacs_socket, "-file ");
1680           quote_argument (emacs_socket, argv[i]);
1681           send_to_emacs (emacs_socket, " ");
1682         }
1683     }
1684   else if (eval)
1685     {
1686       /* Read expressions interactively.  */
1687       while ((str = fgets (string, BUFSIZ, stdin)))
1688         {
1689           send_to_emacs (emacs_socket, "-eval ");
1690           quote_argument (emacs_socket, str);
1691         }
1692       send_to_emacs (emacs_socket, " ");
1693     }
1694
1695   send_to_emacs (emacs_socket, "\n");
1696
1697   /* Wait for an answer. */
1698   if (!eval && !tty && !nowait)
1699     {
1700       printf ("Waiting for Emacs...");
1701       needlf = 2;
1702     }
1703   fflush (stdout);
1704   fsync (1);
1705
1706   /* Now, wait for an answer and print any messages.  */
1707   while ((rl = recv (emacs_socket, string, BUFSIZ, 0)) > 0)
1708     {
1709       char *p;
1710       string[rl] = '\0';
1711
1712       p = string + strlen (string) - 1;
1713       while (p > string && *p == '\n')
1714         *p-- = 0;
1715
1716       if (strprefix ("-emacs-pid ", string))
1717         {
1718           /* -emacs-pid PID: The process id of the Emacs process. */
1719           emacs_pid = strtol (string + strlen ("-emacs-pid"), NULL, 10);
1720         }
1721       else if (strprefix ("-window-system-unsupported ", string))
1722         {
1723           /* -window-system-unsupported: Emacs was compiled without X
1724               support.  Try again on the terminal. */
1725           nowait = 0;
1726           tty = 1;
1727           goto retry;
1728         }
1729       else if (strprefix ("-print ", string))
1730         {
1731           /* -print STRING: Print STRING on the terminal. */
1732           str = unquote_argument (string + strlen ("-print "));
1733           if (needlf)
1734             printf ("\n");
1735           printf ("%s", str);
1736           needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1737         }
1738       else if (strprefix ("-error ", string))
1739         {
1740           /* -error DESCRIPTION: Signal an error on the terminal. */
1741           str = unquote_argument (string + strlen ("-error "));
1742           if (needlf)
1743             printf ("\n");
1744           fprintf (stderr, "*ERROR*: %s", str);
1745           needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1746         }
1747 #ifdef SIGSTOP
1748       else if (strprefix ("-suspend ", string))
1749         {
1750           /* -suspend: Suspend this terminal, i.e., stop the process. */
1751           if (needlf)
1752             printf ("\n");
1753           needlf = 0;
1754           kill (0, SIGSTOP);
1755         }
1756 #endif
1757       else
1758         {
1759           /* Unknown command. */
1760           if (needlf)
1761             printf ("\n");
1762           printf ("*ERROR*: Unknown message: %s", string);
1763           needlf = string[0] == '\0' ? needlf : string[strlen (string) - 1] != '\n';
1764         }
1765     }
1766
1767   if (needlf)
1768     printf ("\n");
1769   fflush (stdout);
1770   fsync (1);
1771
1772   CLOSE_SOCKET (emacs_socket);
1773   return EXIT_SUCCESS;
1774 }
1775
1776 #endif /* HAVE_SOCKETS && HAVE_INET_SOCKETS */
1777
1778 \f
1779 #ifndef HAVE_STRERROR
1780 char *
1781 strerror (errnum)
1782      int errnum;
1783 {
1784   extern char *sys_errlist[];
1785   extern int sys_nerr;
1786
1787   if (errnum >= 0 && errnum < sys_nerr)
1788     return sys_errlist[errnum];
1789   return (char *) "Unknown error";
1790 }
1791
1792 #endif /* ! HAVE_STRERROR */
1793
1794 /* arch-tag: f39bb9c4-73eb-477e-896d-50832e2ca9a7
1795    (do not change this comment) */
1796
1797 /* emacsclient.c ends here */