package main
import (
"encoding/binary"
"encoding/json"
"fmt"
"io"
"net"
)
type REQ struct {
Code int64
Content string
}
type RESP struct {
Content string
Code int64
}
func RecvPck(conn net.Conn) (*REQ, error) {
var sizeBuffer = make([]byte, 2)
_, err := io.ReadFull(conn, sizeBuffer)
if err != nil {
fmt.Println("read head err")
return nil, err
}
size := binary.BigEndian.Uint16(sizeBuffer)
fmt.Printf("L=%d\n", size)
body := make([]byte, size)
_, err = io.ReadFull(conn, body)
if err != nil {
fmt.Println("read body err")
return nil, err
}
T := binary.LittleEndian.Uint16(body[:2])
fmt.Printf("T=%d\n", T)
req := &REQ{}
err = json.Unmarshal(body[2:], req)
if err != nil {
return nil, err
}
fmt.Printf("V=%+v\n", req)
return req, nil
}
func SendPck(conn net.Conn, T uint16, req string) error {
resp := &RESP{
Code: int64(T),
Content: req,
}
json_content, _ := json.Marshal(resp)
L := len(string(json_content)) + 2
fmt.Printf("send L=%d\n", L)
buffer := make([]byte, L+2)
binary.BigEndian.PutUint16(buffer, uint16(L))
tmp := make([]byte, 2)
binary.LittleEndian.PutUint16(tmp, T)
copy(buffer[2:4], tmp)
copy(buffer[2+2:], json_content)
if _, err := conn.Write(buffer); err != nil {
return err
}
return nil
}
func process(conn net.Conn) {
defer conn.Close()
for {
req, err := RecvPck(conn)
if err != nil && err == io.EOF {
fmt.Printf("client close %s %d\n", conn.RemoteAddr().(*net.TCPAddr).IP,
conn.RemoteAddr().(*net.TCPAddr).Port)
break
}
err = SendPck(conn, 2, req.Content)
}
}
func main() {
listen, err := net.Listen("tcp", "127.0.0.1:20000")
if err != nil {
fmt.Println("listen failed, err:", err)
return
}
fmt.Println("listen on 127.0.0.1:20000")
for {
conn, err := listen.Accept()
if err != nil {
fmt.Println("accept failed, err:", err)
continue
}
fmt.Printf("new client %s %d\n", conn.RemoteAddr().(*net.TCPAddr).IP,
conn.RemoteAddr().(*net.TCPAddr).Port)
go process(conn)
}
}
package main
import (
"bufio"
"encoding/binary"
"encoding/json"
"fmt"
"io"
"net"
"os"
"strings"
)
type REQ struct {
Code int64
Content string
}
type RESP struct {
Content string
Code int64
}
func RecvPck(conn net.Conn) (*RESP, error) {
var sizeBuffer = make([]byte, 2)
_, err := io.ReadFull(conn, sizeBuffer)
if err != nil {
fmt.Println("read head err")
return nil, err
}
size := binary.BigEndian.Uint16(sizeBuffer)
fmt.Printf("L=%d\n", size)
body := make([]byte, size)
_, err = io.ReadFull(conn, body)
if err != nil {
fmt.Println("read body err")
return nil, err
}
T := binary.LittleEndian.Uint16(body[:2])
fmt.Printf("T=%d\n", T)
req := &RESP{}
err = json.Unmarshal(body[2:], req)
if err != nil {
return nil, err
}
fmt.Printf("V=%+v\n", req)
return req, nil
}
func SendPck(conn net.Conn, T uint16, msg string) error {
resq := &REQ{
Code: int64(T),
Content: msg,
}
json_content, _ := json.Marshal(resq)
L := len(string(json_content)) + 2
fmt.Printf("send L=%d\n", L)
buffer := make([]byte, L+2)
binary.BigEndian.PutUint16(buffer, uint16(L))
tmp := make([]byte, 2)
binary.LittleEndian.PutUint16(tmp, T)
copy(buffer[2:4], tmp)
copy(buffer[2+2:], json_content)
if _, err := conn.Write(buffer); err != nil {
return err
}
return nil
}
func process(conn net.Conn) {
defer conn.Close()
for {
req, err := RecvPck(conn)
if err != nil && err == io.EOF {
fmt.Printf("server close %s %d\n", conn.RemoteAddr().(*net.TCPAddr).IP,
conn.RemoteAddr().(*net.TCPAddr).Port)
break
}
fmt.Printf("%+v\n", req)
}
}
func main() {
conn, err := net.Dial("tcp", "127.0.0.1:20000")
if err != nil {
fmt.Println("conn failed, err:", err)
return
}
fmt.Println("connect ok")
go process(conn)
for {
text, err := bufio.NewReader(os.Stdin).ReadString('\n')
if err != nil {
break
}
text = strings.TrimSpace(text)
err = SendPck(conn, 1, text)
}
}
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
int tcp_client(const char*ip, int port);
int main()
{
int fd = tcp_client("127.0.0.1", 20000);
assert(fd);
char json_str[20] = "{\"Content\":\"qwe\"}";
unsigned short type = 1;
unsigned short len = sizeof(type) + strlen(json_str);
char *buf = (char*)malloc(len + 2);
*(unsigned short*)buf = htons(len);
*(unsigned short*)(buf+2) = type;
memcpy(buf+2+2, json_str, strlen(json_str));
printf("send body len=%d\n", len);
write(fd, buf, len + 2);
memset(buf, 0, len + 2);
char tmp[3];
read(fd, tmp, 2);
len = *(unsigned short*)tmp;
len = ntohs(len);
printf("recv body len=%u\n", len);
memset(buf, 0, len + 2);
read(fd, buf, len);
buf[len] = '\0';
type = *(unsigned short*)buf;
printf("L=%d,T=%d,V=%s\n", len, type, buf+2);
close(fd);
}
int tcp_client(const char*ip, int port)
{
int sock;
struct sockaddr_in addr;
memset(&addr, 0, sizeof addr);
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr(ip);
addr.sin_port = htons(port);
sock = socket(AF_INET, SOCK_STREAM, 0);
socklen_t len = sizeof addr;
int r = connect(sock, (struct sockaddr*)&addr, len);
if(r==-1)
{
return 0;
}
else
{
return sock;
}
}