Remove unneeded SXE_SHLIB_STUFF

[sxemacs] / src / process.c

/* Asynchronous subprocess control for SXEmacs.
   Copyright (C) 1985, 1986, 1987, 1988, 1992, 1993, 1994, 1995, 2003
   Free Software Foundation, Inc.
   Copyright (C) 1995 Sun Microsystems, Inc.
   Copyright (C) 1995, 1996 Ben Wing.

This file is part of SXEmacs

SXEmacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

SXEmacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>. */


/* This file has been Mule-ized except for `start-process-internal',
   `open-network-stream-internal' and `open-multicast-group-internal'. */

/* This file has been split into process.c and process-unix.c by
   Kirill M. Katsnelson <kkm@kis.ru>, so please bash him and not
   the original author(s) */

#include <config.h>

#if !defined (NO_SUBPROCESSES)

/* The entire file is within this conditional */

#include "lisp.h"

#include "buffer.h"
#include "commands.h"
#include "events/events.h"
#include "ui/frame.h"
#include "hash.h"
#include "ui/insdel.h"
#include "lstream.h"
#include "opaque.h"
#include "process.h"
#include "procimpl.h"
#include "ui/window.h"
#ifdef FILE_CODING
#include "mule/file-coding.h"
#endif

#include "sysfile.h"
#include "sysproc.h"
#include "systime.h"
#include "syssignal.h"          /* Always include before systty.h */
#include "ui/systty.h"
#include "syswait.h"

#if defined(HAVE_OPENSSL) && defined(OPENSSL_SSL)
#include "openssl.h"
#endif
#include "dynacat.h"

Lisp_Object Qprocessp, Qprocess_live_p, Qprocess_readable_p;

/* Process methods */
struct process_methods the_process_methods;

/* a process object is a network connection when its pid field a cons
   (name of name of port we are connected to . foreign host name) */
#ifdef HAVE_SOCKETS
/* valid objects to server stream host parameter */
Lisp_Object Qip_any, Qlocalhost;
#endif

/* Valid values of process->status_symbol */
Lisp_Object Qrun, Qstop;
/* Qrun => Qopen, Qexit => Qclosed for "network connection" processes */
Lisp_Object Qopen, Qclosed;
/* Protocol families */
Lisp_Object Qtcp, Qudp;

#ifdef HAVE_MULTICAST
Lisp_Object Qmulticast;         /* Will be used for occasional warnings */
#endif

/* t means use pty, nil means use a pipe,
   maybe other values to come.  */
Lisp_Object Vprocess_connection_type;

/* Read comments to DEFVAR of this */
int windowed_process_io;

#ifdef PROCESS_IO_BLOCKING
/* List of port numbers or port names to set a blocking I/O mode.
   Nil means set a non-blocking I/O mode [default]. */
Lisp_Object network_stream_blocking_port_list;
#endif                          /* PROCESS_IO_BLOCKING */

/* Number of events of change of status of a process.  */
volatile int process_tick;

/* Number of events for which the user or sentinel has been notified.  */
static int update_tick;

/* Nonzero means delete a process right away if it exits.  */
int delete_exited_processes;

/* Hash table which maps USIDs as returned by create_stream_pair_cb to
   process objects. Processes are not GC-protected through this! */
struct hash_table *usid_to_process;
Lisp_Object Vusid_to_process;

/* List of process objects. */
Lisp_Object Vprocess_list;

extern Lisp_Object Vlisp_EXEC_SUFFIXES;
Lisp_Object Vnull_device;
\f
static Lisp_Object mark_process(Lisp_Object object)
{
        Lisp_Process *process = XPROCESS(object);
        MAYBE_PROCMETH(mark_process_data, (process));
        mark_object(process->name);
        mark_object(process->command);
        mark_object(process->filter);
        mark_object(process->sentinel);
        mark_object(process->buffer);
        mark_object(process->mark);
        mark_object(process->pid);
        mark_object(process->pipe_instream);
        mark_object(process->pipe_outstream);
#ifdef FILE_CODING
        mark_object(process->coding_instream);
        mark_object(process->coding_outstream);
#endif
        mark_object(process->process_type_data);
        return process->status_symbol;
}

