Golang client server login

client/login.go

package main

import (
	"encoding/binary"
	"encoding/json"
	"fmt"
	"net"
	"testgo/chatrroom/common/message"
)

func login(userId int, userPwd string) (err error) {
	// Start making agreement 

	//fmt.Println("userId = %d,userPwd = %d", userId, userPwd)
	//return nil

	//1. Connect to server 
	conn, err := net.Dial("tcp", "localhost:8889")
	if err != nil {
		fmt.Println("net.Dial err", err)
		return
	}
	// Delay off 
	defer conn.Close()
	//2. Prepared by coon Send a message to the service 
	var mes message.Message
	mes.Type = message.LoginMesType
	// Create a LoginMes Structure 
	var loginMes message.LoginMes
	loginMes.UserId = userId
	loginMes.UserPwd = userPwd
	//4. take loginMes serialize 
	data, err := json.Marshal(loginMes)
	if err != nil {
		fmt.Println("json.Marshal err", err)
		return
	}
	//5. hold data to mes.Data Field 
	mes.Data = string(data)
	//6. take mes serialize 
	data, err = json.Marshal(mes)
	if err != nil {
		fmt.Println("json.Marshal err", err)
		return
	}
	//7. data Is what we want to send 
	//7.1  The first data The length is sent to the server 
	// First get data The length of , conversion byte section 
	var pkgLen uint32
	pkgLen = uint32(len(data))
	var buf [4]byte
	binary.BigEndian.PutUint32(buf[0:4], pkgLen)
	// Sending length 
	n, err := conn.Write(buf[:4])
	if n != 4 || err != nil {
		fmt.Println("coon.Write", err)
		return
	}
	//fmt.Println(" client , The length of the message sent was successful   Content =%s", len(data), string(data))
	// Send the message itself 
	_, err = conn.Write(data)
	if err != nil {
		fmt.Println("coon.Write（data）", err)
		return
	}
	//time.Sleep(2 * time.Second)
	//fmt.Println(" Dormant 2...")
	// You also need to deal with the server 
	mes, err = readPkg(conn)
	// take mes Of data Partial anti serialization  LoginResMes
	if err != nil {
		fmt.Println("readPkg(conn) err=", err)
		return
	}
	// take mes Of data Partial anti serialization LoginresMes
	var loginResMes message.LoginResMes
	err = json.Unmarshal([]byte(mes.Data), &loginResMes)
	if loginResMes.Code == 200 {
		fmt.Println(" Login successful ")
	} else if loginResMes.Code == 500 {
		fmt.Println(loginResMes.Error)
	}
	return
}

client/main.go

package main

import (
	"fmt"
	"os"
)

// Define two variables   user id  User password 

var userId int
var userPwd string

func main() {
	// Accept user name 
	var key int
	var loop = true

	for loop {
		fmt.Println("---- Welcome to chat room ----")
		fmt.Println("\t\t\t----1. Log in to chat room ----")
		fmt.Println("\t\t\t----2. Registered users ----")
		fmt.Println("\t\t\t----3. Exit the system ----")
		fmt.Println("\t\t\t---- Please select （1-3）----")
		fmt.Scanf("%d\n", &key)
		switch key {
		case 1:
			fmt.Println(" Log in to chat room ")
			loop = false
		case 2:
			fmt.Println(" Registered users ")
			loop = false
		case 3:
			fmt.Println(" Exit the system ")
			os.Exit(0)
		default:
			fmt.Println(" Incorrect input , Please try again ")
		}
	}
	// According to the user's input , Display a new prompt 
	if key == 1 {
		// The user wants to log in 
		fmt.Println(" Please enter the user id")
		fmt.Scanln(&userId)
		fmt.Println(" Please enter the user password ")
		fmt.Scanln(&userPwd)
		// First put the login function , Write to another file 
		login(userId, userPwd)
		//if err != nil {
		//	fmt.Println(" Login failed ")
		//} else {
		//	fmt.Println(" Login successful ")
		//}
	} else if key == 2 {
		fmt.Println(" Register users ")
	}
}

cilent/utils.go

package main

import (
	"encoding/binary"
	"encoding/json"
	"fmt"
	"net"
	"testgo/chatrroom/common/message"
)

func readPkg(conn net.Conn) (mes message.Message, err error) {
	buf := make([]byte, 8096)
	fmt.Println(" Read the information sent by the client ...")
	// stay conn Without being shut down , Will block 
	_, err = conn.Read(buf[:4])
	if err != nil {
		//	err = errors.New("read pkg header error")
		return
	}
	//fmt.Println(" Read about buf=", buf[:4])
	var pkgLen uint32
	pkgLen = binary.BigEndian.Uint32(buf[0:4])

	// according to pkgLen Read message content 
	n, err := conn.Read(buf[:pkgLen])
	if n != int(pkgLen) || err != nil {
		//err = errors.New(" conn.Read error")
		return
	}
	//  hold pkgLen  Deserialization  ->message.Message
	err = json.Unmarshal(buf[:pkgLen], &mes)
	if err != nil {
		fmt.Println("json.Unmarshal err=", err)
		return
	}
	return
}
func writePkg(conn net.Conn, data []byte) (err error) {
	// Send a length to the other party first 
	var pkgLen uint32
	pkgLen = uint32(len(data))
	var buf [4]byte
	binary.BigEndian.PutUint32(buf[0:4], pkgLen)
	// Sending length 
	n, err := conn.Write(buf[:4])
	if n != 4 || err != nil {
		fmt.Println("conn.Write err=", err)
		return
	}
	// serialize 
	n, err = conn.Write(data)
	if n != int(pkgLen) || err != nil {
		fmt.Println("conn.Write(bytes) fail", err)
		return
	}
	// Send the message itself 
	err = writePkg(conn, data)
	return err
}

