channel.c 47.2 KB
Newer Older
Niels Möller's avatar
Niels Möller committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/* channel.c
 *
 * $Id$
 */

/* 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
J.H.M. Dassen's avatar
J.H.M. Dassen committed
22
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
Niels Möller's avatar
Niels Möller committed
23
24
25
26
27
 */

#include "channel.h"

#include "format.h"
28
#include "io.h"
Niels Möller's avatar
Niels Möller committed
29
#include "read_data.h"
Niels Möller's avatar
Niels Möller committed
30
31
32
33
34
#include "ssh.h"
#include "werror.h"
#include "xalloc.h"

#include <assert.h>
35
#include <string.h>
Niels Möller's avatar
Niels Möller committed
36

37
#define GABA_DEFINE
38
#include "channel.h.x"
39
#undef GABA_DEFINE
40

41
42
#include "channel.c.x"

43
44
struct exception *
make_channel_open_exception(UINT32 error_code, const char *msg)
Niels Möller's avatar
Niels Möller committed
45
46
{
  NEW(channel_open_exception, self);
Niels Möller's avatar
Niels Möller committed
47
48
49
50
51
52
53
54
55
56
57
58
59
60

#define MAX_ERROR 4
  static const char *msgs[MAX_ERROR + 1] = {
    "",
    "Administratively prohibited",
    "Connect failed",
    "Unknown channel type",
    "Resource shortage"
  };

  assert(error_code > 0);
  assert(error_code <= MAX_ERROR);
#undef MAX_ERROR
  
Niels Möller's avatar
Niels Möller committed
61
  self->super.type = EXC_CHANNEL_OPEN;
Niels Möller's avatar
Niels Möller committed
62
  self->super.msg = msg ? msg : msgs[error_code];
Niels Möller's avatar
Niels Möller committed
63
64
65
66
67
  self->error_code = error_code;

  return &self->super;
}

68
/* GABA:
69
70
   (class
     (name connection_service)
71
     (super command)
72
73
74
75
     (vars
       ; Supported global requests 
       (global_requests object alist)

76
       (channel_types object alist) ))
77
78
79
80

       ; Initialize connection (for instance, request channels to be 
       ; opened or services to be forwarded).

81
       ; (start object connection_startup)))
82
83
*/

84

Niels Möller's avatar
Niels Möller committed
85
86
87
88
89
struct lsh_string *format_global_failure(void)
{
  return ssh_format("%c", SSH_MSG_REQUEST_FAILURE);
}

90
91
92
93
94
struct lsh_string *format_global_success(void)
{
  return ssh_format("%c", SSH_MSG_REQUEST_SUCCESS);
}

95
96
struct lsh_string *format_open_confirmation(struct ssh_channel *channel,
					    UINT32 channel_number,
97
					    const char *format, ...)
98
99
100
101
102
103
{
  va_list args;
  UINT32 l1, l2;
  struct lsh_string *packet;

#define CONFIRM_FORMAT "%c%i%i%i%i"
104
105
#define CONFIRM_ARGS \
  SSH_MSG_CHANNEL_OPEN_CONFIRMATION, channel->channel_number, \
106
107
108
109
110
111
112
113
114
115
116
117
118
  channel_number, channel->rec_window_size, channel->rec_max_packet
    
  l1 = ssh_format_length(CONFIRM_FORMAT, CONFIRM_ARGS);

  va_start(args, format);
  l2 = ssh_vformat_length(format, args);
  va_end(args);

  packet = lsh_string_alloc(l1 + l2);

  ssh_format_write(CONFIRM_FORMAT, l1, packet->data, CONFIRM_ARGS);

  va_start(args, format);
119
  ssh_vformat_write(format, l2, packet->data+l1, args);
120
121
122
123
124
125
126
  va_end(args);

  return packet;
#undef CONFIRM_FORMAT
#undef CONFIRM_ARGS
}

Niels Möller's avatar
Niels Möller committed
127
struct lsh_string *format_open_failure(UINT32 channel, UINT32 reason,
128
				       const char *msg, const char *language)
Niels Möller's avatar
Niels Möller committed
129
130
131
132
133
{
  return ssh_format("%c%i%i%z%z", SSH_MSG_CHANNEL_OPEN_FAILURE,
		    channel, reason, msg, language);
}

134
135
136
137
138
struct lsh_string *format_channel_success(UINT32 channel)
{
  return ssh_format("%c%i", SSH_MSG_CHANNEL_SUCCESS, channel);
}

Niels Möller's avatar
Niels Möller committed
139
140
141
142
143
struct lsh_string *format_channel_failure(UINT32 channel)
{
  return ssh_format("%c%i", SSH_MSG_CHANNEL_FAILURE, channel);
}

144
145
146
147
148
149
150
151
152
153
struct lsh_string *prepare_window_adjust(struct ssh_channel *channel,
					 UINT32 add)
{
  channel->rec_window_size += add;
  
  return ssh_format("%c%i%i",
		    SSH_MSG_CHANNEL_WINDOW_ADJUST,
		    channel->channel_number, add);
}

Niels Möller's avatar
Niels Möller committed
154
155
156
157
158
/* GABA:
   (class
     (name exc_finish_channel_handler)
     (super exception_handler)
     (vars
159
160
       (connection object ssh_connection)
       ;; (table object channel_table)
161
162
       ; Non-zero if the channel has already been deallocated.
       (dead . int)
Niels Möller's avatar
Niels Möller committed
163
164
165
166
       ; Local channel number 
       (channel_number . UINT32)))
*/

167
168
169
static void
do_exc_finish_channel_handler(struct exception_handler *s,
			      const struct exception *e)
