process.h 7.83 KB
Newer Older
Jim Blandy's avatar
Jim Blandy committed
1
/* Definitions for asynchronous process control in GNU Emacs.
2
   Copyright (C) 1985, 1994, 2001-2012  Free Software Foundation, Inc.
Jim Blandy's avatar
Jim Blandy committed
3 4 5

This file is part of GNU Emacs.

6
GNU Emacs is free software: you can redistribute it and/or modify
Jim Blandy's avatar
Jim Blandy committed
7
it under the terms of the GNU General Public License as published by
8 9
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Jim Blandy's avatar
Jim Blandy committed
10 11 12 13 14 15 16

GNU Emacs 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
17
along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
Jim Blandy's avatar
Jim Blandy committed
18

Stefan Monnier's avatar
Stefan Monnier committed
19 20 21
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
Paul Eggert's avatar
Paul Eggert committed
22

Stefan Monnier's avatar
Stefan Monnier committed
23
#include <unistd.h>
Jim Blandy's avatar
Jim Blandy committed
24

Ted Zlatanov's avatar
Ted Zlatanov committed
25 26 27 28
#ifdef HAVE_GNUTLS
#include "gnutls.h"
#endif

29 30
/* Most code should use these macros to access Lisp fields in
   struct Lisp_Process.  PGET should not be used as lvalue.  */
31

32 33 34 35 36 37
#define PGET(p, field)						\
  (eassert (offsetof (struct Lisp_Process, field ## _)		\
	    < offsetof (struct Lisp_Process, pid)),		\
   ((p)->INTERNAL_FIELD (field)))

#define PSET(p, field, value) ((p)->INTERNAL_FIELD (field) = (value))
38

39 40
/* This structure records information about a subprocess
   or network connection.  */
Jim Blandy's avatar
Jim Blandy committed
41 42 43

struct Lisp_Process
  {
44
    struct vectorlike_header header;
45

46
    /* Name of subprocess terminal.  */
47 48
    Lisp_Object INTERNAL_FIELD (tty_name);

Jim Blandy's avatar
Jim Blandy committed
49
    /* Name of this process */
50 51
    Lisp_Object INTERNAL_FIELD (name);

52 53
    /* List of command arguments that this process was run with.
       Is set to t for a stopped network process; nil otherwise. */
54 55
    Lisp_Object INTERNAL_FIELD (command);

Jim Blandy's avatar
Jim Blandy committed
56 57
    /* (funcall FILTER PROC STRING)  (if FILTER is non-nil)
       to dispose of a bunch of chars from the process all at once */
58 59
    Lisp_Object INTERNAL_FIELD (filter);

Jim Blandy's avatar
Jim Blandy committed
60
    /* (funcall SENTINEL PROCESS) when process state changes */
61 62
    Lisp_Object INTERNAL_FIELD (sentinel);

63 64
    /* (funcall LOG SERVER CLIENT MESSAGE) when a server process
       accepts a connection from a client.  */
65 66
    Lisp_Object INTERNAL_FIELD (log);

Jim Blandy's avatar
Jim Blandy committed
67
    /* Buffer that output is going to */
68 69
    Lisp_Object INTERNAL_FIELD (buffer);

70 71 72
    /* t if this is a real child process.  For a network or serial
       connection, it is a plist based on the arguments to
       make-network-process or make-serial-process.  */
73 74 75

    Lisp_Object INTERNAL_FIELD (childp);

76
    /* Plist for programs to keep per-process state information, parameters, etc.  */
77 78
    Lisp_Object INTERNAL_FIELD (plist);

79
    /* Symbol indicating the type of process: real, network, serial  */
80 81
    Lisp_Object INTERNAL_FIELD (type);

Jim Blandy's avatar
Jim Blandy committed
82
    /* Marker set to end of last buffer-inserted output from this process */
83 84
    Lisp_Object INTERNAL_FIELD (mark);

Jim Blandy's avatar
Jim Blandy committed
85 86 87 88 89
    /* Symbol indicating status of process.
       This may be a symbol: run, open, or closed.
       Or it may be a list, whose car is stop, exit or signal
       and whose cdr is a pair (EXIT_CODE . COREDUMP_FLAG)
       or (SIGNAL_NUMBER . COREDUMP_FLAG).  */
90 91
    Lisp_Object INTERNAL_FIELD (status);

92
    /* Coding-system for decoding the input from this process.  */
93 94
    Lisp_Object INTERNAL_FIELD (decode_coding_system);

95
    /* Working buffer for decoding.  */
96 97
    Lisp_Object INTERNAL_FIELD (decoding_buf);

98
    /* Coding-system for encoding the output to this process.  */
99 100
    Lisp_Object INTERNAL_FIELD (encode_coding_system);

101
    /* Working buffer for encoding.  */
102 103
    Lisp_Object INTERNAL_FIELD (encoding_buf);

104
    /* Queue for storing waiting writes */
105
    Lisp_Object INTERNAL_FIELD (write_queue);
106

Ted Zlatanov's avatar
Ted Zlatanov committed
107
#ifdef HAVE_GNUTLS
108
    Lisp_Object INTERNAL_FIELD (gnutls_cred_type);
Ted Zlatanov's avatar
Ted Zlatanov committed
109 110
#endif

111
    /* After this point, there are no Lisp_Objects any more.  */
112
    /* alloc.c assumes that `pid' is the first such non-Lisp slot.  */
113 114 115

    /* Number of this process.
       allocate_process assumes this is the first non-Lisp_Object field.
116 117
       A value 0 is used for pseudo-processes such as network or serial
       connections.  */
118
    pid_t pid;
119 120 121 122 123
    /* Descriptor by which we read from this process */
    int infd;
    /* Descriptor by which we write to this process */
    int outfd;
    /* Event-count of last event in which this process changed status.  */
124
    EMACS_INT tick;
125
    /* Event-count of last such event reported.  */
126
    EMACS_INT update_tick;
127 128 129 130 131 132
    /* Size of carryover in decoding.  */
    int decoding_carryover;
    /* Hysteresis to try to read process output in larger blocks.
       On some systems, e.g. GNU/Linux, Emacs is seen as
       an interactive app also when reading process output, meaning
       that process output can be read in as little as 1 byte at a
133 134
       time.  Value is nanoseconds to delay reading output from
       this process.  Range is 0 .. 50 * 1000 * 1000.  */
135 136 137 138
    int read_output_delay;
    /* Should we delay reading output from this process.
       Initialized from `Vprocess_adaptive_read_buffering'.
       0 = nil, 1 = t, 2 = other.  */
139
    unsigned int adaptive_read_buffering : 2;
140
    /* Skip reading this process on next read.  */
141
    unsigned int read_output_skip : 1;
142 143
    /* Non-nil means kill silently if Emacs is exited.
       This is the inverse of the `query-on-exit' flag.  */
144
    unsigned int kill_without_query : 1;
145
    /* Non-nil if communicating through a pty.  */
146
    unsigned int pty_flag : 1;
147 148
    /* Flag to set coding-system of the process buffer from the
       coding_system used to decode process output.  */
149
    unsigned int inherit_coding_system_flag : 1;
150 151 152 153
    /* Record the process status in the raw form in which it comes from `wait'.
       This is to avoid consing in a signal handler.  The `raw_status_new'
       flag indicates that `raw_status' contains a new status that still
       needs to be synced to `status'.  */
154
    unsigned int raw_status_new : 1;
155
    int raw_status;
Ted Zlatanov's avatar
Ted Zlatanov committed
156 157 158 159

#ifdef HAVE_GNUTLS
    gnutls_initstage_t gnutls_initstage;
    gnutls_session_t gnutls_state;
160 161 162
    gnutls_certificate_client_credentials gnutls_x509_cred;
    gnutls_anon_client_credentials_t gnutls_anon_cred;
    int gnutls_log_level;
163
    int gnutls_handshakes_tried;
164
    int gnutls_p;
Ted Zlatanov's avatar
Ted Zlatanov committed
165
#endif
Jim Blandy's avatar
Jim Blandy committed
166 167
};

168 169 170
/* Every field in the preceding structure except for the first two
   must be a Lisp_Object, for GC's sake.  */

171
#define ChannelMask(n) (1 << (n))
Jim Blandy's avatar
Jim Blandy committed
172

Glenn Morris's avatar
Glenn Morris committed
173
/* True if we are about to fork off a synchronous process or if we
Jim Blandy's avatar
Jim Blandy committed
174 175 176
   are waiting for it.  */
extern int synch_process_alive;

Karl Heuer's avatar
Karl Heuer committed
177
/* Communicate exit status of sync process to from sigchld_handler
Jim Blandy's avatar
Jim Blandy committed
178 179
   to Fcall_process.  */

Jim Blandy's avatar
Jim Blandy committed
180
/* Nonzero => this is a string explaining death of synchronous subprocess.  */
181
extern const char *synch_process_death;
Jim Blandy's avatar
Jim Blandy committed
182

183
/* Nonzero => this is the signal number that terminated the subprocess.  */
184
extern int synch_process_termsig;
185

Jim Blandy's avatar
Jim Blandy committed
186 187 188 189
/* If synch_process_death is zero,
   this is exit code of synchronous subprocess.  */
extern int synch_process_retcode;

190 191 192 193
/* Nonzero means don't run process sentinels.  This is used
   when exiting.  */
extern int inhibit_sentinels;

194 195 196 197
extern Lisp_Object Qeuid, Qegid, Qcomm, Qstate, Qppid, Qpgrp, Qsess, Qttname;
extern Lisp_Object Qminflt, Qmajflt, Qcminflt, Qcmajflt, Qutime, Qstime;
extern Lisp_Object Qcutime, Qpri, Qnice, Qthcount, Qstart, Qvsize, Qrss, Qargs;
extern Lisp_Object Quser, Qgroup, Qetime, Qpcpu, Qpmem, Qtpgid, Qcstime;
Eli Zaretskii's avatar
Eli Zaretskii committed
198
extern Lisp_Object Qtime, Qctime;
199
extern Lisp_Object QCspeed;
200 201
extern Lisp_Object QCbytesize, QCstopbits, QCparity, Qodd, Qeven;
extern Lisp_Object QCflowcontrol, Qhw, Qsw, QCsummary;
202

203 204 205
extern Lisp_Object list_system_processes (void);
extern Lisp_Object system_process_attributes (Lisp_Object);

206 207 208 209
extern void hold_keyboard_input (void);
extern void unhold_keyboard_input (void);
extern int kbd_on_hold_p (void);

210 211 212 213 214 215
typedef void (*fd_callback)(int fd, void *data, int for_read);

extern void add_read_fd (int fd, fd_callback func, void *data);
extern void delete_read_fd (int fd);
extern void add_write_fd (int fd, fd_callback func, void *data);
extern void delete_write_fd (int fd);