github/bettercap
1
0
Fork 0
mirror of https://github.com/bettercap/bettercap synced 2025-08-20 13:33:21 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

misc: small fix or general refactoring i did not bother commenting

Browse source
This commit is contained in:
evilsocket 2019-02-13 10:12:34 +01:00
commit 4eead7eafa
No known key found for this signature in database
GPG key ID: 1564D7F30393A456
58 changed files with 2052 additions and 2052 deletions
Download patch file Download diff file Expand all files Collapse all files

146
modules/api_rest/api_rest.go
View file

@ -29,7 +29,7 @@ type RestAPI struct {
}
func NewRestAPI(s *session.Session) *RestAPI {
api := &RestAPI{
mod := &RestAPI{
SessionModule: session.NewSessionModule("api.rest", s),
server: &http.Server{},
quit: make(chan bool),
@ -41,59 +41,59 @@ func NewRestAPI(s *session.Session) *RestAPI {
},
}
api.AddParam(session.NewStringParameter("api.rest.address",
mod.AddParam(session.NewStringParameter("api.rest.address",
session.ParamIfaceAddress,
session.IPv4Validator,
"Address to bind the API REST server to."))
api.AddParam(session.NewIntParameter("api.rest.port",
mod.AddParam(session.NewIntParameter("api.rest.port",
"8081",
"Port to bind the API REST server to."))
api.AddParam(session.NewStringParameter("api.rest.alloworigin",
api.allowOrigin,
mod.AddParam(session.NewStringParameter("api.rest.alloworigin",
mod.allowOrigin,
"",
"Value of the Access-Control-Allow-Origin header of the API server."))
api.AddParam(session.NewStringParameter("api.rest.username",
mod.AddParam(session.NewStringParameter("api.rest.username",
"",
"",
"API authentication username."))
api.AddParam(session.NewStringParameter("api.rest.password",
mod.AddParam(session.NewStringParameter("api.rest.password",
"",
"",
"API authentication password."))
api.AddParam(session.NewStringParameter("api.rest.certificate",
mod.AddParam(session.NewStringParameter("api.rest.certificate",
"",
"",
"API TLS certificate."))
tls.CertConfigToModule("api.rest", &api.SessionModule, tls.DefaultLegitConfig)
tls.CertConfigToModule("api.rest", &mod.SessionModule, tls.DefaultLegitConfig)
api.AddParam(session.NewStringParameter("api.rest.key",
mod.AddParam(session.NewStringParameter("api.rest.key",
"",
"",
"API TLS key"))
api.AddParam(session.NewBoolParameter("api.rest.websocket",
mod.AddParam(session.NewBoolParameter("api.rest.websocket",
"false",
"If true the /api/events route will be available as a websocket endpoint instead of HTTPS."))
api.AddHandler(session.NewModuleHandler("api.rest on", "",
mod.AddHandler(session.NewModuleHandler("api.rest on", "",
"Start REST API server.",
func(args []string) error {
return api.Start()
return mod.Start()
}))
api.AddHandler(session.NewModuleHandler("api.rest off", "",
mod.AddHandler(session.NewModuleHandler("api.rest off", "",
"Stop REST API server.",
func(args []string) error {
return api.Stop()
return mod.Stop()
}))
return api
return mod
}
type JSSessionRequest struct {
@ -104,113 +104,113 @@ type JSSessionResponse struct {
Error string `json:"error"`
}
func (api *RestAPI) Name() string {
func (mod *RestAPI) Name() string {
return "api.rest"
}
func (api *RestAPI) Description() string {
func (mod *RestAPI) Description() string {
return "Expose a RESTful API."
}
func (api *RestAPI) Author() string {
func (mod *RestAPI) Author() string {
return "Simone Margaritelli <evilsocket@gmail.com>"
}
func (api *RestAPI) isTLS() bool {
return api.certFile != "" && api.keyFile != ""
func (mod *RestAPI) isTLS() bool {
return mod.certFile != "" && mod.keyFile != ""
}
func (api *RestAPI) Configure() error {
func (mod *RestAPI) Configure() error {
var err error
var ip string
var port int
if api.Running() {
if mod.Running() {
return session.ErrAlreadyStarted
} else if err, ip = api.StringParam("api.rest.address"); err != nil {
} else if err, ip = mod.StringParam("api.rest.address"); err != nil {
return err
} else if err, port = api.IntParam("api.rest.port"); err != nil {
} else if err, port = mod.IntParam("api.rest.port"); err != nil {
return err
} else if err, api.allowOrigin = api.StringParam("api.rest.alloworigin"); err != nil {
} else if err, mod.allowOrigin = mod.StringParam("api.rest.alloworigin"); err != nil {
return err
} else if err, api.certFile = api.StringParam("api.rest.certificate"); err != nil {
} else if err, mod.certFile = mod.StringParam("api.rest.certificate"); err != nil {
return err
} else if api.certFile, err = fs.Expand(api.certFile); err != nil {
} else if mod.certFile, err = fs.Expand(mod.certFile); err != nil {
return err
} else if err, api.keyFile = api.StringParam("api.rest.key"); err != nil {
} else if err, mod.keyFile = mod.StringParam("api.rest.key"); err != nil {
return err
} else if api.keyFile, err = fs.Expand(api.keyFile); err != nil {
} else if mod.keyFile, err = fs.Expand(mod.keyFile); err != nil {
return err
} else if err, api.username = api.StringParam("api.rest.username"); err != nil {
} else if err, mod.username = mod.StringParam("api.rest.username"); err != nil {
return err
} else if err, api.password = api.StringParam("api.rest.password"); err != nil {
} else if err, mod.password = mod.StringParam("api.rest.password"); err != nil {
return err
} else if err, api.useWebsocket = api.BoolParam("api.rest.websocket"); err != nil {
} else if err, mod.useWebsocket = mod.BoolParam("api.rest.websocket"); err != nil {
return err
}
if api.isTLS() {
if !fs.Exists(api.certFile) || !fs.Exists(api.keyFile) {
err, cfg := tls.CertConfigFromModule("api.rest", api.SessionModule)
if mod.isTLS() {
if !fs.Exists(mod.certFile) || !fs.Exists(mod.keyFile) {
err, cfg := tls.CertConfigFromModule("api.rest", mod.SessionModule)
if err != nil {
return err
}
api.Debug("%+v", cfg)
api.Info("generating TLS key to %s", api.keyFile)
api.Info("generating TLS certificate to %s", api.certFile)
if err := tls.Generate(cfg, api.certFile, api.keyFile); err != nil {
mod.Debug("%+v", cfg)
mod.Info("generating TLS key to %s", mod.keyFile)
mod.Info("generating TLS certificate to %s", mod.certFile)
if err := tls.Generate(cfg, mod.certFile, mod.keyFile); err != nil {
return err
}
} else {
api.Info("loading TLS key from %s", api.keyFile)
api.Info("loading TLS certificate from %s", api.certFile)
mod.Info("loading TLS key from %s", mod.keyFile)
mod.Info("loading TLS certificate from %s", mod.certFile)
}
}
api.server.Addr = fmt.Sprintf("%s:%d", ip, port)
mod.server.Addr = fmt.Sprintf("%s:%d", ip, port)
router := mux.NewRouter()
router.HandleFunc("/api/events", api.eventsRoute)
router.HandleFunc("/api/session", api.sessionRoute)
router.HandleFunc("/api/session/ble", api.sessionRoute)
router.HandleFunc("/api/session/ble/{mac}", api.sessionRoute)
router.HandleFunc("/api/session/env", api.sessionRoute)
router.HandleFunc("/api/session/gateway", api.sessionRoute)
router.HandleFunc("/api/session/interface", api.sessionRoute)
router.HandleFunc("/api/session/modules", api.sessionRoute)
router.HandleFunc("/api/session/lan", api.sessionRoute)
router.HandleFunc("/api/session/lan/{mac}", api.sessionRoute)
router.HandleFunc("/api/session/options", api.sessionRoute)
router.HandleFunc("/api/session/packets", api.sessionRoute)
router.HandleFunc("/api/session/started-at", api.sessionRoute)
router.HandleFunc("/api/session/wifi", api.sessionRoute)
router.HandleFunc("/api/session/wifi/{mac}", api.sessionRoute)
router.HandleFunc("/api/events", mod.eventsRoute)
router.HandleFunc("/api/session", mod.sessionRoute)
router.HandleFunc("/api/session/ble", mod.sessionRoute)
router.HandleFunc("/api/session/ble/{mac}", mod.sessionRoute)
router.HandleFunc("/api/session/env", mod.sessionRoute)
router.HandleFunc("/api/session/gateway", mod.sessionRoute)
router.HandleFunc("/api/session/interface", mod.sessionRoute)
router.HandleFunc("/api/session/modules", mod.sessionRoute)
router.HandleFunc("/api/session/lan", mod.sessionRoute)
router.HandleFunc("/api/session/lan/{mac}", mod.sessionRoute)
router.HandleFunc("/api/session/options", mod.sessionRoute)
router.HandleFunc("/api/session/packets", mod.sessionRoute)
router.HandleFunc("/api/session/started-at", mod.sessionRoute)
router.HandleFunc("/api/session/wifi", mod.sessionRoute)
router.HandleFunc("/api/session/wifi/{mac}", mod.sessionRoute)
api.server.Handler = router
mod.server.Handler = router
if api.username == "" || api.password == "" {
api.Warning("api.rest.username and/or api.rest.password parameters are empty, authentication is disabled.")
if mod.username == "" || mod.password == "" {
mod.Warning("api.rest.username and/or api.rest.password parameters are empty, authentication is disabled.")
}
return nil
}
func (api *RestAPI) Start() error {
if err := api.Configure(); err != nil {
func (mod *RestAPI) Start() error {
if err := mod.Configure(); err != nil {
return err
}
api.SetRunning(true, func() {
mod.SetRunning(true, func() {
var err error
if api.isTLS() {
api.Info("api server starting on https://%s", api.server.Addr)
err = api.server.ListenAndServeTLS(api.certFile, api.keyFile)
if mod.isTLS() {
mod.Info("api server starting on https://%s", mod.server.Addr)
err = mod.server.ListenAndServeTLS(mod.certFile, mod.keyFile)
} else {
api.Info("api server starting on http://%s", api.server.Addr)
err = api.server.ListenAndServe()
mod.Info("api server starting on http://%s", mod.server.Addr)
err = mod.server.ListenAndServe()
}
if err != nil && err != http.ErrServerClosed {
@ -221,14 +221,14 @@ func (api *RestAPI) Start() error {
return nil
}
func (api *RestAPI) Stop() error {
return api.SetRunning(false, func() {
func (mod *RestAPI) Stop() error {
return mod.SetRunning(false, func() {
go func() {
api.quit <- true
mod.quit <- true
}()
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
defer cancel()
api.server.Shutdown(ctx)
mod.server.Shutdown(ctx)
})
}

130
modules/api_rest/api_rest_controller.go
View file

@ -21,116 +21,116 @@ type APIResponse struct {
Message string `json:"msg"`
}
func (api *RestAPI) setAuthFailed(w http.ResponseWriter, r *http.Request) {
api.Warning("Unauthorized authentication attempt from %s", r.RemoteAddr)
func (mod *RestAPI) setAuthFailed(w http.ResponseWriter, r *http.Request) {
mod.Warning("Unauthorized authentication attempt from %s", r.RemoteAddr)
w.Header().Set("WWW-Authenticate", `Basic realm="auth"`)
w.WriteHeader(401)
w.Write([]byte("Unauthorized"))
}
func (api *RestAPI) toJSON(w http.ResponseWriter, o interface{}) {
func (mod *RestAPI) toJSON(w http.ResponseWriter, o interface{}) {
w.Header().Set("Content-Type", "application/json")
if err := json.NewEncoder(w).Encode(o); err != nil {
api.Error("error while encoding object to JSON: %v", err)
mod.Error("error while encoding object to JSON: %v", err)
}
}
func (api *RestAPI) setSecurityHeaders(w http.ResponseWriter) {
func (mod *RestAPI) setSecurityHeaders(w http.ResponseWriter) {
w.Header().Add("X-Frame-Options", "DENY")
w.Header().Add("X-Content-Type-Options", "nosniff")
w.Header().Add("X-XSS-Protection", "1; mode=block")
w.Header().Add("Referrer-Policy", "same-origin")
w.Header().Set("Access-Control-Allow-Origin", api.allowOrigin)
w.Header().Set("Access-Control-Allow-Origin", mod.allowOrigin)
}
func (api *RestAPI) checkAuth(r *http.Request) bool {
if api.username != "" && api.password != "" {
func (mod *RestAPI) checkAuth(r *http.Request) bool {
if mod.username != "" && mod.password != "" {
user, pass, _ := r.BasicAuth()
// timing attack my ass
if subtle.ConstantTimeCompare([]byte(user), []byte(api.username)) != 1 {
if subtle.ConstantTimeCompare([]byte(user), []byte(mod.username)) != 1 {
return false
} else if subtle.ConstantTimeCompare([]byte(pass), []byte(api.password)) != 1 {
} else if subtle.ConstantTimeCompare([]byte(pass), []byte(mod.password)) != 1 {
return false
}
}
return true
}
func (api *RestAPI) showSession(w http.ResponseWriter, r *http.Request) {
api.toJSON(w, session.I)
func (mod *RestAPI) showSession(w http.ResponseWriter, r *http.Request) {
mod.toJSON(w, session.I)
}
func (api *RestAPI) showBle(w http.ResponseWriter, r *http.Request) {
func (mod *RestAPI) showBle(w http.ResponseWriter, r *http.Request) {
params := mux.Vars(r)
mac := strings.ToLower(params["mac"])
if mac == "" {
api.toJSON(w, session.I.BLE)
mod.toJSON(w, session.I.BLE)
} else if dev, found := session.I.BLE.Get(mac); found {
api.toJSON(w, dev)
mod.toJSON(w, dev)
} else {
http.Error(w, "Not Found", 404)
}
}
func (api *RestAPI) showEnv(w http.ResponseWriter, r *http.Request) {
api.toJSON(w, session.I.Env)
func (mod *RestAPI) showEnv(w http.ResponseWriter, r *http.Request) {
mod.toJSON(w, session.I.Env)
}
func (api *RestAPI) showGateway(w http.ResponseWriter, r *http.Request) {
api.toJSON(w, session.I.Gateway)
func (mod *RestAPI) showGateway(w http.ResponseWriter, r *http.Request) {
mod.toJSON(w, session.I.Gateway)
}
func (api *RestAPI) showInterface(w http.ResponseWriter, r *http.Request) {
api.toJSON(w, session.I.Interface)
func (mod *RestAPI) showInterface(w http.ResponseWriter, r *http.Request) {
mod.toJSON(w, session.I.Interface)
}
func (api *RestAPI) showModules(w http.ResponseWriter, r *http.Request) {
api.toJSON(w, session.I.Modules)
func (mod *RestAPI) showModules(w http.ResponseWriter, r *http.Request) {
mod.toJSON(w, session.I.Modules)
}
func (api *RestAPI) showLan(w http.ResponseWriter, r *http.Request) {
func (mod *RestAPI) showLan(w http.ResponseWriter, r *http.Request) {
params := mux.Vars(r)
mac := strings.ToLower(params["mac"])
if mac == "" {
api.toJSON(w, session.I.Lan)
mod.toJSON(w, session.I.Lan)
} else if host, found := session.I.Lan.Get(mac); found {
api.toJSON(w, host)
mod.toJSON(w, host)
} else {
http.Error(w, "Not Found", 404)
}
}
func (api *RestAPI) showOptions(w http.ResponseWriter, r *http.Request) {
api.toJSON(w, session.I.Options)
func (mod *RestAPI) showOptions(w http.ResponseWriter, r *http.Request) {
mod.toJSON(w, session.I.Options)
}
func (api *RestAPI) showPackets(w http.ResponseWriter, r *http.Request) {
api.toJSON(w, session.I.Queue)
func (mod *RestAPI) showPackets(w http.ResponseWriter, r *http.Request) {
mod.toJSON(w, session.I.Queue)
}
func (api *RestAPI) showStartedAt(w http.ResponseWriter, r *http.Request) {
api.toJSON(w, session.I.StartedAt)
func (mod *RestAPI) showStartedAt(w http.ResponseWriter, r *http.Request) {
mod.toJSON(w, session.I.StartedAt)
}
func (api *RestAPI) showWiFi(w http.ResponseWriter, r *http.Request) {
func (mod *RestAPI) showWiFi(w http.ResponseWriter, r *http.Request) {
params := mux.Vars(r)
mac := strings.ToLower(params["mac"])
if mac == "" {
api.toJSON(w, session.I.WiFi)
mod.toJSON(w, session.I.WiFi)
} else if station, found := session.I.WiFi.Get(mac); found {
api.toJSON(w, station)
mod.toJSON(w, station)
} else if client, found := session.I.WiFi.GetClient(mac); found {
api.toJSON(w, client)
mod.toJSON(w, client)
} else {
http.Error(w, "Not Found", 404)
}
}
func (api *RestAPI) runSessionCommand(w http.ResponseWriter, r *http.Request) {
func (mod *RestAPI) runSessionCommand(w http.ResponseWriter, r *http.Request) {
var err error
var cmd CommandRequest
@ -141,15 +141,15 @@ func (api *RestAPI) runSessionCommand(w http.ResponseWriter, r *http.Request) {
} else if err = session.I.Run(cmd.Command); err != nil {
http.Error(w, err.Error(), 400)
} else {
api.toJSON(w, APIResponse{Success: true})
mod.toJSON(w, APIResponse{Success: true})
}
}
func (api *RestAPI) showEvents(w http.ResponseWriter, r *http.Request) {
func (mod *RestAPI) showEvents(w http.ResponseWriter, r *http.Request) {
var err error
if api.useWebsocket {
api.startStreamingEvents(w, r)
if mod.useWebsocket {
mod.startStreamingEvents(w, r)
} else {
events := session.I.Events.Sorted()
nevents := len(events)
@ -169,22 +169,22 @@ func (api *RestAPI) showEvents(w http.ResponseWriter, r *http.Request) {
}
}
api.toJSON(w, events[nevents-n:])
mod.toJSON(w, events[nevents-n:])
}
}
func (api *RestAPI) clearEvents(w http.ResponseWriter, r *http.Request) {
func (mod *RestAPI) clearEvents(w http.ResponseWriter, r *http.Request) {
session.I.Events.Clear()
}
func (api *RestAPI) sessionRoute(w http.ResponseWriter, r *http.Request) {
api.setSecurityHeaders(w)
func (mod *RestAPI) sessionRoute(w http.ResponseWriter, r *http.Request) {
mod.setSecurityHeaders(w)
if !api.checkAuth(r) {
api.setAuthFailed(w, r)
if !mod.checkAuth(r) {
mod.setAuthFailed(w, r)
return
} else if r.Method == "POST" {
api.runSessionCommand(w, r)
mod.runSessionCommand(w, r)
return
} else if r.Method != "GET" {
http.Error(w, "Bad Request", 400)
@ -197,55 +197,55 @@ func (api *RestAPI) sessionRoute(w http.ResponseWriter, r *http.Request) {
path := r.URL.String()
switch {
case path == "/api/session":
api.showSession(w, r)
mod.showSession(w, r)
case path == "/api/session/env":
api.showEnv(w, r)
mod.showEnv(w, r)
case path == "/api/session/gateway":
api.showGateway(w, r)
mod.showGateway(w, r)
case path == "/api/session/interface":
api.showInterface(w, r)
mod.showInterface(w, r)
case strings.HasPrefix(path, "/api/session/modules"):
api.showModules(w, r)
mod.showModules(w, r)
case strings.HasPrefix(path, "/api/session/lan"):
api.showLan(w, r)
mod.showLan(w, r)
case path == "/api/session/options":
api.showOptions(w, r)
mod.showOptions(w, r)
case path == "/api/session/packets":
api.showPackets(w, r)
mod.showPackets(w, r)
case path == "/api/session/started-at":
api.showStartedAt(w, r)
mod.showStartedAt(w, r)
case strings.HasPrefix(path, "/api/session/ble"):
api.showBle(w, r)
mod.showBle(w, r)
case strings.HasPrefix(path, "/api/session/wifi"):
api.showWiFi(w, r)
mod.showWiFi(w, r)
default:
http.Error(w, "Not Found", 404)
}
}
func (api *RestAPI) eventsRoute(w http.ResponseWriter, r *http.Request) {
api.setSecurityHeaders(w)
func (mod *RestAPI) eventsRoute(w http.ResponseWriter, r *http.Request) {
mod.setSecurityHeaders(w)
if !api.checkAuth(r) {
api.setAuthFailed(w, r)
if !mod.checkAuth(r) {
mod.setAuthFailed(w, r)
return
}
if r.Method == "GET" {
api.showEvents(w, r)
mod.showEvents(w, r)
} else if r.Method == "DELETE" {
api.clearEvents(w, r)
mod.clearEvents(w, r)
} else {
http.Error(w, "Bad Request", 400)
}

42
modules/api_rest/api_rest_ws.go
View file

@ -20,17 +20,17 @@ const (
pingPeriod = (pongWait * 9) / 10
)
func (api *RestAPI) streamEvent(ws *websocket.Conn, event session.Event) error {
func (mod *RestAPI) streamEvent(ws *websocket.Conn, event session.Event) error {
msg, err := json.Marshal(event)
if err != nil {
api.Error("Error while creating websocket message: %s", err)
mod.Error("Error while creating websocket message: %s", err)
return err
}
ws.SetWriteDeadline(time.Now().Add(writeWait))
if err := ws.WriteMessage(websocket.TextMessage, msg); err != nil {
if !strings.Contains(err.Error(), "closed connection") {
api.Error("Error while writing websocket message: %s", err)
mod.Error("Error while writing websocket message: %s", err)
return err
}
}
@ -38,25 +38,25 @@ func (api *RestAPI) streamEvent(ws *websocket.Conn, event session.Event) error {
return nil
}
func (api *RestAPI) sendPing(ws *websocket.Conn) error {
func (mod *RestAPI) sendPing(ws *websocket.Conn) error {
ws.SetWriteDeadline(time.Now().Add(writeWait))
if err := ws.WriteMessage(websocket.PingMessage, []byte{}); err != nil {
api.Error("Error while writing websocket ping message: %s", err)
mod.Error("Error while writing websocket ping message: %s", err)
return err
}
return nil
}
func (api *RestAPI) streamWriter(ws *websocket.Conn, w http.ResponseWriter, r *http.Request) {
func (mod *RestAPI) streamWriter(ws *websocket.Conn, w http.ResponseWriter, r *http.Request) {
defer ws.Close()
// first we stream what we already have
events := session.I.Events.Sorted()
n := len(events)
if n > 0 {
api.Debug("Sending %d events.", n)
mod.Debug("Sending %d events.", n)
for _, event := range events {
if err := api.streamEvent(ws, event); err != nil {
if err := mod.streamEvent(ws, event); err != nil {
return
}
}
@ -64,7 +64,7 @@ func (api *RestAPI) streamWriter(ws *websocket.Conn, w http.ResponseWriter, r *h
session.I.Events.Clear()
api.Debug("Listening for events and streaming to ws endpoint ...")
mod.Debug("Listening for events and streaming to ws endpoint ...")
pingTicker := time.NewTicker(pingPeriod)
listener := session.I.Events.Listen()
@ -73,21 +73,21 @@ func (api *RestAPI) streamWriter(ws *websocket.Conn, w http.ResponseWriter, r *h
for {
select {
case <-pingTicker.C:
if err := api.sendPing(ws); err != nil {
if err := mod.sendPing(ws); err != nil {
return
}
case event := <-listener:
if err := api.streamEvent(ws, event); err != nil {
if err := mod.streamEvent(ws, event); err != nil {
return
}
case <-api.quit:
api.Info("Stopping websocket events streamer ...")
case <-mod.quit:
mod.Info("Stopping websocket events streamer ...")
return
}
}
}
func (api *RestAPI) streamReader(ws *websocket.Conn) {
func (mod *RestAPI) streamReader(ws *websocket.Conn) {
defer ws.Close()
ws.SetReadLimit(512)
ws.SetReadDeadline(time.Now().Add(pongWait))
@ -95,23 +95,23 @@ func (api *RestAPI) streamReader(ws *websocket.Conn) {
for {
_, _, err := ws.ReadMessage()
if err != nil {
api.Debug("Closing websocket reader.")
mod.Debug("Closing websocket reader.")
break
}
}
}
func (api *RestAPI) startStreamingEvents(w http.ResponseWriter, r *http.Request) {
ws, err := api.upgrader.Upgrade(w, r, nil)
func (mod *RestAPI) startStreamingEvents(w http.ResponseWriter, r *http.Request) {
ws, err := mod.upgrader.Upgrade(w, r, nil)
if err != nil {
if _, ok := err.(websocket.HandshakeError); !ok {
api.Error("Error while updating api.rest connection to websocket: %s", err)
mod.Error("Error while updating api.rest connection to websocket: %s", err)
}
return
}
api.Debug("Websocket streaming started for %s", r.RemoteAddr)
mod.Debug("Websocket streaming started for %s", r.RemoteAddr)
go api.streamWriter(ws, w, r)
api.streamReader(ws)
go mod.streamWriter(ws, w, r)
mod.streamReader(ws)
}