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