rtl8720dn: add SetupAndConnectToAccessPoint()

Signed-off-by: deadprogram <ron@hybridgroup.com>

examples/rtl8720dn/tlsclient/main.go

@@ -6,9 +6,8 @@ import (
 	"strings"
 	"time"
 
-	"tinygo.org/x/drivers/net"
+	"tinygo.org/x/drivers/examples/rtl8720dn"
 	"tinygo.org/x/drivers/net/http"
-	"tinygo.org/x/drivers/rtl8720dn"
 )
 
 // You can override the setting with the init() in another source code.
@@ -53,12 +52,6 @@ CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4=
 -----END CERTIFICATE-----
 `
 
-var buf [0x1000]byte
-
-var lastRequestTime time.Time
-var conn net.Conn
-var adaptor *rtl8720dn.RTL8720DN
-
 func main() {
 	err := run()
 	for err != nil {
@@ -68,26 +61,12 @@ func main() {
 }
 
 func run() error {
-	rtl, err := setupRTL8720DN()
+	rtl8720dn.Debug(debug)
+	rtl, err := rtl8720dn.SetupAndConnectToAccessPoint(ssid, password, 10*time.Second)
 	if err != nil {
 		return err
 	}
 	rtl.SetRootCA(&test_root_ca)
-	net.UseDriver(rtl)
-	http.SetBuf(buf[:])
-
-	err = rtl.ConnectToAccessPoint(ssid, password, 10*time.Second)
-	if err != nil {
-		return err
-	}
-
-	ip, subnet, gateway, err := rtl.GetIP()
-	if err != nil {
-		return err
-	}
-	fmt.Printf("IP Address : %s\r\n", ip)
-	fmt.Printf("Mask       : %s\r\n", subnet)
-	fmt.Printf("Gateway    : %s\r\n", gateway)
 
 	// You can send and receive cookies in the following way
 	// 	import "tinygo.org/x/drivers/net/http/cookiejar"

examples/rtl8720dn/tlsclient/wioterminal.go

@@ -1,72 +0,0 @@
-//go:build wioterminal
-// +build wioterminal
-
-package main
-
-import (
-	"device/sam"
-	"machine"
-	"runtime/interrupt"
-	"time"
-
-	"tinygo.org/x/drivers/rtl8720dn"
-)
-
-var (
-	uart UARTx
-)
-
-func handleInterrupt(interrupt.Interrupt) {
-	// should reset IRQ
-	uart.Receive(byte((uart.Bus.DATA.Get() & 0xFF)))
-	uart.Bus.INTFLAG.SetBits(sam.SERCOM_USART_INT_INTFLAG_RXC)
-}
-
-func setupRTL8720DN() (*rtl8720dn.RTL8720DN, error) {
-	machine.RTL8720D_CHIP_PU.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	machine.RTL8720D_CHIP_PU.Low()
-	time.Sleep(100 * time.Millisecond)
-	machine.RTL8720D_CHIP_PU.High()
-	time.Sleep(1000 * time.Millisecond)
-	waitSerial()
-
-	uart = UARTx{
-		UART: &machine.UART{
-			Buffer: machine.NewRingBuffer(),
-			Bus:    sam.SERCOM0_USART_INT,
-			SERCOM: 0,
-		},
-	}
-
-	uart.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, handleInterrupt)
-	uart.Configure(machine.UARTConfig{TX: machine.PB24, RX: machine.PC24, BaudRate: 614400})
-
-	rtl := rtl8720dn.New(uart)
-	rtl.Debug(debug)
-
-	_, err := rtl.Rpc_tcpip_adapter_init()
-	if err != nil {
-		return nil, err
-	}
-
-	return rtl, nil
-}
-
-// Wait for user to open serial console
-func waitSerial() {
-	for !machine.Serial.DTR() {
-		time.Sleep(100 * time.Millisecond)
-	}
-}
-
-type UARTx struct {
-	*machine.UART
-}
-
-func (u UARTx) Read(p []byte) (n int, err error) {
-	if u.Buffered() == 0 {
-		time.Sleep(1 * time.Millisecond)
-		return 0, nil
-	}
-	return u.UART.Read(p)
-}

examples/rtl8720dn/webclient-tinyterm/main.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 	"time"
 
-	"tinygo.org/x/drivers/net"
+	"tinygo.org/x/drivers/examples/rtl8720dn"
 	"tinygo.org/x/drivers/net/http"
 	"tinygo.org/x/tinyfont/proggy"
 	"tinygo.org/x/tinyterm"
@@ -30,7 +30,7 @@ var (
 )
 
 var (
-	terminal = tinyterm.NewTerminal(display)
+	terminal *tinyterm.Terminal
 
 	black = color.RGBA{0, 0, 0, 255}
 	white = color.RGBA{255, 255, 255, 255}
@@ -41,12 +41,10 @@ var (
 	font = &proggy.TinySZ8pt7b
 )
 
-var buf [0x400]byte
-
 func main() {
 	display.FillScreen(black)
-	backlight.High()
 
+	terminal = tinyterm.NewTerminal(display)
 	terminal.Configure(&tinyterm.Config{
 		Font:       font,
 		FontHeight: 10,
@@ -65,29 +63,14 @@ func run() error {
 	if debug {
 		fmt.Fprintf(terminal, "Running in debug mode.\r\n")
 		fmt.Fprintf(terminal, "A serial connection is required to continue execution.\r\n")
+		rtl8720dn.Debug(true)
 	}
-	rtl, err := setupRTL8720DN()
-	if err != nil {
-		return err
-	}
-	net.UseDriver(rtl)
-	http.SetBuf(buf[:])
-
-	fmt.Fprintf(terminal, "ConnectToAP()\r\n")
-	err = rtl.ConnectToAccessPoint(ssid, password, 10*time.Second)
+	_, err := rtl8720dn.SetupAndConnectToAccessPoint(ssid, password, 10*time.Second)
 	if err != nil {
 		return err
 	}
 	fmt.Fprintf(terminal, "connected\r\n\r\n")
 
-	ip, subnet, gateway, err := rtl.GetIP()
-	if err != nil {
-		return err
-	}
-	fmt.Fprintf(terminal, "IP Address : %s\r\n", ip)
-	fmt.Fprintf(terminal, "Mask       : %s\r\n", subnet)
-	fmt.Fprintf(terminal, "Gateway    : %s\r\n", gateway)
-
 	// You can send and receive cookies in the following way
 	// 	import "tinygo.org/x/drivers/net/http/cookiejar"
 	// 	jar, err := cookiejar.New(nil)

examples/rtl8720dn/webclient-tinyterm/wioterminal.go

@@ -4,95 +4,15 @@
 package main
 
 import (
-	"device/sam"
-	"machine"
-	"runtime/interrupt"
-	"time"
-
+	"tinygo.org/x/drivers/examples/ili9341/initdisplay"
 	"tinygo.org/x/drivers/ili9341"
-	"tinygo.org/x/drivers/rtl8720dn"
 )
 
 var (
-	uart UARTx
-)
-
-var (
-	display = ili9341.NewSPI(
-		machine.SPI3,
-		machine.LCD_DC,
-		machine.LCD_SS_PIN,
-		machine.LCD_RESET,
-	)
-
-	backlight = machine.LCD_BACKLIGHT
+	display *ili9341.Device
 )
 
 func init() {
-	machine.SPI3.Configure(machine.SPIConfig{
-		SCK:       machine.LCD_SCK_PIN,
-		SDO:       machine.LCD_SDO_PIN,
-		SDI:       machine.LCD_SDI_PIN,
-		Frequency: 40000000,
-	})
-	display.Configure(ili9341.Config{})
-
-	backlight.Configure(machine.PinConfig{machine.PinOutput})
-}
-
-func handleInterrupt(interrupt.Interrupt) {
-	// should reset IRQ
-	uart.Receive(byte((uart.Bus.DATA.Get() & 0xFF)))
-	uart.Bus.INTFLAG.SetBits(sam.SERCOM_USART_INT_INTFLAG_RXC)
-}
-
-func setupRTL8720DN() (*rtl8720dn.RTL8720DN, error) {
-	machine.RTL8720D_CHIP_PU.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	machine.RTL8720D_CHIP_PU.Low()
-	time.Sleep(100 * time.Millisecond)
-	machine.RTL8720D_CHIP_PU.High()
-	time.Sleep(1000 * time.Millisecond)
-	if debug {
-		waitSerial()
-	}
-
-	uart = UARTx{
-		UART: &machine.UART{
-			Buffer: machine.NewRingBuffer(),
-			Bus:    sam.SERCOM0_USART_INT,
-			SERCOM: 0,
-		},
-	}
-
-	uart.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, handleInterrupt)
-	uart.Configure(machine.UARTConfig{TX: machine.PB24, RX: machine.PC24, BaudRate: 614400})
-
-	rtl := rtl8720dn.New(uart)
-	rtl.Debug(debug)
-
-	_, err := rtl.Rpc_tcpip_adapter_init()
-	if err != nil {
-		return nil, err
-	}
-
-	return rtl, nil
-}
-
-// Wait for user to open serial console
-func waitSerial() {
-	for !machine.Serial.DTR() {
-		time.Sleep(100 * time.Millisecond)
-	}
-}
-
-type UARTx struct {
-	*machine.UART
-}
-
-func (u UARTx) Read(p []byte) (n int, err error) {
-	if u.Buffered() == 0 {
-		time.Sleep(1 * time.Millisecond)
-		return 0, nil
-	}
-	return u.UART.Read(p)
+	display = initdisplay.InitDisplay()
+	display.SetRotation(ili9341.Rotation0)
 }

examples/rtl8720dn/webclient/main.go

@@ -6,7 +6,7 @@ import (
 	"strings"
 	"time"
 
-	"tinygo.org/x/drivers/net"
+	"tinygo.org/x/drivers/examples/rtl8720dn"
 	"tinygo.org/x/drivers/net/http"
 )
 
@@ -25,8 +25,6 @@ var (
 	debug    = false
 )
 
-var buf [0x400]byte
-
 func main() {
 	err := run()
 	for err != nil {
@@ -36,25 +34,10 @@ func main() {
 }
 
 func run() error {
-	rtl, err := setupRTL8720DN()
+	_, err := rtl8720dn.SetupAndConnectToAccessPoint(ssid, password, 10*time.Second)
 	if err != nil {
 		return err
 	}
-	net.UseDriver(rtl)
-	http.SetBuf(buf[:])
-
-	err = rtl.ConnectToAccessPoint(ssid, password, 10*time.Second)
-	if err != nil {
-		return err
-	}
-
-	ip, subnet, gateway, err := rtl.GetIP()
-	if err != nil {
-		return err
-	}
-	fmt.Printf("IP Address : %s\r\n", ip)
-	fmt.Printf("Mask       : %s\r\n", subnet)
-	fmt.Printf("Gateway    : %s\r\n", gateway)
 
 	// You can send and receive cookies in the following way
 	// 	import "tinygo.org/x/drivers/net/http/cookiejar"

examples/rtl8720dn/webclient/wioterminal.go

@@ -1,72 +0,0 @@
-//go:build wioterminal
-// +build wioterminal
-
-package main
-
-import (
-	"device/sam"
-	"machine"
-	"runtime/interrupt"
-	"time"
-
-	"tinygo.org/x/drivers/rtl8720dn"
-)
-
-var (
-	uart UARTx
-)
-
-func handleInterrupt(interrupt.Interrupt) {
-	// should reset IRQ
-	uart.Receive(byte((uart.Bus.DATA.Get() & 0xFF)))
-	uart.Bus.INTFLAG.SetBits(sam.SERCOM_USART_INT_INTFLAG_RXC)
-}
-
-func setupRTL8720DN() (*rtl8720dn.RTL8720DN, error) {
-	machine.RTL8720D_CHIP_PU.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	machine.RTL8720D_CHIP_PU.Low()
-	time.Sleep(100 * time.Millisecond)
-	machine.RTL8720D_CHIP_PU.High()
-	time.Sleep(1000 * time.Millisecond)
-	waitSerial()
-
-	uart = UARTx{
-		UART: &machine.UART{
-			Buffer: machine.NewRingBuffer(),
-			Bus:    sam.SERCOM0_USART_INT,
-			SERCOM: 0,
-		},
-	}
-
-	uart.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, handleInterrupt)
-	uart.Configure(machine.UARTConfig{TX: machine.PB24, RX: machine.PC24, BaudRate: 614400})
-
-	rtl := rtl8720dn.New(uart)
-	rtl.Debug(debug)
-
-	_, err := rtl.Rpc_tcpip_adapter_init()
-	if err != nil {
-		return nil, err
-	}
-
-	return rtl, nil
-}
-
-// Wait for user to open serial console
-func waitSerial() {
-	for !machine.Serial.DTR() {
-		time.Sleep(100 * time.Millisecond)
-	}
-}
-
-type UARTx struct {
-	*machine.UART
-}
-
-func (u UARTx) Read(p []byte) (n int, err error) {
-	if u.Buffered() == 0 {
-		time.Sleep(1 * time.Millisecond)
-		return 0, nil
-	}
-	return u.UART.Read(p)
-}

examples/rtl8720dn/webserver/main.go

@@ -2,11 +2,15 @@ package main
 
 import (
 	"fmt"
+	"image/color"
 	"machine"
 	"strconv"
 	"time"
 
+	"tinygo.org/x/drivers/examples/rtl8720dn"
 	"tinygo.org/x/drivers/net/http"
+	"tinygo.org/x/tinyfont"
+	"tinygo.org/x/tinyfont/freemono"
 )
 
 // You can override the setting with the init() in another source code.
@@ -23,11 +27,9 @@ var (
 )
 
 var led = machine.LED
-var backlight = machine.LCD_BACKLIGHT
 
 func main() {
 	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	backlight.Configure(machine.PinConfig{Mode: machine.PinOutput})
 
 	err := run()
 	for err != nil {
@@ -37,13 +39,9 @@ func main() {
 }
 
 func run() error {
-	rtl, err := setupRTL8720DN()
-	if err != nil {
-		return err
-	}
-	http.UseDriver(rtl)
+	tinyfont.WriteLine(display, &freemono.Regular9pt7b, 5, 15, "setup...", color.RGBA{0x00, 0x00, 0x00, 0xFF})
 
-	err = rtl.ConnectToAccessPoint(ssid, password, 10*time.Second)
+	rtl, err := rtl8720dn.SetupAndConnectToAccessPoint(ssid, password, 10*time.Second)
 	if err != nil {
 		return err
 	}
@@ -55,6 +53,8 @@ func run() error {
 	fmt.Printf("IP Address : %s\r\n", ip)
 	fmt.Printf("Mask       : %s\r\n", subnet)
 	fmt.Printf("Gateway    : %s\r\n", gateway)
+	tinyfont.WriteLine(display, &freemono.Regular9pt7b, 5, 15, "setup...done", color.RGBA{0x00, 0x00, 0x00, 0xFF})
+	tinyfont.WriteLine(display, &freemono.Regular9pt7b, 5, 30, fmt.Sprintf("listen:\nhttp://%s/", ip), color.RGBA{0x00, 0x00, 0x00, 0xFF})
 
 	http.HandleFunc("/", root)
 	http.HandleFunc("/hello", hello)
@@ -154,14 +154,12 @@ func sixlines(w http.ResponseWriter, r *http.Request) {
 
 func LED_ON(w http.ResponseWriter, r *http.Request) {
 	led.High()
-	backlight.High()
 	w.Header().Set(`Content-Type`, `text/plain; charset=UTF-8`)
 	fmt.Fprintf(w, "led.High()")
 }
 
 func LED_OFF(w http.ResponseWriter, r *http.Request) {
 	led.Low()
-	backlight.Low()
 	w.Header().Set(`Content-Type`, `text/plain; charset=UTF-8`)
 	fmt.Fprintf(w, "led.Low()")
 }

examples/rtl8720dn/webserver/wioterminal.go

@@ -4,71 +4,20 @@
 package main
 
 import (
-	"device/sam"
 	"machine"
-	"runtime/interrupt"
-	"time"
 
-	"tinygo.org/x/drivers/rtl8720dn"
+	"tinygo.org/x/drivers/examples/ili9341/initdisplay"
+	"tinygo.org/x/drivers/ili9341"
 )
 
 var (
-	uart UARTx
+	display *ili9341.Device
 )
 
-func handleInterrupt(interrupt.Interrupt) {
-	// should reset IRQ
-	uart.Receive(byte((uart.Bus.DATA.Get() & 0xFF)))
-	uart.Bus.INTFLAG.SetBits(sam.SERCOM_USART_INT_INTFLAG_RXC)
-}
-
-func setupRTL8720DN() (*rtl8720dn.RTL8720DN, error) {
-	machine.RTL8720D_CHIP_PU.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	machine.RTL8720D_CHIP_PU.Low()
-	time.Sleep(100 * time.Millisecond)
-	machine.RTL8720D_CHIP_PU.High()
-	time.Sleep(1000 * time.Millisecond)
-	if debug {
-		waitSerial()
-	}
-
-	uart = UARTx{
-		UART: &machine.UART{
-			Buffer: machine.NewRingBuffer(),
-			Bus:    sam.SERCOM0_USART_INT,
-			SERCOM: 0,
-		},
-	}
-
-	uart.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, handleInterrupt)
-	uart.Configure(machine.UARTConfig{TX: machine.PB24, RX: machine.PC24, BaudRate: 614400})
-
-	rtl := rtl8720dn.New(uart)
-	rtl.Debug(debug)
-
-	_, err := rtl.Rpc_tcpip_adapter_init()
-	if err != nil {
-		return nil, err
-	}
-
-	return rtl, nil
-}
-
-// Wait for user to open serial console
-func waitSerial() {
-	for !machine.Serial.DTR() {
-		time.Sleep(100 * time.Millisecond)
-	}
-}
-
-type UARTx struct {
-	*machine.UART
-}
-
-func (u UARTx) Read(p []byte) (n int, err error) {
-	if u.Buffered() == 0 {
-		time.Sleep(1 * time.Millisecond)
-		return 0, nil
-	}
-	return u.UART.Read(p)
+func init() {
+	display = initdisplay.InitDisplay()
+	display.SetRotation(ili9341.Rotation270)
+
+	// override
+	led = machine.LCD_BACKLIGHT
 }

examples/rtl8720dn/wioterminal.go

@@ -9,12 +9,15 @@ import (
 	"runtime/interrupt"
 	"time"
 
+	"tinygo.org/x/drivers/net"
+	"tinygo.org/x/drivers/net/http"
 	"tinygo.org/x/drivers/rtl8720dn"
 )
 
 var (
 	uart  UARTx
 	debug bool
+	buf   [0x1000]byte
 )
 
 func handleInterrupt(interrupt.Interrupt) {
@@ -55,6 +58,24 @@ func Setup() (*rtl8720dn.RTL8720DN, error) {
 	return rtl, nil
 }
 
+func SetupAndConnectToAccessPoint(ssid, pass string, timeout time.Duration) (*rtl8720dn.RTL8720DN, error) {
+	rtl, err := Setup()
+	if err != nil {
+		return nil, err
+	}
+
+	err = rtl.ConnectToAccessPoint(ssid, pass, 10*time.Second)
+	if err != nil {
+		return rtl, err
+	}
+
+	net.UseDriver(rtl)
+	http.UseDriver(rtl)
+	http.SetBuf(buf[:])
+
+	return rtl, nil
+}
+
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {

go.mod

@@ -5,8 +5,8 @@ go 1.15
 require (
 	github.com/eclipse/paho.mqtt.golang v1.2.0
 	github.com/frankban/quicktest v1.10.2
-	golang.org/x/net v0.0.0-20210614182718-04defd469f4e // indirect
+	golang.org/x/net v0.0.0-20210614182718-04defd469f4e
 	tinygo.org/x/tinyfont v0.2.1
-	tinygo.org/x/tinyfs v0.1.0
+	tinygo.org/x/tinyfs v0.2.0
 	tinygo.org/x/tinyterm v0.1.0
 )

go.sum

@@ -24,9 +24,11 @@ golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8T
 tinygo.org/x/drivers v0.14.0/go.mod h1:uT2svMq3EpBZpKkGO+NQHjxjGf1f42ra4OnMMwQL2aI=
 tinygo.org/x/drivers v0.15.1/go.mod h1:uT2svMq3EpBZpKkGO+NQHjxjGf1f42ra4OnMMwQL2aI=
 tinygo.org/x/drivers v0.16.0/go.mod h1:uT2svMq3EpBZpKkGO+NQHjxjGf1f42ra4OnMMwQL2aI=
+tinygo.org/x/drivers v0.19.0/go.mod h1:uJD/l1qWzxzLx+vcxaW0eY464N5RAgFi1zTVzASFdqI=
 tinygo.org/x/tinyfont v0.2.1 h1:FAaemBzw8wsfhAtG6fWW+QjyWw/K8YqEeiWo4N1pv4o=
 tinygo.org/x/tinyfont v0.2.1/go.mod h1:eLqnYSrFRjt5STxWaMeOWJTzrKhXqpWw7nU3bPfKOAM=
-tinygo.org/x/tinyfs v0.1.0 h1:yx1Tq9L60rpCm6HURo45x+Tnag+O9RGSbQfgeCb6XYU=
 tinygo.org/x/tinyfs v0.1.0/go.mod h1:ysc8Y92iHfhTXeyEM9+c7zviUQ4fN9UCFgSOFfMWv20=
+tinygo.org/x/tinyfs v0.2.0 h1:M0lwZC/dEGFt16XYN5GTQsif/qCkAN2qUVNxELVD1xg=
+tinygo.org/x/tinyfs v0.2.0/go.mod h1:6ZHYdvB3sFYeMB3ypmXZCNEnFwceKc61ADYTYHpep1E=
 tinygo.org/x/tinyterm v0.1.0 h1:80i+j+KWoxCFa/Xfp6pWbh79x+8zUdMXC1vaKj2QhkY=
 tinygo.org/x/tinyterm v0.1.0/go.mod h1:/DDhNnGwNF2/tNgHywvyZuCGnbH3ov49Z/6e8LPLRR4=

net/http/tinygo.go

@@ -20,6 +20,11 @@ func SetBuf(b []byte) {
 }
 
 func (c *Client) Do(req *Request) (*Response, error) {
+	if c.Jar != nil {
+		for _, cookie := range c.Jar.Cookies(req.URL) {
+			req.AddCookie(cookie)
+		}
+	}
 	switch req.URL.Scheme {
 	case "http":
 		return c.doHTTP(req)
@@ -31,15 +36,17 @@ func (c *Client) Do(req *Request) (*Response, error) {
 }
 
 func (c *Client) doHTTP(req *Request) (*Response, error) {
-	if c.Jar != nil {
-		for _, cookie := range c.Jar.Cookies(req.URL) {
-			req.AddCookie(cookie)
-		}
-	}
-
 	// make TCP connection
-	ip := net.ParseIP(req.URL.Host)
-	raddr := &net.TCPAddr{IP: ip, Port: 80}
+	ip := net.ParseIP(req.URL.Hostname())
+	port := 80
+	if req.URL.Port() != "" {
+		p, err := strconv.ParseUint(req.URL.Port(), 0, 64)
+		if err != nil {
+			return nil, err
+		}
+		port = int(p)
+	}
+	raddr := &net.TCPAddr{IP: ip, Port: port}
 	laddr := &net.TCPAddr{Port: 8080}
 
 	conn, err := net.DialTCP("tcp", laddr, raddr)
@@ -178,12 +185,17 @@ func (c *Client) doResp(conn net.Conn, req *Request) (*Response, error) {
 			if err != nil {
 				println("Read error: " + err.Error())
 			} else {
-				idx := bytes.Index(buf[ofs:ofs+n], []byte("\r\n\r\n"))
+				// Take care of the case where "\r\n\r\n" is on the boundary of a buffer
+				start := ofs
+				if start > 3 {
+					start -= 3
+				}
+				idx := bytes.Index(buf[start:ofs+n], []byte("\r\n\r\n"))
 				if idx == -1 {
 					ofs += n
 					continue
 				}
-				idx += ofs + 4
+				idx += start + 4
 
 				scanner = bufio.NewScanner(bytes.NewReader(buf[0 : ofs+n]))
 				if resp.Status == "" && scanner.Scan() {
@@ -261,6 +273,9 @@ func (c *Client) doResp(conn net.Conn, req *Request) (*Response, error) {
 				return nil, fmt.Errorf("slice out of range : use http.SetBuf() to change the allocation to %d bytes or more", end)
 			}
 			n, err := conn.Read(buf[ofs : ofs+0x400])
+			if err != nil {
+				return nil, err
+			}
 			if n == 0 {
 				continue
 			}

rtl8720dn/netdriver.go

@@ -118,6 +118,9 @@ func (r *RTL8720DN) ConnectSSLSocket(addr, port string) error {
 	if r.debug {
 		fmt.Printf("ConnectSSLSocket(%q, %q)\r\n", addr, port)
 	}
+	if r.root_ca == nil {
+		return fmt.Errorf("root_ca is not set")
+	}
 
 	client, err := r.Rpc_wifi_ssl_client_create()
 	if err != nil {