provisioning.go

// matrix-pulsesms - A Matrix-PulseSMS puppeting bridge.
// Copyright (C) 2021 Cam Sweeney
// Copyright (C) 2020 Tulir Asokan
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

package main

import (
	"bufio"
	"context"
	"encoding/json"
	"errors"
	"net"
	"net/http"
	"strings"
	"time"

	"github.com/gorilla/websocket"

	log "maunium.net/go/maulogger/v2"

	"maunium.net/go/mautrix/id"
)

type ProvisioningAPI struct {
	bridge *Bridge
	log    log.Logger
}

func (prov *ProvisioningAPI) Init() {
	prov.log = prov.bridge.Log.Sub("Provisioning")
	prov.log.Debugln("Enabling provisioning API at", prov.bridge.Config.AppService.Provisioning.Prefix)
	r := prov.bridge.AS.Router.PathPrefix(prov.bridge.Config.AppService.Provisioning.Prefix).Subrouter()
	r.Use(prov.AuthMiddleware)
	r.HandleFunc("/ping", prov.Ping).Methods(http.MethodGet)
	// r.HandleFunc("/login", prov.Login).Methods(http.MethodGet)
	// r.HandleFunc("/logout", prov.Logout).Methods(http.MethodPost)
	// r.HandleFunc("/delete_session", prov.DeleteSession).Methods(http.MethodPost)
	// r.HandleFunc("/delete_connection", prov.DeleteConnection).Methods(http.MethodPost)
	r.HandleFunc("/disconnect", prov.Disconnect).Methods(http.MethodPost)
	// r.HandleFunc("/reconnect", prov.Reconnect).Methods(http.MethodPost)
	prov.bridge.AS.Router.HandleFunc("/_matrix/app/com.beeper.asmux/ping", prov.AsmuxPing).Methods(http.MethodPost)
}

type responseWrap struct {
	http.ResponseWriter
	statusCode int
}

var _ http.Hijacker = (*responseWrap)(nil)

func (rw *responseWrap) WriteHeader(statusCode int) {
	rw.ResponseWriter.WriteHeader(statusCode)
	rw.statusCode = statusCode
}

func (rw *responseWrap) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	hijacker, ok := rw.ResponseWriter.(http.Hijacker)
	if !ok {
		return nil, nil, errors.New("response does not implement http.Hijacker")
	}
	return hijacker.Hijack()
}

func (prov *ProvisioningAPI) AuthMiddleware(h http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		auth := r.Header.Get("Authorization")
		if len(auth) == 0 && strings.HasSuffix(r.URL.Path, "/login") {
			authParts := strings.Split(r.Header.Get("Sec-WebSocket-Protocol"), ",")
			for _, part := range authParts {
				part = strings.TrimSpace(part)
				if strings.HasPrefix(part, "dev.spherics.pulsesms.auth-") {
					auth = part[len("dev.spherics.pulsesms.auth-"):]
					break
				}
			}
		} else if strings.HasPrefix(auth, "Bearer ") {
			auth = auth[len("Bearer "):]
		}
		if auth != prov.bridge.Config.AppService.Provisioning.SharedSecret {
			jsonResponse(w, http.StatusForbidden, map[string]interface{}{
				"error":   "Invalid auth token",
				"errcode": "M_FORBIDDEN",
			})
			return
		}
		userID := r.URL.Query().Get("user_id")
		user := prov.bridge.GetUserByMXID(id.UserID(userID))
		start := time.Now()
		wWrap := &responseWrap{w, 200}
		h.ServeHTTP(wWrap, r.WithContext(context.WithValue(r.Context(), "user", user)))
		duration := time.Now().Sub(start).Seconds()
		prov.log.Infofln("%s %s from %s took %.2f seconds and returned status %d", r.Method, r.URL.Path, user.MXID, duration, wWrap.statusCode)
	})
}

type Error struct {
	Success bool   `json:"success"`
	Error   string `json:"error"`
	ErrCode string `json:"errcode"`
}

type Response struct {
	Success bool   `json:"success"`
	Status  string `json:"status"`
}

func (prov *ProvisioningAPI) DeleteSession(w http.ResponseWriter, r *http.Request) {
	user := r.Context().Value("user").(*User)
	if user.Session == nil && user.Pulse == nil {
		jsonResponse(w, http.StatusNotFound, Error{
			Error:   "Nothing to purge: no session information stored and no active connection.",
			ErrCode: "no session",
		})
		return
	}
	user.DeleteConnection()
	user.SetSession(nil)
	jsonResponse(w, http.StatusOK, Response{true, "Session information purged"})
}

func (prov *ProvisioningAPI) DeleteConnection(w http.ResponseWriter, r *http.Request) {
	user := r.Context().Value("user").(*User)
	if user.Pulse == nil {
		jsonResponse(w, http.StatusNotFound, Error{
			Error:   "You don't have a PulseSMS connection.",
			ErrCode: "not connected",
		})
		return
	}
	user.DeleteConnection()
	jsonResponse(w, http.StatusOK, Response{true, "Disconnected from PulseSMS and connection deleted"})
}

