code.delx.au - gnu-emacs/blob - 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 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 2, or (at your option)
  10 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; see the file COPYING.  If not, write to
  19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20 Boston, MA 02110-1301, USA.  */
  21
  22
  23 #define NO_SHORTNAMES
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #ifdef WINDOWSNT
  30
  31 # include <malloc.h>
  32 # include <stdlib.h>
  33
  34 # define HAVE_SOCKETS
  35 # define HAVE_INET_SOCKETS
  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 # ifdef HAVE_INET_SOCKETS
  45 #  include <netinet/in.h>
  46 # endif
  47
  48 # define INVALID_SOCKET -1
  49 # define HSOCKET int
  50 # define CLOSE_SOCKET close
  51 # define INITIALIZE()
  52
  53 #endif /* !WINDOWSNT */
  54
  55 #undef signal
  56
  57 #include <ctype.h>
  58 #include <stdio.h>
  59 #include "getopt.h"
  60 #ifdef HAVE_UNISTD_H
  61 #include <unistd.h>
  62 #endif
  63
  64 #ifdef VMS
  65 # include "vms-pwd.h"
  66 #else /* not VMS */
  67 #ifdef WINDOWSNT
  68 # include <io.h>
  69 #else /* not WINDOWSNT */
  70 # include <pwd.h>
  71 #endif /* not WINDOWSNT */
  72 #endif /* not VMS */
  73
  74 char *getenv (), *getwd ();
  75 char *(getcwd) ();
  76
  77 #ifndef VERSION
  78 #define VERSION "unspecified"
  79 #endif
  80 \f
  81 #define SEND_STRING(data) (send_to_emacs (s, (data)))
  82 #define SEND_QUOTED(data) (quote_file_name (s, (data)))
  83
  84 #ifndef EXIT_SUCCESS
  85 #define EXIT_SUCCESS 0
  86 #endif
  87
  88 #ifndef EXIT_FAILURE
  89 #define EXIT_FAILURE 1
  90 #endif
  91
  92 #ifndef FALSE
  93 #define FALSE 0
  94 #endif
  95
  96 #ifndef TRUE
  97 #define TRUE 1
  98 #endif
  99
 100 #ifndef NO_RETURN
 101 #define NO_RETURN
 102 #endif
 103 \f
 104 /* Name used to invoke this program.  */
 105 char *progname;
 106
 107 /* Nonzero means don't wait for a response from Emacs.  --no-wait.  */
 108 int nowait = 0;
 109
 110 /* Nonzero means args are expressions to be evaluated.  --eval.  */
 111 int eval = 0;
 112
 113 /* The display on which Emacs should work.  --display.  */
 114 char *display = NULL;
 115
 116 /* If non-NULL, the name of an editor to fallback to if the server
 117    is not running.  --alternate-editor.   */
 118 const char *alternate_editor = NULL;
 119
 120 /* If non-NULL, the filename of the UNIX socket.  */
 121 char *socket_name = NULL;
 122
 123 /* If non-NULL, the filename of the authentication file.  */
 124 char *server_file = NULL;
 125
 126 void print_help_and_exit () NO_RETURN;
 127
 128 struct option longopts[] =
 129 {
 130   { "no-wait",  no_argument,       NULL, 'n' },
 131   { "eval",     no_argument,       NULL, 'e' },
 132   { "help",     no_argument,       NULL, 'H' },
 133   { "version",  no_argument,       NULL, 'V' },
 134   { "alternate-editor", required_argument, NULL, 'a' },
 135 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
 136   { "socket-name",      required_argument, NULL, 's' },
 137 #endif
 138   { "server-file",      required_argument, NULL, 'f' },
 139   { "display",  required_argument, NULL, 'd' },
 140   { 0, 0, 0, 0 }
 141 };
 142
 143 /* Decode the options from argv and argc.
 144    The global variable `optind' will say how many arguments we used up.  */
 145
 146 void
 147 decode_options (argc, argv)
 148      int argc;
 149      char **argv;
 150 {
 151   alternate_editor = getenv ("ALTERNATE_EDITOR");
 152
 153   while (1)
 154     {
 155       int opt = getopt_long (argc, argv,
 156 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
 157                              "VHnea:s:f:d:",
 158 #else
 159                              "VHnea:f:d:",
 160 #endif
 161                              longopts, 0);
 162
 163       if (opt == EOF)
 164         break;
 165
 166       switch (opt)
 167         {
 168         case 0:
 169           /* If getopt returns 0, then it has already processed a
 170              long-named option.  We should do nothing.  */
 171           break;
 172
 173         case 'a':
 174           alternate_editor = optarg;
 175           break;
 176
 177 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
 178         case 's':
 179           socket_name = optarg;
 180           break;
 181 #endif
 182
 183         case 'f':
 184           server_file = optarg;
 185           break;
 186
 187         case 'd':
 188           display = optarg;
 189           break;
 190
 191         case 'n':
 192           nowait = 1;
 193           break;
 194
 195         case 'e':
 196           eval = 1;
 197           break;
 198
 199         case 'V':
 200           printf ("emacsclient %s\n", VERSION);
 201           exit (EXIT_SUCCESS);
 202           break;
 203
 204         case 'H':
 205           print_help_and_exit ();
 206           break;
 207
 208         default:
 209           fprintf (stderr, "Try `%s --help' for more information\n", progname);
 210           exit (EXIT_FAILURE);
 211           break;
 212         }
 213     }
 214 }
 215
 216 void
 217 print_help_and_exit ()
 218 {
 219   printf (
 220           "Usage: %s [OPTIONS] FILE...\n\
 221 Tell the Emacs server to visit the specified files.\n\
 222 Every FILE can be either just a FILENAME or [+LINE[:COLUMN]] FILENAME.\n\
 223 \n\
 224 The following OPTIONS are accepted:\n\
 225 -V, --version           Just print a version info and return\n\
 226 -H, --help              Print this usage information message\n\
 227 -n, --no-wait           Don't wait for the server to return\n\
 228 -e, --eval              Evaluate the FILE arguments as ELisp expressions\n\
 229 -d, --display=DISPLAY   Visit the file in the given display\n"
 230 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
 231 "-s, --socket-name=FILENAME\n\
 232                         Set the filename of the UNIX socket for communication\n"
 233 #endif
 234 "-f, --server-file=FILENAME\n\
 235                         Set the filename of the TCP configuration file\n\
 236 -a, --alternate-editor=EDITOR\n\
 237                         Editor to fallback to if the server is not running\n\
 238 \n\
 239 Report bugs to bug-gnu-emacs@gnu.org.\n", progname);
 240   exit (EXIT_SUCCESS);
 241 }
 242
 243 \f
 244 /*
 245   Try to run a different command, or --if no alternate editor is
 246   defined-- exit with an errorcode.
 247 */
 248 void
 249 fail (argc, argv)
 250      int argc;
 251      char **argv;
 252 {
 253   if (alternate_editor)
 254     {
 255       int i = optind - 1;
 256 #ifdef WINDOWSNT
 257       argv[i] = (char *)alternate_editor;
 258 #endif
 259       execvp (alternate_editor, argv + i);
 260       fprintf (stderr, "%s: error executing alternate editor \"%s\"\n",
 261                progname, alternate_editor);
 262     }
 263   exit (EXIT_FAILURE);
 264 }
 265
 266 \f
 267 #if !defined (HAVE_SOCKETS) || !defined (HAVE_INET_SOCKETS)
 268
 269 int
 270 main (argc, argv)
 271      int argc;
 272      char **argv;
 273 {
 274   fprintf (stderr, "%s: Sorry, the Emacs server is supported only\n",
 275            argv[0]);
 276   fprintf (stderr, "on systems with Berkeley sockets.\n");
 277
 278   fail (argc, argv);
 279 }
 280
 281 #else /* HAVE_SOCKETS && HAVE_INET_SOCKETS */
 282
 283 #ifdef WINDOWSNT
 284 # include <winsock2.h>
 285 #else
 286 # include <sys/types.h>
 287 # include <sys/socket.h>
 288 # include <sys/un.h>
 289 # include <sys/stat.h>
 290 # include <errno.h>
 291 #endif
 292
 293 #define AUTH_KEY_LENGTH      64
 294 #define SEND_BUFFER_SIZE   4096
 295
 296 extern char *strerror ();
 297 extern int errno;
 298
 299 /* Buffer to accumulate data to send in TCP connections.  */
 300 char send_buffer[SEND_BUFFER_SIZE + 1];
 301 int sblen = 0;  /* Fill pointer for the send buffer.  */
 302
 303 /* Let's send the data to Emacs when either
 304    - the data ends in "\n", or
 305    - the buffer is full (but this shouldn't happen)
 306    Otherwise, we just accumulate it.  */
 307 void
 308 send_to_emacs (s, data)
 309      HSOCKET s;
 310      char *data;
 311 {
 312   while (data)
 313     {
 314       int dlen = strlen (data);
 315       if (dlen + sblen >= SEND_BUFFER_SIZE)
 316         {
 317           int part = SEND_BUFFER_SIZE - sblen;
 318           strncpy (&send_buffer[sblen], data, part);
 319           data += part;
 320           sblen = SEND_BUFFER_SIZE;
 321         }
 322       else if (dlen)
 323         {
 324           strcpy (&send_buffer[sblen], data);
 325           data = NULL;
 326           sblen += dlen;
 327         }
 328       else
 329         break;
 330
 331       if (sblen == SEND_BUFFER_SIZE
 332           || (sblen > 0 && send_buffer[sblen-1] == '\n'))
 333         {
 334           int sent = send (s, send_buffer, sblen, 0);
 335           if (sent != sblen)
 336             strcpy (send_buffer, &send_buffer[sent]);
 337           sblen -= sent;
 338         }
 339     }
 340 }
 341
 342 /* In NAME, insert a & before each &, each space, each newline, and
 343    any initial -.  Change spaces to underscores, too, so that the
 344    return value never contains a space.  */
 345 void
 346 quote_file_name (s, name)
 347      HSOCKET s;
 348      char *name;
 349 {
 350   char *copy = (char *) malloc (strlen (name) * 2 + 1);
 351   char *p, *q;
 352
 353   p = name;
 354   q = copy;
 355   while (*p)
 356     {
 357       if (*p == ' ')
 358         {
 359           *q++ = '&';
 360           *q++ = '_';
 361           p++;
 362         }
 363       else if (*p == '\n')
 364         {
 365           *q++ = '&';
 366           *q++ = 'n';
 367           p++;
 368         }
 369       else
 370         {
 371           if (*p == '&' || (*p == '-' && p == name))
 372             *q++ = '&';
 373           *q++ = *p++;
 374         }
 375     }
 376   *q++ = 0;
 377
 378   SEND_STRING (copy);
 379
 380   free (copy);
 381 }
 382
 383 int
 384 file_name_absolute_p (filename)
 385      const unsigned char *filename;
 386 {
 387   /* Sanity check, it shouldn't happen.  */
 388   if (! filename) return FALSE;
 389
 390   /* /xxx is always an absolute path.  */
 391   if (filename[0] == '/') return TRUE;
 392
 393   /* Empty filenames (which shouldn't happen) are relative.  */
 394   if (filename[0] == '\0') return FALSE;
 395
 396 #ifdef WINDOWSNT
 397   /* X:\xxx is always absolute; X:xxx is an error and will fail.  */
 398   if (islower (tolower (filename[0]))
 399       && filename[1] == ':' && filename[2] == '\\')
 400     return TRUE;
 401
 402   /* Both \xxx and \\xxx\yyy are absolute.  */
 403   if (filename[0] == '\\') return TRUE;
 404 #endif
 405
 406   return FALSE;
 407 }
 408
 409 #ifdef WINDOWSNT
 410 /* Wrapper to make WSACleanup a cdecl, as required by atexit().  */
 411 void
 412 __cdecl close_winsock ()
 413 {
 414   WSACleanup ();
 415 }
 416
 417 /* Initialize the WinSock2 library.  */
 418 void
 419 initialize_sockets ()
 420 {
 421   WSADATA wsaData;
 422
 423   if (WSAStartup (MAKEWORD (2, 0), &wsaData))
 424     {
 425       fprintf (stderr, "%s: error initializing WinSock2", progname);
 426       exit (EXIT_FAILURE);
 427     }
 428
 429   atexit (close_winsock);
 430 }
 431 #endif /* WINDOWSNT */
 432 \f
 433 /*
 434  * Read the information needed to set up a TCP comm channel with
 435  * the Emacs server: host, port, pid and authentication string.
 436 */
 437 int
 438 get_server_config (server, authentication)
 439      struct sockaddr_in *server;
 440      char *authentication;
 441 {
 442   char dotted[32];
 443   char *port;
 444   char *pid;
 445   FILE *config = NULL;
 446
 447   if (file_name_absolute_p (server_file))
 448     config = fopen (server_file, "rb");
 449   else
 450     {
 451       char *home = getenv ("HOME");
 452
 453       if (home)
 454         {
 455           char *path = alloca (32 + strlen (home) + strlen (server_file));
 456           sprintf (path, "%s/.emacs.d/server/%s", home, server_file);
 457           config = fopen (path, "rb");
 458         }
 459 #ifdef WINDOWSNT
 460       if (!config && (home = getenv ("APPDATA")))
 461         {
 462           char *path = alloca (32 + strlen (home) + strlen (server_file));
 463           sprintf (path, "%s/.emacs.d/server/%s", home, server_file);
 464           config = fopen (path, "rb");
 465         }
 466 #endif
 467     }
 468
 469   if (! config)
 470     return FALSE;
 471
 472   if (fgets (dotted, sizeof dotted, config)
 473       && (port = strchr (dotted, ':'))
 474       && (pid = strchr (port, ' ')))
 475     {
 476       *port++ = '\0';
 477       *pid++  = '\0';
 478     }
 479   else
 480     {
 481       fprintf (stderr, "%s: invalid configuration info", progname);
 482       exit (EXIT_FAILURE);
 483     }
 484
 485   server->sin_family = AF_INET;
 486   server->sin_addr.s_addr = inet_addr (dotted);
 487   server->sin_port = htons (atoi (port));
 488
 489   if (! fread (authentication, AUTH_KEY_LENGTH, 1, config))
 490     {
 491       fprintf (stderr, "%s: cannot read authentication info", progname);
 492       exit (EXIT_FAILURE);
 493     }
 494
 495   fclose (config);
 496
 497 #ifdef WINDOWSNT
 498   /*
 499     Modern Windows restrict which processes can set the foreground window.
 500     So, for emacsclient to be able to force Emacs into the foreground, we
 501     have to call AllowSetForegroundWindow().  Unfortunately, older Windows
 502     (W95, W98 and NT) don't have this function, so we have to check first.
 503
 504     We're doing this here because it has to be done before sending info
 505     to Emacs, and otherwise we'll need a global variable just to pass around
 506     the pid, which is also inelegant.
 507    */
 508   {
 509     HMODULE hUser32;
 510
 511     if (hUser32 = LoadLibrary ("user32.dll"))
 512       {
 513         FARPROC set_fg;
 514         if (set_fg = GetProcAddress (hUser32, "AllowSetForegroundWindow"))
 515           set_fg (atoi (pid));
 516         FreeLibrary (hUser32);
 517       }
 518   }
 519 #endif
 520
 521   return TRUE;
 522 }
 523
 524 HSOCKET
 525 set_tcp_socket ()
 526 {
 527   HSOCKET s;
 528   struct sockaddr_in server;
 529   struct linger l_arg = {1, 1};
 530   char auth_string[AUTH_KEY_LENGTH + 1];
 531
 532   if (! get_server_config (&server, auth_string))
 533     return INVALID_SOCKET;
 534
 535   if (server.sin_addr.s_addr != inet_addr ("127.0.0.1"))
 536     fprintf (stderr, "%s: connected to remote socket at %s\n",
 537              progname, inet_ntoa (server.sin_addr));
 538
 539   /*
 540    * Open up an AF_INET socket
 541    */
 542   if ((s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
 543     {
 544       fprintf (stderr, "%s: ", progname);
 545       perror ("socket");
 546       return INVALID_SOCKET;
 547     }
 548
 549   /*
 550    * Set up the socket
 551    */
 552   if (connect (s, (struct sockaddr *) &server, sizeof server) < 0)
 553     {
 554       fprintf (stderr, "%s: ", progname);
 555       perror ("connect");
 556       return INVALID_SOCKET;
 557     }
 558
 559   setsockopt (s, SOL_SOCKET, SO_LINGER, (char *) &l_arg, sizeof l_arg);
 560
 561   /*
 562    * Send the authentication
 563    */
 564   auth_string[AUTH_KEY_LENGTH] = '\0';
 565
 566   SEND_STRING ("-auth ");
 567   SEND_STRING (auth_string);
 568   SEND_STRING ("\n");
 569
 570   return s;
 571 }
 572
 573 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
 574
 575 /* Three possibilities:
 576    2 - can't be `stat'ed                (sets errno)
 577    1 - isn't owned by us
 578    0 - success: none of the above */
 579
 580 static int
 581 socket_status (socket_name)
 582      char *socket_name;
 583 {
 584   struct stat statbfr;
 585
 586   if (stat (socket_name, &statbfr) == -1)
 587     return 2;
 588
 589   if (statbfr.st_uid != geteuid ())
 590     return 1;
 591
 592   return 0;
 593 }
 594
 595 HSOCKET
 596 set_local_socket ()
 597 {
 598   HSOCKET s;
 599   struct sockaddr_un server;
 600
 601   /*
 602    * Open up an AF_UNIX socket in this person's home directory
 603    */
 604
 605   if ((s = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
 606     {
 607       fprintf (stderr, "%s: ", progname);
 608       perror ("socket");
 609       return INVALID_SOCKET;
 610     }
 611
 612   server.sun_family = AF_UNIX;
 613
 614   {
 615     int sock_status = 0;
 616     int default_sock = !socket_name;
 617     int saved_errno;
 618     char *server_name = "server";
 619
 620     if (socket_name && !index (socket_name, '/') && !index (socket_name, '\\'))
 621       { /* socket_name is a file name component.  */
 622         server_name = socket_name;
 623         socket_name = NULL;
 624         default_sock = 1;       /* Try both UIDs.  */
 625       }
 626
 627     if (default_sock)
 628       {
 629         socket_name = alloca (100 + strlen (server_name));
 630         sprintf (socket_name, "/tmp/emacs%d/%s",
 631                  (int) geteuid (), server_name);
 632       }
 633
 634     if (strlen (socket_name) < sizeof (server.sun_path))
 635       strcpy (server.sun_path, socket_name);
 636     else
 637       {
 638         fprintf (stderr, "%s: socket-name %s too long",
 639                  progname, socket_name);
 640         exit (EXIT_FAILURE);
 641       }
 642
 643     /* See if the socket exists, and if it's owned by us. */
 644     sock_status = socket_status (server.sun_path);
 645     saved_errno = errno;
 646     if (sock_status && default_sock)
 647       {
 648         /* Failing that, see if LOGNAME or USER exist and differ from
 649            our euid.  If so, look for a socket based on the UID
 650            associated with the name.  This is reminiscent of the logic
 651            that init_editfns uses to set the global Vuser_full_name.  */
 652
 653         char *user_name = (char *) getenv ("LOGNAME");
 654
 655         if (!user_name)
 656           user_name = (char *) getenv ("USER");
 657
 658         if (user_name)
 659           {
 660             struct passwd *pw = getpwnam (user_name);
 661
 662             if (pw && (pw->pw_uid != geteuid ()))
 663               {
 664                 /* We're running under su, apparently. */
 665                 socket_name = alloca (100 + strlen (server_name));
 666                 sprintf (socket_name, "/tmp/emacs%d/%s",
 667                          (int) pw->pw_uid, server_name);
 668
 669                 if (strlen (socket_name) < sizeof (server.sun_path))
 670                   strcpy (server.sun_path, socket_name);
 671                 else
 672                   {
 673                     fprintf (stderr, "%s: socket-name %s too long",
 674                              progname, socket_name);
 675                     exit (EXIT_FAILURE);
 676                   }
 677
 678                 sock_status = socket_status (server.sun_path);
 679                 saved_errno = errno;
 680               }
 681             else
 682               errno = saved_errno;
 683           }
 684       }
 685
 686     switch (sock_status)
 687       {
 688       case 1:
 689         /* There's a socket, but it isn't owned by us.  This is OK if
 690            we are root. */
 691         if (0 != geteuid ())
 692           {
 693             fprintf (stderr, "%s: Invalid socket owner\n", progname);
 694             return INVALID_SOCKET;
 695           }
 696         break;
 697
 698       case 2:
 699         /* `stat' failed */
 700         if (saved_errno == ENOENT)
 701           fprintf (stderr,
 702                    "%s: can't find socket; have you started the server?\n\
 703 To start the server in Emacs, type \"M-x server-start\".\n",
 704                    progname);
 705         else
 706           fprintf (stderr, "%s: can't stat %s: %s\n",
 707                    progname, server.sun_path, strerror (saved_errno));
 708         return INVALID_SOCKET;
 709       }
 710   }
 711
 712   if (connect (s, (struct sockaddr *) &server, strlen (server.sun_path) + 2)
 713       < 0)
 714     {
 715       fprintf (stderr, "%s: ", progname);
 716       perror ("connect");
 717       return INVALID_SOCKET;
 718     }
 719
 720   return s;
 721 }
 722 #endif /* ! NO_SOCKETS_IN_FILE_SYSTEM */
 723
 724 HSOCKET
 725 set_socket ()
 726 {
 727   HSOCKET s;
 728
 729   INITIALIZE ();
 730
 731 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
 732   /* Explicit --socket-name argument.  */
 733   if (socket_name)
 734     {
 735       s = set_local_socket ();
 736       if ((s != INVALID_SOCKET) || alternate_editor)
 737         return s;
 738
 739       fprintf (stderr, "%s: error accessing socket \"%s\"",
 740                progname, socket_name);
 741       exit (EXIT_FAILURE);
 742     }
 743 #endif
 744
 745   /* Explicit --server-file arg or EMACS_SERVER_FILE variable.  */
 746   if (!server_file)
 747     server_file = getenv ("EMACS_SERVER_FILE");
 748
 749   if (server_file)
 750     {
 751       s = set_tcp_socket ();
 752       if ((s != INVALID_SOCKET) || alternate_editor)
 753         return s;
 754
 755       fprintf (stderr, "%s: error accessing server file \"%s\"",
 756                progname, server_file);
 757       exit (EXIT_FAILURE);
 758     }
 759
 760 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
 761   /* Implicit local socket.  */
 762   s = set_local_socket ();
 763   if (s != INVALID_SOCKET)
 764     return s;
 765 #endif
 766
 767   /* Implicit server file.  */
 768   server_file = "server";
 769   s = set_tcp_socket ();
 770   if ((s != INVALID_SOCKET) || alternate_editor)
 771     return s;
 772
 773   /* No implicit or explicit socket, and no alternate editor.  */
 774   fprintf (stderr, "%s: No socket or alternate editor.  Please use:\n\n"
 775 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
 776 "\t--socket-name\n"
 777 #endif
 778 "\t--server-file      (or environment variable EMACS_SERVER_FILE)\n\
 779 \t--alternate-editor (or environment variable ALTERNATE_EDITOR)\n",
 780            progname);
 781   exit (EXIT_FAILURE);
 782 }
 783
 784 int
 785 main (argc, argv)
 786      int argc;
 787      char **argv;
 788 {
 789   HSOCKET s;
 790   int i, rl, needlf = 0;
 791   char *cwd;
 792   char string[BUFSIZ+1];
 793
 794   progname = argv[0];
 795
 796   /* Process options.  */
 797   decode_options (argc, argv);
 798
 799   if ((argc - optind < 1) && !eval)
 800     {
 801       fprintf (stderr, "%s: file name or argument required\n", progname);
 802       fprintf (stderr, "Try `%s --help' for more information\n", progname);
 803       exit (EXIT_FAILURE);
 804     }
 805
 806   if ((s = set_socket ()) == INVALID_SOCKET)
 807     fail (argc, argv);
 808
 809 #ifdef HAVE_GETCWD
 810   cwd = getcwd (string, sizeof string);
 811 #else
 812   cwd = getwd (string);
 813 #endif
 814   if (cwd == 0)
 815     {
 816       /* getwd puts message in STRING if it fails.  */
 817 #ifdef HAVE_GETCWD
 818       fprintf (stderr, "%s: %s (%s)\n", progname,
 819                "Cannot get current working directory", strerror (errno));
 820 #else
 821       fprintf (stderr, "%s: %s (%s)\n", progname, string, strerror (errno));
 822 #endif
 823       fail (argc, argv);
 824     }
 825
 826   if (nowait)
 827     SEND_STRING ("-nowait ");
 828
 829   if (eval)
 830     SEND_STRING ("-eval ");
 831
 832   if (display)
 833     {
 834       SEND_STRING ("-display ");
 835       SEND_QUOTED (display);
 836       SEND_STRING (" ");
 837     }
 838
 839   if ((argc - optind > 0))
 840     {
 841       for (i = optind; i < argc; i++)
 842         {
 843           if (eval)
 844             ; /* Don't prepend any cwd or anything like that.  */
 845           else if (*argv[i] == '+')
 846             {
 847               char *p = argv[i] + 1;
 848               while (isdigit ((unsigned char) *p) || *p == ':') p++;
 849               if (*p != 0)
 850                 {
 851                   SEND_QUOTED (cwd);
 852                   SEND_STRING ("/");
 853                 }
 854             }
 855           else if (! file_name_absolute_p (argv[i]))
 856             {
 857               SEND_QUOTED (cwd);
 858               SEND_STRING ("/");
 859             }
 860
 861           SEND_QUOTED (argv[i]);
 862           SEND_STRING (" ");
 863         }
 864     }
 865   else
 866     {
 867       while (fgets (string, BUFSIZ, stdin))
 868         {
 869           SEND_QUOTED (string);
 870         }
 871       SEND_STRING (" ");
 872     }
 873
 874   SEND_STRING ("\n");
 875
 876   /* Maybe wait for an answer.   */
 877   if (!nowait)
 878     {
 879       if (!eval)
 880         {
 881           printf ("Waiting for Emacs...");
 882           needlf = 2;
 883         }
 884       fflush (stdout);
 885
 886       /* Now, wait for an answer and print any messages.  */
 887       while ((rl = recv (s, string, BUFSIZ, 0)) > 0)
 888         {
 889           string[rl] = '\0';
 890           if (needlf == 2)
 891             printf ("\n");
 892           printf ("%s", string);
 893           needlf = string[0] == '\0' ? needlf : string[strlen (string) - 1] != '\n';
 894         }
 895
 896       if (needlf)
 897         printf ("\n");
 898       fflush (stdout);
 899     }
 900
 901   CLOSE_SOCKET (s);
 902   return EXIT_SUCCESS;
 903 }
 904
 905 #endif /* HAVE_SOCKETS && HAVE_INET_SOCKETS */
 906
 907 #ifndef HAVE_STRERROR
 908 char *
 909 strerror (errnum)
 910      int errnum;
 911 {
 912   extern char *sys_errlist[];
 913   extern int sys_nerr;
 914
 915   if (errnum >= 0 && errnum < sys_nerr)
 916     return sys_errlist[errnum];
 917   return (char *) "Unknown error";
 918 }
 919
 920 #endif /* ! HAVE_STRERROR */
 921
 922 /* arch-tag: f39bb9c4-73eb-477e-896d-50832e2ca9a7
 923    (do not change this comment) */
 924
 925 /* emacsclient.c ends here */