static void
print_process(Lisp_Object object, Lisp_Object printcharfun, int escapeflag)
{
        Lisp_Process *process = XPROCESS(object);

        if (print_readably)
                error("printing unreadable object #<process %s>",
                      XSTRING_DATA(process->name));

        if (!escapeflag) {
                print_internal(process->name, printcharfun, 0);
        } else {
                /* int netp = network_connection_p(object); */
                int netp = ((process->process_type == PROCESS_TYPE_NETWORK) ||
                            (process->process_type == PROCESS_TYPE_MULTICAST) ||
                            (process->process_type == PROCESS_TYPE_SSL) ||
                            (process->process_type == PROCESS_TYPE_NETWORK_SERVER_LISTEN));
                switch (process->process_type) {
                case PROCESS_TYPE_NETWORK:
                        write_c_string(
                                GETTEXT("#<network connection "),
                                printcharfun);
                        break;
                case PROCESS_TYPE_NETWORK_SERVER_LISTEN:
                        write_c_string(
                                GETTEXT("#<network server accepting connections "),
                                printcharfun);
                        break;
                case PROCESS_TYPE_MULTICAST:
                        write_c_string(
                                GETTEXT("#<multicast network connection "),
                                printcharfun);
                        break;
                case PROCESS_TYPE_SSL:
                        write_c_string(
                                GETTEXT("#<secure network connection "),
                                printcharfun);
                        break;
                case PROCESS_TYPE_PROC:
                default:
                        write_c_string(
                                GETTEXT("#<process "),
                                printcharfun);
                        break;
                }
                print_internal(process->name, printcharfun, 1);
                write_c_string((netp ? " " : " pid "), printcharfun);
                print_internal(process->pid, printcharfun, 1);
                write_c_string(" state:", printcharfun);
                print_internal(process->status_symbol, printcharfun, 1);
                MAYBE_PROCMETH(print_process_data, (process, printcharfun));
                write_c_string(">", printcharfun);
        }
}

#ifdef HAVE_WINDOW_SYSTEM
extern void debug_process_finalization(Lisp_Process * p);
#endif                          /* HAVE_WINDOW_SYSTEM */

static void finalize_process(void *header, int for_disksave)
{
        /* #### this probably needs to be tied into the tty event loop */
        /* #### when there is one */
        Lisp_Process *p = (Lisp_Process *) header;
#ifdef HAVE_WINDOW_SYSTEM
        if (!for_disksave) {
                debug_process_finalization(p);
        }
#endif                          /* HAVE_WINDOW_SYSTEM */

        if (p->process_data) {
                MAYBE_PROCMETH(finalize_process_data, (p, for_disksave));
                if (!for_disksave)
                        xfree(p->process_data);
        }
}

DEFINE_LRECORD_IMPLEMENTATION("process", process,
                              mark_process, print_process, finalize_process,
                              0, 0, 0, Lisp_Process);
\f
/************************************************************************/
/*                       basic process accessors                        */
/************************************************************************/

/* Under FILE_CODING, this function returns low-level streams, connected
   directly to the child process, rather than en/decoding FILE_CODING
   streams */
void
get_process_streams(Lisp_Process * p, Lisp_Object * instr, Lisp_Object * outstr)
{
        assert(p);
        assert(NILP(p->pipe_instream) || LSTREAMP(p->pipe_instream));
        assert(NILP(p->pipe_outstream) || LSTREAMP(p->pipe_outstream));
        *instr = p->pipe_instream;
        *outstr = p->pipe_outstream;
}

Lisp_Process *get_process_from_usid(USID usid)
{
        const void *vval;

        assert(usid != USID_ERROR && usid != USID_DONTHASH);

        if (gethash((const void *)usid, usid_to_process, &vval)) {
                Lisp_Object process;
                CVOID_TO_LISP(process, vval);
                return XPROCESS(process);
        } else 
                return 0;
}

int get_process_selected_p(Lisp_Process * p)
{
        return p->selected;
}

void set_process_selected_p(Lisp_Process * p, int selected_p)
{
        p->selected = !!selected_p;
}

int connected_via_filedesc_p(Lisp_Process * p)
{
        /* In the bad old days of tooltalk this would return non-0 if
         * there was a tooltalk connection.  So that really means that
         * in 101 times out of 100 this would return 0 because nobody
         * ever used tooltalk.  It is possible that one day this might
         * need some d-bus love. */
        return 0;
}

