/* logChannel returns a logger which can be used to log channel activities to a
file in the directory ldir. The logger as well as the filename are
returned. */
func logChannel(
ldir string,
nc ssh.NewChannel,
) (*log.Logger, *os.File, string, error) {
/* Log file is named after the channel time and type */
logName := filepath.Join(
ldir,
time.Now().Format(LOGFORMAT)+"-"+nc.ChannelType(),
)
/* Open the file */
lf, err := os.OpenFile(
logName,
os.O_WRONLY|os.O_APPEND|os.O_CREATE|os.O_EXCL,
0600,
)
if nil != err {
return nil, nil, "", err
}
return log.New(
//lf,
io.MultiWriter(lf, os.Stderr), /* DEBUG */
"",
log.LstdFlags|log.Lmicroseconds,
), lf, logName, nil
}
func handleSSHChannel(newChan ssh.NewChannel, session *Session) {
ch, reqs, err := newChan.Accept()
if err != nil {
log.Println("handle channel failed:", err)
return
}
exitCh := make(chan int)
go func() {
status := struct{ Status uint32 }{uint32(<-exitCh)}
_, err = ch.SendRequest("exit-status", false, ssh.Marshal(&status))
assert(err)
ch.Close()
}()
for req := range reqs {
go func(req *ssh.Request) {
if req.WantReply {
req.Reply(true, nil)
}
switch req.Type {
case "exec":
var payload = struct{ Value string }{}
ssh.Unmarshal(req.Payload, &payload)
line := strings.Trim(payload.Value, "\n")
var args []string
if line != "" {
args = strings.Split(line, " ")
}
RunCmd(args, ch, ch, ch.Stderr(), exitCh, session)
}
}(req)
}
}
func (sshClient *sshClient) handleNewPortForwardChannel(newChannel ssh.NewChannel) {
defer sshClient.channelHandlerWaitGroup.Done()
// http://tools.ietf.org/html/rfc4254#section-7.2
var directTcpipExtraData struct {
HostToConnect string
PortToConnect uint32
OriginatorIPAddress string
OriginatorPort uint32
}
err := ssh.Unmarshal(newChannel.ExtraData(), &directTcpipExtraData)
if err != nil {
sshClient.rejectNewChannel(newChannel, ssh.Prohibited, "invalid extra data")
return
}
// Intercept TCP port forwards to a specified udpgw server and handle directly.
// TODO: also support UDP explicitly, e.g. with a custom "direct-udp" channel type?
isUDPChannel := sshClient.sshServer.support.Config.UDPInterceptUdpgwServerAddress != "" &&
sshClient.sshServer.support.Config.UDPInterceptUdpgwServerAddress ==
fmt.Sprintf("%s:%d",
directTcpipExtraData.HostToConnect,
directTcpipExtraData.PortToConnect)
if isUDPChannel {
sshClient.handleUDPChannel(newChannel)
} else {
sshClient.handleTCPChannel(
directTcpipExtraData.HostToConnect, int(directTcpipExtraData.PortToConnect), newChannel)
}
}
func (handler *SessionChannelHandler) HandleNewChannel(logger lager.Logger, newChannel ssh.NewChannel) {
err := newChannel.Reject(ssh.Prohibited, "SSH is not supported on windows cells")
if err != nil {
logger.Error("handle-new-session-channel-failed", err)
}
return
}
func (handler *SessionChannelHandler) HandleNewChannel(logger lager.Logger, newChannel ssh.NewChannel) {
channel, requests, err := newChannel.Accept()
if err != nil {
logger.Error("handle-new-session-channel-failed", err)
return
}
handler.newSession(logger, channel, handler.keepalive).serviceRequests(requests)
}
func (s *Server) handleChannel(ch ssh.NewChannel) {
id := rand.Int()
s.Debug("Handling Channel", "id", id, "chan", ch.ChannelType())
if ch.ChannelType() != "session" {
s.Info("Received unknown channel type", "chan", ch.ChannelType())
ch.Reject(ssh.UnknownChannelType, "unknown channel type")
return
}
channel, requests, err := ch.Accept()
if err != nil {
s.Error("Failed to accept channe", "err", err)
return
}
var closer sync.Once
closeChannel := func() {
s.Debug("Closed Channel", "id", id)
channel.Close()
}
defer closer.Do(closeChannel)
for req := range requests {
spew.Dump(req.Type)
switch req.Type {
case "exec":
// Let it through
case "env":
if req.WantReply {
if err = req.Reply(true, nil); err != nil {
s.Error("Failed to ignore env command", "err", err)
}
}
continue
default:
s.Info("Received unhandled request type", "type", req.Type)
continue
}
r := &scpRequest{db: s.DB}
processors := []processor{
r.ParseSCPRequest, r.DownloadFile, r.EndConnectionGracefully,
}
for _, proc := range processors {
if err := proc(channel, req); err != nil {
fmt.Fprintln(channel, "failed to process request:", err.Error())
// log.Printf("%+v", err)
break
}
}
closer.Do(closeChannel)
}
}
func (sshClient *sshClient) rejectNewChannel(newChannel ssh.NewChannel, reason ssh.RejectionReason, message string) {
// TODO: log more details?
log.WithContextFields(
LogFields{
"channelType": newChannel.ChannelType(),
"rejectMessage": message,
"rejectReason": reason,
}).Warning("reject new channel")
newChannel.Reject(reason, message)
}
func handleChannel(newChannel ssh.NewChannel, sh SessionHandler) {
// At this point, we have the opportunity to reject the client's
// request for another logical connection
channel, requests, err := newChannel.Accept()
if err != nil {
log.Printf("Could not accept channel (%s)", err)
return
}
// Prepare teardown function
close := func() {
channel.Close()
log.Printf("Session closed")
}
defer close()
sh.SetChannel(&channel)
var payload []byte
ok := true
for req := range requests {
if len(req.Payload) == 0 {
req.Reply(true, nil)
}
path := string(req.Payload)
typ := Mode(req.Type)
switch typ {
// in reality, this would be an scp with the appropriate args,
// but for testing this is fine.
case SOURCE:
ok, payload = sh.Source(path)
case DEST:
ok, payload = sh.Destination(path)
default:
return
}
// make sure that errors get send back if we failed
if req.WantReply {
log.Printf("Wants reply %s", string(payload))
req.Reply(ok, payload)
}
// run any pending work now that a reply has been sent
pendingFn := sh.GetPendingWork()
if pendingFn != nil {
pendingFn()
}
}
}
// ChannelForward establishes a secure channel forward (ssh -W) to the server
// requested by the user, assuming it is a permitted host.
func (s *Server) ChannelForward(session *Session, newChannel ssh.NewChannel) {
var msg channelOpenDirectMsg
ssh.Unmarshal(newChannel.ExtraData(), &msg)
address := fmt.Sprintf("%s:%d", msg.RAddr, msg.RPort)
permitted := false
for _, remote := range session.Remotes {
if remote == address {
permitted = true
break
}
}
if !permitted {
log.Printf("Disallowed access to %s for user %s", address, session.User.Name)
newChannel.Reject(ssh.Prohibited, "remote host access denied for user")
return
}
// Log the selection
if s.Selected != nil {
if err := s.Selected(session, address); err != nil {
newChannel.Reject(ssh.Prohibited, "access denied")
return
}
}
conn, err := net.Dial("tcp", address)
if err != nil {
newChannel.Reject(ssh.ConnectionFailed, fmt.Sprintf("error: %v", err))
return
}
channel, reqs, err := newChannel.Accept()
go ssh.DiscardRequests(reqs)
var closer sync.Once
closeFunc := func() {
channel.Close()
conn.Close()
}
go func() {
io.Copy(channel, conn)
closer.Do(closeFunc)
}()
go func() {
io.Copy(conn, channel)
closer.Do(closeFunc)
}()
}
func (handler *DirectTcpipChannelHandler) HandleNewChannel(logger lager.Logger, newChannel ssh.NewChannel) {
type channelOpenDirectTcpipMsg struct {
TargetAddr string
TargetPort uint32
OriginAddr string
OriginPort uint32
}
var directTcpipMessage channelOpenDirectTcpipMsg
err := ssh.Unmarshal(newChannel.ExtraData(), &directTcpipMessage)
if err != nil {
newChannel.Reject(ssh.ConnectionFailed, "Failed to parse open channel message")
return
}
destination := fmt.Sprintf("%s:%d", directTcpipMessage.TargetAddr, directTcpipMessage.TargetPort)
conn, err := handler.dialer.Dial("tcp", destination)
if err != nil {
newChannel.Reject(ssh.ConnectionFailed, err.Error())
return
}
channel, requests, err := newChannel.Accept()
go ssh.DiscardRequests(requests)
wg := &sync.WaitGroup{}
wg.Add(2)
go helpers.CopyAndClose(logger.Session("to-target"), wg, conn, channel)
go helpers.CopyAndClose(logger.Session("to-channel"), wg, channel, conn)
wg.Wait()
}
// HandleChannel handles one SSH channel
func (c *Client) HandleChannel(newChannel ssh.NewChannel) error {
if newChannel.ChannelType() != "session" {
log.Debugf("Unknown channel type: %s", newChannel.ChannelType())
newChannel.Reject(ssh.UnknownChannelType, "unknown channel type")
return nil
}
channel, requests, err := newChannel.Accept()
if err != nil {
log.Errorf("newChannel.Accept failed: %v", err)
return err
}
c.ChannelIdx++
log.Debugf("HandleChannel.channel (client=%d channel=%d)", c.Idx, c.ChannelIdx)
log.Debug("Creating pty...")
c.Pty, c.Tty, err = pty.Open()
if err != nil {
log.Errorf("pty.Open failed: %v", err)
return nil
}
c.HandleChannelRequests(channel, requests)
return nil
}
func (s *Session) HandleDirectChannel(newChannel ssh.NewChannel) (bool, ssh.RejectionReason) {
data, err := UnmarshalTunnelData(newChannel.ExtraData())
if err != nil {
return false, ssh.UnknownChannelType
}
// look up session by name
session, host, port := s.Gateway().LookupSessionService(data.Host, uint16(data.Port))
if session == nil {
return false, ssh.ConnectionFailed
}
// found the service, attempt to open a channel
data.Host = host
data.Port = uint32(port)
c2, err := session.OpenChannel("forwarded-tcpip", MarshalTunnelData(data))
if err != nil {
return false, ssh.ConnectionFailed
}
defer func() {
if c2 != nil {
c2.Close()
}
}()
// accept the channel
channel, requests, err := newChannel.Accept()
if err != nil {
return false, ssh.ResourceShortage
}
// cannot return false from this point on
// also need to accepted close the channel
defer func() {
if channel != nil {
if err := channel.Close(); err != nil {
glog.Warningf("failed to close accepted channel: %s", err)
}
}
}()
c, err := NewChannel(s, channel, newChannel.ChannelType(), newChannel.ExtraData())
if err != nil {
glog.Errorf("failed to create accepted channel: %s", err)
return true, 0
}
s.AddChannel(c)
// no failure
go c.HandleRequests(requests)
go c.HandleTunnelChannel(c2)
// do not close channel on exit
channel = nil
c2 = nil
return true, 0
}
func (svr *sshServer) handleChanReq(chanReq ssh.NewChannel) {
fmt.Fprintf(sshServerDebugStream, "channel request: %v, extra: '%v'\n", chanReq.ChannelType(), hex.EncodeToString(chanReq.ExtraData()))
switch chanReq.ChannelType() {
case "session":
if ch, reqs, err := chanReq.Accept(); err != nil {
fmt.Fprintf(sshServerDebugStream, "fail to accept channel request: %v\n", err)
chanReq.Reject(ssh.ResourceShortage, "channel accept failure")
} else {
chsvr := &sshSessionChannelServer{
sshChannelServer: &sshChannelServer{svr, chanReq, ch, reqs},
env: append([]string{}, os.Environ()...),
}
chsvr.handle()
}
default:
chanReq.Reject(ssh.UnknownChannelType, "channel type is not a session")
}
}
func handleSSHChannel(newChan ssh.NewChannel) {
ch, reqs, err := newChan.Accept()
if err != nil {
log.Println("handle channel failed:", err)
return
}
for req := range reqs {
go func(req *ssh.Request) {
if req.WantReply {
req.Reply(true, nil)
}
switch req.Type {
case "exec":
defer ch.Close()
var payload = struct{ Value string }{}
ssh.Unmarshal(req.Payload, &payload)
line := strings.Trim(payload.Value, "\n")
var args []string
if line != "" {
args = strings.Split(line, " ")
}
cmd := exec.Command("/bin/envy", args...)
cmd.Stdout = ch
cmd.Stderr = ch.Stderr()
err := cmd.Run()
status := struct{ Status uint32 }{0}
if err != nil {
if exiterr, ok := err.(*exec.ExitError); ok {
if stat, ok := exiterr.Sys().(syscall.WaitStatus); ok {
status = struct{ Status uint32 }{uint32(stat.ExitStatus())}
} else {
assert(err)
}
}
}
_, err = ch.SendRequest("exit-status", false, ssh.Marshal(&status))
assert(err)
return
}
}(req)
}
}
func (server *Server) handleChannel(newChannel ssh.NewChannel, conn *ssh.ServerConn) {
channelType := newChannel.ChannelType()
if channelType != "session" {
newChannel.Reject(ssh.UnknownChannelType,
fmt.Sprintf("Unknown SSH Channel Type: %s, only `session` is supported", channelType))
server.Logger.Errorf("Rejected SSH Channel Request from %s due to unknown channel type: %s",
conn.RemoteAddr().String(), newChannel.ChannelType())
return
}
channel, requests, err := newChannel.Accept()
if err != nil {
newChannel.Reject(ssh.ConnectionFailed, "Failed to accept SSH Channel Request, developers are working on it.")
server.Logger.Errorf("Rejected SSH Channel Request from %s due to accept request failure: %s",
conn.RemoteAddr().String(), err)
return
}
server.Logger.Debugf("Accepted new SSH Channel Request from %s", conn.RemoteAddr().String())
server.handleRequest(channel, requests, conn)
}
func handleChannel(newChannel ssh.NewChannel, rClient *ssh.Client) {
if newChannel.ChannelType() != "session" {
newChannel.Reject(ssh.UnknownChannelType, "unknown channel type: "+newChannel.ChannelType())
return
}
psChannel, psRequests, err := newChannel.Accept()
if err != nil {
panic("could not accept channel.")
}
sChannel, sRequests, err := rClient.OpenChannel(newChannel.ChannelType(), nil)
if err != nil {
panic("Failed to create session: " + err.Error())
}
go pipeRequests(psChannel, sChannel, psRequests, sRequests)
time.Sleep(50 * time.Millisecond)
go pipe(sChannel, psChannel)
go pipe(psChannel, sChannel)
}
func (s *server) handleChanReq(chanReq ssh.NewChannel, authInfo map[string]string) {
if chanReq.ChannelType() != "session" {
chanReq.Reject(ssh.Prohibited, "channel type is not a session")
return
}
ch, reqs, err := chanReq.Accept()
if err != nil {
log.Errorf("fail to accept channel request %v", err)
return
}
for {
req := <-reqs
switch req.Type {
case "env":
case "exec":
s.handleExec(ch, req, authInfo)
return
default:
ch.Write([]byte(fmt.Sprintf("request type %q not allowed\r\n", req.Type)))
ch.Close()
return
}
}
}
func handleChannel(conn *ssh.ServerConn, newChan ssh.NewChannel, execHandler []string) {
ch, reqs, err := newChan.Accept()
if err != nil {
log.Println("newChan.Accept failed:", err)
return
}
// Setup stdout/stderr
var stdout, stderr io.Writer
if *debug {
stdout = io.MultiWriter(ch, os.Stdout)
stderr = io.MultiWriter(ch.Stderr(), os.Stdout)
} else {
stdout = ch
stderr = ch.Stderr()
}
handler := sshHandler{
ExecHandler: execHandler,
channel: ch,
stdout: stdout,
stderr: stderr,
}
// Load default environment
if *env {
handler.Env = os.Environ()
}
if conn.Permissions != nil {
// Using Permissions.Extensions as a way to get state from PublicKeyCallback
if conn.Permissions.Extensions["environ"] != "" {
handler.Env = append(handler.Env, strings.Split(conn.Permissions.Extensions["environ"], "\n")...)
}
handler.Env = append(handler.Env, "USER="******"user"])
}
for req := range reqs {
go handler.Request(req)
}
}
func handleChannel(chanRequest ssh.NewChannel) {
handle, err := NewHandle(chanRequest.ChannelType())
if err != nil {
config.Log.Debug("wrong handler %v", err)
chanRequest.Reject(ssh.UnknownChannelType, err.Error())
return
}
ch, reqs, err := chanRequest.Accept()
if err != nil {
config.Log.Debug("fail to accept channel request %v", err)
return
}
defer ch.Close()
for req := range reqs {
done, err := handle.Request(ch, req)
if err != nil {
config.Log.Debug("request errored out %v", err)
_, err := ch.Write([]byte(fmt.Sprintf("%v\r\n", err)))
if err != nil {
config.Log.Debug(err.Error())
}
}
if done {
return
}
}
}
func sshHandleChannel(conn net.Conn, newChannel ssh.NewChannel) {
// Channels have a type, depending on the application level protocol
// intended. In the case of a shell, the type is "session" and ServerShell
// may be used to present a simple terminal interface.
if newChannel.ChannelType() != "session" {
newChannel.Reject(ssh.UnknownChannelType, "unknown channel type")
return
}
channel, requests, err := newChannel.Accept()
if err != nil {
log.Errorln(err)
return
}
// Sessions have out-of-band requests such as "shell", "pty-req" and "env".
// Here we handle only the "shell" request.
go func(in <-chan *ssh.Request) {
for req := range in {
ok := false
switch req.Type {
case "shell":
ok = true
if len(req.Payload) > 0 {
// We don't accept any commands, only the default shell.
ok = false
}
case "pty-req":
ok = true
}
req.Reply(ok, nil)
}
}(requests)
term := terminal.NewTerminal(channel, "> ")
go func() {
defer channel.Close()
for {
line, err := term.ReadLine()
start := time.Now().UnixNano()
if err != nil {
if err != io.EOF {
log.Errorln(err)
}
return
}
sshReportChan <- uint64(len(line))
// just echo the message
log.Debugln("ssh received: ", line)
term.Write([]byte(line))
term.Write([]byte{'\r', '\n'})
stop := time.Now().UnixNano()
log.Info("ssh %v %vns", conn.RemoteAddr(), uint64(stop-start))
}
}()
}
// Make new terminal from a session channel
func NewTerminal(conn *ssh.ServerConn, ch ssh.NewChannel) (*Terminal, error) {
if ch.ChannelType() != "session" {
return nil, errors.New("terminal requires session channel")
}
channel, requests, err := ch.Accept()
if err != nil {
return nil, err
}
term := Terminal{
*terminal.NewTerminal(channel, "Connecting..."),
sshConn{conn},
channel,
}
go term.listen(requests)
go func() {
// FIXME: Is this necessary?
conn.Wait()
channel.Close()
}()
return &term, nil
}
// handleUDPChannel implements UDP port forwarding. A single UDP
// SSH channel follows the udpgw protocol, which multiplexes many
// UDP port forwards.
//
// The udpgw protocol and original server implementation:
// Copyright (c) 2009, Ambroz Bizjak <*****@*****.**>
// https://github.com/ambrop72/badvpn
//
func (sshClient *sshClient) handleUDPChannel(newChannel ssh.NewChannel) {
// Accept this channel immediately. This channel will replace any
// previously existing UDP channel for this client.
sshChannel, requests, err := newChannel.Accept()
if err != nil {
log.WithContextFields(LogFields{"error": err}).Warning("accept new channel failed")
return
}
go ssh.DiscardRequests(requests)
defer sshChannel.Close()
sshClient.setUDPChannel(sshChannel)
multiplexer := &udpPortForwardMultiplexer{
sshClient: sshClient,
sshChannel: sshChannel,
portForwards: make(map[uint16]*udpPortForward),
portForwardLRU: psiphon.NewLRUConns(),
relayWaitGroup: new(sync.WaitGroup),
}
multiplexer.run()
}
/* rejectChannel tells the attacker the channel's been rejected by the real
server. It requires the error from the channel request to the real server, the
channel request log string, the channel request from the attacker, and the
logger for the connection. */
func rejectChannel(nce error, crl string, nc ssh.NewChannel, lg *log.Logger) {
/* Values to return to the attacker */
reason := ssh.Prohibited
message := nce.Error()
/* Try and get the real story */
if oce, ok := nce.(*ssh.OpenChannelError); ok {
reason = oce.Reason
message = oce.Message
}
lg.Printf(
"Channel Rejection %v Reason:%v Message:%q",
crl,
reason,
message,
)
/* Send the rejection */
if err := nc.Reject(reason, message); nil != err {
lg.Printf(
"Unable to respond to channel request of type %q: %v",
nc.ChannelType(),
err,
)
}
}
func (s *Server) HandleNewChannel(session *Session, newChannel ssh.NewChannel) {
log.Printf("New Channel: %s", newChannel)
switch newChannel.ChannelType() {
case "direct-tcpip":
s.ChannelForward(session, newChannel)
default:
log.Printf("Unknown SSH channel type: %s", newChannel.ChannelType())
newChannel.Reject(ssh.UnknownChannelType, "connection flow not supported by sshmux")
}
}
func (server *SshServer) handleChannel(user string, newChannel ssh.NewChannel) {
if t := newChannel.ChannelType(); t != "session" {
newChannel.Reject(ssh.UnknownChannelType, fmt.Sprintf("unknown channel type: %s", t))
return
}
connection, requests, err := newChannel.Accept()
if err != nil {
fmt.Printf("Could not accept channel (%s)", err)
return
}
defer connection.Close()
logfile, err := os.Create(fmt.Sprintf("%s_%s", user, storyLogFilename(server.story)))
if err != nil {
panic(err)
}
defer logfile.Close()
logger := log.New(logfile, "", log.LstdFlags)
terminal := terminal.NewTerminal(connection, "")
zsshterm := &gork.ZSshTerminal{Term: terminal}
zm, err := gork.NewZMachine(server.mem, server.header, zsshterm, logger)
if err != nil {
fmt.Println(err)
return
}
go func() {
for req := range requests {
switch req.Type {
case "shell":
if len(req.Payload) == 0 {
req.Reply(true, nil)
}
case "pty-req":
termLen := req.Payload[3]
w, h := parseDims(req.Payload[termLen+4:])
terminal.SetSize(w, h)
case "window-change":
w, h := parseDims(req.Payload)
terminal.SetSize(w, h)
}
}
}()
defer func() {
recover()
}()
zm.InterpretAll()
}
func handleChannel(c ssh.NewChannel) {
if t := c.ChannelType(); t != "session" {
log.Println("rejected unknown channel type:", t)
c.Reject(ssh.UnknownChannelType, "unknown channel type")
}
connection, requests, err := c.Accept()
if err != nil {
log.Println("channel not accepted:", err)
return
}
bash := exec.Command("/bin/bash")
close := func() {
connection.Close()
_, err := bash.Process.Wait()
if err != nil {
log.Println("bash not exited:", err)
}
log.Println("session closed")
}
bashf, err := pty.Start(bash)
if err != nil {
log.Println("pty not started:", err)
close()
return
}
var once sync.Once
go func() {
io.Copy(connection, bashf)
once.Do(close)
}()
go func() {
io.Copy(bashf, connection)
once.Do(close)
}()
go func() {
for req := range requests {
log.Println("got request:", req.Type, "want reply:", req.WantReply)
switch req.Type {
case "shell":
if len(req.Payload) == 0 {
req.Reply(true, nil)
}
case "pty-req":
termLen := req.Payload[3]
w, h := parseDims(req.Payload[termLen+4:])
SetWinsize(bashf.Fd(), w, h)
req.Reply(true, nil)
case "window-change":
w, h := parseDims(req.Payload)
SetWinsize(bashf.Fd(), w, h)
}
}
}()
}
func (s *Session) HandleChannel(newChannel ssh.NewChannel) {
glog.V(9).Infof("new channel: type = %s, data = %v", newChannel.ChannelType(), newChannel.ExtraData())
ok := false
rejection := ssh.UnknownChannelType
switch newChannel.ChannelType() {
case "session":
ok, rejection = s.HandleSessionChannel(newChannel)
case "direct-tcpip":
ok, rejection = s.HandleDirectChannel(newChannel)
}
if !ok {
// reject the channel
if err := newChannel.Reject(rejection, ""); err != nil {
glog.Warningf("failed to reject channel: %s", err)
}
}
}
func (s *sshServer) handleChannel(newChannel ssh.NewChannel) error {
if newChannel.ChannelType() != "session" {
newChannel.Reject(ssh.UnknownChannelType, "unknown channel type")
return nil
}
channel, requests, err := newChannel.Accept()
if err != nil {
log.Println("newChannel accept failed: ", err)
return nil
}
return s.handleRequests(channel, requests)
}
func (u *SimpleDispatcher) Dispatch(c context.Context, conn *ssh.ServerConn, ch ssh.NewChannel) {
defer conn.Close()
var ctx *Context
if u.PanicHandler != nil {
if rcv := recover(); rcv != nil {
u.PanicHandler.Handle(ctx, rcv)
}
}
// Get channel type
chType := ch.ChannelType()
handler, ok := u.Handlers[chType]
if !ok {
return
}
// Otherwise, accept the channel
channel, requests, err := ch.Accept()
if err != nil {
u.Logger.Warn("Error creating channel", "type", chType, "err", err)
ch.Reject(ChannelAcceptError, chType)
return
}
// Handle the channel
ctx = &Context{
Context: c,
Channel: channel,
Requests: requests,
}
err = handler.Handle(ctx)
if err != nil {
u.Logger.Warn("Error handling channel", "type", chType, "err", err)
ch.Reject(ChannelHandleError, fmt.Sprintf("error handling channel: %s", err.Error()))
return
}
}
func reject(chType string, uri *url.URL, ch ssh.NewChannel, logger log.Logger) bool {
if uri.Scheme != "" {
logger.Warn("URI schemes not supported", "type", chType)
ch.Reject(SchemeNotSupported, "schemes are not supported in the channel URI")
return true
} else if uri.User != nil {
logger.Warn("URI users not supported", "type", chType)
ch.Reject(UserNotSupported, "users are not supported in the channel URI")
return true
} else if uri.Host != "" {
logger.Warn("URI hosts not supported", "type", chType)
ch.Reject(HostNotSupported, "hosts are not supported in the channel URI")
return true
}
return false
}