Niels Möller's avatar
Niels Möller committed
170
171
172
173
174
{
  CAST(exc_finish_channel_handler, self, s);

  switch (e->type)
    {
Niels Möller's avatar
Niels Möller committed
175
    case EXC_FINISH_PENDING:
176
177
      if (self->dead)
	werror("channel.c: EXC_FINISH_PENDING on dead channel.\n");
Niels Möller's avatar
Niels Möller committed
178

179
      self->connection->table->pending_close = 1;
180
      
181
182
      if (!self->connection->table->next_channel)
	EXCEPTION_RAISE(self->connection->e, &finish_read_exception);
Niels Möller's avatar
Niels Möller committed
183
184
      break;
      
Niels Möller's avatar
Niels Möller committed
185
186
    case EXC_FINISH_CHANNEL:
      /* NOTE: This type of exception must be handled only once.
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
       * However, there is at least one case where it is difficult to
       * ensure that the exception is raised only once.
       *
       * For instance, in do_channel_close, the CHANNEL_EOF callback
       * can decide to call close_channel, which might raise this
       * exception. When control gets back to do_channel_close, and
       * CHANNEL_SENT_CLOSE is true, it raises the exception again.
       *
       * To get this right, we set a flag when the channel is
       * deallocated. */
      if (self->dead)
	debug("EXC_FINISH_CHANNEL on dead channel.\n");
      else
	{
	  struct ssh_channel *channel
202
	    = self->connection->table->channels[self->channel_number];
203
204
205
206
207
208
209
210

	  assert(channel);
	  assert(channel->resources->super.alive);

	  if (channel->close)
	    CHANNEL_CLOSE(channel);
	
	  KILL_RESOURCE_LIST(channel->resources);
Niels Möller's avatar
Niels Möller committed
211
	
212
	  dealloc_channel(self->connection->table, self->channel_number);
213
214
	  self->dead = 1;

215
216
	  if (self->connection->table->pending_close &&
	      !self->connection->table->next_channel)
217
218
	    {
	      /* FIXME: Send a SSH_DISCONNECT_BY_APPLICATION message? */
219
	      EXCEPTION_RAISE(self->connection->e, &finish_read_exception);
220
221
	    }
	}
Niels Möller's avatar
Niels Möller committed
222
223
224
225
226
227
228
      break;
    default:
      EXCEPTION_RAISE(self->super.parent, e);
    }
}

static struct exception_handler *
229
make_exc_finish_channel_handler(struct ssh_connection *connection,
Niels Möller's avatar
Niels Möller committed
230
				UINT32 channel_number,
231
232
				struct exception_handler *e,
				const char *context)
Niels Möller's avatar
Niels Möller committed
233
234
235
236
{
  NEW(exc_finish_channel_handler, self);
  self->super.parent = e;
  self->super.raise = do_exc_finish_channel_handler;
237
  self->super.context = context;
Niels Möller's avatar
Niels Möller committed
238

239
  self->connection = connection;
240
  self->channel_number = channel_number;
241
  self->dead = 0;
242
  
Niels Möller's avatar
Niels Möller committed
243
  return &self->super;
Niels Möller's avatar
Niels Möller committed
244
245
246
}
				

247
/* Channel objects */
Niels Möller's avatar
Niels Möller committed
248
249
250
251
252

#define INITIAL_CHANNELS 32
/* Arbitrary limit */
#define MAX_CHANNELS (1L<<17)

Niels Möller's avatar
Niels Möller committed
253
struct channel_table *make_channel_table(void)
Niels Möller's avatar
Niels Möller committed
254
{
255
  NEW(channel_table, table);
Niels Möller's avatar
Niels Möller committed
256

257
  table->channels = lsh_space_alloc(sizeof(struct ssh_channel *)
258
				      * INITIAL_CHANNELS);
Niels Möller's avatar
Niels Möller committed
259
260
  table->in_use = lsh_space_alloc(INITIAL_CHANNELS);
  
261
262
263
264
  table->allocated_channels = INITIAL_CHANNELS;
  table->next_channel = 0;
  table->used_channels = 0;
  table->max_channels = MAX_CHANNELS;
Niels Möller's avatar
Niels Möller committed
265

Niels Möller's avatar
Niels Möller committed
266
  table->pending_close = 0;
267

268
269
270
  table->global_requests = make_alist(0, -1);
  table->channel_types = make_alist(0, -1);
  
271
272
273
  object_queue_init(&table->local_ports);
  object_queue_init(&table->remote_ports);
  
274
275
  object_queue_init(&table->active_global_requests);
  object_queue_init(&table->pending_global_requests);
Niels Möller's avatar
Niels Möller committed
276
  
277
  return table;
Niels Möller's avatar
Niels Möller committed
278
279
280
};

/* Returns -1 if allocation fails */
281
282
283
/* NOTE: This function returns locally chosen channel numbers, which
 * are always small integers. So there's no problem fitting them in
 * a signed int. */
284
int alloc_channel(struct channel_table *table)
Niels Möller's avatar
Niels Möller committed
285
{
286
  UINT32 i;
287
  
288
  for(i = table->next_channel; i < table->used_channels; i++)
Niels Möller's avatar
Niels Möller committed
289
    {
290
      if (table->in_use[i] == CHANNEL_FREE)
Niels Möller's avatar
Niels Möller committed
291
	{
Niels Möller's avatar
Niels Möller committed
292
	  assert(!table->channels[i]);
293
	  table->in_use[i] = CHANNEL_RESERVED;
294
	  table->next_channel = i+1;
295

296
	  verbose("Allocated local channel number %i\n", i);
Niels Möller's avatar
Niels Möller committed
297
298
299
	  return i;
	}
    }
300
  if (i == table->max_channels)
Niels Möller's avatar
Niels Möller committed
301
    return -1;
302

303
  if (i == table->allocated_channels) 
Niels Möller's avatar
Niels Möller committed
304
    {
305
      int new_size = table->allocated_channels * 2;
Niels Möller's avatar
Niels Möller committed
306
      struct ssh_channel **new_channels;
Niels Möller's avatar
Niels Möller committed
307
      UINT8 *new_in_use;
Niels Möller's avatar
Niels Möller committed
308

Niels Möller's avatar
Niels Möller committed
309
310
311
      new_channels = lsh_space_alloc(sizeof(struct ssh_channel *)
				     * new_size);
      memcpy(new_channels, table->channels,
312
	     sizeof(struct ssh_channel *) * table->used_channels);
Niels Möller's avatar
Niels Möller committed
313
314
315
      lsh_space_free(table->channels);
      table->channels = new_channels;

316
      /* FIXME: Use realloc(). */
Niels Möller's avatar
Niels Möller committed
317
318
319
320
321
      new_in_use = lsh_space_alloc(new_size);
      memcpy(new_in_use, table->in_use, table->used_channels);
      lsh_space_free(table->in_use);
      table->in_use = new_in_use;

322
      table->allocated_channels = new_size;
Niels Möller's avatar
Niels Möller committed
323
324
    }

325
  table->next_channel = table->used_channels = i+1;
Niels Möller's avatar
Niels Möller committed
326

327
  table->in_use[i] = CHANNEL_RESERVED;
328
  verbose("Allocated local channel number %i\n", i);
329

Niels Möller's avatar
Niels Möller committed
330
331
332
  return i;
}

