/
61.go
70 lines (62 loc) · 1.83 KB
/
61.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
package main
import (
"bytes"
"crypto/rand"
"crypto/rsa"
"crypto/sha1"
"encoding/gob"
"errors"
"fmt"
"log"
. "net"
)
var HELLO_WORLD = []byte("Hello World")
var RSA_LABEL = []byte("served")
func main() {
Serve(":1025", func(connection *UDPConn, c *UDPAddr, packet *bytes.Buffer) (n int) {
var key rsa.PublicKey
var response []byte
if e := gob.NewDecoder(packet).Decode(&key); e != nil {
log.Println("unable to decode wrapper:", c)
} else if response, e = rsa.EncryptOAEP(sha1.New(), rand.Reader, &key, HELLO_WORLD, RSA_LABEL); e != nil {
log.Println("unable to encrypt server response")
} else if n, e = connection.WriteToUDP(response, c); e != nil {
log.Println("unable to write response to client:", c)
}
return
})
}
func Serve(address string, f func(*UDPConn, *UDPAddr, *bytes.Buffer) int) {
e := Launch(address, func(connection *UDPConn) (e error) {
defer func() {
if x := recover(); x != nil {
e = fmt.Errorf("serve failure %v", x)
}
}()
for {
buffer := make([]byte, 1024)
if n, client, e := connection.ReadFromUDP(buffer); e == nil {
go func(c *UDPAddr, b []byte) {
if n := f(connection, c, bytes.NewBuffer(b)); n != 0 {
log.Println(n, "bytes written to", c)
}
}(client, buffer[:n])
} else {
log.Println(address, e.Error())
}
}
return
})
if e != nil {
log.Fatalln(e.Error())
}
}
func Launch(address string, f func(*UDPConn) error) error {
var connection *UDPConn
if a, e := ResolveUDPAddr("udp", address); e != nil {
return fmt.Errorf("unable to resolve UDP address: %v", e)
} else if connection, e = ListenUDP("udp", a); e != nil {
return errors.New(fmt.Sprintf("can't open socket for listening: %v", e.Error()))
}
return f(connection)
}