channel.h 9.21 KB
Newer Older
Niels Möller's avatar
Niels Möller committed
1
2
/* channel.h
 *
3
4
5
 * Information about ssh channels.
 *
 * $Id$
Niels Möller's avatar
Niels Möller committed
6
7
 */

Niels Möller's avatar
Niels Möller committed
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/* lsh, an implementation of the ssh protocol
 *
 * Copyright (C) 1998 Niels Mller
 *
 * This program 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 2 of the
 * License, or (at your option) any later version.
 *
 * This program 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

Niels Möller's avatar
Niels Möller committed
27
28
29
#ifndef LSH_CHANNEL_H_INCLUDED
#define LSH_CHANNEL_H_INCLUDED

Niels Möller's avatar
Niels Möller committed
30
#include "alist.h"
31
#include "command.h"
Niels Möller's avatar
Niels Möller committed
32
33
#include "connection.h"
#include "parse.h"
Niels Möller's avatar
Niels Möller committed
34
#include "server_pty.h"
Niels Möller's avatar
Niels Möller committed
35

36
#define GABA_DECLARE
37
#include "channel.h.x"
38
#undef GABA_DECLARE
39

Niels Möller's avatar
Niels Möller committed
40
41
42
43
44
45
46
47
/* Channels are indexed by local channel number in some array. This
 * index is not stored in the channel struct. When sending messages on
 * the channel, it is identified by the *remote* sides index number,
 * and this number must be stored. */

#define CHANNEL_DATA 0
#define CHANNEL_STDERR_DATA 1

48
#define CHANNEL_SENT_CLOSE 1
49
#define CHANNEL_RECEIVED_CLOSE 2
50
#define CHANNEL_SENT_EOF 4
51
#define CHANNEL_RECEIVED_EOF 8
52

53
/* Means that we should send close when we have both sent and received EOF. */
54
#define CHANNEL_CLOSE_AT_EOF 0x10
55

56

57
/* GABA:
58
59
60
61
62
63
   (class
     (name ssh_channel)
     (vars
       ; Remote channel number 
       (channel_number simple UINT32)

64
       ; We try to keep the rec_window_size between max_window / 2
65
66
67
68
69
70
71
72
73
74
75
       ; and max_window.
       (max_window simple UINT32)       

       (rec_window_size simple UINT32)
       (rec_max_packet simple UINT32)

       (send_window_size simple UINT32)
       (send_max_packet simple UINT32)

       ; FIXME: Perhaps this should be moved to the channel_table, and
       ; a pointer to that table be stored here instead?
76
77
       ; Now that we pass the connection pointer to most functions,
       ; is this field needed at all?
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
       (write object abstract_write)
  
       (request_types object alist)

       (flags simple int)

       ; Number of files connected to this channel. For instance,
       ; stdout and stderr can be multiplexed on the same channel. We
       ; should not close the channel until we have got an EOF on both
       ; sources.
       (sources simple int)

       ; FIXME: What about return values from these functions? A
       ; channel may fail to process it's data. Is there some way to
       ; propagate a channel broken message to the other end? 

       ; Type is CHANNEL_DATA or CHANNEL_STDERR_DATA
95
       (receive method int "int type" "struct lsh_string *data")
96
97
98
99

       ; Called when we are allowed to send data on the channel. 
       (send method int)

Niels Möller's avatar
Niels Möller committed
100
101
       ; Called when the channel is closed
       ; FIXME: Is this needed for anything?
102
       (close method int)
103

104
       ; Called when eof is received on the channel (or when it is
105
106
107
108
       ; closed, whatever happens first).
       (eof method int)
  
       ; Reply from SSH_MSG_CHANNEL_OPEN_REQUEST
109
110
111
       ;; (open_confirm method int)
       ;; (open_failure method int)
       (open_continuation object command_continuation)
112

113
114
115
       ;; Queue of channel requests that we expect replies on
       (pending_requests struct object_queue)))
       
116
       ; Reply from SSH_MSG_CHANNEL_REQUEST 
117
118
119
       ;; (channel_success method int)
       ;; (channel_failure method int)))
*/
120

121
122
#define CHANNEL_RECEIVE(s, t, d) \
((s)->receive((s), (t), (d)))
Niels Möller's avatar
Niels Möller committed
123

124
125
126
127
#define CHANNEL_SEND(s) ((s)->send((s)))
     
#define CHANNEL_CLOSE(s) \
((s)->close((s)))
Niels Möller's avatar
Niels Möller committed
128

129
130
#define CHANNEL_EOF(s) \
((s)->eof((s)))
Niels Möller's avatar
Niels Möller committed
131

132
133
#define CHANNEL_OPEN_CONFIRM(s) \
((s)->open_confirm((s)))
134

135
136
#define CHANNEL_OPEN_FAILURE(s) \
((s)->open_failure((s)))
Niels Möller's avatar
Niels Möller committed
137

138
     
Niels Möller's avatar
Niels Möller committed
139
/* FIXME: Perhaps, this information is better kept in the connection
140
 * object? */
141

142
/* GABA:
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
   (class
     (name channel_table)
     (vars
       ; FIXME: This is relevant only for the server side. It's
       ; probably better to store this in the connection struct.

       ;; uid_t user;  ; Authenticated user 

       ; Channels are indexed by local number
       (channels pointer (object ssh_channel) used_channels)

       ; Allocation of local channel numbers is managed using the same
       ; method as is traditionally used for allocation of unix file 
       ; descriptors.

       (allocated_channels simple UINT32)
       (next_channel simple UINT32)
     
       (used_channels simple UINT32)
       (max_channels simple UINT32) ; Max number of channels allowed 

       ; If non-zero, close connection after all active channels have
       ; died.
       (pending_close simple int)

       ; FIXME: Perhaps we should use an flag to indicate whether or
       ; not new channels can be opened?
       ))
*/
Niels Möller's avatar
Niels Möller committed
172
173

