Untested basic driver for 8810ft completed

Author: brokenCursor

drivers/8810ft.go

@@ -1,31 +1,64 @@
 package drivers
 
-
 import (
+	"encoding/json"
+	"fmt"
+	"io"
 	"net/http"
+	"net/url"
+	"strconv"
+	"time"
 )
 
 // DO NOT USE DIRECTLY
-type zte8810ft struct {
-	TargetIP string
-	basePath string
-}
+type (
+	zte8810ft struct {
+		ip       string
+		basePath string
+	}
+
+	result struct {
+		Result string `json:"result"`
+	}
+
+	pppConnected struct {
+		Connected string `json:"ppp_connected"`
+	}
+)
+
+var httpClient *http.Client
 
 func init() {
-	registerModel("8810FT", newZTE8810FT)
+	httpClient = &http.Client{Timeout: time.Second * 10}
+	registerDriver("ZTE 8810FT", newZTE8810FT)
 }
 
 func newZTE8810FT(ip string) BaseModem {
-	return &zte8810ft{TargetIP: ip, basePath: "/goform/goform_set_cmd_process"}
+	return &zte8810ft{ip: ip, basePath: "/goform/goform_set_cmd_process"}
+}
+
+func (m *zte8810ft) getBaseURL(path string) *url.URL {
+	return &url.URL{Scheme: "https", Host: m.ip, Path: path}
+}
+
+func (m *zte8810ft) getNewRequest(method string, url *url.URL) *http.Request {
+	return &http.Request{
+		Proto:  "HTTP/1.1",
+		Method: method,
+		URL:    url,
+		Header: http.Header{
+			"Referer": {fmt.Sprintf("http://%s/index.html", m.ip)},
+		},
+	}
 }
 
 func (m *zte8810ft) SetTargetIP(ip string) error {
-	m.TargetIP = ip
+	m.ip = ip
 	return nil
 }
 
 func (m *zte8810ft) GetTargetIP() string {
-	return m.TargetIP
+	return m.ip
 }
 
 func (m *zte8810ft) GetModel() string {
@@ -34,17 +67,123 @@ func (m *zte8810ft) GetModel() string {
 
 func (m *zte8810ft) ConnectCell() error {
 	// 	GET /goform/goform_set_cmd_process?goformId=CONNECT_NETWORK
+	// Prepare everything to make a request
+	u := m.getBaseURL("/goform/goform_set_cmd_process")
+	query := u.Query()
+	query.Add("goformId", "CONNECT_NETWORK")
+	u.RawQuery = query.Encode()
+	request := m.getNewRequest("GET", u)
+
+	resp, err := httpClient.Do(request)
+
+	// Process errors
+	switch {
+	case err != nil:
+		return ActionError{Action: "connect", Err: err}
+	case resp.StatusCode != 200:
+		return ActionError{Action: "connect", Err: fmt.Errorf("response status %d", resp.StatusCode)}
+	}
+
+	// Read the response
+	defer resp.Body.Close()
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return ErrUnknown
+	}
+
+	result := new(result)
+	if err := json.Unmarshal(body, result); err != nil {
+		return ActionError{Action: "connect", Err: UnmarshalError{RawData: &body, Err: err}}
+	}
+
+	if result.Result != "success" {
+		return ActionError{Action: "connect", Err: fmt.Errorf("result: %s", result.Result)}
+	}
+
 	return nil
 }
 
 func (m *zte8810ft) DisconnectCell() error {
 	// 	GET /goform/goform_set_cmd_process?goformId=DISCONNECT_NETWORK
+	// Prepare everything to make a request
+	u := m.getBaseURL("/goform/goform_set_cmd_process")
+	query := u.Query()
+	query.Add("goformId", "DISCONNECT_NETWORK")
+	u.RawQuery = query.Encode()
+	request := m.getNewRequest("GET", u)
+
+	resp, err := httpClient.Do(request)
+
+	// Process errors
+	switch {
+	case err != nil:
+		return ActionError{Action: "disconnect", Err: err}
+	case resp.StatusCode != 200:
+		return ActionError{Action: "disconnect", Err: fmt.Errorf("response status %d", resp.StatusCode)}
+	}
+
+	// Read the response
+	defer resp.Body.Close()
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return ErrUnknown
+	}
+
+	result := new(result)
+	if err := json.Unmarshal(body, result); err != nil {
+		return ActionError{Action: "disconnect", Err: UnmarshalError{RawData: &body, Err: err}}
+	}
+
+	if result.Result != "success" {
+		return ActionError{Action: "disconnect", Err: fmt.Errorf("result: %s", result.Result)}
+	}
+
 	return nil
 }
 
 func (m *zte8810ft) GetCellConnStatus() (bool, error) {
 	// Lines 251-258
-	resp, err := http.Get()
 	// /goform/goform_get_cmd_process?isTest=False&cmd=ppp_connected,multi_data=1&sms_received_flag_flag=0&sts_received_flag_flag=0&_=<curr_time>
-	return false, nil
+
+	// Build URL
+	u := m.getBaseURL("/goform/goform_get_cmd_process")
+	query := u.Query()
+	query.Add("isTest", "False")
+	query.Add("cmd", "ppp_connected")
+	query.Add("multi_data", "1")
+	query.Add("sms_received_flag_flag", "0")
+	query.Add("sts_received_flag_flag", "0")
+	query.Add("_", strconv.FormatInt((time.Now().UnixMilli)(), 10))
+	u.RawQuery = query.Encode()
+
+	request := m.getNewRequest("POST", u)
+
+	resp, err := httpClient.Do(request)
+
+	// Process errors
+	switch {
+	case err != nil:
+		return false, ActionError{Action: "status", Err: err}
+	case resp.StatusCode != 200:
+		return false, ActionError{Action: "status", Err: fmt.Errorf("response status %d", resp.StatusCode)}
+	}
+
+	// Read the response
+	defer resp.Body.Close()
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return false, ErrUnknown
+	}
+
+	result := new(pppConnected)
+	if err := json.Unmarshal(body, result); err != nil {
+		return false, ActionError{Action: "status", Err: UnmarshalError{RawData: &body, Err: err}}
+	}
+
+	// Process the result
+	if result.Connected != "ppp_connected" {
+		return false, nil
+	}
+
+	return true, nil
 }