333
void dealloc_channel(struct channel_table *table, int i)
Niels Möller's avatar
Niels Möller committed
334
335
{
  assert(i >= 0);
336
  assert( (unsigned) i < table->used_channels);
337

338
  verbose("Deallocating local channel %i\n", i);
339
  table->channels[i] = NULL;
340
  table->in_use[i] = CHANNEL_FREE;
Niels Möller's avatar
Niels Möller committed
341
  
342
  if ( (unsigned) i < table->next_channel)
343
344
345
    table->next_channel = i;
}

346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
void
use_channel(struct ssh_connection *connection,
	    UINT32 local_channel_number)
{
  struct channel_table *table = connection->table;
  struct ssh_channel *channel = table->channels[local_channel_number];

  assert(channel);
  assert(table->in_use[local_channel_number] == CHANNEL_RESERVED);
  
  table->in_use[local_channel_number] = CHANNEL_IN_USE;
  verbose("Taking channel %i in use, (local %i).\n",
	  channel->channel_number, local_channel_number);
}
	    
361
362
363
void
register_channel(struct ssh_connection *connection,
		 UINT32 local_channel_number,
364
365
		 struct ssh_channel *channel,
		 int take_into_use)
366
{
367
368
  struct channel_table *table = connection->table;
  
369
  assert(table->in_use[local_channel_number] == CHANNEL_RESERVED);
Niels Möller's avatar
Niels Möller committed
370
  assert(!table->channels[local_channel_number]);
371

372
373
374
  verbose("Registering local channel %i.\n",
	  local_channel_number);
  
Niels Möller's avatar
Niels Möller committed
375
  /* FIXME: Is this the right place to install this exception handler? */
376
377
378
379
380
381
382
  channel->e =
    make_exc_finish_channel_handler(connection,
				    local_channel_number,
				    channel->e ? channel->e : connection->e,
				    HANDLER_CONTEXT);

  table->channels[local_channel_number] = channel;
383

384
385
386
  if (take_into_use)
    use_channel(connection, local_channel_number);
  
387
  REMEMBER_RESOURCE(connection->resources, &channel->resources->super);
Niels Möller's avatar
Niels Möller committed
388
389
}

390
391
392
393
394
395
396
397
398
399
struct ssh_channel *
lookup_channel(struct channel_table *table, UINT32 i)
{
  return ( (i < table->used_channels)
	   && (table->in_use[i] == CHANNEL_IN_USE))
    ? table->channels[i] : NULL;
}

struct ssh_channel *
lookup_channel_reserved(struct channel_table *table, UINT32 i)
Niels Möller's avatar
Niels Möller committed
400
{
401
402
  return ( (i < table->used_channels)
	   && (table->in_use[i] == CHANNEL_RESERVED))
403
    ? table->channels[i] : NULL;
Niels Möller's avatar
Niels Möller committed
404
405
}

406

407
408
409
410
411
412
413
414
415
416
/* FIXME: It seems suboptimal to send a window adjust message for *every* write that we do.
 * A better scheme might be as follows:
 *
 * Delay window adjust messages, keeping track of both the locally
 * maintained window size, which is updated after each write, and the
 * size that has been reported to the remote end. When the difference
 * between these two values gets large enough (say, larger than one
 * half or one third of the maximum window size), we send a
 * window_adjust message to sync them. */
static void adjust_rec_window(struct flow_controlled *f, UINT32 written)
417
{
418
419
  CAST_SUBTYPE(ssh_channel, channel, f);

Niels Möller's avatar
Niels Möller committed
420
  A_WRITE(channel->write,
421
	  prepare_window_adjust(channel, written));
422
423
}

Niels Möller's avatar
Niels Möller committed
424
void channel_start_receive(struct ssh_channel *channel)
425
{
Niels Möller's avatar
Niels Möller committed
426
427
  A_WRITE(channel->write,
	  prepare_window_adjust
428
	  (channel, channel->max_window - channel->rec_window_size));
429
430
}

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

432
433
434
/* Ugly macros to make it a little simpler to free the input packet at
 * the right time. */

Niels Möller's avatar
Niels Möller committed
435
436
437
438
439
#define RETURN goto foo_finish
#define END(s) do { foo_finish: \
                    lsh_string_free((s)); \
                    return; } while(0)

440

Niels Möller's avatar
Niels Möller committed
441
/* Channel related messages */
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460

/* GABA:
   (class
     (name global_request_status)
     (vars
       ; -1 for still active requests,
       ; 0 for failure,
       ; 1 for success
       (status . int)))
*/

static struct global_request_status *make_global_request_status(void)
{
  NEW(global_request_status, self);
  self->status = -1;

  return self;
}

Niels Möller's avatar
Niels Möller committed
461
/* FIXME: Split into a continuation and an exception handler */
462
463
464
465
466
467
468
469
/* GABA:
   (class
     (name global_request_response)
     (super global_request_callback)
     (vars
       (active object global_request_status)))
*/

Niels Möller's avatar
Niels Möller committed
470
static void
471
472
473
474
do_global_request_response(struct global_request_callback *c,
			   int success)
{
  CAST(global_request_response, self, c);
Niels Möller's avatar
Niels Möller committed
475
  struct object_queue *q = &self->super.connection->table->active_global_requests;
476
477
478
479
480
481
482
483
484
485
486

  assert( self->active->status == -1);
  assert( (success == 0) || (success == 1) );
  assert( !object_queue_is_empty(q));
	  
  self->active->status = success;

  for (;;)
    {
      CAST(global_request_status, n, object_queue_peek_head(q));
      if (!n || (n->status < 0))
Niels Möller's avatar
Niels Möller committed
487
	break;
488
489

      object_queue_remove_head(q);
Niels Möller's avatar
Niels Möller committed
490
491
492

      /* FIXME: Perhaps install some exception handler that cancels
       * the queue as soon as a write failes. */
493
      C_WRITE(self->super.connection,
Niels Möller's avatar
Niels Möller committed
494
495
	      (n->status
	       ? format_global_success()
496
	       : format_global_failure()));
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
    }
}

static struct global_request_callback *
make_global_request_response(struct ssh_connection *connection,
			     struct global_request_status *active)
{
  NEW(global_request_response, self);

  self->super.connection = connection;
  self->super.response = do_global_request_response;

  self->active = active;

  return &self->super;
}
     
Niels Möller's avatar
Niels Möller committed
514
515
516
static void do_global_request(struct packet_handler *s UNUSED,
			      struct ssh_connection *connection,
			      struct lsh_string *packet)
Niels Möller's avatar
Niels Möller committed
517
{
518
  /* CAST(global_request_handler, closure, c); */
Niels Möller's avatar
Niels Möller committed
519
520

  struct simple_buffer buffer;
521
  unsigned msg_number;
Niels Möller's avatar
Niels Möller committed
522
523
524
525
526
527
528
529
530
531
532
  int name;
  int want_reply;
  
  simple_buffer_init(&buffer, packet->length, packet->data);

  if (parse_uint8(&buffer, &msg_number)
      && (msg_number == SSH_MSG_GLOBAL_REQUEST)
      && parse_atom(&buffer, &name)
      && parse_boolean(&buffer, &want_reply))
    {
      struct global_request *req;
533
534
      struct global_request_callback *c = NULL;
      
Niels Möller's avatar
Niels Möller committed
535
      if (!name || !(req = ALIST_GET(connection->table->global_requests,
536
				     name)))
537
	{
Niels Möller's avatar
Niels Möller committed
538
	  lsh_string_free(packet);
539

Niels Möller's avatar
Niels Möller committed
540
541
	  C_WRITE(connection, format_global_failure());
	  return;
Niels Möller's avatar
Niels Möller committed
542
543
544
545
546
547
548
	}
      else
	{
	  if (want_reply)
	    {
	      struct global_request_status *a = make_global_request_status();
	      
Niels Möller's avatar
Niels Möller committed
549
	      object_queue_add_tail(&connection->table->active_global_requests,
Niels Möller's avatar
Niels Möller committed
550
551
552
553
554
				    &a->super);
	      
	      c = make_global_request_response(connection, a);
	    }
	  GLOBAL_REQUEST(req, connection, &buffer, c);
555
	}
Niels Möller's avatar
Niels Möller committed
556
    }
Niels Möller's avatar
Niels Möller committed
557
558
  else
    {
559
      PROTOCOL_ERROR(connection->e, "Invalid SSH_MSG_GLOBAL_REQUEST message.");
Niels Möller's avatar
Niels Möller committed
560
561
    }
  lsh_string_free(packet);
Niels Möller's avatar
Niels Möller committed
562
563
}

Niels Möller's avatar
Niels Möller committed
564
565
566
567
static void
do_global_request_success(struct packet_handler *s UNUSED,
			  struct ssh_connection *connection,
			  struct lsh_string *packet)
568
569
{
  if (packet->length != 1)
Niels Möller's avatar
Niels Möller committed
570
    {
571
      PROTOCOL_ERROR(connection->e, "Invalid GLOBAL_REQUEST_SUCCESS message.");
Niels Möller's avatar
Niels Möller committed
572
573
      RETURN;
    }
574
575
576

  assert(packet->data[0] == SSH_MSG_REQUEST_SUCCESS);

Niels Möller's avatar
Niels Möller committed
577
  if (object_queue_is_empty(&connection->table->pending_global_requests))
578
579
    {
      werror("do_global_request_success: Unexpected message, ignoring.\n");
Niels Möller's avatar
Niels Möller committed
580
      return;
581
582
    }
  {
583
    CAST_SUBTYPE(command_context, ctx,
Niels Möller's avatar
Niels Möller committed
584
585
		 object_queue_remove_head(&connection->table->pending_global_requests));
    COMMAND_RETURN(ctx->c, connection);
586
  }
Niels Möller's avatar
Niels Möller committed
587
  END(packet);
588
589
}

590
591
592
struct exception global_request_exception =
STATIC_EXCEPTION(EXC_GLOBAL_REQUEST, "Global request failed");

Niels Möller's avatar
Niels Möller committed
593
594
595
596
static void
do_global_request_failure(struct packet_handler *s UNUSED,
			  struct ssh_connection *connection,
			  struct lsh_string *packet)
597
598
{
  if (packet->length != 1)
Niels Möller's avatar
Niels Möller committed
599
    {
600
      PROTOCOL_ERROR(connection->e, "Invalid GLOBAL_REQUEST_FAILURE message.");
Niels Möller's avatar
Niels Möller committed
601
602
      RETURN;
    }
603
604
605

  assert(packet->data[0] == SSH_MSG_REQUEST_FAILURE);

Niels Möller's avatar
Niels Möller committed
606
  if (object_queue_is_empty(&connection->table->pending_global_requests))
607
608
609
    {
      werror("do_global_request_failure: Unexpected message, ignoring.\n");
    }
Niels Möller's avatar
Niels Möller committed
610
611
612
613
614
615
616
  else
    {
      CAST_SUBTYPE(command_context, ctx,
		   object_queue_remove_head(&connection->table->pending_global_requests));
      EXCEPTION_RAISE(ctx->e, &global_request_exception);
    }
  END(packet);
617
618
}

619

Niels Möller's avatar
Niels Möller committed
620
/* GABA:
621
622
623
624
625
   (class
     (name channel_open_continuation)
     (super command_continuation)
     (vars
       (connection object ssh_connection)
Niels Möller's avatar
Niels Möller committed
626
627
628
629
       (local_channel_number . UINT32)
       (remote_channel_number . UINT32)
       (window_size . UINT32)
       (max_packet . UINT32)))
630
*/
631