/* SSH_MSG_GLOBAL_REQUEST */
174
/* GABA:
175
176
177
   (class
     (name global_request)
     (vars
178
179
       (handler method int "struct ssh_connection *connection"
                           "int want_reply" "struct simple_buffer *args")))
180
181
*/

182
#define GLOBAL_REQUEST(r, c, w, a) ((r)->handler((r), (c), (w), (a)))
Niels Möller's avatar
Niels Möller committed
183
184

/* SSH_MSG_CHANNEL_OPEN */
185
186
187
188
  
/* Callback function, used to report success or failure for a
 * requested channel open. */
  
189
/* GABA:
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
   (class
     (name channel_open_callback)
     (vars
       (response method int
                "struct ssh_channel *channel"
                "UINT32 error"
                "char *error_msg"
                "struct lsh_string *args")
       (connection object ssh_connection)))
*/
  
/* xxCLASS:
   (class
     (name channel_open_response)
     (vars
       (response method int
                "struct ssh_channel *channel"
                "UINT32 error"
		; FIXME: Use an lsh_string for error messages
                "char *error_msg"
                "struct lsh_string *args")
       (connection object ssh_connection)
       (remote_channel_number simple UINT32)
       (window_size simple UINT32)
       (max_packet simple UINT32)))
*/

#define CHANNEL_OPEN_CALLBACK(c, ch, e, m, a) \
  (c)->response((c), (ch), (e), (m), (a))

220
/* GABA:
221
222
223
   (class
     (name channel_open)
     (vars
224
       (handler method int
225
                "struct ssh_connection *connection"
226
227
                "struct simple_buffer *data"
                "struct channel_open_callback *response")))
228
229
*/

230
231
#define CHANNEL_OPEN(o, c, d, n) \
((o)->handler((o), (c), (d), (n)))
Niels Möller's avatar
Niels Möller committed
232

Niels Möller's avatar
Niels Möller committed
233
/* SSH_MSG_CHANNEL_REQUEST */
234
/* GABA:
235
236
237
238
239
   (class
     (name channel_request)
     (vars
       (handler method int
		"struct ssh_channel *channel"
240
		"struct ssh_connection *connection"
241
242
243
244
		"int want_reply"
		"struct simple_buffer *args")))
*/

245
246
#define CHANNEL_REQUEST(s, c, conn, w, a) \
((s)->handler((s), (c), (conn), (w), (a)))
Niels Möller's avatar
Niels Möller committed
247

248
/* GABA:
249
250
251
252
   (class
     (name connection_startup)
     (vars
       (start method int
253
	      "struct ssh_connection *connection")))
254
255
*/

256
#define CONNECTION_START(c, s) ((c)->start((c), (s)))
257

258
259
void init_channel(struct ssh_channel *channel);

260
261
262
263
264
struct channel_table *make_channel_table(void);
int alloc_channel(struct channel_table *table);
void dealloc_channel(struct channel_table *table, int i);
int register_channel(struct channel_table *table, struct ssh_channel *channel);
struct ssh_channel *lookup_channel(struct channel_table *table, UINT32 i);
Niels Möller's avatar
Niels Möller committed
265

266
267
268
269
270
271
272
struct abstract_write *make_channel_write(struct ssh_channel *channel);
struct abstract_write *make_channel_write_extended(struct ssh_channel *channel,
						   UINT32 type);

struct read_handler *make_channel_read_data(struct ssh_channel *channel);
struct read_handler *make_channel_read_stderr(struct ssh_channel *channel);

Niels Möller's avatar
Niels Möller committed
273
struct lsh_string *format_global_failure(void);
274
struct lsh_string *format_global_success(void);
275

Niels Möller's avatar
Niels Möller committed
276
struct lsh_string *format_open_failure(UINT32 channel, UINT32 reason,
277
				       const char *msg, const char *language);
278
279
struct lsh_string *format_open_confirmation(struct ssh_channel *channel,
					    UINT32 channel_number,
280
					    const char *format, ...);
281
282

struct lsh_string *format_channel_success(UINT32 channel);
Niels Möller's avatar
Niels Möller committed
283
284
struct lsh_string *format_channel_failure(UINT32 channel);

Niels Möller's avatar
Niels Möller committed
285
286
287
struct lsh_string *prepare_window_adjust(struct ssh_channel *channel,
					 UINT32 add);

288
struct lsh_string *prepare_channel_open(struct channel_table *table,
289
290
					int type,
					struct ssh_channel *channel,
291
					const char *format, ...);
292

293
294
295
296
struct lsh_string *format_channel_request(int type,
					  struct ssh_channel *channel,
					  int want_reply,
					  const char *format, ...);
297

298
299
struct lsh_string *format_channel_close(struct ssh_channel *channel);
struct lsh_string *format_channel_eof(struct ssh_channel *channel);
300

301
302
int channel_close(struct ssh_channel *channel);
int channel_eof(struct ssh_channel *channel);
303

304
305
struct close_callback *make_channel_close(struct ssh_channel *channel);

306
307
struct lsh_string *channel_transmit_data(struct ssh_channel *channel,
					 struct lsh_string *data);
308

309
310
311
struct lsh_string *channel_transmit_extended(struct ssh_channel *channel,
					     UINT32 type,
					     struct lsh_string *data);
312

313
314
struct command *make_connection_service(struct alist *global_requests,
					struct alist *channel_types);
315

Niels Möller's avatar
Niels Möller committed
316

Niels Möller's avatar
Niels Möller committed
317
#endif /* LSH_CHANNEL_H_INCLUDED */