#ifdef HAVE_SOCKETS
int network_connection_p(Lisp_Object process)
{
        return CONSP(XPROCESS(process)->pid);
}
#endif

DEFUN("processp", Fprocessp, 1, 1, 0,   /*
Return t if OBJECT is a process.
*/
      (object))
{
        return PROCESSP(object) ? Qt : Qnil;
}

DEFUN("process-live-p", Fprocess_live_p, 1, 1, 0,       /*
Return t if OBJECT is a process that is alive.
*/
      (object))
{
        return PROCESSP(object) && PROCESS_LIVE_P(XPROCESS(object))
            ? Qt : Qnil;
}

#if 0
/* This is a reasonable definition for this new primitive.  Kyle sez:

   "The patch looks OK to me except for the creation and exporting of the
   Fprocess_readable_p function.  I don't think a new Lisp function
   should be created until we know something actually needs it.  If
   we later want to give process-readable-p different semantics it
   may be hard to do it and stay compatible with what we hastily
   create today."

   He's right, not yet.  Let's discuss the semantics on XEmacs Design
   before enabling this.
*/
DEFUN("process-readable-p", Fprocess_readable_p, 1, 1, 0,       /*
Return t if OBJECT is a process from which input may be available.
*/
      (object))
{
        return PROCESSP(object) && PROCESS_READABLE_P(XPROCESS(object))
            ? Qt : Qnil;
}
#endif

DEFUN("process-list", Fprocess_list, 0, 0, 0,   /*
Return a list of all processes.
*/
      ())
{
        return Fcopy_sequence(Vprocess_list);
}

DEFUN("get-process", Fget_process, 1, 1, 0,     /*
Return the process named PROCESS-NAME (a string), or nil if there is none.
PROCESS-NAME may also be a process; if so, the value is that process.
*/
      (process_name))
{
        if (PROCESSP(process_name))
                return process_name;

        if (!gc_in_progress)
                /* this only gets called during GC when emacs is going away as a result
                   of a signal or crash. */
                CHECK_STRING(process_name);

        {
                LIST_LOOP_2(process, Vprocess_list)
                    if (internal_equal
                        (process_name, XPROCESS(process)->name, 0))
                        return process;
        }
        return Qnil;
}

DEFUN("get-buffer-process", Fget_buffer_process, 1, 1, 0,       /*
Return the (or, a) process associated with BUFFER.
BUFFER may be a buffer or the name of one.
*/
      (buffer))
{
        if (NILP(buffer))
                return Qnil;
        buffer = Fget_buffer(buffer);
        if (NILP(buffer))
                return Qnil;

        {
                LIST_LOOP_2(process, Vprocess_list)
                    if (EQ(XPROCESS(process)->buffer, buffer))
                        return process;
        }
        return Qnil;
}

/* This is how commands for the user decode process arguments.  It
   accepts a process, a process name, a buffer, a buffer name, or nil.
   Buffers denote the first process in the buffer, and nil denotes the
   current buffer.  */

static Lisp_Object get_process(Lisp_Object name)
{
        Lisp_Object buffer;

#ifdef I18N3
        /* #### Look more closely into translating process names. */
#endif

        /* This may be called during a GC from process_send_signal() from
           kill_buffer_processes() if emacs decides to abort(). */
        if (PROCESSP(name))
                return name;
        else if (STRINGP(name)) {
                Lisp_Object object = Fget_process(name);
                if (PROCESSP(object))
                        return object;

                buffer = Fget_buffer(name);
                if (BUFFERP(buffer))
                        goto have_buffer_object;

                error("Process %s does not exist", XSTRING_DATA(name));
        } else if (NILP(name)) {
                buffer = Fcurrent_buffer();
                goto have_buffer_object;
        } else if (BUFFERP(name)) {
                Lisp_Object process;
                buffer = name;

              have_buffer_object:
                process = Fget_buffer_process(buffer);
                if (PROCESSP(process))
                        return process;

                error("Buffer %s has no process",
                      XSTRING_DATA(XBUFFER(buffer)->name));
        } else
                return get_process(Fsignal(Qwrong_type_argument,
                                           (list2
                                            (build_string
                                             ("process or buffer or nil"),
                                             name))));
}