func (prov *ProvisioningAPI) Disconnect(w http.ResponseWriter, r *http.Request) {
	user := r.Context().Value("user").(*User)
	if user.Pulse == nil {
		jsonResponse(w, http.StatusNotFound, Error{
			Error:   "You don't have a PulseSMS connection.",
			ErrCode: "no connection",
		})
		return
	}
	user.Pulse.Disconnect()
	user.bridge.Metrics.TrackConnectionState(user.PID, false)
	jsonResponse(w, http.StatusOK, Response{true, "Disconnected from PulseSMS"})
}

// func (prov *ProvisioningAPI) Reconnect(w http.ResponseWriter, r *http.Request) {
// 	user := r.Context().Value("user").(*User)
// 	if user.Pulse == nil {
// 		if user.Session == nil {
// 			jsonResponse(w, http.StatusForbidden, Error{
// 				Error:   "No existing connection and no session. Please log in first.",
// 				ErrCode: "no session",
// 			})
// 		} else {
// 			user.Connect(false)
// 			jsonResponse(w, http.StatusOK, Response{true, "Created connection to PulseSMS."})
// 		}
// 		return
// 	}

// 	user.log.Debugln("Received /reconnect request, disconnecting")
//     user.Pulse = nil

// 	wasConnected := true
// 	err := user.Conn.Disconnect()
// 	if err == whatsapp.ErrNotConnected {
// 		wasConnected = false
// 	} else if err != nil {
// 		user.log.Warnln("Error while disconnecting:", err)
// 	}

// 	user.log.Debugln("Restoring session for /reconnect")
// 	err = user.Conn.Restore(true, r.Context())
// 	user.log.Debugfln("Restore session for /reconnect responded with %v", err)
// 	if err == whatsapp.ErrInvalidSession {
// 		if user.Session != nil {
// 			user.log.Debugln("Got invalid session error when reconnecting, but user has session. Retrying using RestoreWithSession()...")
// 			user.Conn.SetSession(*user.Session)
// 			err = user.Conn.Restore(true, r.Context())
// 		} else {
// 			jsonResponse(w, http.StatusForbidden, Error{
// 				Error:   "You're not logged in",
// 				ErrCode: "not logged in",
// 			})
// 			return
// 		}
// 	}
// 	if err == whatsapp.ErrLoginInProgress {
// 		jsonResponse(w, http.StatusConflict, Error{
// 			Error:   "A login or reconnection is already in progress.",
// 			ErrCode: "login in progress",
// 		})
// 		return
// 	} else if err == whatsapp.ErrAlreadyLoggedIn {
// 		jsonResponse(w, http.StatusConflict, Error{
// 			Error:   "You were already connected.",
// 			ErrCode: err.Error(),
// 		})
// 		return
// 	}
// 	if err != nil {
// 		user.log.Warnln("Error while reconnecting:", err)
// 		jsonResponse(w, http.StatusInternalServerError, Error{
// 			Error:   fmt.Sprintf("Unknown error while reconnecting: %v", err),
// 			ErrCode: err.Error(),
// 		})
// 		user.log.Debugln("Disconnecting due to failed session restore in reconnect command...")
// 		err = user.Conn.Disconnect()
// 		if err != nil {
// 			user.log.Errorln("Failed to disconnect after failed session restore in reconnect command:", err)
// 		}
// 		return
// 	}
// 	user.ConnectionErrors = 0
// 	user.PostLogin()

// 	var msg string
// 	if wasConnected {
// 		msg = "Reconnected successfully."
// 	} else {
// 		msg = "Connected successfully."
// 	}

// 	jsonResponse(w, http.StatusOK, Response{true, msg})
// }

func (prov *ProvisioningAPI) Ping(w http.ResponseWriter, r *http.Request) {
	user := r.Context().Value("user").(*User)
	wa := map[string]interface{}{
		"has_session":     user.Session != nil,
		"management_room": user.ManagementRoom,
		"pid":             user.PID,
		"conn":            nil,
		"ping":            nil,
	}

	loggedIn := user.Session != nil

	if user.Pulse != nil {
		wa["conn"] = map[string]interface{}{
			"is_connected": user.Pulse.IsConnected(),
			"is_logged_in": loggedIn,
		}
		// user.log.Debugln("Pinging PulseSMS mobile due to /ping API request")
		// err := user.Conn.AdminTest()
		// var errStr string
		// if err == whatsapp.ErrPingFalse {
		// 	user.log.Debugln("Forwarding ping false error from provisioning API to HandleError")
		// 	go user.HandleError(err)
		// }
		// if err != nil {
		// errStr = err.Error()
		// }
		// wa["ping"] = map[string]interface{}{
		// 	"ok":  err == nil,
		// 	"err": errStr,
		// }
		user.log.Debugfln("Admin test response for /ping: (conn: %t, login: %t)",
			user.Pulse.IsConnected(), loggedIn)
	}
	resp := map[string]interface{}{
		"mxid":                 user.MXID,
		"admin":                user.Admin,
		"whitelisted":          user.Whitelisted,
		"relaybot_whitelisted": user.RelaybotWhitelisted,
		"whatsapp":             wa,
	}
	jsonResponse(w, http.StatusOK, resp)
}

