comparison src/process.c @ 44067:e8a136850817

(QCfeature, QCdatagram): Removed variables. (QCtype, Qdatagram): New variables. (network_process_featurep): Removed function. (Fmake_network_process): Removed :feature check. Use :type 'datagram instead of :datagram t to create a datagram socket. This allows us to add other connection types (e.g. raw sockets) later in a consistent manner. (init_process) [subprocess]: Provide list of supported subfeatures for feature make-network-process. (syms_of_process) [subprocess]: Remove QCfeature and QCdatagram. Intern and staticpro QCtype and Qdatagram. (syms_of_process) [!subprocess]: Intern and staticpro QCtype.

44066:d0bef01f3cb3

#include "atimer.h"

Lisp_Object Qprocessp;
Lisp_Object Qrun, Qstop, Qsignal;
Lisp_Object Qopen, Qclosed, Qconnect, Qfailed, Qlisten;
Lisp_Object Qlocal;
Lisp_Object QCname, QCbuffer, QChost, QCservice;
Lisp_Object QClocal, QCremote, QCcoding;
Lisp_Object QCserver, QCdatagram, QCnowait, QCnoquery, QCstop;
Lisp_Object QCsentinel, QClog, QCoptions, QCfeature;
Lisp_Object Qlast_nonmenu_event;
/* QCfamily is declared and initialized in xfaces.c,
   QCfilter in keyboard.c.  */
extern Lisp_Object QCfamily, QCfilter;

      set_socket_options (XPROCESS (process)->infd, opts, 0);
    }
  return process;
}

/* Check whether a given KEY VALUE pair is supported on this system.  */

static int
network_process_featurep (key, value)
       Lisp_Object key, value;
{

  if (EQ (key, QCnowait))
    {
#ifdef NON_BLOCKING_CONNECT
      return 1;
#else
      return NILP (value);
#endif
    }

  if (EQ (key, QCdatagram))
    {
#ifdef DATAGRAM_SOCKETS
      return 1;
#else
      return NILP (value);
#endif
    }

  if (EQ (key, QCfamily))
    {
      if (NILP (value))
	return 1;
#ifdef HAVE_LOCAL_SOCKETS
      if (EQ (key, Qlocal))
	return 1;
#endif
      return 0;
    }

  if (EQ (key, QCname))
    return STRINGP (value);

  if (EQ (key, QCbuffer))
    return (NILP (value) || STRINGP (value) || BUFFERP (value));

  if (EQ (key, QClocal) || EQ (key, QCremote))
    {
      int family;
      return get_lisp_to_sockaddr_size (value, &family);
    }

  if (EQ (key, QChost))
    return (NILP (value) || STRINGP (value));

  if (EQ (key, QCservice))
    {
#ifdef HAVE_GETSOCKNAME
      if (EQ (value, Qt))
	return 1;
#endif
      return (INTEGERP (value) || STRINGP (value));
    }

  if (EQ (key, QCserver))
    {
#ifndef TERM
      return 1;
#else
      return NILP (value);
#endif
    }

  if (EQ (key, QCoptions))
    return set_socket_options (-1, value, 0);

  if (EQ (key, QCcoding))
    return 1;
  if (EQ (key, QCsentinel))
    return 1;
  if (EQ (key, QCfilter))
    return 1;
  if (EQ (key, QClog))
    return 1;
  if (EQ (key, QCnoquery))
    return 1;
  if (EQ (key, QCstop))
    return 1;

  return 0;
}

/* A version of request_sigio suitable for a record_unwind_protect.  */

Lisp_Object
unwind_request_sigio (dummy)
     Lisp_Object dummy;

host, and only clients connecting to that address will be accepted.

:service SERVICE -- SERVICE is name of the service desired, or an
integer specifying a port number to connect to.  If SERVICE is t,
a random port number is selected for the server.

:family FAMILY -- FAMILY is the address (and protocol) family for the
service specified by HOST and SERVICE.  The default address family is
Inet (or IPv4) for the host and port number specified by HOST and
SERVICE.  Other address families supported are:

address data with one element per address data byte.  Do not rely on
this format in portable code, as it may depend on implementation
defined constants, data sizes, and data structure alignment.

:coding CODING -- CODING is coding system for this process.

:datagram BOOL -- Create a datagram type connection if BOOL is
non-nil.  Default is a stream type connection.

:options OPTIONS -- Set the specified options for the network process.
See `set-process-options' for details.

:nowait BOOL -- If BOOL is non-nil for a stream type client process,

Notice that the FILTER and SENTINEL args are never used directly by
the server process.  Also, the BUFFER argument is not used directly by
the server process, but via `network-server-log-function' hook, a log
of the accepted (and failed) connections may be recorded in the server
process' buffer.

The following special call returns t iff a given KEY VALUE
pair is supported on this system:
  (make-network-process :feature KEY VALUE)

usage: (make-network-process &rest ARGS)  */)
     (nargs, args)
     int nargs;
     Lisp_Object *args;

  Lisp_Object tem;
  Lisp_Object name, buffer, host, service, address;
  Lisp_Object filter, sentinel;
  int is_non_blocking_client = 0;
  int is_server = 0;
  int socktype = SOCK_STREAM;
  int family = -1;

  if (nargs == 0)
    return Qnil;

  /* Handle :feature KEY VALUE query.  */
  if (EQ (args[0], QCfeature))
    {
      if (nargs != 3)
	return Qnil;
      return network_process_featurep (args[1], args[2]) ? Qt : Qnil;
    }

  /* Save arguments for process-contact and clone-process.  */
  contact = Flist (nargs, args);
  GCPRO1 (contact);

#ifdef WINDOWSNT
  /* Ensure socket support is loaded if available. */
  init_winsock (TRUE);
#endif

  /* :datagram BOOL */
  tem = Fplist_get (contact, QCdatagram);
  if (!NILP (tem))
    {
#ifndef DATAGRAM_SOCKETS
      error ("Datagram connections not supported");
#else
      socktype = SOCK_DGRAM;
#endif
    }

  /* :server BOOL */
  tem = Fplist_get (contact, QCserver);
  if (!NILP (tem))
    {


void
init_process ()
{
  register int i;

#ifdef SIGCHLD
#ifndef CANNOT_DUMP
  if (! noninteractive || initialized)
#endif

  bzero (proc_decode_coding_system, sizeof proc_decode_coding_system);
  bzero (proc_encode_coding_system, sizeof proc_encode_coding_system);
#ifdef DATAGRAM_SOCKETS
  bzero (datagram_address, sizeof datagram_address);
#endif
}

void
syms_of_process ()
{

  staticpro (&Qfailed);
  Qlisten = intern ("listen");
  staticpro (&Qlisten);
  Qlocal = intern ("local");
  staticpro (&Qlocal);

  QCname = intern (":name");
  staticpro (&QCname);
  QCbuffer = intern (":buffer");
  staticpro (&QCbuffer);
  QChost = intern (":host");
  staticpro (&QChost);
  QCservice = intern (":service");
  staticpro (&QCservice);
  QClocal = intern (":local");
  staticpro (&QClocal);
  QCremote = intern (":remote");
  staticpro (&QCremote);
  QCcoding = intern (":coding");
  staticpro (&QCcoding);
  QCserver = intern (":server");
  staticpro (&QCserver);
  QCdatagram = intern (":datagram");
  staticpro (&QCdatagram);
  QCnowait = intern (":nowait");
  staticpro (&QCnowait);
  QCsentinel = intern (":sentinel");
  staticpro (&QCsentinel);
  QClog = intern (":log");

  staticpro (&QCnoquery);
  QCstop = intern (":stop");
  staticpro (&QCstop);
  QCoptions = intern (":options");
  staticpro (&QCoptions);
  QCfeature = intern (":feature");
  staticpro (&QCfeature);
    
  Qlast_nonmenu_event = intern ("last-nonmenu-event");
  staticpro (&Qlast_nonmenu_event);

  staticpro (&Vprocess_alist);

extern int frame_garbaged;

extern EMACS_TIME timer_check ();
extern int timers_run;

/* As described above, except assuming that there are no subprocesses:

   Wait for timeout to elapse and/or keyboard input to be available.

   time_limit is:

}

void
syms_of_process ()
{
  defsubr (&Sget_buffer_process);
  defsubr (&Sprocess_inherit_coding_system_flag);
}



44067:e8a136850817

#include "atimer.h"

Lisp_Object Qprocessp;
Lisp_Object Qrun, Qstop, Qsignal;
Lisp_Object Qopen, Qclosed, Qconnect, Qfailed, Qlisten;
Lisp_Object Qlocal, Qdatagram;
Lisp_Object QCname, QCbuffer, QChost, QCservice, QCtype;
Lisp_Object QClocal, QCremote, QCcoding;
Lisp_Object QCserver, QCnowait, QCnoquery, QCstop;
Lisp_Object QCsentinel, QClog, QCoptions;
Lisp_Object Qlast_nonmenu_event;
/* QCfamily is declared and initialized in xfaces.c,
   QCfilter in keyboard.c.  */
extern Lisp_Object QCfamily, QCfilter;

      set_socket_options (XPROCESS (process)->infd, opts, 0);
    }
  return process;
}

