channel.h 9.18 KB
Newer Older
Niels Möller's avatar
Niels Möller committed
1
2
3
4
5
/* channel.h
 *
 * Information about one ssh channel.
 */

Niels Möller's avatar
Niels Möller committed
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/* 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
25
26
27
#ifndef LSH_CHANNEL_H_INCLUDED
#define LSH_CHANNEL_H_INCLUDED

Niels Möller's avatar
Niels Möller committed
28
29
30
#include "alist.h"
#include "connection.h"
#include "parse.h"
Niels Möller's avatar
Niels Möller committed
31
#include "server_pty.h"
Niels Möller's avatar
Niels Möller committed
32

33
34
35
36
#define CLASS_DECLARE
#include "channel.h.x"
#undef CLASS_DECLARE

Niels Möller's avatar
Niels Möller committed
37
38
39
40
41
42
43
44
/* 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

45
#define CHANNEL_SENT_CLOSE 1
46
#define CHANNEL_RECEIVED_CLOSE 2
47
#define CHANNEL_SENT_EOF 4
48
#define CHANNEL_RECEIVED_EOF 8
49

50
/* Means that we should send close when we have both sent and received EOF. */
51
#define CHANNEL_CLOSE_AT_EOF 0x10
52

53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
/* CLASS:
   (class
     (name ssh_channel)
     (vars
       ; Remote channel number 
       (channel_number simple UINT32)

       ; We try to keep the rec_window_size ; between max_window / 2
       ; 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?
72
73
       ; Now that we pass the connection pointer to most functions,
       ; is this field needed at all?
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
       (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
91
       (receive method int "int type" "struct lsh_string *data")
92
93
94
95

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

Niels Möller's avatar
Niels Möller committed
96
97
       ; Called when the channel is closed
       ; FIXME: Is this needed for anything?
98
99
       (close method void)

100
       ; Called when eof is received on the channel (or when it is
101
102
103
104
105
106
107
108
109
110
       ; closed, whatever happens first).
 
       (eof method int)
  
       ; Reply from SSH_MSG_CHANNEL_OPEN_REQUEST
       (open_confirm method int)
       (open_failure method int)

       ; Reply from SSH_MSG_CHANNEL_REQUEST 
       (channel_success method int)
Niels Möller's avatar
Niels Möller committed
111
       (channel_failure method int))) */
112

113
114
#define CHANNEL_RECEIVE(s, t, d) \
((s)->receive((s), (t), (d)))
Niels Möller's avatar
Niels Möller committed
115

116
117
118
119
#define CHANNEL_SEND(s) ((s)->send((s)))
     
#define CHANNEL_CLOSE(s) \
((s)->close((s)))
Niels Möller's avatar
Niels Möller committed
120

121
122
#define CHANNEL_EOF(s) \
((s)->eof((s)))
Niels Möller's avatar
Niels Möller committed
123

124
125
#define CHANNEL_OPEN_CONFIRM(s) \
((s)->open_confirm((s)))
126

127
128
#define CHANNEL_OPEN_FAILURE(s) \
((s)->open_failure((s)))
Niels Möller's avatar
Niels Möller committed
129

130
131
#define CHANNEL_SUCCESS(s) \
((s)->channel_success((s)))
Niels Möller's avatar
Niels Möller committed
132

133
134
#define CHANNEL_FAILURE(s) \
((s)->channel_failure((s)))
135
     
Niels Möller's avatar
Niels Möller committed
136
/* FIXME: Perhaps, this information is better kept in the connection
137
 * object? */
138
139
140
141
142
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

/* CLASS:
   (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
169
170

/* SSH_MSG_GLOBAL_REQUEST */
171
172
173
174
/* CLASS:
   (class
     (name global_request)
     (vars
175
176
       (handler method int "struct ssh_connection *connection"
                           "int want_reply" "struct simple_buffer *args")))
177
178
*/

179
#define GLOBAL_REQUEST(r, c, w, a) ((r)->handler((r), (c), (w), (a)))
Niels Möller's avatar
Niels Möller committed
180
181

/* SSH_MSG_CHANNEL_OPEN */
182
183
184
185
186
187
188
189
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
  
/* Callback function, used to report success or failure for a
 * requested channel open. */
  
/* CLASS:
   (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))

217
218
219
220
/* CLASS:
   (class
     (name channel_open)
     (vars
221
       (handler method int
222
                "struct ssh_connection *connection"
223
224
                "struct simple_buffer *data"
                "struct channel_open_callback *response")))
225
226
*/

227
228
#define CHANNEL_OPEN(o, c, d, n) \
((o)->handler((o), (c), (d), (n)))
Niels Möller's avatar
Niels Möller committed
229

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

242
243
#define CHANNEL_REQUEST(s, c, conn, w, a) \
((s)->handler((s), (c), (conn), (w), (a)))
Niels Möller's avatar
Niels Möller committed
244

245
246
247
248
249
/* CLASS:
   (class
     (name connection_startup)
     (vars
       (start method int
250
	      "struct ssh_connection *connection")))
251
252
*/

253
#define CONNECTION_START(c, s) ((c)->start((c), (s)))
254

255
256
void init_channel(struct ssh_channel *channel);

257
258
259
260
261
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
262

263
264
265
266
267
268
269
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
270
struct lsh_string *format_global_failure(void);
271
struct lsh_string *format_global_success(void);
272

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

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

Niels Möller's avatar
Niels Möller committed
282
283
284
struct lsh_string *prepare_window_adjust(struct ssh_channel *channel,
					 UINT32 add);

285
struct lsh_string *prepare_channel_open(struct channel_table *table,
286
287
					int type,
					struct ssh_channel *channel,
288
					const char *format, ...);
289

290
291
292
293
struct lsh_string *format_channel_request(int type,
					  struct ssh_channel *channel,
					  int want_reply,
					  const char *format, ...);
294

295
296
struct lsh_string *format_channel_close(struct ssh_channel *channel);
struct lsh_string *format_channel_eof(struct ssh_channel *channel);
297

298
299
int channel_close(struct ssh_channel *channel);
int channel_eof(struct ssh_channel *channel);
300

301
302
struct close_callback *make_channel_close(struct ssh_channel *channel);

303
304
struct lsh_string *channel_transmit_data(struct ssh_channel *channel,
					 struct lsh_string *data);
305

306
307
308
struct lsh_string *channel_transmit_extended(struct ssh_channel *channel,
					     UINT32 type,
					     struct lsh_string *data);
309

Niels Möller's avatar
Niels Möller committed
310
struct ssh_service *make_connection_service(struct alist *global_requests,
311
312
313
					    struct alist *channel_types,
					    struct connection_startup *start);

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

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