package main

import (
    "fmt"
    "github.com/gin-gonic/gin"
    "github.com/unrolled/secure"
    "io/ioutil"
)
func TLSHandler() gin.HandlerFunc {
    return func(context *gin.Context) {
        secureMiddleware := secure.New(secure.Options{
            SSLRedirect: true,
            SSLHost: "localhost:8080",
        })
        err := secureMiddleware.Process(context.Writer, context.Request)
        if err != nil {
            fmt.Println(err)
        }
        context.Next()
    }
}

func main() {
    e := gin.Default()
    e.Use(TLSHandler())

    e.POST("/", func(context *gin.Context) {
        fmt.Println("收到请求....")
    })
    // 使用SSL启动
    err := e.RunTLS(":8080", "server.crt", "server.key")
    fmt.Println(err)
}

int main() {
    wg := sync.WaitGroup{}
    wg.Add(1)
    go func(){
        // gorountine 1
        // code...
        wg.Done()
    }()
    
    wg.Add(1)
    go func(){
        // gorountine 2
        // code...
        wg.Done()
    }()
    
    // 等待协程完成之后退出
    wg.Wait()
}

package main

import (
    "bytes"
    "crypto/aes"
    "crypto/cipher"
    "crypto/sha256"
    "errors"
    "golang.org/x/crypto/pbkdf2"
    "log"
)

func PKCS7Padding(cipherText []byte, blockSize int) []byte{
    paddingLength := blockSize - len(cipherText) % blockSize
    paddingCtx := bytes.Repeat([]byte{byte(paddingLength)}, paddingLength)
    return append(cipherText, paddingCtx...)
}
func PKCS7UnPadding(cipherText []byte) ([]byte, error) {
    length := len(cipherText)
    if length <= 0 {
        return nil ,errors.New("unpadding context is invalid")
    }
    unPaddingLength := int(cipherText[length - 1])
    if unPaddingLength > length {
        return nil, errors.New("unPadding length over origin data")
    }
    return cipherText[:(length - unPaddingLength)], nil
    
}

func AESCBCEncrypt(plainText []byte, key, iv []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }
    blockSize := block.BlockSize()
    paddingText := PKCS7Padding(plainText, blockSize)
    
    blockMode := cipher.NewCBCEncrypter(block, iv)
    encryptText := make([]byte, len(paddingText))
    blockMode.CryptBlocks(encryptText, paddingText)
    return encryptText, nil
}

func AesCBCDecrypt(encryptText []byte, key, iv []byte)([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }
    blockMode := cipher.NewCBCDecrypter(block, iv)
    decryptLen := len(encryptText)
    decryptText := make([]byte, decryptLen)
    blockMode.CryptBlocks(decryptText, encryptText)
    unPaddingText, err := PKCS7UnPadding(decryptText)
    return unPaddingText, err
}


func getPbkdf2Key(securityKey, salt []byte) []byte {
    key := pbkdf2.Key(securityKey, salt, 1, len(securityKey), sha256.New)
    return key
}

func main() {
    salt := []byte("ABCDEF0123456789")
    iv := []byte("0123456789ABCDEF")
    key := getPbkdf2Key([]byte("MYPasswordxfaewfaewfaewfaeafeawf"),salt)
    plainText := "Hello World"
    encrypt, err := AESCBCEncrypt([]byte(plainText), key, iv)
    if err != nil {
        log.Println(err)
        return
    }
    decrypt, err := AesCBCDecrypt(encrypt, key, iv)
    
    log.Printf("encrypt  value : %q", encrypt)
    log.Printf("plainText value %q: ", plainText)
    log.Printf("decrypt value %q: ", decrypt)
    
    if err == nil && string(decrypt) == plainText  {
        log.Println("TEST PASS")
    }else{
        log.Fatal("TEST FAILED")
    }
}

requestBody := fmt.Sprintf("{\"jsonrpc\":\"2.0\",\"method\":\"aria2.tellStatus\",\"id\":\"QXJpYU5nXzE2MTY4NTg0ODZfMC44NzA1NzgxMzY4ODM5NjUz\", \"params\":[\"%s\"]}",gid)
reader := bytes.NewReader([]byte(requestBody))
request,err := http.NewRequest("POST", rpc_url, reader)
if err != nil {
    fmt.Println(err)
    return nil, err
}
request.Header.Set("Content-Type", "application/json")
client := &http.Client{}
response, err := client.Do(request)

var rpc_url = "http://localhost:6800/jsonrpc"