common/message/message.go

package message

const (
	LoginMesType    = "LoginMes"
	LoginResMesType = "LoginResMes"
	RegisterMesType = "RegisterMes"
)

type Message struct {
	Type string `json:"type"` // Message type 
	Data string `json:"data"` // The type of message 
}

// LoginMes  Define two messages 
type LoginMes struct {
	UserId   int    `json:"userId"`   // user id
	UserPwd  string `json:"userPwd"`  // User password 
	UserName string `json:"userName"` // user name 
}

type LoginResMes struct {
	Code  int    `json:"code"`  // Status code 
	Error string `json:"error"` // Return error message 
}

type RegisterMes struct {
	//...
}

server/main.go

package main

import (
	"encoding/binary"
	"encoding/json"
	"fmt"
	"io"
	"net"
	"testgo/chatrroom/common/message"
)

func readPkg(conn net.Conn) (mes message.Message, err error) {
	buf := make([]byte, 8096)
	fmt.Println(" Read the information sent by the client ...")
	// stay conn Without being shut down , Will block 
	_, err = conn.Read(buf[:4])
	if err != nil {
		//	err = errors.New("read pkg header error")
		return
	}
	//fmt.Println(" Read about buf=", buf[:4])
	var pkgLen uint32
	pkgLen = binary.BigEndian.Uint32(buf[0:4])

	// according to pkgLen Read message content 
	n, err := conn.Read(buf[:pkgLen])
	if n != int(pkgLen) || err != nil {
		//err = errors.New(" conn.Read error")
		return
	}
	//  hold pkgLen  Deserialization  ->message.Message
	err = json.Unmarshal(buf[:pkgLen], &mes)
	if err != nil {
		fmt.Println("json.Unmarshal err=", err)
		return
	}
	return
}
func writePkg(conn net.Conn, data []byte) (err error) {
	// Send a length to the other party first 
	var pkgLen uint32
	pkgLen = uint32(len(data))
	var buf [4]byte
	binary.BigEndian.PutUint32(buf[0:4], pkgLen)
	// Sending length 
	n, err := conn.Write(buf[:4])
	if n != 4 || err != nil {
		fmt.Println("conn.Write err=", err)
		return
	}
	// send out data In itself 
	n, err = conn.Write(data)
	if n != int(pkgLen) || err != nil {
		fmt.Println("conn.Write(bytes) fail", err)
		return
	}
	return
}

// Write a serverProcessLogin function   Processing login requests 
func serverProcessLogin(conn net.Conn, mes *message.Message) (err error) {
	// Core code 
	//1. from mes  Remove from mes.data  Deserialize to loginMes
	var loginMes message.LoginMes
	err = json.Unmarshal([]byte(mes.Data), &loginMes)
	if err != nil {
		fmt.Println("json.Unmarshal fail err=", err)
		return
	}
	// Make a statement resMes
	var resMes message.Message
	resMes.Type = message.LoginResMesType
	// Statement  LoginResMes
	var loginResMes message.LoginResMes
	if loginMes.UserId == 100 && loginMes.UserPwd == "123456" {
		loginResMes.Code = 200
	} else {
		loginResMes.Code = 500
		loginResMes.Error = " The user doesn't exist , Please re register "
	}
	//3. take loginResMes serialize 
	data, err := json.Marshal(loginResMes)
	if err != nil {
		fmt.Println("json.marshal err=", err)
		return
	}
	//4. take data Assign a value to resMes
	resMes.Data = string(data)
	//5. Yes resMes serialize 
	data, err = json.Marshal(resMes)
	if err != nil {
		fmt.Println("json.marshal err=", err)
		return
	}
	//3. send out data
	err = writePkg(conn, data)
	return err
}

// Write a serverProcessMes function 
// According to the type of information sent by the client , Decide to call that function to handle 
func serverProcessMes(conn net.Conn, mes *message.Message) (err error) {
	switch mes.Type {
	case message.LoginMesType:
		// Process login 
		err = serverProcessLogin(conn, mes)
	case message.RegisterMesType:
	// Deal with registration 
	default:
		fmt.Println(" Message type does not exist , Unable to deal with ")
	}
	return
}
func process(conn net.Conn) {
	// Read the information sent by the client 
	defer conn.Close()
	// Cyclic reading 
	for {
		// Read packets , Directly encapsulated into a function readPKG(), return ,Message,err
		mes, err := readPkg(conn)
		if err != nil {
			if err == io.EOF {
				fmt.Println(" Client exit , The server also exits ")
				return
			} else {
				fmt.Println("readPkg(conn) err=", err)
				return
			}
		}
		//fmt.Println("message=", mes)
		err = serverProcessMes(conn, &mes)
		if err != nil {
			return
		}
	}
}
func main() {
	// Prompt information 
	fmt.Println(" The server 8889 monitor ")
	listen, err := net.Listen("tcp", "0.0.0.0:8889")
	defer listen.Close()
	if err != nil {
		fmt.Println("net.Listen err=", err)
		return
	}
	// Monitor successful , Wait for the client to connect to the server 
	for {
		fmt.Println(" Wait for the client to connect ...")
		conn, err := listen.Accept()
		if err != nil {
			fmt.Println("listen err=", err)
		}

		// Once the connection is successful , Then start a process to maintain communication with the client ..
		go process(conn)
	}
}