/* A version of request_sigio suitable for a record_unwind_protect.  */

Lisp_Object
unwind_request_sigio (dummy)
     Lisp_Object dummy;

host, and only clients connecting to that address will be accepted.

:service SERVICE -- SERVICE is name of the service desired, or an
integer specifying a port number to connect to.  If SERVICE is t,
a random port number is selected for the server.

:type TYPE -- TYPE is the type of connection.  The default (nil) is a
stream type connection, `datagram' creates a datagram type connection.

:family FAMILY -- FAMILY is the address (and protocol) family for the
service specified by HOST and SERVICE.  The default address family is
Inet (or IPv4) for the host and port number specified by HOST and
SERVICE.  Other address families supported are:

address data with one element per address data byte.  Do not rely on
this format in portable code, as it may depend on implementation
defined constants, data sizes, and data structure alignment.

:coding CODING -- CODING is coding system for this process.

:options OPTIONS -- Set the specified options for the network process.
See `set-process-options' for details.

:nowait BOOL -- If BOOL is non-nil for a stream type client process,

Notice that the FILTER and SENTINEL args are never used directly by
the server process.  Also, the BUFFER argument is not used directly by
the server process, but via `network-server-log-function' hook, a log
of the accepted (and failed) connections may be recorded in the server
process' buffer.

usage: (make-network-process &rest ARGS)  */)
     (nargs, args)
     int nargs;
     Lisp_Object *args;

  Lisp_Object tem;
  Lisp_Object name, buffer, host, service, address;
  Lisp_Object filter, sentinel;
  int is_non_blocking_client = 0;
  int is_server = 0;
  int socktype;
  int family = -1;

  if (nargs == 0)
    return Qnil;

  /* Save arguments for process-contact and clone-process.  */
  contact = Flist (nargs, args);
  GCPRO1 (contact);

#ifdef WINDOWSNT
  /* Ensure socket support is loaded if available. */
  init_winsock (TRUE);
#endif

  /* :type TYPE  (nil: stream, datagram */
  tem = Fplist_get (contact, QCtype);
  if (NILP (tem))
    socktype = SOCK_STREAM;
#ifdef DATAGRAM_SOCKETS
  else if (EQ (tem, Qdatagram))
    socktype = SOCK_DGRAM;
#endif
  else
    error ("Unsupported connection type");

  /* :server BOOL */
  tem = Fplist_get (contact, QCserver);
  if (!NILP (tem))
    {


void
init_process ()
{
  register int i;
  Lisp_Object subfeatures;

#ifdef SIGCHLD
#ifndef CANNOT_DUMP
  if (! noninteractive || initialized)
#endif

  bzero (proc_decode_coding_system, sizeof proc_decode_coding_system);
  bzero (proc_encode_coding_system, sizeof proc_encode_coding_system);
#ifdef DATAGRAM_SOCKETS
  bzero (datagram_address, sizeof datagram_address);
#endif

#define ADD_SUBFEATURE(key, val) \
  subfeatures = Fcons (Fcons (key, Fcons (val, Qnil)), subfeatures)

  subfeatures = Qnil;
#ifdef NON_BLOCKING_CONNECT
  ADD_SUBFEATURE (QCnowait, Qt);
#endif
#ifdef DATAGRAM_SOCKETS
  ADD_SUBFEATURE (QCtype, Qdatagram);
#endif
#ifdef HAVE_LOCAL_SOCKETS
  ADD_SUBFEATURE (QCfamily, Qlocal);
#endif
#ifdef HAVE_GETSOCKNAME
  ADD_SUBFEATURE (QCservice, Qt);
#endif
#ifndef TERM
  ADD_SUBFEATURE (QCserver, Qt);
#endif
#ifdef SO_BINDTODEVICE
  ADD_SUBFEATURE (QCoptions, intern ("bindtodevice"));
#endif
#ifdef SO_BROADCAST
  ADD_SUBFEATURE (QCoptions, intern ("broadcast"));
#endif
#ifdef SO_DONTROUTE
  ADD_SUBFEATURE (QCoptions, intern ("dontroute"));
#endif
#ifdef SO_KEEPALIVE
  ADD_SUBFEATURE (QCoptions, intern ("keepalive"));
#endif
#ifdef SO_LINGER
  ADD_SUBFEATURE (QCoptions, intern ("linger"));
#endif
#ifdef SO_OOBINLINE
  ADD_SUBFEATURE (QCoptions, intern ("oobinline"));
#endif
#ifdef SO_PRIORITY
  ADD_SUBFEATURE (QCoptions, intern ("priority"));
#endif
#ifdef SO_REUSEADDR
  ADD_SUBFEATURE (QCoptions, intern ("reuseaddr"));
#endif
  Fprovide (intern ("make-network-process"), subfeatures);
}

void
syms_of_process ()
{

  staticpro (&Qfailed);
  Qlisten = intern ("listen");
  staticpro (&Qlisten);
  Qlocal = intern ("local");
  staticpro (&Qlocal);
  Qdatagram = intern ("datagram");
  staticpro (&Qdatagram);

  QCname = intern (":name");
  staticpro (&QCname);
  QCbuffer = intern (":buffer");
  staticpro (&QCbuffer);
  QChost = intern (":host");
  staticpro (&QChost);
  QCservice = intern (":service");
  staticpro (&QCservice);
  QCtype = intern (":type");
  staticpro (&QCtype);
  QClocal = intern (":local");
  staticpro (&QClocal);
  QCremote = intern (":remote");
  staticpro (&QCremote);
  QCcoding = intern (":coding");
  staticpro (&QCcoding);
  QCserver = intern (":server");
  staticpro (&QCserver);
  QCnowait = intern (":nowait");
  staticpro (&QCnowait);
  QCsentinel = intern (":sentinel");
  staticpro (&QCsentinel);
  QClog = intern (":log");

  staticpro (&QCnoquery);
  QCstop = intern (":stop");
  staticpro (&QCstop);
  QCoptions = intern (":options");
  staticpro (&QCoptions);
    
  Qlast_nonmenu_event = intern ("last-nonmenu-event");
  staticpro (&Qlast_nonmenu_event);

  staticpro (&Vprocess_alist);

extern int frame_garbaged;

extern EMACS_TIME timer_check ();
extern int timers_run;

Lisp_Object QCtype;

/* As described above, except assuming that there are no subprocesses:

   Wait for timeout to elapse and/or keyboard input to be available.

   time_limit is:

}

void
syms_of_process ()
{
  QCtype = intern (":type");
  staticpro (&QCtype);

  defsubr (&Sget_buffer_process);
  defsubr (&Sprocess_inherit_coding_system_flag);
}