wefree/tcpserver-client
1
0 Fork 0
mirror of https://gitee.com/willfree/tcpserver-client.git synced 2026-10-04 19:52:23 +08:00
Code Issues Projects Releases Wiki Activity

update code

Browse Source
This commit is contained in:
free will committed 2021-05-04 20:31:47 +08:00
1 parent 89af0d2725
commit 49aaa82414
8 files changed
+193 -190
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

AddrServer/AddrServer.go
+114
View File
@@ -0,0 +1,114 @@
package main
// 提供可用服务器地址的服务器
import (
"TCPServerClient/utils"
"fmt"
"net"
"strconv"
"strings"
)
const (
DefaultServerIP = "localhost" // 本机服务器IP
DefaultServerPort = 50000 // 本机服务器端口号
DefaultRequestInfo = "Request Addr" // 请求可用服务器IP的命令字段
DefaultSyncInfo = "Sync Addr" // 同步IP地址的命令字段
DefaultPassword = "12345678" // 消息加解密密码。必须是八位
)
type AddrServer struct {
serverIP string // 本机服务器IP
serverPort int // 本机服务器端口号
requestInfo string
syncInfo string
password string
addr CanBeUsedAddr // 可用服务器的地址
}
// 开启server，并建立监听
func (s *AddrServer) start() {
fmt.Println("Starting the addr server ...")
// 初始化
s.serverIP= DefaultServerIP
s.serverPort= DefaultServerPort
s.requestInfo=DefaultRequestInfo
s.password=DefaultPassword
s.syncInfo=DefaultSyncInfo
// 创建 listener
listener, err := net.Listen("tcp", s.serverIP+":"+strconv.Itoa(s.serverPort))
if err != nil {
fmt.Println("Error listening", err.Error())
return
}
// 监听并接受来自客户端或服务器的连接，并进行处理
for {
conn, err := listener.Accept()
if err != nil {
fmt.Println("Error accepting", err.Error())
return
}else{
fmt.Println("Main AddrServer Accept conn form "+conn.RemoteAddr().String())
}
// 处理请求
go s.doMainServerStuff(conn)
}
}
/**
处理TCP请求
*/
func (s *AddrServer) doMainServerStuff(conn net.Conn) {
for {
// 读取原始数据
buf := make([]byte, 512)
len, err := conn.Read(buf)
if err != nil {
fmt.Println("Error reading", err.Error())
return
}
msg:=string(buf[:len])
fmt.Println("Received raw data: %v", msg)
// 解密数据为可读格式
msg=utils.DecryptMsgByDES(msg, s.password)
fmt.Println("Received decrypt data: %v", msg)
// 判断是否是请求子网IP。是，则返回一个可用IP（）
if(msg == s.requestInfo){
s.doRequestStuff(conn)
}else if(msg == s.syncInfo){
s.doSyncStuff(conn)
}else{
fmt.Println("Unable to handle request: %v", msg)
continue
}
return
}
}
/**
处理客户端请求：只对请求可用服务器地址的客户端连接进行响应
*/
func (s *AddrServer) doRequestStuff(conn net.Conn) {
// 将该子网地址返回给客户端
_ , err := conn.Write([]byte(s.addr.ip))
if err != nil {
fmt.Println("Error writing", err.Error())
}else{
fmt.Println("Send addr information to client successfully.")
}
_ = conn.Close()
}
/**
处理服务器请求：同步服务器地址
*/
func (s *AddrServer) doSyncStuff(conn net.Conn) {
// 取出conn地址，更新到s.addr中
addrS := conn.RemoteAddr().String()
s.addr.ip=strings.Split(addrS,":")[0]
fmt.Println("Updated addr success : "+addrS)
_ = conn.Close()
}
AddrServer/CanBeUsedAddr.go
+11
View File
@@ -0,0 +1,11 @@
package main
// 模拟服务器地址列表
type CanBeUsedAddr struct {
ip string
}
func (addr CanBeUsedAddr) getIP() (ip string){
// 返回一个可用地址
return addr.ip
}
AddrServer/main.go
+24
View File
@@ -0,0 +1,24 @@
package main
func main() {
addrServer := new(AddrServer)
addrServer.start()
//go startMainServer()
//
//// 等待用户输入。如果输入q，则退出程序
//inputReader := bufio.NewReader(os.Stdin)
//input, _ := inputReader.ReadString('\n')
//trimmedInput := strings.Trim(input, "\r\n")
//// 判断是否要退出
//if trimmedInput == "Q" {
// return
//}
}
// 启动记录可用IP的Server处理程序
func startMainServer() {
addrServer := new(AddrServer)
addrServer.start()
}
Client/Client.go
+5 -33
View File
@@ -1,20 +1,17 @@
package main
// 连接子网服务器的客户端程序
// 连接可用服务器的客户端程序
import (
"TCPServerClient/utils"
"bufio"
"fmt"
"net"
"os"
"strconv"
"strings"
)
const (
DefaultServerIP = "localhost" // 服务器IP
DefaultServerPort = 50000 // 服务器端口号
DefaultRequestInfo = "Request Addr" // 请求子网IP
DefaultRequestInfo = "Request Addr" // 请求子网IP的命令字段
DefaultPassword = "12345678" // 消息加解密密码。必须是八位
)
@@ -43,7 +40,7 @@ func (c *Client) start() {
fmt.Println("Successful conn to main server : "+conn.RemoteAddr().String())
}
// 请求子网服务器地址
// 请求可用服务器地址
subServerAddr,err:=getSubServerAddr(conn)
if err != nil {
fmt.Println("Error getSubServerAddr", err.Error())
@@ -52,33 +49,8 @@ func (c *Client) start() {
fmt.Println("Successful get sub server addr: "+subServerAddr)
}
// 连接子网服务器
conn, err = net.Dial("tcp", subServerAddr)
if err != nil {
fmt.Println("Error dialing to sub server", err.Error())
return
}else{
fmt.Println("Successful conn to sub server : "+conn.RemoteAddr().String())
}
// 向子网服务器发送数据
inputReader := bufio.NewReader(os.Stdin)
fmt.Println("First, what is your name?")
clientName, _ := inputReader.ReadString('\n')
trimmedClient := strings.Trim(clientName, "\r\n") // Windows 平台下用 "\r\n"，Linux平台下使用 "\n"
// 给服务器发送信息直到程序退出
for {
// 接收用户输入
fmt.Println("What to send to the server? Type Q to quit.")
input, _ := inputReader.ReadString('\n')
trimmedInput := strings.Trim(input, "\r\n")
// 判断是否要退出
if trimmedInput == "Q" {
return
}
// 发送加密数据给服务器
_, err = conn.Write([]byte(utils.EncryptMsgByDES((trimmedClient + " says: " + trimmedInput),DefaultPassword)))
}
// 连接可用服务器,
// 并做一些事。。。
}
func getSubServerAddr(conn net.Conn) (string,error) {
Server/AddrList.go
-17
View File
@@ -1,17 +0,0 @@
package main
// 模拟子网服务器地址列表
import "net"
const (
//addr1 =
)
type AddrList struct {
addrList []net.TCPAddr
}
func (al AddrList) iniAndGetIP() (ip string,port int){
// 寻找可用子网IP，返回一个可用地址
return "localhost",50005
}
Server/Server.go
-93
View File
@@ -1,93 +0,0 @@
package main
// 分配子网边界服务器地址的服务器
import (
"fmt"
"net"
"strconv"
"TCPServerClient/utils"
)
const (
DefaultServerIP = "localhost" // 服务器IP
DefaultServerPort = 50000 // 服务器端口号
DefaultRequestInfo = "Request Addr" // 请求子网IP
DefaultPassword = "12345678" // 消息加解密密码。必须是八位
)
type Server struct {
serverIP string
serverPort int
}
// 开启server，并建立监听
func (s *Server) start() {
fmt.Println("Starting the main server ...")
// 初始化
s.serverIP=DefaultServerIP
s.serverPort=DefaultServerPort
// 创建 listener
listener, err := net.Listen("tcp", s.serverIP+":"+strconv.Itoa(s.serverPort))
if err != nil {
fmt.Println("Error listening", err.Error())
return
}
// 监听并接受来自客户端的连接，并进行处理
for {
conn, err := listener.Accept()
if err != nil {
fmt.Println("Error accepting", err.Error())
return
}else{
fmt.Println("Main Server Accept conn form "+conn.RemoteAddr().String())
}
// 处理客户端请求
go doMainServerStuff(conn)
}
}
/**
处理客户端请求：只对请求子网地址的客户端连接进行响应
*/
func doMainServerStuff(conn net.Conn) {
for {
// 读取原始数据
buf := make([]byte, 512)
len, err := conn.Read(buf)
if err != nil {
fmt.Println("Error reading", err.Error())
return
}
msg:=string(buf[:len])
fmt.Println("Received raw data: %v", msg)
// 解密数据为可读格式
msg=utils.DecryptMsgByDES(msg,DefaultPassword)
fmt.Println("Received decrypt data: %v", msg)
// 判断是否是请求子网IP。是，则返回一个可用IP（）
if(msg!=DefaultRequestInfo){
fmt.Println("Unable to handle request: %v", msg)
continue
}
ip,port:=searchAddr()
// 将该子网地址返回给客户端
len, err = conn.Write([]byte(ip+":"+strconv.Itoa(port)))
if err != nil {
fmt.Println("Error writing", err.Error())
}else{
fmt.Println("Send addr information to client successfully.")
}
_ = conn.Close()
return
}
}
/**
搜索子网，寻找一个可用的接入IP
*/
func searchAddr() (ip string,port int) {
addrList:=new(AddrList)
return addrList.iniAndGetIP()
}
Server/SubServer.go
+38 -39
View File
@@ -1,66 +1,65 @@
package main
// 分配子网边界服务器地址的服务器
// 可用服务器
// 每间隔3s，主动连接一次AddrServer，从而让AddrServer更新IP
import (
"TCPServerClient/utils"
"fmt"
"net"
"strconv"
"TCPServerClient/utils"
"time"
)
const (
DefaultSubServerIP = "localhost" // 服务器IP
DefaultSubServerPort = 50005 // 服务器端口号
DefaultAddrServerIP = "localhost" // 地址服务器IP
DefaultAddrServerPort = 50000 // 地址服务器端口号
DefaultSyncInfo = "Sync Addr" // 同步IP地址的命令字段
DefaultPassword = "12345678" // 消息加解密密码。必须是八位
)
type SubServer struct {
serverIP string
serverPort int
addrServerIP string // 地址服务器IP
addrServerPort int // 地址服务器端口号
syncInfo string
password string
}
// 开启server，并建立监听
func (s *SubServer) start() {
fmt.Println("Starting the sub server ...")
// 初始化
s.serverIP=DefaultSubServerIP
s.serverPort=DefaultSubServerPort
// 创建 listener
listener, err := net.Listen("tcp", s.serverIP+":"+strconv.Itoa(s.serverPort))
if err != nil {
fmt.Println("Error listening", err.Error())
return
}
// 监听并接受来自客户端的连接，并进行处理
for {
conn, err := listener.Accept()
if err != nil {
fmt.Println("Error accepting", err.Error())
return
}else{
fmt.Println("Sub Server Accept conn form "+conn.RemoteAddr().String())
}
// 处理客户端请求
go doSubServerStuff(conn)
}
s.addrServerIP=DefaultAddrServerIP
s.addrServerPort=DefaultAddrServerPort
s.password=DefaultPassword
s.syncInfo=DefaultSyncInfo
// 循环同步本机IP到地址服务器
s.doSubServerStuff()
}
/**
处理客户端请求：接收并打印客户端发来的消息
循环同步本机IP到地址服务器，间隔三秒
*/
func doSubServerStuff(conn net.Conn) {
func (s *SubServer) doSubServerStuff() {
for {
// 读取原始数据
buf := make([]byte, 512)
len, err := conn.Read(buf)
// 睡眠三秒
time.Sleep(time.Second*3)
// 创建TCP连接，连接地址服务器
conn, err := net.Dial("tcp", s.addrServerIP+":"+strconv.Itoa(s.addrServerPort))
if err != nil {
fmt.Println("Error reading", err.Error())
return
// 由于目标计算机积极拒绝而无法创建连接
fmt.Println("Error dialing to addr server", err.Error())
continue
}else{
fmt.Println("Successful conn to addr server : "+conn.RemoteAddr().String())
}
msg:=string(buf[:len])
fmt.Println("Received raw data: %v", msg)
// 解密数据为可读格式
utils.DecryptMsgByDES(msg,DefaultPassword)
fmt.Println("Received decrypt data: %v", msg)
// 发送加密请求给服务器
_, err = conn.Write([]byte(utils.EncryptMsgByDES(s.syncInfo, s.password)))
if err != nil {
fmt.Println("Error writing", err.Error())
}else{
fmt.Println("Successful send addr info to addr server : "+conn.RemoteAddr().String())
}
// 关闭本次连接
_ = conn.Close()
}
}
Server/main.go
+1 -8
View File
@@ -8,7 +8,6 @@ import (
func main() {
go startSubServer()
go startMainServer()
// 等待用户输入。如果输入q，则退出程序
inputReader := bufio.NewReader(os.Stdin)
@@ -20,16 +19,10 @@ func main() {
}
}
// 启动子网边界Server
// 启动Server
func startSubServer() {
subServer:=new(SubServer)
subServer.start()
}
// 启动分配子网IP的Server处理程序
func startMainServer() {
mainServer := new(Server)
mainServer.start()
}