Skip to content

Instantly share code, notes, and snippets.

@ruandao

ruandao/DataSerialisation_ASN.1.go

Created July 27, 2016 03:10
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save ruandao/523730083679a6f9219c17a28520a28c to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save ruandao/523730083679a6f9219c17a28520a28c to your computer and use it in GitHub Desktop.
Download ZIP
<<Network programming with Go>> Chapter 4 Data serialisation
Raw
DataSerialisation_ASN.1.go
package main
import (
"encoding/asn1"
"fmt"
"os"
)
func main_ASN_1() {
mdata, err := asn1.Marshal(13)
checkError(err)
var n int
_, err1 := asn1.Unmarshal(mdata, &n)
checkError(err1)
fmt.Println("After marshal/unmarshal: ", n)
}
func checkError(err error) {
if err != nil {
fmt.Fprintf(os.Stderr, "Fatal err: ", err.Error())
os.Exit(1)
}
}
Raw
DataSerialisation_ASN1Daytimeclient.go
package main
import (
"os"
"fmt"
"net"
"time"
"encoding/asn1"
"bytes"
"io"
)
func main_ASN1DaytimeClient() {
if len(os.Args) != 2 {
fmt.Fprintf(os.Stderr, "Usage: %s host:port", os.Args[0])
os.Exit(1)
}
service := os.Args[1]
conn, err := net.Dial("tcp", service)
checkError(err)
result, err := readFully(conn)
checkError(err)
var newtime time.Time
_, err1 := asn1.Unmarshal(result, &newtime)
checkError(err1)
fmt.Println("After marshal/unmarshal: ", newtime.String())
os.Exit(0)
}
func readFully(conn net.Conn) ([]byte, error) {
defer conn.Close()
result := bytes.NewBuffer(nil)
var buf [512]byte
for {
n, err := conn.Read(buf[0:])
result.Write(buf[0: n])
if hasErr(err) {
if err == io.EOF {
break
}
return nil, err
}
}
return result.Bytes(), nil
}
Raw
DataSerialisation_ASN1DaytimeServer.go
package main
import (
"net"
"time"
"encoding/asn1"
)
func main_ASN1DaytimeServer() {
service := ":1200"
tcpAddr, err := net.ResolveTCPAddr("tcp", service)
checkError(err)
listener, err := net.ListenTCP("tcp", tcpAddr)
checkError(err)
for {
conn, err := listener.Accept()
if hasErr(err) {
continue
}
daytime := time.Now()
// Ignore return network errrors.
mdata, _ := asn1.Marshal(daytime)
conn.Write(mdata)
conn.Close() // we're finished
}
}
func hasErr(err error) bool {
return err != nil
}
Raw
DataSerialisation_Base64.go
package main
import (
"bytes"
"encoding/base64"
"fmt"
)
func main_Base64() {
eightBitData := []byte{1, 2, 3, 4, 5, 6, 7, 8}
bb := &bytes.Buffer{}
encoder := base64.NewEncoder(base64.StdEncoding, bb)
encoder.Write(eightBitData)
encoder.Close()
fmt.Println(bb)
dbuf := make([]byte, 12)
decoder := base64.NewDecoder(base64.StdEncoding, bb)
decoder.Read(dbuf)
for _, ch := range dbuf {
fmt.Print(ch)
}
}
Raw
DataSerialisation_DataSerialisation.iml
<?xml version="1.0" encoding="UTF-8"?>
<module type="GO_MODULE" version="4">
<component name="NewModuleRootManager" inherit-compiler-output="true">
<exclude-output />
<content url="file://$MODULE_DIR$" />
<orderEntry type="jdk" jdkName="Go 1.6.2" jdkType="Go SDK" />
<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="library" name="GOPATH &lt;DataSerialisation&gt;" level="project" />
</component>
</module>
Raw
DataSerialisation_EchoClient.go
package main
import (
"os"
"fmt"
"net"
"encoding/json"
)
func main_EchoClient() {
person := Person{
Name: Name{Family:"Newmarch", Personal: "Jan"},
Email: []Email{
Email{Kind:"home", Address:"jan@newmarch.name"},
Email{Kind:"work", Address: "j.newmarch@boxhill.edu.cn"},
},
}
if len(os.Args) != 2 {
fmt.Println("Usage: ", os.Args[0], "host:port")
os.Exit(1)
}
service := os.Args[1]
conn, err := net.Dial("tcp", service)
checkError(err)
encoder := json.NewEncoder(conn)
decoder := json.NewDecoder(conn)
for n := 0; n < 10; n++ {
encoder.Encode(person)
var newPerson Person
decoder.Decode(&newPerson)
fmt.Println(newPerson.String())
}
os.Exit(0)
}
Raw
DataSerialisation_EchoServer.go
package main
import (
"net"
"encoding/json"
"fmt"
)
func main_EchoServer() {
service := "0.0.0.0:1200"
tcpAddr, err := net.ResolveTCPAddr("tcp", service)
checkError(err)
listener, err := net.ListenTCP("tcp", tcpAddr)
checkError(err)
for {
conn, err := listener.Accept()
if hasErr(err) {
continue
}
encoder := json.NewEncoder(conn)
decoder := json.NewDecoder(conn)
for n := 0; n < 10; n++ {
var person Person
decoder.Decode(&person)
fmt.Println(person.String())
encoder.Encode(person)
}
conn.Close()
}
}
Raw
DataSerialisation_GobEchoClient.go
package main
import (
"os"
"fmt"
"net"
"encoding/gob"
)
func main_GobEchoClient() {
person := Person{
Name:Name{Family: "Newmarch", Personal:"Jan"},
Email:[]Email{
{Kind: "home", Address:"jan@newmarch.name"},
{Kind: "work", Address:"j.newmarch@boxhill.edu.cn"},
},
}
if len(os.Args) != 2 {
fmt.Println("Usage: ", os.Args[0], "host:port")
os.Exit(1)
}
service := os.Args[1]
conn, err := net.Dial("tcp", service)
checkError(err)
encoder := gob.NewEncoder(conn)
decoder := gob.NewDecoder(conn)
for n := 0; n < 10; n ++ {
encoder.Encode(person)
var newPerson Person
decoder.Decode(&newPerson)
fmt.Println(newPerson.String())
}
os.Exit(0)
}
Raw
DataSerialisation_GobEchoServer.go
package main
import (
"net"
"encoding/gob"
"fmt"
)
func main_GobEchoServer() {
service := "0.0.0.0: 1200"
tcpAddr, err := net.ResolveTCPAddr("tcp", service)
checkError(err)
listener, err := net.ListenTCP("tcp", tcpAddr)
checkError(err)
for {
conn, err := listener.Accept()
if hasErr(err) {
continue
}
encoder := gob.NewEncoder(conn)
decoder := gob.NewDecoder(conn)
for n := 0; n < 10; n++ {
var person Person
decoder.Decode(&person)
fmt.Println("Person ", person)
encoder.Encode(person)
}
conn.Close()
}
}
Raw
DataSerialisation_LoadGob.go
package main
import (
"fmt"
"os"
"encoding/gob"
)
func main_LoadGob() {
var person Person
loadGob("person.gob", &person)
fmt.Println("Person", person.String())
}
func loadGob(fileName string, key interface{}) {
inFile, err := os.Open(fileName)
checkError(err)
decoder := gob.NewDecoder(inFile)
err = decoder.Decode(key)
checkError(err)
inFile.Close()
}
Raw
DataSerialisation_LoadJSON.go
package main
import (
"fmt"
"os"
"encoding/json"
)
func (p Person) String() string {
s := p.Name.Personal + " " + p.Name.Family
for _, v := range p.Email {
s += "\n" + v.Kind + ": " + v.Address
}
return s
}
func main_LoadJSON() {
var person Person
loadJSON("person.json", &person)
fmt.Println("Person", person.String())
}
func loadJSON(fileName string, key interface{}) {
file, err := os.Open(fileName)
checkError(err)
decoder := json.NewDecoder(file)
err = decoder.Decode(key)
checkError(err)
file.Close()
}
Raw
DataSerialisation_SaveGob.go
package main
import (
"os"
"encoding/gob"
)
func main_SaveGob() {
person := Person{
Name: Name{Family: "Newmarch", Personal: "Jan"},
Email: []Email{
Email{Kind:"home", Address:"jan@newmarch.name"},
Email{Kind:"work", Address:"j.newmarch@boxhill.edu.cn"},
},
}
saveGob("person.gob", person)
}
func saveGob(fileName string, key interface{}) {
outFile, err := os.Create(fileName)
checkError(err)
encoder := gob.NewEncoder(outFile)
err = encoder.Encode(key)
checkError(err)
outFile.Close()
}
Raw
DataSerialisation_SaveJSON.go
package main
import (
"os"
"encoding/json"
)
type Person struct {
Name Name
Email []Email
}
type Name struct {
Family string
Personal string
}
type Email struct {
Kind string
Address string
}
func main_SaveJSON() {
person := Person {
Name: Name{Family: "Newmarch", Personal: "Jan"},
Email: []Email{
Email{Kind:"home", Address:"jan@newmarch.name"},
Email{Kind: "work", Address:"j.newmarch@boxhill.edu.au"},
},
}
saveJSON("person.json", &person)
}
func saveJSON(fileName string, key interface{}) {
outFile, err := os.Create(fileName)
checkError(err)
encoder := json.NewEncoder(outFile)
err = encoder.Encode(key)
checkError(err)
outFile.Close()
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment