2 * Author: Tatu Ylonen <ylo@cs.hut.fi>
3 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
5 * Server main loop for handling the interactive session.
7 * As far as I am concerned, the code I have written for this software
8 * can be used freely for any purpose. Any derived versions of this
9 * software must be clearly marked as such, and if the derived work is
10 * incompatible with the protocol description in the RFC file, it must be
11 * called by a name other than "ssh" or "Secure Shell".
13 * SSH2 support by Markus Friedl.
14 * Copyright (c) 2000, 2001 Markus Friedl. All rights reserved.
16 * Redistribution and use in source and binary forms, with or without
17 * modification, are permitted provided that the following conditions
19 * 1. Redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer.
21 * 2. Redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in the
23 * documentation and/or other materials provided with the distribution.
25 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
26 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
27 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
28 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
29 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
30 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
34 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 RCSID("$OpenBSD: serverloop.c,v 1.115 2004/01/19 21:25:15 markus Exp $");
54 #include "auth-options.h"
55 #include "serverloop.h"
59 extern ServerOptions options
;
63 extern Authctxt
*the_authctxt
;
65 static Buffer stdin_buffer
; /* Buffer for stdin data. */
66 static Buffer stdout_buffer
; /* Buffer for stdout data. */
67 static Buffer stderr_buffer
; /* Buffer for stderr data. */
68 static int fdin
; /* Descriptor for stdin (for writing) */
69 static int fdout
; /* Descriptor for stdout (for reading);
70 May be same number as fdin. */
71 static int fderr
; /* Descriptor for stderr. May be -1. */
72 static long stdin_bytes
= 0; /* Number of bytes written to stdin. */
73 static long stdout_bytes
= 0; /* Number of stdout bytes sent to client. */
74 static long stderr_bytes
= 0; /* Number of stderr bytes sent to client. */
75 static long fdout_bytes
= 0; /* Number of stdout bytes read from program. */
76 static int stdin_eof
= 0; /* EOF message received from client. */
77 static int fdout_eof
= 0; /* EOF encountered reading from fdout. */
78 static int fderr_eof
= 0; /* EOF encountered readung from fderr. */
79 static int fdin_is_tty
= 0; /* fdin points to a tty. */
80 static int connection_in
; /* Connection to client (input). */
81 static int connection_out
; /* Connection to client (output). */
82 static int connection_closed
= 0; /* Connection to client closed. */
83 static u_int buffer_high
; /* "Soft" max buffer size. */
84 static int client_alive_timeouts
= 0;
87 * This SIGCHLD kludge is used to detect when the child exits. The server
88 * will exit after that, as soon as forwarded connections have terminated.
91 static volatile sig_atomic_t child_terminated
= 0; /* The child has terminated. */
94 static void server_init_dispatch(void);
97 * we write to this pipe if a SIGCHLD is caught in order to avoid
98 * the race between select() and child_terminated
100 static int notify_pipe
[2];
104 if (pipe(notify_pipe
) < 0) {
105 error("pipe(notify_pipe) failed %s", strerror(errno
));
106 } else if ((fcntl(notify_pipe
[0], F_SETFD
, 1) == -1) ||
107 (fcntl(notify_pipe
[1], F_SETFD
, 1) == -1)) {
108 error("fcntl(notify_pipe, F_SETFD) failed %s", strerror(errno
));
109 close(notify_pipe
[0]);
110 close(notify_pipe
[1]);
112 set_nonblock(notify_pipe
[0]);
113 set_nonblock(notify_pipe
[1]);
116 notify_pipe
[0] = -1; /* read end */
117 notify_pipe
[1] = -1; /* write end */
122 if (notify_pipe
[1] != -1)
123 write(notify_pipe
[1], "", 1);
126 notify_prepare(fd_set
*readset
)
128 if (notify_pipe
[0] != -1)
129 FD_SET(notify_pipe
[0], readset
);
132 notify_done(fd_set
*readset
)
136 if (notify_pipe
[0] != -1 && FD_ISSET(notify_pipe
[0], readset
))
137 while (read(notify_pipe
[0], &c
, 1) != -1)
138 debug2("notify_done: reading");
142 sigchld_handler(int sig
)
144 int save_errno
= errno
;
145 debug("Received SIGCHLD.");
146 child_terminated
= 1;
148 mysignal(SIGCHLD
, sigchld_handler
);
155 * Make packets from buffered stderr data, and buffer it for sending
159 make_packets_from_stderr_data(void)
163 /* Send buffered stderr data to the client. */
164 while (buffer_len(&stderr_buffer
) > 0 &&
165 packet_not_very_much_data_to_write()) {
166 len
= buffer_len(&stderr_buffer
);
167 if (packet_is_interactive()) {
171 /* Keep the packets at reasonable size. */
172 if (len
> packet_get_maxsize())
173 len
= packet_get_maxsize();
175 packet_start(SSH_SMSG_STDERR_DATA
);
176 packet_put_string(buffer_ptr(&stderr_buffer
), len
);
178 buffer_consume(&stderr_buffer
, len
);
184 * Make packets from buffered stdout data, and buffer it for sending to the
188 make_packets_from_stdout_data(void)
192 /* Send buffered stdout data to the client. */
193 while (buffer_len(&stdout_buffer
) > 0 &&
194 packet_not_very_much_data_to_write()) {
195 len
= buffer_len(&stdout_buffer
);
196 if (packet_is_interactive()) {
200 /* Keep the packets at reasonable size. */
201 if (len
> packet_get_maxsize())
202 len
= packet_get_maxsize();
204 packet_start(SSH_SMSG_STDOUT_DATA
);
205 packet_put_string(buffer_ptr(&stdout_buffer
), len
);
207 buffer_consume(&stdout_buffer
, len
);
213 client_alive_check(void)
217 /* timeout, check to see how many we have had */
218 if (++client_alive_timeouts
> options
.client_alive_count_max
)
219 packet_disconnect("Timeout, your session not responding.");
222 * send a bogus global/channel request with "wantreply",
223 * we should get back a failure
225 if ((channel_id
= channel_find_open()) == -1) {
226 packet_start(SSH2_MSG_GLOBAL_REQUEST
);
227 packet_put_cstring("keepalive@openssh.com");
228 packet_put_char(1); /* boolean: want reply */
230 channel_request_start(channel_id
, "keepalive@openssh.com", 1);
236 * Sleep in select() until we can do something. This will initialize the
237 * select masks. Upon return, the masks will indicate which descriptors
238 * have data or can accept data. Optionally, a maximum time can be specified
239 * for the duration of the wait (0 = infinite).
242 wait_until_can_do_something(fd_set
**readsetp
, fd_set
**writesetp
, int *maxfdp
,
243 int *nallocp
, u_int max_time_milliseconds
)
245 struct timeval tv
, *tvp
;
247 int client_alive_scheduled
= 0;
250 * if using client_alive, set the max timeout accordingly,
251 * and indicate that this particular timeout was for client
252 * alive by setting the client_alive_scheduled flag.
254 * this could be randomized somewhat to make traffic
255 * analysis more difficult, but we're not doing it yet.
258 max_time_milliseconds
== 0 && options
.client_alive_interval
) {
259 client_alive_scheduled
= 1;
260 max_time_milliseconds
= options
.client_alive_interval
* 1000;
263 /* Allocate and update select() masks for channel descriptors. */
264 channel_prepare_select(readsetp
, writesetp
, maxfdp
, nallocp
, 0);
268 /* wrong: bad condition XXX */
269 if (channel_not_very_much_buffered_data())
271 FD_SET(connection_in
, *readsetp
);
274 * Read packets from the client unless we have too much
275 * buffered stdin or channel data.
277 if (buffer_len(&stdin_buffer
) < buffer_high
&&
278 channel_not_very_much_buffered_data())
279 FD_SET(connection_in
, *readsetp
);
281 * If there is not too much data already buffered going to
282 * the client, try to get some more data from the program.
284 if (packet_not_very_much_data_to_write()) {
286 FD_SET(fdout
, *readsetp
);
288 FD_SET(fderr
, *readsetp
);
291 * If we have buffered data, try to write some of that data
294 if (fdin
!= -1 && buffer_len(&stdin_buffer
) > 0)
295 FD_SET(fdin
, *writesetp
);
297 notify_prepare(*readsetp
);
300 * If we have buffered packet data going to the client, mark that
303 if (packet_have_data_to_write())
304 FD_SET(connection_out
, *writesetp
);
307 * If child has terminated and there is enough buffer space to read
308 * from it, then read as much as is available and exit.
310 if (child_terminated
&& packet_not_very_much_data_to_write())
311 if (max_time_milliseconds
== 0 || client_alive_scheduled
)
312 max_time_milliseconds
= 100;
314 if (max_time_milliseconds
== 0)
317 tv
.tv_sec
= max_time_milliseconds
/ 1000;
318 tv
.tv_usec
= 1000 * (max_time_milliseconds
% 1000);
322 /* Wait for something to happen, or the timeout to expire. */
323 ret
= select((*maxfdp
)+1, *readsetp
, *writesetp
, NULL
, tvp
);
326 memset(*readsetp
, 0, *nallocp
);
327 memset(*writesetp
, 0, *nallocp
);
329 error("select: %.100s", strerror(errno
));
330 } else if (ret
== 0 && client_alive_scheduled
)
331 client_alive_check();
333 notify_done(*readsetp
);
337 * Processes input from the client and the program. Input data is stored
338 * in buffers and processed later.
341 process_input(fd_set
* readset
)
346 /* Read and buffer any input data from the client. */
347 if (FD_ISSET(connection_in
, readset
)) {
348 len
= read(connection_in
, buf
, sizeof(buf
));
350 verbose("Connection closed by %.100s",
351 get_remote_ipaddr());
352 connection_closed
= 1;
356 } else if (len
< 0) {
357 if (errno
!= EINTR
&& errno
!= EAGAIN
) {
358 verbose("Read error from remote host "
360 get_remote_ipaddr(), strerror(errno
));
364 /* Buffer any received data. */
365 packet_process_incoming(buf
, len
);
371 /* Read and buffer any available stdout data from the program. */
372 if (!fdout_eof
&& FD_ISSET(fdout
, readset
)) {
373 len
= read(fdout
, buf
, sizeof(buf
));
374 if (len
< 0 && (errno
== EINTR
|| errno
== EAGAIN
)) {
376 } else if (len
<= 0) {
379 buffer_append(&stdout_buffer
, buf
, len
);
383 /* Read and buffer any available stderr data from the program. */
384 if (!fderr_eof
&& FD_ISSET(fderr
, readset
)) {
385 len
= read(fderr
, buf
, sizeof(buf
));
386 if (len
< 0 && (errno
== EINTR
|| errno
== EAGAIN
)) {
388 } else if (len
<= 0) {
391 buffer_append(&stderr_buffer
, buf
, len
);
397 * Sends data from internal buffers to client program stdin.
400 process_output(fd_set
* writeset
)
407 /* Write buffered data to program stdin. */
408 if (!compat20
&& fdin
!= -1 && FD_ISSET(fdin
, writeset
)) {
409 data
= buffer_ptr(&stdin_buffer
);
410 dlen
= buffer_len(&stdin_buffer
);
411 len
= write(fdin
, data
, dlen
);
412 if (len
< 0 && (errno
== EINTR
|| errno
== EAGAIN
)) {
414 } else if (len
<= 0) {
418 shutdown(fdin
, SHUT_WR
); /* We will no longer send. */
421 /* Successful write. */
422 if (fdin_is_tty
&& dlen
>= 1 && data
[0] != '\r' &&
423 tcgetattr(fdin
, &tio
) == 0 &&
424 !(tio
.c_lflag
& ECHO
) && (tio
.c_lflag
& ICANON
)) {
426 * Simulate echo to reduce the impact of
429 packet_send_ignore(len
);
432 /* Consume the data from the buffer. */
433 buffer_consume(&stdin_buffer
, len
);
434 /* Update the count of bytes written to the program. */
438 /* Send any buffered packet data to the client. */
439 if (FD_ISSET(connection_out
, writeset
))
444 * Wait until all buffered output has been sent to the client.
445 * This is used when the program terminates.
450 /* Send any buffered stdout data to the client. */
451 if (buffer_len(&stdout_buffer
) > 0) {
452 packet_start(SSH_SMSG_STDOUT_DATA
);
453 packet_put_string(buffer_ptr(&stdout_buffer
),
454 buffer_len(&stdout_buffer
));
456 /* Update the count of sent bytes. */
457 stdout_bytes
+= buffer_len(&stdout_buffer
);
459 /* Send any buffered stderr data to the client. */
460 if (buffer_len(&stderr_buffer
) > 0) {
461 packet_start(SSH_SMSG_STDERR_DATA
);
462 packet_put_string(buffer_ptr(&stderr_buffer
),
463 buffer_len(&stderr_buffer
));
465 /* Update the count of sent bytes. */
466 stderr_bytes
+= buffer_len(&stderr_buffer
);
468 /* Wait until all buffered data has been written to the client. */
473 process_buffered_input_packets(void)
475 dispatch_run(DISPATCH_NONBLOCK
, NULL
, compat20
? xxx_kex
: NULL
);
479 * Performs the interactive session. This handles data transmission between
480 * the client and the program. Note that the notion of stdin, stdout, and
481 * stderr in this function is sort of reversed: this function writes to
482 * stdin (of the child program), and reads from stdout and stderr (of the
486 server_loop(pid_t pid
, int fdin_arg
, int fdout_arg
, int fderr_arg
)
488 fd_set
*readset
= NULL
, *writeset
= NULL
;
489 int max_fd
= 0, nalloc
= 0;
490 int wait_status
; /* Status returned by wait(). */
491 pid_t wait_pid
; /* pid returned by wait(). */
492 int waiting_termination
= 0; /* Have displayed waiting close message. */
493 u_int max_time_milliseconds
;
494 u_int previous_stdout_buffer_bytes
;
495 u_int stdout_buffer_bytes
;
498 debug("Entering interactive session.");
500 /* Initialize the SIGCHLD kludge. */
501 child_terminated
= 0;
502 mysignal(SIGCHLD
, sigchld_handler
);
504 /* Initialize our global variables. */
512 /* we don't have stderr for interactive terminal sessions, see below */
516 if (!(datafellows
& SSH_BUG_IGNOREMSG
) && isatty(fdin
))
519 connection_in
= packet_get_connection_in();
520 connection_out
= packet_get_connection_out();
524 previous_stdout_buffer_bytes
= 0;
526 /* Set approximate I/O buffer size. */
527 if (packet_is_interactive())
530 buffer_high
= 64 * 1024;
533 /* Initialize max_fd to the maximum of the known file descriptors. */
534 max_fd
= MAX(connection_in
, connection_out
);
535 max_fd
= MAX(max_fd
, fdin
);
536 max_fd
= MAX(max_fd
, fdout
);
538 max_fd
= MAX(max_fd
, fderr
);
541 /* Initialize Initialize buffers. */
542 buffer_init(&stdin_buffer
);
543 buffer_init(&stdout_buffer
);
544 buffer_init(&stderr_buffer
);
547 * If we have no separate fderr (which is the case when we have a pty
548 * - there we cannot make difference between data sent to stdout and
549 * stderr), indicate that we have seen an EOF from stderr. This way
550 * we don\'t need to check the descriptor everywhere.
555 server_init_dispatch();
557 /* Main loop of the server for the interactive session mode. */
560 /* Process buffered packets from the client. */
561 process_buffered_input_packets();
564 * If we have received eof, and there is no more pending
565 * input data, cause a real eof by closing fdin.
567 if (stdin_eof
&& fdin
!= -1 && buffer_len(&stdin_buffer
) == 0) {
571 shutdown(fdin
, SHUT_WR
); /* We will no longer send. */
574 /* Make packets from buffered stderr data to send to the client. */
575 make_packets_from_stderr_data();
578 * Make packets from buffered stdout data to send to the
579 * client. If there is very little to send, this arranges to
580 * not send them now, but to wait a short while to see if we
581 * are getting more data. This is necessary, as some systems
582 * wake up readers from a pty after each separate character.
584 max_time_milliseconds
= 0;
585 stdout_buffer_bytes
= buffer_len(&stdout_buffer
);
586 if (stdout_buffer_bytes
!= 0 && stdout_buffer_bytes
< 256 &&
587 stdout_buffer_bytes
!= previous_stdout_buffer_bytes
) {
588 /* try again after a while */
589 max_time_milliseconds
= 10;
592 make_packets_from_stdout_data();
594 previous_stdout_buffer_bytes
= buffer_len(&stdout_buffer
);
596 /* Send channel data to the client. */
597 if (packet_not_very_much_data_to_write())
598 channel_output_poll();
601 * Bail out of the loop if the program has closed its output
602 * descriptors, and we have no more data to send to the
603 * client, and there is no pending buffered data.
605 if (fdout_eof
&& fderr_eof
&& !packet_have_data_to_write() &&
606 buffer_len(&stdout_buffer
) == 0 && buffer_len(&stderr_buffer
) == 0) {
607 if (!channel_still_open())
609 if (!waiting_termination
) {
610 const char *s
= "Waiting for forwarded connections to terminate...\r\n";
612 waiting_termination
= 1;
613 buffer_append(&stderr_buffer
, s
, strlen(s
));
615 /* Display list of open channels. */
616 cp
= channel_open_message();
617 buffer_append(&stderr_buffer
, cp
, strlen(cp
));
621 max_fd
= MAX(connection_in
, connection_out
);
622 max_fd
= MAX(max_fd
, fdin
);
623 max_fd
= MAX(max_fd
, fdout
);
624 max_fd
= MAX(max_fd
, fderr
);
625 max_fd
= MAX(max_fd
, notify_pipe
[0]);
627 /* Sleep in select() until we can do something. */
628 wait_until_can_do_something(&readset
, &writeset
, &max_fd
,
629 &nalloc
, max_time_milliseconds
);
631 /* Process any channel events. */
632 channel_after_select(readset
, writeset
);
634 /* Process input from the client and from program stdout/stderr. */
635 process_input(readset
);
637 /* Process output to the client and to program stdin. */
638 process_output(writeset
);
645 /* Cleanup and termination code. */
647 /* Wait until all output has been sent to the client. */
650 debug("End of interactive session; stdin %ld, stdout (read %ld, sent %ld), stderr %ld bytes.",
651 stdin_bytes
, fdout_bytes
, stdout_bytes
, stderr_bytes
);
653 /* Free and clear the buffers. */
654 buffer_free(&stdin_buffer
);
655 buffer_free(&stdout_buffer
);
656 buffer_free(&stderr_buffer
);
658 /* Close the file descriptors. */
673 /* We no longer want our SIGCHLD handler to be called. */
674 mysignal(SIGCHLD
, SIG_DFL
);
676 while ((wait_pid
= waitpid(-1, &wait_status
, 0)) < 0)
678 packet_disconnect("wait: %.100s", strerror(errno
));
680 error("Strange, wait returned pid %ld, expected %ld",
681 (long)wait_pid
, (long)pid
);
683 /* Check if it exited normally. */
684 if (WIFEXITED(wait_status
)) {
685 /* Yes, normal exit. Get exit status and send it to the client. */
686 debug("Command exited with status %d.", WEXITSTATUS(wait_status
));
687 packet_start(SSH_SMSG_EXITSTATUS
);
688 packet_put_int(WEXITSTATUS(wait_status
));
693 * Wait for exit confirmation. Note that there might be
694 * other packets coming before it; however, the program has
695 * already died so we just ignore them. The client is
696 * supposed to respond with the confirmation when it receives
700 type
= packet_read();
702 while (type
!= SSH_CMSG_EXIT_CONFIRMATION
);
704 debug("Received exit confirmation.");
707 /* Check if the program terminated due to a signal. */
708 if (WIFSIGNALED(wait_status
))
709 packet_disconnect("Command terminated on signal %d.",
710 WTERMSIG(wait_status
));
712 /* Some weird exit cause. Just exit. */
713 packet_disconnect("wait returned status %04x.", wait_status
);
718 collect_children(void)
724 /* block SIGCHLD while we check for dead children */
726 sigaddset(&nset
, SIGCHLD
);
727 sigprocmask(SIG_BLOCK
, &nset
, &oset
);
728 if (child_terminated
) {
729 while ((pid
= waitpid(-1, &status
, WNOHANG
)) > 0 ||
730 (pid
< 0 && errno
== EINTR
))
732 session_close_by_pid(pid
, status
);
733 child_terminated
= 0;
735 sigprocmask(SIG_SETMASK
, &oset
, NULL
);
739 server_loop2(Authctxt
*authctxt
)
741 fd_set
*readset
= NULL
, *writeset
= NULL
;
742 int rekeying
= 0, max_fd
, nalloc
= 0;
744 debug("Entering interactive session for SSH2.");
746 mysignal(SIGCHLD
, sigchld_handler
);
747 child_terminated
= 0;
748 connection_in
= packet_get_connection_in();
749 connection_out
= packet_get_connection_out();
753 max_fd
= MAX(connection_in
, connection_out
);
754 max_fd
= MAX(max_fd
, notify_pipe
[0]);
756 server_init_dispatch();
759 process_buffered_input_packets();
761 rekeying
= (xxx_kex
!= NULL
&& !xxx_kex
->done
);
763 if (!rekeying
&& packet_not_very_much_data_to_write())
764 channel_output_poll();
765 wait_until_can_do_something(&readset
, &writeset
, &max_fd
,
770 channel_after_select(readset
, writeset
);
771 if (packet_need_rekeying()) {
772 debug("need rekeying");
774 kex_send_kexinit(xxx_kex
);
777 process_input(readset
);
778 if (connection_closed
)
780 process_output(writeset
);
789 /* free all channels, no more reads and writes */
792 /* free remaining sessions, e.g. remove wtmp entries */
793 session_destroy_all(NULL
);
797 server_input_keep_alive(int type
, u_int32_t seq
, void *ctxt
)
799 debug("Got %d/%u for keepalive", type
, seq
);
801 * reset timeout, since we got a sane answer from the client.
802 * even if this was generated by something other than
803 * the bogus CHANNEL_REQUEST we send for keepalives.
805 client_alive_timeouts
= 0;
809 server_input_stdin_data(int type
, u_int32_t seq
, void *ctxt
)
814 /* Stdin data from the client. Append it to the buffer. */
815 /* Ignore any data if the client has closed stdin. */
818 data
= packet_get_string(&data_len
);
820 buffer_append(&stdin_buffer
, data
, data_len
);
821 memset(data
, 0, data_len
);
826 server_input_eof(int type
, u_int32_t seq
, void *ctxt
)
829 * Eof from the client. The stdin descriptor to the
830 * program will be closed when all buffered data has
833 debug("EOF received for stdin.");
839 server_input_window_size(int type
, u_int32_t seq
, void *ctxt
)
841 int row
= packet_get_int();
842 int col
= packet_get_int();
843 int xpixel
= packet_get_int();
844 int ypixel
= packet_get_int();
846 debug("Window change received.");
849 pty_change_window_size(fdin
, row
, col
, xpixel
, ypixel
);
853 server_request_direct_tcpip(void)
857 char *target
, *originator
;
858 int target_port
, originator_port
;
860 target
= packet_get_string(NULL
);
861 target_port
= packet_get_int();
862 originator
= packet_get_string(NULL
);
863 originator_port
= packet_get_int();
866 debug("server_request_direct_tcpip: originator %s port %d, target %s port %d",
867 originator
, originator_port
, target
, target_port
);
869 /* XXX check permission */
870 sock
= channel_connect_to(target
, target_port
);
875 c
= channel_new("direct-tcpip", SSH_CHANNEL_CONNECTING
,
876 sock
, sock
, -1, CHAN_TCP_WINDOW_DEFAULT
,
877 CHAN_TCP_PACKET_DEFAULT
, 0, "direct-tcpip", 1);
882 server_request_session(void)
886 debug("input_session_request");
889 * A server session has no fd to read or write until a
890 * CHANNEL_REQUEST for a shell is made, so we set the type to
891 * SSH_CHANNEL_LARVAL. Additionally, a callback for handling all
892 * CHANNEL_REQUEST messages is registered.
894 c
= channel_new("session", SSH_CHANNEL_LARVAL
,
895 -1, -1, -1, /*window size*/0, CHAN_SES_PACKET_DEFAULT
,
896 0, "server-session", 1);
897 if (session_open(the_authctxt
, c
->self
) != 1) {
898 debug("session open failed, free channel %d", c
->self
);
902 channel_register_cleanup(c
->self
, session_close_by_channel
);
907 server_input_channel_open(int type
, u_int32_t seq
, void *ctxt
)
912 u_int rmaxpack
, rwindow
, len
;
914 ctype
= packet_get_string(&len
);
915 rchan
= packet_get_int();
916 rwindow
= packet_get_int();
917 rmaxpack
= packet_get_int();
919 debug("server_input_channel_open: ctype %s rchan %d win %d max %d",
920 ctype
, rchan
, rwindow
, rmaxpack
);
922 if (strcmp(ctype
, "session") == 0) {
923 c
= server_request_session();
924 } else if (strcmp(ctype
, "direct-tcpip") == 0) {
925 c
= server_request_direct_tcpip();
928 debug("server_input_channel_open: confirm %s", ctype
);
929 c
->remote_id
= rchan
;
930 c
->remote_window
= rwindow
;
931 c
->remote_maxpacket
= rmaxpack
;
932 if (c
->type
!= SSH_CHANNEL_CONNECTING
) {
933 packet_start(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION
);
934 packet_put_int(c
->remote_id
);
935 packet_put_int(c
->self
);
936 packet_put_int(c
->local_window
);
937 packet_put_int(c
->local_maxpacket
);
941 debug("server_input_channel_open: failure %s", ctype
);
942 packet_start(SSH2_MSG_CHANNEL_OPEN_FAILURE
);
943 packet_put_int(rchan
);
944 packet_put_int(SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED
);
945 if (!(datafellows
& SSH_BUG_OPENFAILURE
)) {
946 packet_put_cstring("open failed");
947 packet_put_cstring("");
955 server_input_global_request(int type
, u_int32_t seq
, void *ctxt
)
961 rtype
= packet_get_string(NULL
);
962 want_reply
= packet_get_char();
963 debug("server_input_global_request: rtype %s want_reply %d", rtype
, want_reply
);
965 /* -R style forwarding */
966 if (strcmp(rtype
, "tcpip-forward") == 0) {
968 char *listen_address
;
971 pw
= the_authctxt
->pw
;
972 if (pw
== NULL
|| !the_authctxt
->valid
)
973 fatal("server_input_global_request: no/invalid user");
974 listen_address
= packet_get_string(NULL
);
975 listen_port
= (u_short
)packet_get_int();
976 debug("server_input_global_request: tcpip-forward listen %s port %d",
977 listen_address
, listen_port
);
979 /* check permissions */
980 if (!options
.allow_tcp_forwarding
||
981 no_port_forwarding_flag
982 #ifndef NO_IPPORT_RESERVED_CONCEPT
983 || (listen_port
< IPPORT_RESERVED
&& pw
->pw_uid
!= 0)
987 packet_send_debug("Server has disabled port forwarding.");
989 /* Start listening on the port */
990 success
= channel_setup_remote_fwd_listener(
991 listen_address
, listen_port
, options
.gateway_ports
);
993 xfree(listen_address
);
996 packet_start(success
?
997 SSH2_MSG_REQUEST_SUCCESS
: SSH2_MSG_REQUEST_FAILURE
);
1004 server_input_channel_req(int type
, u_int32_t seq
, void *ctxt
)
1007 int id
, reply
, success
= 0;
1010 id
= packet_get_int();
1011 rtype
= packet_get_string(NULL
);
1012 reply
= packet_get_char();
1014 debug("server_input_channel_req: channel %d request %s reply %d",
1017 if ((c
= channel_lookup(id
)) == NULL
)
1018 packet_disconnect("server_input_channel_req: "
1019 "unknown channel %d", id
);
1020 if (c
->type
== SSH_CHANNEL_LARVAL
|| c
->type
== SSH_CHANNEL_OPEN
)
1021 success
= session_input_channel_req(c
, rtype
);
1023 packet_start(success
?
1024 SSH2_MSG_CHANNEL_SUCCESS
: SSH2_MSG_CHANNEL_FAILURE
);
1025 packet_put_int(c
->remote_id
);
1032 server_init_dispatch_20(void)
1034 debug("server_init_dispatch_20");
1035 dispatch_init(&dispatch_protocol_error
);
1036 dispatch_set(SSH2_MSG_CHANNEL_CLOSE
, &channel_input_oclose
);
1037 dispatch_set(SSH2_MSG_CHANNEL_DATA
, &channel_input_data
);
1038 dispatch_set(SSH2_MSG_CHANNEL_EOF
, &channel_input_ieof
);
1039 dispatch_set(SSH2_MSG_CHANNEL_EXTENDED_DATA
, &channel_input_extended_data
);
1040 dispatch_set(SSH2_MSG_CHANNEL_OPEN
, &server_input_channel_open
);
1041 dispatch_set(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION
, &channel_input_open_confirmation
);
1042 dispatch_set(SSH2_MSG_CHANNEL_OPEN_FAILURE
, &channel_input_open_failure
);
1043 dispatch_set(SSH2_MSG_CHANNEL_REQUEST
, &server_input_channel_req
);
1044 dispatch_set(SSH2_MSG_CHANNEL_WINDOW_ADJUST
, &channel_input_window_adjust
);
1045 dispatch_set(SSH2_MSG_GLOBAL_REQUEST
, &server_input_global_request
);
1047 dispatch_set(SSH2_MSG_CHANNEL_FAILURE
, &server_input_keep_alive
);
1048 dispatch_set(SSH2_MSG_REQUEST_SUCCESS
, &server_input_keep_alive
);
1049 dispatch_set(SSH2_MSG_REQUEST_FAILURE
, &server_input_keep_alive
);
1051 dispatch_set(SSH2_MSG_KEXINIT
, &kex_input_kexinit
);
1054 server_init_dispatch_13(void)
1056 debug("server_init_dispatch_13");
1057 dispatch_init(NULL
);
1058 dispatch_set(SSH_CMSG_EOF
, &server_input_eof
);
1059 dispatch_set(SSH_CMSG_STDIN_DATA
, &server_input_stdin_data
);
1060 dispatch_set(SSH_CMSG_WINDOW_SIZE
, &server_input_window_size
);
1061 dispatch_set(SSH_MSG_CHANNEL_CLOSE
, &channel_input_close
);
1062 dispatch_set(SSH_MSG_CHANNEL_CLOSE_CONFIRMATION
, &channel_input_close_confirmation
);
1063 dispatch_set(SSH_MSG_CHANNEL_DATA
, &channel_input_data
);
1064 dispatch_set(SSH_MSG_CHANNEL_OPEN_CONFIRMATION
, &channel_input_open_confirmation
);
1065 dispatch_set(SSH_MSG_CHANNEL_OPEN_FAILURE
, &channel_input_open_failure
);
1066 dispatch_set(SSH_MSG_PORT_OPEN
, &channel_input_port_open
);
1069 server_init_dispatch_15(void)
1071 server_init_dispatch_13();
1072 debug("server_init_dispatch_15");
1073 dispatch_set(SSH_MSG_CHANNEL_CLOSE
, &channel_input_ieof
);
1074 dispatch_set(SSH_MSG_CHANNEL_CLOSE_CONFIRMATION
, &channel_input_oclose
);
1077 server_init_dispatch(void)
1080 server_init_dispatch_20();
1082 server_init_dispatch_13();
1084 server_init_dispatch_15();