func AddNewDownloadTask(url string, dir string, filename string) (string, error) {
    requestBody := fmt.Sprintf("{\"jsonrpc\":\"2.0\",\"id\":\"QXJpYU5nXzE2MTY4NTc3MTZfMC4wNDc5NjM4NzcyODIzNTc2MjU=\",\"method\":\"aria2.addUri\",\"params\":[[\"%s\"],{\"dir\":\"%s\", \"out\":\"%s\",\"allow-overwrite\":\"true\"}]}",
        url, dir, filename)
    
    reader := bytes.NewReader([]byte(requestBody))
    request,err := http.NewRequest("POST", rpc_url, reader)
    if err != nil {
        fmt.Println(err)
        return "", err
    }
    request.Header.Set("Content-Type", "application/json")
    client := &http.Client{}
    response, err := client.Do(request)
    if err != nil {
        return "",err
    }
    defer response.Body.Close()
    resp, err := ioutil.ReadAll(response.Body)
    if err != nil {
        return "",err
    }
    res := struct {
        Id string `json:"id"`
        Result string `json:"result"`
    }{}
    err = json.Unmarshal(resp, &res)
    if err != nil {
        return "",err
    }
    return res.Result, nil
}

type GetGlobalStatResponseDAO struct {
    Id string `json:"id"`
    Jsonrpc string `json:"jsonrpc"`
    Result struct {
        DownloadSpeed string `json:"downloadSpeed"`
        NumActive string `json:"numActive"`
        NumStopped string `json:"numStopped"`
        NumStoppedTotal string `json:"numStoppedTotal"`
        NumWaiting string `json:"numWaiting"`
        UploadSpeed string `json:"uploadSpeed"`
    } `json:"result"`
}

func GetGlobalStat() (*GetGlobalStatResponseDAO, error){
    requestBody := "{\"jsonrpc\":\"2.0\",\"method\":\"aria2.getGlobalStat\",\"id\":\"QXJpYU5nXzE2MTY4NTg0ODZfMC44NzA1NzgxMzY4ODM5NjUz\"}"
    reader := bytes.NewReader([]byte(requestBody))
    request,err := http.NewRequest("POST", rpc_url, reader)
    if err != nil {
        fmt.Println(err)
        return nil, err
    }
    request.Header.Set("Content-Type", "application/json")
    client := &http.Client{}
    response, err := client.Do(request)
    if err != nil {
        return nil,err
    }
    defer response.Body.Close()
    resp, err := ioutil.ReadAll(response.Body)
    if err != nil {
        return nil,err
    }
    res := GetGlobalStatResponseDAO{}
    err = json.Unmarshal(resp, &res)
    if err != nil {
        return nil,err
    }
    return &res, nil
}

type TellStatusDAO struct {
    Id string `json:"id"`
    Jsonrpc string `json:"jsonrpc"`
    Result struct {
        Status string `json:"status"`
    } `json:"result"`
}

func TellStatus(gid string) (*TellStatusDAO, error) {
    requestBody := fmt.Sprintf("{\"jsonrpc\":\"2.0\",\"method\":\"aria2.tellStatus\",\"id\":\"QXJpYU5nXzE2MTY4NTg0ODZfMC44NzA1NzgxMzY4ODM5NjUz\", \"params\":[\"%s\"]}",gid)
    reader := bytes.NewReader([]byte(requestBody))
    request,err := http.NewRequest("POST", rpc_url, reader)
    if err != nil {
        fmt.Println(err)
        return nil, err
    }
    request.Header.Set("Content-Type", "application/json")
    client := &http.Client{}
    response, err := client.Do(request)
    if err != nil {
        return nil,err
    }
    defer response.Body.Close()
    resp, err := ioutil.ReadAll(response.Body)
    if err != nil {
        return nil,err
    }
    res := TellStatusDAO{}
    err = json.Unmarshal(resp, &res)
    if err != nil {
        return nil,err
    }
    return &res, nil
}

var port = 1400
func UdpEcho() {
    addr := fmt.Sprintf(":%d", port)
    upd, err := net.ResolveUDPAddr("udp4", addr)
    conn, err := net.ListenUDP("udp4", upd)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()
    readBuf := make([]byte, 1024)
    writeBuf := []byte("HI,Client")
    log.Printf("server listen %d ", port)

    laddr := net.UDPAddr{}
    laddr.Port = 1402
    for {
        time.Sleep(50 * time.Millisecond)
        n, remoteAddr, err := conn.ReadFromUDP(readBuf)
        if err != nil {
            fmt.Println(err)
            continue
        }
        fmt.Println("客户端 ip:", remoteAddr.IP, "端口:", remoteAddr.Port, "数据:", string(readBuf[:n]))
        // peerConn, err := net.DialUDP("udp4", &laddr , remoteAddr)
        conn.WriteTo(writeBuf, remoteAddr)
        if err != nil {
            fmt.Println(err)
            continue
        }
        fmt.Println("发送响应....")
        //peerConn.Write(writeBuf)
        //peerConn.Close()
    }
}

func main() {
    UdpEcho()
}

peerConn, err := net.DialUDP("udp4", &laddr , remoteAddr)

package main
import "net/http"

func main()  {
    http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
        writer.Write([]byte("HelloWorld"))
    })
    _ = http.ListenAndServe(":9090", nil)
}

package main

import (
    "github.com/gin-gonic/gin"
)
func main() {
    e := gin.Default()

    e.GET("/", func(context *gin.Context) {
        context.Writer.Write([]byte("HelloWorld"))
    })
    e.Run(":8088")
}