Niels Möller's avatar
Niels Möller committed
632
633
634
static void
do_channel_open_continue(struct command_continuation *c,
			 struct lsh_object *value)
635
636
{
  CAST(channel_open_continuation, self, c);
Niels Möller's avatar
Niels Möller committed
637
638
639
640
641
642
643
644
645
646
647
648
  CAST_SUBTYPE(ssh_channel, channel, value);

  assert(channel);

  /* FIXME: This copying could just as well be done by the
   * CHANNEL_OPEN handler? Then we can remove the corresponding fields
   * from the closure as well. */
  channel->send_window_size = self->window_size;
  channel->send_max_packet = self->max_packet;
  channel->channel_number = self->remote_channel_number;

  /* FIXME: Is the channel->write field really needed? */
Niels Möller's avatar
Niels Möller committed
649
  channel->write = self->connection->write;
Niels Möller's avatar
Niels Möller committed
650

651
  register_channel(self->connection,
652
653
		   self->local_channel_number, channel,
		   1);
Niels Möller's avatar
Niels Möller committed
654
655
656
657
658

  /* FIXME: Doesn't support sending extra arguments with the
   * confirmation message. */

  C_WRITE(self->connection,
Niels Möller's avatar
Niels Möller committed
659
	  format_open_confirmation(channel, self->local_channel_number, ""));
660
}
Niels Möller's avatar
Niels Möller committed
661

Niels Möller's avatar
Niels Möller committed
662
static struct command_continuation *
Niels Möller's avatar
Niels Möller committed
663
664
665
666
667
668
669
make_channel_open_continuation(struct ssh_connection *connection,
			       UINT32 local_channel_number,
			       UINT32 remote_channel_number,
			       UINT32 window_size,
			       UINT32 max_packet)
{
  NEW(channel_open_continuation, self);
Niels Möller's avatar
Niels Möller committed
670

Niels Möller's avatar
Niels Möller committed
671
672
673
674
675
676
677
  self->super.c = do_channel_open_continue;
  self->connection = connection;
  self->local_channel_number = local_channel_number;
  self->remote_channel_number = remote_channel_number;
  self->window_size = window_size;
  self->max_packet = max_packet;

Niels Möller's avatar
Niels Möller committed
678
  return &self->super;
Niels Möller's avatar
Niels Möller committed
679
680
681
682
683
684
685
686
687
}
			       
/* GABA:
   (class
     (name exc_channel_open_handler)
     (super exception_handler)
     (vars
       (connection object ssh_connection)
       (local_channel_number . UINT32)
Niels Möller's avatar
Niels Möller committed
688
       (remote_channel_number . UINT32)))
Niels Möller's avatar
Niels Möller committed
689
690
691
*/

static void do_exc_channel_open_handler(struct exception_handler *s,
Niels Möller's avatar
Niels Möller committed
692
					const struct exception *e)
Niels Möller's avatar
Niels Möller committed
693
694
695
696
697
698
699
700
{
  CAST(exc_channel_open_handler, self, s);

  switch (e->type)
    {
    case EXC_CHANNEL_OPEN:
      {
	CAST_SUBTYPE(channel_open_exception, exc, e);
Niels Möller's avatar
Niels Möller committed
701
	struct channel_table *table = self->connection->table;
Niels Möller's avatar
Niels Möller committed
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
	
	assert(table->in_use[self->local_channel_number]);
	assert(!table->channels[self->local_channel_number]);

	dealloc_channel(table, self->local_channel_number);
	
        C_WRITE(self->connection,
		format_open_failure(self->remote_channel_number,
				    exc->error_code, e->msg, ""));
	break;
      }
    default:
      EXCEPTION_RAISE(self->super.parent, e);
    }      
}

static struct exception_handler *
make_exc_channel_open_handler(struct ssh_connection *connection,
			      UINT32 local_channel_number,
			      UINT32 remote_channel_number,
722
723
			      struct exception_handler *parent,
			      const char *context)
Niels Möller's avatar
Niels Möller committed
724
{
Niels Möller's avatar
Niels Möller committed
725
  NEW(exc_channel_open_handler, self);
Niels Möller's avatar
Niels Möller committed
726
  self->super.parent = parent;
Niels Möller's avatar
Niels Möller committed
727
  self->super.raise = do_exc_channel_open_handler;
728
729
  self->super.context = context;
  
Niels Möller's avatar
Niels Möller committed
730
  self->connection = connection;
Niels Möller's avatar
Niels Möller committed
731
732
733
734
735
736
737
738
739
  self->local_channel_number = local_channel_number;
  self->remote_channel_number = remote_channel_number;

  return &self->super;
}

static void do_channel_open(struct packet_handler *c UNUSED,
			    struct ssh_connection *connection,
			    struct lsh_string *packet)
Niels Möller's avatar
Niels Möller committed
740
{
741
  /* CAST(channel_open_handler, closure, c); */
Niels Möller's avatar
Niels Möller committed
742
743

  struct simple_buffer buffer;
744
  unsigned msg_number;
Niels Möller's avatar
Niels Möller committed
745
  int type;
746
747
748
  UINT32 remote_channel_number;
  UINT32 window_size;
  UINT32 max_packet;
Niels Möller's avatar
Niels Möller committed
749
750
751
752
753
754
  
  simple_buffer_init(&buffer, packet->length, packet->data);

  if (parse_uint8(&buffer, &msg_number)
      && (msg_number == SSH_MSG_CHANNEL_OPEN)
      && parse_atom(&buffer, &type)
755
756
757
      && parse_uint32(&buffer, &remote_channel_number)
      && parse_uint32(&buffer, &window_size)
      && parse_uint32(&buffer, &max_packet))
Niels Möller's avatar
Niels Möller committed
758
759
    {
      struct channel_open *open;
Niels Möller's avatar
Niels Möller committed
760

Niels Möller's avatar
Niels Möller committed
761
762
763
764
      /* NOTE: We can't free the packet yet, as the buffer is passed
       * to the CHANNEL_OPEN method later. */

      if (connection->table->pending_close)
Niels Möller's avatar
Niels Möller committed
765
766
767
768
769
770
771
772
	{
	  /* We are waiting for channels to close. Don't open any new ones. */

	  C_WRITE(connection,
		  format_open_failure(remote_channel_number,
				      SSH_OPEN_ADMINISTRATIVELY_PROHIBITED,
				      "Waiting for channels to close.", ""));
	}
Niels Möller's avatar
Niels Möller committed
773
      else if (!type || !(open = ALIST_GET(connection->table->channel_types,
774
				      type)))
Niels Möller's avatar
Niels Möller committed
775
776
777
778
779
780
781
782
	{
	  C_WRITE(connection,
		  format_open_failure(remote_channel_number,
				      SSH_OPEN_UNKNOWN_CHANNEL_TYPE,
				      "Unknown channel type", ""));
	}
      else
	{
Niels Möller's avatar
Niels Möller committed
783
      	  int local_number = alloc_channel(connection->table);
Niels Möller's avatar
Niels Möller committed
784
785
786
787
788
789
790
791

	  if (local_number < 0)
	    C_WRITE(connection,
		    format_open_failure(remote_channel_number,
					SSH_OPEN_RESOURCE_SHORTAGE,
					"Unknown channel type", ""));

	  
Niels Möller's avatar
Niels Möller committed
792
	  
793
	  CHANNEL_OPEN(open, connection, type, &buffer,
Niels Möller's avatar
Niels Möller committed
794
795
796
797
798
799
800
801
		       make_channel_open_continuation(connection,
						      local_number,
						      remote_channel_number,
						      window_size,
						      max_packet),
		       make_exc_channel_open_handler(connection,
						     local_number,
						     remote_channel_number,
802
803
						     connection->e,
						     HANDLER_CONTEXT));
Niels Möller's avatar
Niels Möller committed
804
	}
Niels Möller's avatar
Niels Möller committed
805
    }
Niels Möller's avatar
Niels Möller committed
806
  else
807
    PROTOCOL_ERROR(connection->e, "Invalid SSH_MSG_CHANNEL_OPEN message.");
Niels Möller's avatar
Niels Möller committed
808

Niels Möller's avatar
Niels Möller committed
809
  lsh_string_free(packet);
Niels Möller's avatar
Niels Möller committed
810
811
}     

Niels Möller's avatar
Niels Möller committed
812
813
814
815
static void
do_channel_request(struct packet_handler *closure UNUSED,
		   struct ssh_connection *connection,
		   struct lsh_string *packet)
Niels Möller's avatar
Niels Möller committed
816
817
{
  struct simple_buffer buffer;
818
  unsigned msg_number;
Niels Möller's avatar
Niels Möller committed
819
820
821
  UINT32 channel_number;
  int type;
  int want_reply;
822
  
Niels Möller's avatar
Niels Möller committed
823
824
825
826
827
828
829
830
  simple_buffer_init(&buffer, packet->length, packet->data);

  if (parse_uint8(&buffer, &msg_number)
      && (msg_number == SSH_MSG_CHANNEL_REQUEST)
      && parse_uint32(&buffer, &channel_number)
      && parse_atom(&buffer, &type)
      && parse_boolean(&buffer, &want_reply))
    {
Niels Möller's avatar
Niels Möller committed
831
      struct ssh_channel *channel = lookup_channel(connection->table,
Niels Möller's avatar
Niels Möller committed
832
833
						   channel_number);

834
835
836
837
      /* NOTE: We can't free packet yet, because it is not yet fully
       * parsed. There may be some more arguments, which are parsed by
       * the CHANNEL_REQUEST method below. */

Niels Möller's avatar
Niels Möller committed
838
839
840
841
      if (channel)
	{
	  struct channel_request *req;

842
843
	  if (type && channel->request_types 
	      && ( (req = ALIST_GET(channel->request_types, type)) ))
Niels Möller's avatar
Niels Möller committed
844
	    CHANNEL_REQUEST(req, channel, connection, want_reply, &buffer);
845
	  else
Niels Möller's avatar
Niels Möller committed
846
847
	    {
	      if (want_reply)
Niels Möller's avatar
Niels Möller committed
848
		C_WRITE(connection,
Niels Möller's avatar
Niels Möller committed
849
850
851
852
853
854
855
			format_channel_failure(channel->channel_number));
	    }
	}
      else
	{
	  werror("SSH_MSG_CHANNEL_REQUEST on nonexistant channel %i\n",
		 channel_number);
Niels Möller's avatar
Niels Möller committed
856
	}
857
    }
Niels Möller's avatar
Niels Möller committed
858
  else
859
    PROTOCOL_ERROR(connection->e, "Invalid SSH_MSG_CHANNEL_REQUEST message.");
Niels Möller's avatar
Niels Möller committed
860
  
Niels Möller's avatar
Niels Möller committed
861
  lsh_string_free(packet);
Niels Möller's avatar
Niels Möller committed
862
863
}
      
Niels Möller's avatar
Niels Möller committed
864
865
866
867
static void
do_window_adjust(struct packet_handler *closure UNUSED,
		 struct ssh_connection *connection,
		 struct lsh_string *packet)
Niels Möller's avatar
Niels Möller committed
868
869
{
  struct simple_buffer buffer;
870
  unsigned msg_number;
Niels Möller's avatar
Niels Möller committed
871
872
873
874
875
876
877
  UINT32 channel_number;
  UINT32 size;

  simple_buffer_init(&buffer, packet->length, packet->data);

  if (parse_uint8(&buffer, &msg_number)
      && (msg_number == SSH_MSG_CHANNEL_WINDOW_ADJUST)
878
      && parse_uint32(&buffer, &channel_number)
Niels Möller's avatar
Niels Möller committed
879
880
881
      && parse_uint32(&buffer, &size)
      && parse_eod(&buffer))
    {
Niels Möller's avatar
Niels Möller committed
882
      struct ssh_channel *channel = lookup_channel(connection->table,
Niels Möller's avatar
Niels Möller committed
883
884
885
886
						   channel_number);

      lsh_string_free(packet);
      
Niels Möller's avatar
Niels Möller committed
887
      if (channel
888
889
	  && !(channel->flags & (CHANNEL_RECEIVED_EOF
				 | CHANNEL_RECEIVED_CLOSE)))
Niels Möller's avatar
Niels Möller committed
890
	{
891
	  if (! (channel->flags & (CHANNEL_SENT_CLOSE | CHANNEL_SENT_EOF)))
Niels Möller's avatar
Niels Möller committed
892
893
894
	    {
	      channel->send_window_size += size;
	      if (channel->send_window_size && channel->send)
895
		CHANNEL_SEND(channel, connection);
Niels Möller's avatar
Niels Möller committed
896
	    }
Niels Möller's avatar
Niels Möller committed
897
	}
Niels Möller's avatar
Niels Möller committed
898
899
900
901
902
903
      else
	{
	  /* FIXME: What to do now? Should unknown channel numbers be
	   * ignored silently? */
	  werror("SSH_MSG_CHANNEL_WINDOW_ADJUST on nonexistant or closed "
		 "channel %i\n", channel_number);
904
	  PROTOCOL_ERROR(connection->e, "Unexpected CHANNEL_WINDOW_ADJUST");
Niels Möller's avatar
Niels Möller committed
905
906
907
908
909
	}
    }
  else
    {
      lsh_string_free(packet);
910
      PROTOCOL_ERROR(connection->e, "Invalid CHANNEL_WINDOW_ADJUST message.");
Niels Möller's avatar
Niels Möller committed
911
912
913
    }
}

Niels Möller's avatar
Niels Möller committed
914
915
916
917
static void
do_channel_data(struct packet_handler *closure UNUSED,
		struct ssh_connection *connection,
		struct lsh_string *packet)
Niels Möller's avatar
Niels Möller committed
918
919
{
  struct simple_buffer buffer;
920
  unsigned msg_number;
Niels Möller's avatar
Niels Möller committed
921
922
923
924
925
926
927
  UINT32 channel_number;
  struct lsh_string *data;
  
  simple_buffer_init(&buffer, packet->length, packet->data);

  if (parse_uint8(&buffer, &msg_number)
      && (msg_number == SSH_MSG_CHANNEL_DATA)
928
      && parse_uint32(&buffer, &channel_number)
Niels Möller's avatar
Niels Möller committed
929
930
931
      && ( (data = parse_string_copy(&buffer)) )
      && parse_eod(&buffer))
    {
Niels Möller's avatar
Niels Möller committed
932
      struct ssh_channel *channel = lookup_channel(connection->table,
Niels Möller's avatar
Niels Möller committed
933
934
935
936
						   channel_number);

      lsh_string_free(packet);
      
937
      if (channel && channel->receive
938
939
	  && !(channel->flags & (CHANNEL_RECEIVED_EOF
				 | CHANNEL_RECEIVED_CLOSE)))
Niels Möller's avatar
Niels Möller committed
940
	{
Niels Möller's avatar
Niels Möller committed
941
	  if (channel->flags & CHANNEL_SENT_CLOSE)
Niels Möller's avatar
Niels Möller committed
942
	    {
Niels Möller's avatar
Niels Möller committed
943
	      lsh_string_free(data);
944
	      werror("Ignoring data on channel which is closing\n");
Niels Möller's avatar
Niels Möller committed
945
	      return;
Niels Möller's avatar
Niels Möller committed
946
	    }
Niels Möller's avatar
Niels Möller committed
947
948
949
950
951
	  else
	    {
	      if (data->length > channel->rec_window_size)
		{
		  /* Truncate data to fit window */
952
		  werror("Channel data overflow. Extra data ignored.\n"); 
Niels Möller's avatar
Niels Möller committed
953
954
		  data->length = channel->rec_window_size;
		}
955
956

	      if (!data->length)
Niels Möller's avatar
Niels Möller committed
957
958
959
960
961
		{
		  /* Ignore data packet */
		  lsh_string_free(data);
		  return;
		}
962
963
	      channel->rec_window_size -= data->length;

Niels Möller's avatar
Niels Möller committed
964
	      CHANNEL_RECEIVE(channel, CHANNEL_DATA, data);
Niels Möller's avatar
Niels Möller committed
965
	    }
Niels Möller's avatar
Niels Möller committed
966
	}
Niels Möller's avatar
Niels Möller committed
967
968
969
970
971
972
973
974
975
976
      else
	{
	  werror("Data on closed or non-existant channel %i\n",
		 channel_number);
	  lsh_string_free(data);
	}
    }
  else
    {
      lsh_string_free(packet);
977
      PROTOCOL_ERROR(connection->e, "Invalid CHANNEL_DATA message.");
Niels Möller's avatar
Niels Möller committed
978
979
980
    }
}

Niels Möller's avatar
Niels Möller committed
981
982
983
984
static void
do_channel_extended_data(struct packet_handler *closure UNUSED,
			 struct ssh_connection *connection,
			 struct lsh_string *packet)
Niels Möller's avatar
Niels Möller committed
985
986
{
  struct simple_buffer buffer;
987
  unsigned msg_number;
Niels Möller's avatar
Niels Möller committed
988
989
990
991
992
993
994
995
  UINT32 channel_number;
  UINT32 type;
  struct lsh_string *data;
  
  simple_buffer_init(&buffer, packet->length, packet->data);

  if (parse_uint8(&buffer, &msg_number)
      && (msg_number == SSH_MSG_CHANNEL_EXTENDED_DATA)
996
      && parse_uint32(&buffer, &channel_number)
Niels Möller's avatar
Niels Möller committed
997
998
999
1000
      && parse_uint32(&buffer, &type)
      && ( (data = parse_string_copy(&buffer)) )
      && parse_eod(&buffer))
    {
Niels Möller's avatar
Niels Möller committed
1001
      struct ssh_channel *channel = lookup_channel(connection->table,
Niels Möller's avatar
Niels Möller committed
1002
1003
1004
1005
						   channel_number);

      lsh_string_free(packet);
      
1006
      if (channel && channel->receive
1007
1008
	  && !(channel->flags & (CHANNEL_RECEIVED_EOF
				 | CHANNEL_RECEIVED_CLOSE)))
Niels Möller's avatar
Niels Möller committed
1009
	{
Niels Möller's avatar
Niels Möller committed
1010
	  if (channel->flags & CHANNEL_SENT_CLOSE)
Niels Möller's avatar
Niels Möller committed
1011
	    {
Niels Möller's avatar
Niels Möller committed
1012
	      lsh_string_free(data);
1013
	      werror("Ignoring extended data on channel which is closing\n");
Niels Möller's avatar
Niels Möller committed
1014
	      return;
Niels Möller's avatar
Niels Möller committed
1015
	    }
Niels Möller's avatar
Niels Möller committed
1016
	  else
Niels Möller's avatar
Niels Möller committed
1017
	    {
Niels Möller's avatar
Niels Möller committed
1018
1019
1020
	      if (data->length > channel->rec_window_size)
		{
		  /* Truncate data to fit window */
1021
		  werror("Channel extended data overflow. "
Niels Möller's avatar
Niels Möller committed
1022
1023
1024
1025
			 "Extra data ignored.\n");
		  data->length = channel->rec_window_size;
		}
	      
Niels Möller's avatar
Niels Möller committed
1026
1027
1028
1029
1030
1031
	      if (!data->length)
		{
		  /* Ignore data packet */
		  lsh_string_free(data);
		  return;
		}
1032

Niels Möller's avatar
Niels Möller committed
1033
	      channel->rec_window_size -= data->length;
1034

Niels Möller's avatar
Niels Möller committed
1035
1036
1037
	      switch(type)
		{
		case SSH_EXTENDED_DATA_STDERR:
Niels Möller's avatar
Niels Möller committed
1038
1039
		  CHANNEL_RECEIVE(channel, CHANNEL_STDERR_DATA, data);
		  break;
Niels Möller's avatar
Niels Möller committed
1040
		default:
1041
		  werror("Unknown type %i of extended data.\n",
Niels Möller's avatar
Niels Möller committed
1042
1043
1044
			 type);
		  lsh_string_free(data);
		}
Niels Möller's avatar
Niels Möller committed
1045
1046
	    }
	}
Niels Möller's avatar
Niels Möller committed
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
      else
	{
	  werror("Extended data on closed or non-existant channel %i\n",
		 channel_number);
	  lsh_string_free(data);
	}
    }
  else
    {
      lsh_string_free(packet);
1057
      PROTOCOL_ERROR(connection->e, "Invalid CHANNEL_EXTENDED_DATA message.");
Niels Möller's avatar
Niels Möller committed
1058
1059
1060
    }
}

Niels Möller's avatar
Niels Möller committed
1061
1062
1063
1064
static void
do_channel_eof(struct packet_handler *closure UNUSED,
	       struct ssh_connection *connection,
	       struct lsh_string *packet)
Niels Möller's avatar
Niels Möller committed
1065
1066
{
  struct simple_buffer buffer;
1067
  unsigned msg_number;
Niels Möller's avatar
Niels Möller committed
1068
1069
1070
1071
1072
1073
  UINT32 channel_number;
  
  simple_buffer_init(&buffer, packet->length, packet->data);

  if (parse_uint8(&buffer, &msg_number)
      && (msg_number == SSH_MSG_CHANNEL_EOF)
1074
      && parse_uint32(&buffer, &channel_number)
Niels Möller's avatar
Niels Möller committed
1075
1076
      && parse_eod(&buffer))
    {
Niels Möller's avatar
Niels Möller committed
1077
      struct ssh_channel *channel = lookup_channel(connection->table,
Niels Möller's avatar
Niels Möller committed
1078
1079
1080
1081
						   channel_number);

      lsh_string_free(packet);

Niels Möller's avatar
Niels Möller committed
1082
1083
      if (channel)
	{
1084
	  if (channel->flags & (CHANNEL_RECEIVED_EOF | CHANNEL_RECEIVED_CLOSE))
Niels Möller's avatar
Niels Möller committed
1085
	    {
1086
	      werror("Receiving EOF on channel on closed channel.\n");
1087
1088
	      PROTOCOL_ERROR(connection->e,
			     "Received EOF on channel on closed channel.");
Niels Möller's avatar
Niels Möller committed
1089
	    }
1090
	  else
Niels Möller's avatar
Niels Möller committed
1091
	    {
1092
1093
	      verbose("Receiving EOF on channel %i (local %i)\n",
		      channel->channel_number, channel_number);
1094
	      
Niels Möller's avatar
Niels Möller committed
1095
	      channel->flags |= CHANNEL_RECEIVED_EOF;
1096
	      
Niels Möller's avatar
Niels Möller committed
1097
1098
1099
1100
1101
	      if (channel->eof)
		CHANNEL_EOF(channel);
	      else
		/* FIXME: What is a reasonable default behaviour?
		 * Closing the channel may be the right thing to do. */
1102
		channel_close(channel);
Niels Möller's avatar
Niels Möller committed
1103
1104
	    }
	}
Niels Möller's avatar
Niels Möller committed
1105
1106
1107
1108
      else
	{
	  werror("EOF on non-existant channel %i\n",
		 channel_number);
1109
	  PROTOCOL_ERROR(connection->e, "EOF on non-existant channel");
Niels Möller's avatar
Niels Möller committed
1110
1111
1112
1113
1114
	}
    }
  else
    {
      lsh_string_free(packet);
1115
      PROTOCOL_ERROR(connection->e, "Invalid CHANNEL_EOF message");
Niels Möller's avatar
Niels Möller committed
1116
1117
1118
    }
}

Niels Möller's avatar
Niels Möller committed
1119
1120
1121
1122
static void
do_channel_close(struct packet_handler *closure UNUSED,
		 struct ssh_connection *connection,
		 struct lsh_string *packet)
Niels Möller's avatar
Niels Möller committed
1123
1124
{
  struct simple_buffer buffer;
1125
  unsigned msg_number;
Niels Möller's avatar
Niels Möller committed
1126
1127
1128
1129
1130
1131
  UINT32 channel_number;
  
  simple_buffer_init(&buffer, packet->length, packet->data);

  if (parse_uint8(&buffer, &msg_number)
      && (msg_number == SSH_MSG_CHANNEL_CLOSE)
1132
      && parse_uint32(&buffer, &channel_number)
Niels Möller's avatar
Niels Möller committed
1133
1134
      && parse_eod(&buffer))
    {