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