drivers/common.go

@@ -28,32 +28,40 @@ type ModemSMS interface {
 	GetAllSMS() ([]SMS, error)
 }
 
-var models map[string]func(ip string) BaseModem = map[string]func(ip string) BaseModem{}
+var drivers map[string]func(ip string) BaseModem = map[string]func(ip string) BaseModem{}
 
 func isRegistered(name string) bool {
-	// Check if model has already been registered
-	_, ok := models[name]
+	// Check if driver has already been registered
+	_, ok := drivers[name]
 	return ok
 }
 
-func registerModel(name string, generator func(ip string) BaseModem) {
-	// Check if model has already been registered
+func registerDriver(name string, generator func(ip string) BaseModem) {
+	// Check if driver has already been registered
 	if isRegistered(name) {
 		panic(fmt.Sprintf("attempted to register %s twice", name))
 	}
 
-	// Register the model
-	models[name] = generator
+	// Register the driver
+	drivers[name] = generator
 }
 
 func GetModemDriver(model string, ip string) (BaseModem, error) {
 	if !isRegistered(model) {
 		return nil, ErrUnknownModel
 	}
 
-	return models[model](ip), nil
+	return drivers[model](ip), nil
 }
 
 func GetAvailableDrivers() *[]string {
-	return nil
+	keys := make([]string, len(drivers))
+
+	i := 0
+	for k := range drivers {
+		keys[i] = k
+		i++
+	}
+
+	return &keys
 }

drivers/errors.go

@@ -2,7 +2,36 @@ package drivers
 
 import (
 	"errors"
+	"fmt"
 )
 
 // Basic Errors
 var ErrUnknownModel = errors.New("attempting to get unknown model")
+var ErrUnknown = errors.New("unknown error")
+
+// Complex Errors
+type ActionError struct {
+	Action string
+	Err    error
+}
+
+func (e ActionError) Unwrap() error {
+	return e.Err
+}
+
+func (e ActionError) Error() string {
+	return fmt.Sprintf("action error: %s failed with %e", e.Action, e.Err)
+}
+
+type UnmarshalError struct {
+	RawData *[]byte
+	Err     error
+}
+
+func (e UnmarshalError) Unwrap() error {
+	return e.Err
+}
+
+func (e UnmarshalError) Error() string {
+	return "failed to unmarshal response"
+}

main.go

@@ -14,7 +14,7 @@ import (
 
 type SMSArgs struct {
 	Action      string `arg:""`
-	PhoneNumber string `arg:"-n" help:"Recievers"`
+	PhoneNumber string `arg:"-n" help:"Receiver's phone number"`
 	Message     string `arg:"-m"`
 }
 
@@ -66,7 +66,7 @@ func run() error {
 
 			if err != nil {
 				fmt.Println("Failed to get connection status")
-				return 
+				return
 			}
 			if isConnected {
 				fmt.Println("Status: up")