DEFUN("process-id", Fprocess_id, 1, 1, 0,       /*
Return the process id of PROCESS.
This is the pid of the Unix process which PROCESS uses or talks to.
For a network connection, this value is a cons of
(foreign-network-port . foreign-host-name).
*/
      (process))
{
        Lisp_Object pid;
        CHECK_PROCESS(process);

        pid = XPROCESS(process)->pid;
        if (network_connection_p(process))
                /* return Qnil; */
                return Fcons(Fcar(pid), Fcdr(pid));
        else
                return pid;
}

DEFUN("process-name", Fprocess_name, 1, 1, 0,   /*
Return the name of PROCESS, as a string.
This is the name of the program invoked in PROCESS,
possibly modified to make it unique among process names.
*/
      (process))
{
        CHECK_PROCESS(process);
        return XPROCESS(process)->name;
}

DEFUN("process-command", Fprocess_command, 1, 1, 0,     /*
Return the command that was executed to start PROCESS.
This is a list of strings, the first string being the program executed
and the rest of the strings being the arguments given to it.
*/
      (process))
{
        CHECK_PROCESS(process);
        return XPROCESS(process)->command;
}
\f
/************************************************************************/
/*                          creating a process                          */
/************************************************************************/

Lisp_Object make_process_internal(Lisp_Object name)
{
        Lisp_Object val, name1;
        int i;
        Lisp_Process *p = alloc_lcrecord_type(Lisp_Process, &lrecord_process);

        /* If name is already in use, modify it until it is unused.  */
        name1 = name;
        for (i = 1;; i++) {
                char suffix[24];
                int sz;
                Lisp_Object tem = Fget_process(name1);
                if (NILP(tem))
                        break;
                sz = snprintf(suffix, sizeof(suffix), "<%d>", i);
                assert(sz>=0 && sz<sizeof(suffix));
                name1 = concat2(name, build_string(suffix));
        }
        name = name1;
        p->name = name;

        p->command = Qnil;
        p->filter = Qnil;
        p->sentinel = Qnil;
        p->buffer = Qnil;
        p->mark = Fmake_marker();
        p->pid = Qnil;
        p->status_symbol = Qrun;
        p->exit_code = 0;
        p->core_dumped = 0;
        p->filter_does_read = 0;
        p->kill_without_query = 0;
        p->selected = 0;
        p->tick = 0;
        p->update_tick = 0;
        p->pipe_instream = Qnil;
        p->pipe_outstream = Qnil;
#ifdef FILE_CODING
        p->coding_instream = Qnil;
        p->coding_outstream = Qnil;
#endif
        p->process_type = PROCESS_TYPE_PROC;
        p->process_type_data = Qnil;

        p->process_data = 0;
        MAYBE_PROCMETH(alloc_process_data, (p));

        XSETPROCESS(val, p);

        Vprocess_list = Fcons(val, Vprocess_list);
        return val;
}

void init_process_io_handles(Lisp_Process * p, void *in, void *out, int flags)
{
        USID usid = event_stream_create_stream_pair(in, out,
                                                    &p->pipe_instream,
                                                    &p->pipe_outstream,
                                                    flags);

        if (usid == USID_ERROR)
                report_file_error("Setting up communication with subprocess",
                                  Qnil);

        if (usid != USID_DONTHASH) {
                Lisp_Object process = Qnil;
                XSETPROCESS(process, p);
                puthash((const void *)usid, LISP_TO_VOID(process),
                        usid_to_process);
        }

        MAYBE_PROCMETH(init_process_io_handles, (p, in, out, flags));

#ifdef FILE_CODING
        p->coding_instream = make_decoding_input_stream
            (XLSTREAM(p->pipe_instream),
             Fget_coding_system(Vcoding_system_for_read));
        Lstream_set_character_mode(XLSTREAM(p->coding_instream));
        p->coding_outstream = make_encoding_output_stream
            (XLSTREAM(p->pipe_outstream),
             Fget_coding_system(Vcoding_system_for_write));
        /* CODE_CNTL (&out_state[outchannel]) |= CC_END; !!####
           What's going on here? */
#endif                          /* FILE_CODING */
}