func jsonResponse(w http.ResponseWriter, status int, response interface{}) {
	w.Header().Add("Content-Type", "application/json")
	w.WriteHeader(status)
	_ = json.NewEncoder(w).Encode(response)
}

func (prov *ProvisioningAPI) Logout(w http.ResponseWriter, r *http.Request) {
	user := r.Context().Value("user").(*User)
	if user.Session == nil {
		jsonResponse(w, http.StatusNotFound, Error{
			Error:   "You're not logged in",
			ErrCode: "not logged in",
		})
		return
	}

	force := strings.ToLower(r.URL.Query().Get("force")) != "false"

	if user.Pulse == nil {
		if !force {
			jsonResponse(w, http.StatusNotFound, Error{
				Error:   "You're not connected",
				ErrCode: "not connected",
			})
		}
	} else {
		user.DeleteConnection()
	}

	user.bridge.Metrics.TrackConnectionState(user.PID, false)
	user.removeFromPIDMap()

	// TODO this causes a foreign key violation, which should be fixed
	//ce.User.PID = ""
	user.SetSession(nil)
	jsonResponse(w, http.StatusOK, Response{true, "Logged out successfully."})
}

var upgrader = websocket.Upgrader{
	CheckOrigin: func(r *http.Request) bool {
		return true
	},
	Subprotocols: []string{"dev.spherics.pulsesms.login"},
}

// func (prov *ProvisioningAPI) Login(w http.ResponseWriter, r *http.Request) {
// 	userID := r.URL.Query().Get("user_id")
// 	user := prov.bridge.GetUserByMXID(id.UserID(userID))

// 	c, err := upgrader.Upgrade(w, r, nil)
// 	if err != nil {
// 		prov.log.Errorln("Failed to upgrade connection to websocket:", err)
// 		return
// 	}
// 	defer c.Close()

// 	if !user.Connect(true) {
// 		user.log.Debugln("Connect() returned false, assuming error was logged elsewhere and canceling login.")
// 		_ = c.WriteJSON(Error{
// 			Error:   "Failed to connect to WhatsApp",
// 			ErrCode: "connection error",
// 		})
// 		return
// 	}

// 	qrChan := make(chan string, 3)
// 	go func() {
// 		for code := range qrChan {
// 			if code == "stop" {
// 				return
// 			}
// 			_ = c.WriteJSON(map[string]interface{}{
// 				"code": code,
// 			})
// 		}
// 	}()

// 	go func() {
// 		// Read everything so SetCloseHandler() works
// 		for {
// 			_, _, err = c.ReadMessage()
// 			if err != nil {
// 				break
// 			}
// 		}
// 	}()
// 	ctx, cancel := context.WithCancel(context.Background())
// 	c.SetCloseHandler(func(code int, text string) error {
// 		user.log.Debugfln("Login websocket closed (%d), cancelling login", code)
// 		cancel()
// 		return nil
// 	})

// 	user.log.Debugln("Starting login via provisioning API")
// 	session, pid, err := user.Conn.Login(qrChan, ctx)
// 	qrChan <- "stop"
// 	if err != nil {
// 		var msg string
// 		if errors.Is(err, whatsapp.ErrAlreadyLoggedIn) {
// 			msg = "You're already logged in"
// 		} else if errors.Is(err, whatsapp.ErrLoginInProgress) {
// 			msg = "You have a login in progress already."
// 		} else if errors.Is(err, whatsapp.ErrLoginTimedOut) {
// 			msg = "QR code scan timed out. Please try again."
// 		} else if errors.Is(err, whatsapp.ErrInvalidWebsocket) {
// 			msg = "WhatsApp connection error. Please try again."
// 			// TODO might need to make sure it reconnects?
// 		} else {
// 			msg = fmt.Sprintf("Unknown error while logging in: %v", err)
// 		}
// 		user.log.Warnln("Failed to log in:", err)
// 		_ = c.WriteJSON(Error{
// 			Error:   msg,
// 			ErrCode: err.Error(),
// 		})
// 		return
// 	}
// 	user.log.Debugln("Successful login as", pid, "via provisioning API")
// 	user.ConnectionErrors = 0
// 	user.PID = strings.Replace(pid, whatsapp.OldUserSuffix, whatsapp.NewUserSuffix, 1)
// 	user.addToPIDMap()
// 	user.SetSession(&session)
// 	_ = c.WriteJSON(map[string]interface{}{
// 		"success": true,
// 		"pid":     user.PID,
// 	})
// 	user.PostLogin()
// }