static void
create_process(Lisp_Object process, Lisp_Object * argv, int nargv,
               Lisp_Object program, Lisp_Object cur_dir)
{
        Lisp_Process *p = XPROCESS(process);
        int pid;

        /* *_create_process may change status_symbol, if the process
           is a kind of "fire-and-forget" (no I/O, unwaitable) */
        p->status_symbol = Qrun;
        p->exit_code = 0;

        pid = PROCMETH(create_process, (p, argv, nargv, program, cur_dir));

        p->pid = make_int(pid);
        if (PROCESS_READABLE_P(p))
                event_stream_select_process(p);
}

/* This function is the unwind_protect form for Fstart_process_internal.  If
   PROCESS doesn't have its pid set, then we know someone has signalled
   an error and the process wasn't started successfully, so we should
   remove it from the process list.  */
static void remove_process(Lisp_Object process);
static Lisp_Object start_process_unwind(Lisp_Object process)
{
        /* Was PROCESS started successfully?  */
        if (EQ(XPROCESS(process)->pid, Qnil))
                remove_process(process);
        return Qnil;
}

DEFUN("start-process-internal", Fstart_process_internal, 3, MANY, 0,    /*
Start a program in a subprocess.  Return the process object for it.
Args are NAME BUFFER PROGRAM &rest PROGRAM-ARGS
NAME is name for process.  It is modified if necessary to make it unique.
BUFFER is the buffer or (buffer-name) to associate with the process.
Process output goes at end of that buffer, unless you specify
an output stream or filter function to handle the output.
BUFFER may be also nil, meaning that this process is not associated
with any buffer
Third arg is program file name.  It is searched for as in the shell.
Remaining arguments are strings to give program as arguments.
If bound, `coding-system-for-read' and `coding-system-for-write' specify
the coding-system objects used in input from and output to the process.
*/
      (int nargs, Lisp_Object * args))
{
        /* This function can call lisp */
        /* !!#### This function has not been Mule-ized */
        Lisp_Object buffer, name, program, process, current_dir;
        Lisp_Object tem;
        int i;
        int speccount = specpdl_depth();
        struct gcpro gcpro1, gcpro2, gcpro3;

        name = args[0];
        buffer = args[1];
        program = args[2];
        current_dir = Qnil;

        /* Protect against various file handlers doing GCs below. */
        GCPRO3(buffer, program, current_dir);

        if (!NILP(buffer))
                buffer = Fget_buffer_create(buffer);

        CHECK_STRING(name);
        CHECK_STRING(program);
        for (i = 3; i < nargs; ++i)
                CHECK_STRING(args[i]);

        /* Make sure that the child will be able to chdir to the current
           buffer's current directory, or its unhandled equivalent.  We
           can't just have the child check for an error when it does the
           chdir, since it's in a vfork.

           Note: these assignments and calls are like this in order to insure
           "caller protects args" GC semantics. */
        current_dir = current_buffer->directory;
        current_dir = Funhandled_file_name_directory(current_dir);
        current_dir = expand_and_dir_to_file(current_dir, Qnil);

#if 0                           /* This loser breaks ange-ftp */
        /* dmoore - if you re-enable this code, you have to gcprotect
           current_buffer through the above calls. */
        if (NILP(Ffile_accessible_directory_p(current_dir)))
                report_file_error("Setting current directory",
                                  list1(current_buffer->directory));
#endif                          /* 0 */

        /* If program file name is not absolute, search our path for it */
        if (!IS_DIRECTORY_SEP(XSTRING_BYTE(program, 0))
            && !(XSTRING_LENGTH(program) > 1
                 && IS_DEVICE_SEP(XSTRING_BYTE(program, 1)))) {
                struct gcpro ngcpro1;

                tem = Qnil;
                NGCPRO1(tem);
                locate_file(Vexec_path, program, Vlisp_EXEC_SUFFIXES, &tem,
                            X_OK);
                if (NILP(tem))
                        report_file_error("Searching for program",
                                          list1(program));
                program = Fexpand_file_name(tem, Qnil);
                NUNGCPRO;
        } else {
                /* we still need to canonicalize it and ensure it has the proper
                   ending, e.g. .exe */
                struct gcpro ngcpro1;

                tem = Qnil;
                NGCPRO1(tem);
                locate_file(list1(build_string("")), program,
                            Vlisp_EXEC_SUFFIXES, &tem, X_OK);
                if (NILP(tem))
                        report_file_error("Searching for program",
                                          list1(program));
                program = tem;
                NUNGCPRO;
        }

        if (!NILP(Ffile_directory_p(program)))
                invalid_operation
                    ("Specified program for new process is a directory",
                     program);

        process = make_process_internal(name);

        XPROCESS(process)->buffer = buffer;
        XPROCESS(process)->command = Flist(nargs - 2, args + 2);

        /* Make the process marker point into the process buffer (if any).  */
        if (!NILP(buffer))
                Fset_marker(XPROCESS(process)->mark,
                            make_int(BUF_ZV(XBUFFER(buffer))), buffer);

        /* If an error occurs and we can't start the process, we want to
           remove it from the process list.  This means that each error
           check in create_process doesn't need to call remove_process
           itself; it's all taken care of here.  */
        record_unwind_protect(start_process_unwind, process);

        create_process(process, args + 3, nargs - 3, program, current_dir);

        UNGCPRO;
        return unbind_to(speccount, process);
}
\f
#ifdef HAVE_SOCKETS

/* #### The network support is fairly synthetical. What we actually
   need is a single function, which supports all datagram, stream and
   packet stream connections, arbitrary protocol families should they
   be supported by the target system, multicast groups, in both data
   and control rooted/nonrooted flavors, service quality etc whatever
   is supported by the underlying network.

   It must accept a property list describing the connection. The current
   functions must then go to lisp and provide a suitable list for the
   generalized connection function.

   All modern UNIX other OSs support BSD sockets, and there are many
   extensions available (Sockets 2 spec).

   A todo is define a consistent set of properties abstracting a
   network connection.   -kkm
*/



DEFUN("network-process-listener", Fnetwork_process_listener, 1, 1, 0, /*
Returns the process that listened and accepted the given
network-process. Returns nil if process is closed or was not accepted
through a network server stream.

Args are PROCESS 

PROCESS should be a network-stream process accepted through a network
*/
      (process))
{

        CHECK_PROCESS(process);
        return MAYBE_LISP_PROCMETH(network_process_listener, (process));
}


/* Listen for a TCP network connection to a given SERVICE.  Treated
   exactly like a normal process when reading and writing.  Only
   differences are in status display and process deletion.  A network
   connection has no PID; you cannot signal it.  All you can do is
   deactivate and close it via delete-process. You must provide a
   sentinel. */
DEFUN("open-network-server-stream-internal", Fopen_network_server_stream_internal, 4, 8, 0,     /*
Returns a process object to represent the listening connection. When a
new connection request arrives, it is automatically accepted. A
network-stream process is automatically created for that
connection. If needed a new buffer is also created. If given the
acceptor function is called. If defined filter and sentinel are set
for the new connection process .

Input and output work as for subprocesses; `delete-process' closes it.  

Args are NAME BUFFER HOST SERVICE &optional PROTOCOL ACCEPTOR .  

NAME is name for process.  It is modified if necessary to make it
unique.

BUFFER is the buffer (or buffer-name) to associate with the process.
 Listening Process output goes at end of that buffer, unless you
 specify an output stream or filter function to handle the output. No
 real process output of listening process is expected. However the
 name of this buffer will be used as a base for generating a new
 buffer name for the accepted connections.  
 The BUFFER may be also nil, meaning that this process is not
 associated with any buffer. In this case a filter should be specified
 otherwise there will be no way to retrieve the process output.  
 BUFFER may also be 'auto in which case a buffer is automatically
 created for the accepted connection.

Third arg HOST (a string) is the name of the IP to bind to, or its
 IP address, If nil or ip_any will bind to all addresses on the
 machine. When HOST is 'localhost listening connection will listen
 to connections from the local machine only.
Fourth arg SERVICE is name of the service desired, or an integer
 specifying a port number to connect to.
Fifth argument PROTOCOL is a network protocol.  Currently 'tcp
 (Transmission Control Protocol) and 'udp (User Datagram Protocol) are
 supported.  When omitted, 'tcp is assumed.
Sixt argument ACCEPTOR is a function which will be called upon connection
 acceptance with the accepted connection process as the single argument.
Seventh argument FILTER is a function which will be set as filter for
 the accepted connections automatically. See `set-process-filter' for
 more details.  
Eight argument SENTINEL is a function which will be set as sentinel
 the accepted connections automatically. see `set-process-sentinel'