├── img └── networkGo.png ├── 04_serialitaion ├── 02_gob │ ├── person.gob │ ├── save │ │ └── main.go │ └── load │ │ └── main.go ├── 03_JSON │ ├── person.json │ ├── save_test │ │ └── jsonSaveTest.go │ ├── load_test │ │ └── loadTestJsom.go │ └── echoJSON │ │ ├── echoJSONServer │ │ └── server.go │ │ └── echoJSONClient │ │ └── client.go └── 01_asn.1 │ ├── dataTimeServer │ └── dataTimeASNServer.go │ ├── test │ └── asn.go │ └── dataTimeClient │ └── dataTimeASNClient.go ├── 01_IP ├── 03_ip_parse │ └── ipParse.go ├── 02_host_lookup │ └── hostLookup.go ├── 04_ip_resolve │ └── ipResolve.go ├── 01_ip_mask │ └── ipMask.go └── 05_rawSockets_ping │ └── ping.go ├── 02_TCP ├── 02_simpleTCP │ ├── TCPServer │ │ └── TCPServer.go │ └── TCPClient │ │ └── TCPClient.go ├── 01_lookupPort │ └── lookupPort.go ├── 03_dayTimeServer │ └── dayTimeServer.go ├── 05_echo │ ├── gorutineV2 │ │ └── threaded.go │ ├── simpleEchoServer │ │ └── simple.go │ └── gorutinesSimple │ │ └── threaded.go ├── 04_getHeaderInfo │ ├── v1 │ │ └── getHeaderInfo.go │ └── v2 │ │ └── getHeaderInfo.go └── 06_simple_ftp │ ├── server │ └── server.go │ └── client │ └── client.go ├── 03_UDP ├── 01_simpleUDP │ ├── UDPServer │ │ └── UDPServer.go │ └── UDPClient │ │ └── UDPClient.go └── 02_UDPDaytime │ ├── server │ └── server.go │ └── client │ └── client.go ├── README.md └── LICENSE.md /img/networkGo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dreddsa5dies/networkGo/HEAD/img/networkGo.png -------------------------------------------------------------------------------- /04_serialitaion/02_gob/person.gob: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dreddsa5dies/networkGo/HEAD/04_serialitaion/02_gob/person.gob -------------------------------------------------------------------------------- /04_serialitaion/03_JSON/person.json: -------------------------------------------------------------------------------- 1 | {"Name":{"Family":"Newmarch","Personal":"Jan"},"Email":[{"Kind":"home","Address":"jan@newmarch.name"},{"Kind":"work","Address":"j.newmarch@boxhill.edu.au"}]} 2 | -------------------------------------------------------------------------------- /01_IP/03_ip_parse/ipParse.go: -------------------------------------------------------------------------------- 1 | /* IP */ 2 | 3 | package main 4 | 5 | import ( 6 | "fmt" 7 | "net" 8 | "os" 9 | ) 10 | 11 | func main() { 12 | if len(os.Args) != 2 { 13 | fmt.Fprintf(os.Stderr, "Использование: %s IP\n", os.Args[0]) 14 | os.Exit(1) 15 | } 16 | name := os.Args[1] 17 | // проверка на возможность IP 18 | addr := net.ParseIP(name) 19 | 20 | if addr == nil { 21 | fmt.Println("Invalid address") 22 | } else { 23 | fmt.Println("Айпишник ", addr.String()) 24 | } 25 | os.Exit(0) 26 | } 27 | -------------------------------------------------------------------------------- /01_IP/02_host_lookup/hostLookup.go: -------------------------------------------------------------------------------- 1 | /* LookupHost */ 2 | 3 | package main 4 | 5 | import ( 6 | "fmt" 7 | "net" 8 | "os" 9 | ) 10 | 11 | func main() { 12 | if len(os.Args) != 2 { 13 | fmt.Fprintf(os.Stderr, "Использование: %s hostname\n", os.Args[0]) 14 | os.Exit(1) 15 | } 16 | 17 | name := os.Args[1] 18 | addrs, err := net.LookupHost(name) 19 | if err != nil { 20 | fmt.Println("Error: ", err.Error()) 21 | os.Exit(2) 22 | } 23 | for _, s := range addrs { 24 | fmt.Println(s) 25 | } 26 | os.Exit(0) 27 | } 28 | -------------------------------------------------------------------------------- /01_IP/04_ip_resolve/ipResolve.go: -------------------------------------------------------------------------------- 1 | /* ResolveIP */ 2 | 3 | package main 4 | 5 | import ( 6 | "fmt" 7 | "net" 8 | "os" 9 | ) 10 | 11 | func main() { 12 | if len(os.Args) != 2 { 13 | fmt.Fprintf(os.Stderr, "Использование: %s hostname\n", os.Args[0]) 14 | os.Exit(1) 15 | } 16 | 17 | name := os.Args[1] 18 | addr, err := net.ResolveIPAddr("ip", name) 19 | if err != nil { 20 | fmt.Println("Resolution error", err.Error()) 21 | os.Exit(1) 22 | } 23 | fmt.Println("Resolved address is ", addr.String()) 24 | os.Exit(0) 25 | } 26 | -------------------------------------------------------------------------------- /02_TCP/02_simpleTCP/TCPServer/TCPServer.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "log" 7 | "net" 8 | "strings" 9 | ) 10 | 11 | func main() { 12 | ln, err := net.Listen("tcp", ":8081") 13 | if err != nil { 14 | log.Fatalln(err) 15 | } 16 | 17 | conn, _ := ln.Accept() 18 | 19 | for { 20 | msg, err := bufio.NewReader(conn).ReadString('\n') 21 | if err != nil { 22 | log.Fatalln(err) 23 | } 24 | fmt.Print("Message Received:", string(msg)) 25 | 26 | newMsg := strings.ToUpper(msg) 27 | 28 | conn.Write([]byte(newMsg + "\n")) 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /02_TCP/01_lookupPort/lookupPort.go: -------------------------------------------------------------------------------- 1 | /* LookupPort */ 2 | 3 | package main 4 | 5 | import ( 6 | "fmt" 7 | "net" 8 | "os" 9 | ) 10 | 11 | func main() { 12 | if len(os.Args) != 3 { 13 | fmt.Fprintf(os.Stderr, 14 | "Использование: %s network-type (tcp) service (ssh)\n", 15 | os.Args[0]) 16 | os.Exit(1) 17 | } 18 | networkType := os.Args[1] 19 | service := os.Args[2] 20 | port, err := net.LookupPort(networkType, service) 21 | if err != nil { 22 | fmt.Println("Error: ", err.Error()) 23 | os.Exit(2) 24 | } 25 | fmt.Println("Service port ", port) 26 | os.Exit(0) 27 | } 28 | -------------------------------------------------------------------------------- /03_UDP/01_simpleUDP/UDPServer/UDPServer.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "log" 5 | "net" 6 | ) 7 | 8 | func main() { 9 | serverAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:12000") 10 | if err != nil { 11 | log.Fatal(err) 12 | } 13 | 14 | serverConn, err := net.ListenUDP("udp", serverAddr) 15 | if err != nil { 16 | log.Fatal(err) 17 | } 18 | defer serverConn.Close() 19 | 20 | buf := make([]byte, 1024) 21 | 22 | for { 23 | n, addr, err := serverConn.ReadFromUDP(buf) 24 | println(string(buf[0:n]), " form ", addr.IP.String()) 25 | if err != nil { 26 | log.Fatal(err) 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /02_TCP/02_simpleTCP/TCPClient/TCPClient.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "log" 7 | "net" 8 | "os" 9 | ) 10 | 11 | func main() { 12 | conn, err := net.Dial("tcp", "127.0.0.1:8081") 13 | if err != nil { 14 | log.Fatalln(err) 15 | } 16 | 17 | for { 18 | reader := bufio.NewReader(os.Stdin) 19 | 20 | fmt.Print("Text to send: ") 21 | 22 | text, err := reader.ReadString('\n') 23 | if err != nil { 24 | log.Fatalln(err) 25 | } 26 | 27 | fmt.Fprintf(conn, text+"\n") 28 | 29 | msg, err := bufio.NewReader(conn).ReadString('\n') 30 | if err != nil { 31 | log.Fatalln(err) 32 | } 33 | 34 | fmt.Print("Msg from Server: " + msg) 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /02_TCP/03_dayTimeServer/dayTimeServer.go: -------------------------------------------------------------------------------- 1 | /* DaytimeServer */ 2 | 3 | package main 4 | 5 | import ( 6 | "log" 7 | "net" 8 | "time" 9 | ) 10 | 11 | func main() { 12 | service := ":1200" 13 | tcpAddr, err := net.ResolveTCPAddr("tcp4", service) 14 | if err != nil { 15 | log.Fatalf("Ошибка ResolveTCPAddr %v", err) 16 | } 17 | 18 | listener, err := net.ListenTCP("tcp", tcpAddr) 19 | if err != nil { 20 | log.Fatalf("Ошибка ListenTCP %v", err) 21 | } 22 | 23 | for { 24 | conn, err := listener.Accept() 25 | if err != nil { 26 | continue 27 | } 28 | 29 | log.Print("Connect ok ", conn.RemoteAddr()) 30 | 31 | daytime := time.Now().String() + "\n" 32 | conn.Write([]byte(daytime)) 33 | conn.Close() 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /01_IP/01_ip_mask/ipMask.go: -------------------------------------------------------------------------------- 1 | /* Mask */ 2 | 3 | package main 4 | 5 | import ( 6 | "fmt" 7 | "net" 8 | "os" 9 | ) 10 | 11 | func main() { 12 | if len(os.Args) != 2 { 13 | fmt.Fprintf(os.Stderr, "Использование: %s dotted-ip-addr\n", os.Args[0]) 14 | os.Exit(1) 15 | } 16 | dotAddr := os.Args[1] 17 | addr := net.ParseIP(dotAddr) 18 | if addr == nil { 19 | fmt.Println("Invalid address") 20 | os.Exit(1) 21 | } 22 | mask := addr.DefaultMask() 23 | network := addr.Mask(mask) 24 | ones, bits := mask.Size() 25 | fmt.Println("Address is \t\t", addr.String(), 26 | "\nDefault mask length is \t", bits, 27 | "\nLeading ones count is \t", ones, 28 | "\nMask is (hex) \t\t", mask.String(), 29 | "\nNetwork is \t\t", network.String()) 30 | os.Exit(0) 31 | } 32 | -------------------------------------------------------------------------------- /02_TCP/05_echo/gorutineV2/threaded.go: -------------------------------------------------------------------------------- 1 | /* ThreadedIPEchoServer */ 2 | 3 | package main 4 | 5 | import ( 6 | "log" 7 | "net" 8 | ) 9 | 10 | func main() { 11 | service := ":1200" 12 | listener, err := net.Listen("tcp", service) 13 | if err != nil { 14 | log.Fatalf("Ошибка ListenTCP %v", err) 15 | } 16 | 17 | for { 18 | conn, err := listener.Accept() 19 | if err != nil { 20 | continue 21 | } 22 | go handleClient(conn) 23 | } 24 | } 25 | 26 | func handleClient(conn net.Conn) { 27 | defer conn.Close() 28 | 29 | var buf [512]byte 30 | for { 31 | n, err := conn.Read(buf[0:]) 32 | if err != nil { 33 | return 34 | } 35 | log.Print(conn.RemoteAddr(), " print: ", string(buf[0:])) 36 | 37 | _, err2 := conn.Write(buf[0:n]) 38 | 39 | if err2 != nil { 40 | return 41 | } 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /03_UDP/02_UDPDaytime/server/server.go: -------------------------------------------------------------------------------- 1 | /* UDPDaytimeServer */ 2 | 3 | package main 4 | 5 | import ( 6 | "log" 7 | "net" 8 | "time" 9 | ) 10 | 11 | func main() { 12 | service := ":1200" 13 | udpAddr, err := net.ResolveUDPAddr("udp4", service) 14 | if err != nil { 15 | log.Fatalf("Ошибка ResolveUDPAddr %v", err) 16 | } 17 | 18 | conn, err := net.ListenUDP("udp", udpAddr) 19 | if err != nil { 20 | log.Fatalf("Ошибка ListenUDP %v", err) 21 | } 22 | 23 | for { 24 | handleClient(conn) 25 | } 26 | } 27 | func handleClient(conn *net.UDPConn) { 28 | var buf [512]byte 29 | _, addr, err := conn.ReadFromUDP(buf[0:]) 30 | if err != nil { 31 | return 32 | } 33 | log.Print("connect ", addr.IP.String(), ":", addr.Port) 34 | daytime := time.Now().String() 35 | 36 | conn.WriteToUDP([]byte(daytime), addr) 37 | } 38 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | [![Go Report Card](https://goreportcard.com/badge/github.com/dreddsa5dies/networkGo)](https://goreportcard.com/report/github.com/dreddsa5dies/networkGo) ![License](https://img.shields.io/badge/License-MIT-blue.svg) 2 | 3 | ![IMAGE](img/networkGo.png) 4 | 5 | ## Examples of how to use Go to work with the network 6 | We used examples from the book "Network Programming with Go" Jan Newmarch 7 | 8 | ## The code contains comments in Russian 9 | 10 | ## [Article](https://habr.com/ru/post/491818/) 11 | 12 | ## License 13 | This project is licensed under MIT license. Please read the LICENSE file. 14 | 15 | ## Contribute 16 | Welcomes any kind of contribution, please follow the next steps: 17 | 18 | - Fork the project on github.com. 19 | - Create a new branch. 20 | - Commit changes to the new branch. 21 | - Send a pull request. 22 | -------------------------------------------------------------------------------- /03_UDP/01_simpleUDP/UDPClient/UDPClient.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "log" 6 | "net" 7 | "time" 8 | ) 9 | 10 | func main() { 11 | serverAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:12000") 12 | if err != nil { 13 | log.Fatal(err) 14 | } 15 | 16 | localAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0") 17 | if err != nil { 18 | log.Fatal(err) 19 | } 20 | 21 | conn, err := net.DialUDP("udp", localAddr, serverAddr) 22 | if err != nil { 23 | log.Fatal(err) 24 | } 25 | defer conn.Close() 26 | 27 | for { 28 | fmt.Print("Input lowercase sentence > ") 29 | var msg string 30 | _, err := fmt.Scanf("%s", &msg) 31 | if err != nil { 32 | log.Fatal(err) 33 | } 34 | buf := []byte(msg) 35 | _, err = conn.Write(buf) 36 | if err != nil { 37 | log.Fatal(err) 38 | } 39 | time.Sleep(time.Second * 1) 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /04_serialitaion/01_asn.1/dataTimeServer/dataTimeASNServer.go: -------------------------------------------------------------------------------- 1 | /* ASN1 DaytimeServer */ 2 | 3 | package main 4 | 5 | import ( 6 | "encoding/asn1" 7 | "log" 8 | "net" 9 | "time" 10 | ) 11 | 12 | func main() { 13 | service := ":1200" 14 | tcpAddr, err := net.ResolveTCPAddr("tcp", service) 15 | if err != nil { 16 | log.Fatalf("Ошибка ResolveTCPAddr %v", err) 17 | } 18 | listener, err := net.ListenTCP("tcp", tcpAddr) 19 | if err != nil { 20 | log.Fatalf("Ошибка ListenTCP %v", err) 21 | } 22 | for { 23 | conn, err := listener.Accept() 24 | if err != nil { 25 | continue 26 | } 27 | 28 | daytime := time.Now() 29 | // Ignore return network errors. 30 | mdata, _ := asn1.Marshal(daytime) 31 | log.Print("Data ", mdata) 32 | conn.Write(mdata) 33 | conn.Close() // we're finished 34 | log.Print("Data send to ", conn.RemoteAddr()) 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /04_serialitaion/01_asn.1/test/asn.go: -------------------------------------------------------------------------------- 1 | // Abstract Syntax Notation One 2 | // ASN.1 3 | 4 | package main 5 | 6 | import ( 7 | "encoding/asn1" 8 | "fmt" 9 | "log" 10 | ) 11 | 12 | func main() { 13 | // int 14 | mdata, err := asn1.Marshal(13) 15 | if err != nil { 16 | log.Fatalf("Ошибка Marshal %v", err) 17 | } 18 | fmt.Println("До marshal/unmarshal: ", mdata) 19 | 20 | var n int 21 | _, err = asn1.Unmarshal(mdata, &n) 22 | if err != nil { 23 | log.Fatalf("Ошибка Unmarshal %v", err) 24 | } 25 | 26 | fmt.Println("После marshal/unmarshal: ", n) 27 | 28 | // строка 29 | s := "hello" 30 | mdata, err = asn1.Marshal(s) 31 | if err != nil { 32 | log.Fatalf("Ошибка Marshal %v", err) 33 | } 34 | fmt.Println("До marshal/unmarshal: ", mdata) 35 | var newstr string 36 | asn1.Unmarshal(mdata, &newstr) 37 | fmt.Println("После marshal/unmarshal: ", newstr) 38 | } 39 | -------------------------------------------------------------------------------- /02_TCP/05_echo/simpleEchoServer/simple.go: -------------------------------------------------------------------------------- 1 | /* SimpleEchoServer */ 2 | 3 | package main 4 | 5 | import ( 6 | "log" 7 | "net" 8 | ) 9 | 10 | func main() { 11 | service := ":1201" 12 | tcpAddr, err := net.ResolveTCPAddr("tcp4", service) 13 | if err != nil { 14 | log.Fatalf("Ошибка ResolveTCPAddr %v", err) 15 | } 16 | 17 | listener, err := net.ListenTCP("tcp", tcpAddr) 18 | if err != nil { 19 | log.Fatalf("Ошибка ListenTCP %v", err) 20 | } 21 | 22 | for { 23 | conn, err := listener.Accept() 24 | if err != nil { 25 | continue 26 | } 27 | handleClient(conn) 28 | conn.Close() 29 | } 30 | } 31 | 32 | func handleClient(conn net.Conn) { 33 | var buf [512]byte 34 | for { 35 | n, err := conn.Read(buf[0:]) 36 | if err != nil { 37 | return 38 | } 39 | log.Print(conn.RemoteAddr(), " print: ", string(buf[0:])) 40 | 41 | _, err2 := conn.Write(buf[0:n]) 42 | if err2 != nil { 43 | return 44 | } 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /03_UDP/02_UDPDaytime/client/client.go: -------------------------------------------------------------------------------- 1 | /* UDPDaytimeClient */ 2 | 3 | package main 4 | 5 | import ( 6 | "fmt" 7 | "log" 8 | "net" 9 | "os" 10 | ) 11 | 12 | func main() { 13 | if len(os.Args) != 2 { 14 | fmt.Fprintf(os.Stderr, "Использование: %s host:port", os.Args[0]) 15 | os.Exit(1) 16 | } 17 | 18 | service := os.Args[1] 19 | 20 | udpAddr, err := net.ResolveUDPAddr("udp4", service) 21 | if err != nil { 22 | log.Fatalf("Ошибка ResolveUDPAddr %v", err) 23 | } 24 | 25 | conn, err := net.DialUDP("udp", nil, udpAddr) 26 | if err != nil { 27 | log.Fatalf("Ошибка DialUDP %v", err) 28 | } 29 | 30 | _, err = conn.Write([]byte("hello, get time")) 31 | if err != nil { 32 | log.Fatalf("Ошибка conn.Write %v", err) 33 | } 34 | 35 | var buf [512]byte 36 | n, err := conn.Read(buf[0:]) 37 | if err != nil { 38 | log.Fatalf("Ошибка ResolveTCPAddr %v", err) 39 | } 40 | 41 | fmt.Println(string(buf[0:n])) 42 | os.Exit(0) 43 | } 44 | -------------------------------------------------------------------------------- /02_TCP/04_getHeaderInfo/v1/getHeaderInfo.go: -------------------------------------------------------------------------------- 1 | /* GetHeadInfo */ 2 | 3 | package main 4 | 5 | import ( 6 | "fmt" 7 | "io/ioutil" 8 | "log" 9 | "net" 10 | "os" 11 | ) 12 | 13 | func main() { 14 | if len(os.Args) != 2 { 15 | fmt.Fprintf(os.Stderr, "Использование: %s host:port ", os.Args[0]) 16 | os.Exit(1) 17 | } 18 | 19 | service := os.Args[1] 20 | 21 | tcpAddr, err := net.ResolveTCPAddr("tcp4", service) 22 | if err != nil { 23 | log.Fatalf("Ошибка ResolveTCPAddr %v", err) 24 | } 25 | 26 | conn, err := net.DialTCP("tcp", nil, tcpAddr) 27 | if err != nil { 28 | log.Fatalf("Ошибка DialTCP %v", err) 29 | } 30 | 31 | _, err = conn.Write([]byte("HEAD / HTTP/1.0\r\n\r\n")) 32 | if err != nil { 33 | log.Fatalf("Ошибка conn.Write %v", err) 34 | } 35 | 36 | result, err := ioutil.ReadAll(conn) 37 | if err != nil { 38 | log.Fatalf("Ошибка ioutil.ReadAll %v", err) 39 | } 40 | 41 | fmt.Println(string(result)) 42 | os.Exit(0) 43 | } 44 | -------------------------------------------------------------------------------- /02_TCP/05_echo/gorutinesSimple/threaded.go: -------------------------------------------------------------------------------- 1 | /* ThreadedIPEchoServer */ 2 | 3 | package main 4 | 5 | import ( 6 | "log" 7 | "net" 8 | ) 9 | 10 | func main() { 11 | service := ":1201" 12 | tcpAddr, err := net.ResolveTCPAddr("tcp4", service) 13 | if err != nil { 14 | log.Fatalf("Ошибка ResolveTCPAddr %v", err) 15 | } 16 | 17 | listener, err := net.ListenTCP("tcp", tcpAddr) 18 | if err != nil { 19 | log.Fatalf("Ошибка ListenTCP %v", err) 20 | } 21 | 22 | for { 23 | conn, err := listener.Accept() 24 | if err != nil { 25 | continue 26 | } 27 | go handleClient(conn) 28 | } 29 | } 30 | 31 | func handleClient(conn net.Conn) { 32 | defer conn.Close() 33 | 34 | var buf [512]byte 35 | for { 36 | n, err := conn.Read(buf[0:]) 37 | if err != nil { 38 | return 39 | } 40 | log.Print(conn.RemoteAddr(), " print: ", string(buf[0:])) 41 | 42 | _, err2 := conn.Write(buf[0:n]) 43 | 44 | if err2 != nil { 45 | return 46 | } 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /LICENSE.md: -------------------------------------------------------------------------------- 1 | Copyright 2017 Viktor Solovev 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: 4 | 5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. 6 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.` 7 | -------------------------------------------------------------------------------- /04_serialitaion/02_gob/save/main.go: -------------------------------------------------------------------------------- 1 | /* SaveGob */ 2 | 3 | package main 4 | 5 | import ( 6 | "encoding/gob" 7 | "log" 8 | "os" 9 | ) 10 | 11 | // Person struct 12 | type Person struct { 13 | Name Name 14 | Email []Email 15 | } 16 | 17 | // Name struct 18 | type Name struct { 19 | Family string 20 | Personal string 21 | } 22 | 23 | // Email struct 24 | type Email struct { 25 | Kind string 26 | Address string 27 | } 28 | 29 | func main() { 30 | person := Person{ 31 | Name: Name{Family: "Newmarch", Personal: "Jan"}, 32 | Email: []Email{Email{Kind: "home", Address: "jan@newmarch.name"}, 33 | Email{Kind: "work", Address: "j.newmarch@boxhill.edu.au"}}} 34 | 35 | saveGob("./person.gob", person) 36 | } 37 | 38 | func saveGob(fileName string, key interface{}) { 39 | outFile, err := os.Create(fileName) 40 | if err != nil { 41 | log.Fatalf("Ошибка os.Create %v", err) 42 | } 43 | 44 | encoder := gob.NewEncoder(outFile) 45 | err = encoder.Encode(key) 46 | if err != nil { 47 | log.Fatalf("Ошибка gob.NewEncoder %v", err) 48 | } 49 | 50 | outFile.Close() 51 | } 52 | -------------------------------------------------------------------------------- /04_serialitaion/03_JSON/save_test/jsonSaveTest.go: -------------------------------------------------------------------------------- 1 | /* SaveJSON */ 2 | 3 | package main 4 | 5 | import ( 6 | "encoding/json" 7 | "log" 8 | "os" 9 | ) 10 | 11 | // Person struct 12 | type Person struct { 13 | Name Name 14 | Email []Email 15 | } 16 | 17 | // Name struct 18 | type Name struct { 19 | Family string 20 | Personal string 21 | } 22 | 23 | // Email struct 24 | type Email struct { 25 | Kind string 26 | Address string 27 | } 28 | 29 | func main() { 30 | person := Person{ 31 | Name: Name{Family: "Newmarch", Personal: "Jan"}, 32 | Email: []Email{Email{Kind: "home", Address: "jan@newmarch.name"}, 33 | Email{Kind: "work", Address: "j.newmarch@boxhill.edu.au"}}} 34 | 35 | saveJSON("person.json", person) 36 | } 37 | 38 | func saveJSON(fileName string, key interface{}) { 39 | outFile, err := os.Create(fileName) 40 | if err != nil { 41 | log.Fatalf("Ошибка os.Create %v", err) 42 | } 43 | defer outFile.Close() 44 | 45 | encoder := json.NewEncoder(outFile) 46 | 47 | err = encoder.Encode(key) 48 | if err != nil { 49 | log.Fatalf("Ошибка encoder.Encode %v", err) 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /04_serialitaion/02_gob/load/main.go: -------------------------------------------------------------------------------- 1 | /* LoadGob */ 2 | 3 | package main 4 | 5 | import ( 6 | "encoding/gob" 7 | "fmt" 8 | "log" 9 | "os" 10 | ) 11 | 12 | // Person struct 13 | type Person struct { 14 | Name Name 15 | Email []Email 16 | } 17 | 18 | // Name struct 19 | type Name struct { 20 | Family string 21 | Personal string 22 | } 23 | 24 | // Email struct 25 | type Email struct { 26 | Kind string 27 | Address string 28 | } 29 | 30 | func (p Person) String() string { 31 | s := p.Name.Personal + " " + p.Name.Family 32 | for _, v := range p.Email { 33 | s += "\n" + v.Kind + ": " + v.Address 34 | } 35 | return s 36 | } 37 | 38 | func main() { 39 | var person Person 40 | 41 | loadGob("./person.gob", &person) 42 | 43 | fmt.Println("Person", person.String()) 44 | } 45 | 46 | func loadGob(fileName string, key interface{}) { 47 | inFile, err := os.Open(fileName) 48 | if err != nil { 49 | log.Fatalf("Ошибка os.Open %v", err) 50 | } 51 | 52 | decoder := gob.NewDecoder(inFile) 53 | err = decoder.Decode(key) 54 | if err != nil { 55 | log.Fatalf("Ошибка decoder.Decode %v", err) 56 | } 57 | 58 | inFile.Close() 59 | } 60 | -------------------------------------------------------------------------------- /02_TCP/04_getHeaderInfo/v2/getHeaderInfo.go: -------------------------------------------------------------------------------- 1 | /* GetHeadInfo */ 2 | 3 | package main 4 | 5 | import ( 6 | "bytes" 7 | "fmt" 8 | "io" 9 | "log" 10 | "net" 11 | "os" 12 | ) 13 | 14 | func main() { 15 | if len(os.Args) != 2 { 16 | fmt.Fprintf(os.Stderr, "Использование: %s host:port ", os.Args[0]) 17 | os.Exit(1) 18 | } 19 | 20 | service := os.Args[1] 21 | 22 | conn, err := net.Dial("tcp", service) 23 | if err != nil { 24 | log.Fatalf("Ошибка DialTCP %v", err) 25 | } 26 | 27 | _, err = conn.Write([]byte("HEAD / HTTP/1.0\r\n\r\n")) 28 | if err != nil { 29 | log.Fatalf("Ошибка conn.Write %v", err) 30 | } 31 | 32 | result, err := readFully(conn) 33 | if err != nil { 34 | log.Fatalf("Ошибка readFully %v", err) 35 | } 36 | 37 | fmt.Println(string(result)) 38 | os.Exit(0) 39 | } 40 | 41 | func readFully(conn net.Conn) ([]byte, error) { 42 | defer conn.Close() 43 | result := bytes.NewBuffer(nil) 44 | var buf [512]byte 45 | for { 46 | n, err := conn.Read(buf[0:]) 47 | result.Write(buf[0:n]) 48 | if err != nil { 49 | if err == io.EOF { 50 | break 51 | } 52 | return nil, err 53 | } 54 | } 55 | return result.Bytes(), nil 56 | } 57 | -------------------------------------------------------------------------------- /04_serialitaion/03_JSON/load_test/loadTestJsom.go: -------------------------------------------------------------------------------- 1 | /* LoadJSON */ 2 | 3 | package main 4 | 5 | import ( 6 | "encoding/json" 7 | "fmt" 8 | "log" 9 | "os" 10 | ) 11 | 12 | // Person struct 13 | type Person struct { 14 | Name Name 15 | Email []Email 16 | } 17 | 18 | // Name struct 19 | type Name struct { 20 | Family string 21 | Personal string 22 | } 23 | 24 | // Email struct 25 | type Email struct { 26 | Kind string 27 | Address string 28 | } 29 | 30 | func (p Person) String() string { 31 | s := p.Name.Personal + " " + p.Name.Family 32 | for _, v := range p.Email { 33 | s += "\n" + v.Kind + ":\t" + v.Address 34 | } 35 | return s 36 | } 37 | 38 | func main() { 39 | var person Person 40 | 41 | loadJSON("../network/serialization/JSON/person.json", &person) 42 | 43 | fmt.Println("Person\t", person.String()) 44 | } 45 | 46 | func loadJSON(fileName string, key interface{}) { 47 | inFile, err := os.Open(fileName) 48 | if err != nil { 49 | log.Fatalf("Ошибка os.Open %v", err) 50 | } 51 | defer inFile.Close() 52 | 53 | decoder := json.NewDecoder(inFile) 54 | 55 | err = decoder.Decode(key) 56 | if err != nil { 57 | log.Fatalf("Ошибка decoder.Decode %v", err) 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /04_serialitaion/01_asn.1/dataTimeClient/dataTimeASNClient.go: -------------------------------------------------------------------------------- 1 | /* ASN.1 DaytimeClient */ 2 | 3 | package main 4 | 5 | import ( 6 | "bytes" 7 | "encoding/asn1" 8 | "fmt" 9 | "io" 10 | "log" 11 | "net" 12 | "os" 13 | "time" 14 | ) 15 | 16 | func main() { 17 | if len(os.Args) != 2 { 18 | fmt.Fprintf(os.Stderr, "Использование: %s host:port", os.Args[0]) 19 | os.Exit(1) 20 | } 21 | 22 | service := os.Args[1] 23 | conn, err := net.Dial("tcp", service) 24 | if err != nil { 25 | log.Fatalf("Ошибка net.Dial %v", err) 26 | } 27 | 28 | result, err := readFully(conn) 29 | if err != nil { 30 | log.Fatalf("Ошибка readFully %v", err) 31 | } 32 | 33 | var newtime time.Time 34 | _, err = asn1.Unmarshal(result, &newtime) 35 | if err != nil { 36 | log.Fatalf("Ошибка Unmarshal %v", err) 37 | } 38 | 39 | fmt.Println("После marshal/unmarshal: ", newtime.String()) 40 | os.Exit(0) 41 | } 42 | 43 | func readFully(conn net.Conn) ([]byte, error) { 44 | defer conn.Close() 45 | result := bytes.NewBuffer(nil) 46 | var buf [512]byte 47 | for { 48 | n, err := conn.Read(buf[0:]) 49 | result.Write(buf[0:n]) 50 | if err != nil { 51 | if err == io.EOF { 52 | break 53 | } 54 | return nil, err 55 | } 56 | } 57 | return result.Bytes(), nil 58 | } 59 | -------------------------------------------------------------------------------- /04_serialitaion/03_JSON/echoJSON/echoJSONServer/server.go: -------------------------------------------------------------------------------- 1 | /* JSON EchoServer */ 2 | 3 | package main 4 | 5 | import ( 6 | "encoding/json" 7 | "log" 8 | "net" 9 | ) 10 | 11 | // Person struct 12 | type Person struct { 13 | Name Name 14 | Email []Email 15 | } 16 | 17 | // Name struct 18 | type Name struct { 19 | Family string 20 | Personal string 21 | } 22 | 23 | // Email struct 24 | type Email struct { 25 | Kind string 26 | Address string 27 | } 28 | 29 | func (p Person) String() string { 30 | s := p.Name.Personal + " " + p.Name.Family 31 | for _, v := range p.Email { 32 | s += "\n" + v.Kind + ": " + v.Address 33 | } 34 | return s 35 | } 36 | 37 | func main() { 38 | service := "0.0.0.0:1200" 39 | 40 | tcpAddr, err := net.ResolveTCPAddr("tcp", service) 41 | if err != nil { 42 | log.Fatalf("Ошибка ResolveTCPAddr %v", err) 43 | } 44 | 45 | listener, err := net.ListenTCP("tcp", tcpAddr) 46 | if err != nil { 47 | log.Fatalf("Ошибка ListenTCP %v", err) 48 | } 49 | 50 | for { 51 | conn, err := listener.Accept() 52 | if err != nil { 53 | continue 54 | } 55 | 56 | encoder := json.NewEncoder(conn) 57 | decoder := json.NewDecoder(conn) 58 | 59 | var person Person 60 | decoder.Decode(&person) 61 | encoder.Encode(person) 62 | 63 | log.Printf("Connect ok %v", conn.RemoteAddr()) 64 | log.Printf("Send data \n%v", person) 65 | 66 | conn.Close() // we're finished 67 | } 68 | } 69 | -------------------------------------------------------------------------------- /04_serialitaion/03_JSON/echoJSON/echoJSONClient/client.go: -------------------------------------------------------------------------------- 1 | /* JSON EchoClient */ 2 | 3 | package main 4 | 5 | import ( 6 | "bytes" 7 | "encoding/json" 8 | "fmt" 9 | "io" 10 | "log" 11 | "net" 12 | "os" 13 | ) 14 | 15 | // Person struct 16 | type Person struct { 17 | Name Name 18 | Email []Email 19 | } 20 | 21 | // Name struct 22 | type Name struct { 23 | Family string 24 | Personal string 25 | } 26 | 27 | // Email struct 28 | type Email struct { 29 | Kind string 30 | Address string 31 | } 32 | 33 | func (p Person) String() string { 34 | s := p.Name.Personal + " " + p.Name.Family 35 | for _, v := range p.Email { 36 | s += "\n" + v.Kind + ":\t" + v.Address 37 | } 38 | return s 39 | } 40 | 41 | func main() { 42 | person := Person{ 43 | Name: Name{Family: "Newmarch", Personal: "Jan"}, 44 | Email: []Email{Email{Kind: "home", Address: "jan@newmarch.name"}, 45 | Email{Kind: "work", Address: "j.newmarch@boxhill.edu.au"}}} 46 | 47 | if len(os.Args) != 2 { 48 | fmt.Println("Использование: ", os.Args[0], "host:port") 49 | os.Exit(1) 50 | } 51 | 52 | service := os.Args[1] 53 | 54 | conn, err := net.Dial("tcp", service) 55 | if err != nil { 56 | log.Fatalf("Ошибка net.Dial %v", err) 57 | } 58 | 59 | encoder := json.NewEncoder(conn) 60 | decoder := json.NewDecoder(conn) 61 | 62 | encoder.Encode(person) 63 | var newPerson Person 64 | decoder.Decode(&newPerson) 65 | fmt.Println(newPerson.String()) 66 | 67 | os.Exit(0) 68 | } 69 | 70 | func readFully(conn net.Conn) ([]byte, error) { 71 | defer conn.Close() 72 | result := bytes.NewBuffer(nil) 73 | var buf [512]byte 74 | for { 75 | n, err := conn.Read(buf[0:]) 76 | result.Write(buf[0:n]) 77 | if err != nil { 78 | if err == io.EOF { 79 | break 80 | } 81 | return nil, err 82 | } 83 | } 84 | return result.Bytes(), nil 85 | } 86 | -------------------------------------------------------------------------------- /01_IP/05_rawSockets_ping/ping.go: -------------------------------------------------------------------------------- 1 | /* Ping */ 2 | // go build 3 | // sudo ./ping host 4 | 5 | package main 6 | 7 | import ( 8 | "bytes" 9 | "fmt" 10 | "io" 11 | "log" 12 | "net" 13 | "os" 14 | ) 15 | 16 | func main() { 17 | if len(os.Args) != 2 { 18 | fmt.Println("Использование: ", os.Args[0], "host") 19 | os.Exit(1) 20 | } 21 | 22 | addr, err := net.ResolveIPAddr("ip", os.Args[1]) 23 | if err != nil { 24 | log.Fatalf("Ошибка ResolveIPAddr %v", err) 25 | } 26 | 27 | conn, err := net.DialIP("ip4:icmp", addr, addr) 28 | if err != nil { 29 | log.Fatalf("Ошибка DialIP %v", err) 30 | } 31 | 32 | var msg [512]byte 33 | msg[0] = 8 // echo 34 | msg[1] = 0 // code 0 35 | msg[2] = 0 // checksum, fix later 36 | msg[3] = 0 // checksum, fix later 37 | msg[4] = 0 // identifier[0] 38 | msg[5] = 13 // identifier[1] 39 | msg[6] = 0 // sequence[0] 40 | msg[7] = 37 // sequence[1] 41 | len := 8 42 | 43 | check := checkSum(msg[0:len]) 44 | 45 | msg[2] = byte(check >> 8) 46 | msg[3] = byte(check & 255) 47 | 48 | _, err = conn.Write(msg[0:len]) 49 | if err != nil { 50 | log.Fatalf("Ошибка conn.Write %v", err) 51 | } 52 | 53 | _, err = conn.Read(msg[0:]) 54 | if err != nil { 55 | log.Fatalf("Ошибка conn.Read %v", err) 56 | } 57 | 58 | fmt.Println("Ответ получен") 59 | if msg[5] == 13 { 60 | fmt.Println("Идентификатор соответствует") 61 | } 62 | if msg[7] == 37 { 63 | fmt.Println("Последовательность совпадает") 64 | } 65 | os.Exit(0) 66 | } 67 | 68 | func checkSum(msg []byte) uint16 { 69 | sum := 0 70 | 71 | for n := 1; n < len(msg)-1; n += 2 { 72 | sum += int(msg[n])*256 + int(msg[n+1]) 73 | } 74 | 75 | sum = (sum >> 16) + (sum & 0xffff) 76 | sum += (sum >> 16) 77 | answer := uint16(^sum) 78 | return answer 79 | } 80 | 81 | func readFully(conn net.Conn) ([]byte, error) { 82 | defer conn.Close() 83 | result := bytes.NewBuffer(nil) 84 | var buf [512]byte 85 | for { 86 | n, err := conn.Read(buf[0:]) 87 | result.Write(buf[0:n]) 88 | if err != nil { 89 | if err == io.EOF { 90 | break 91 | } 92 | return nil, err 93 | } 94 | } 95 | return result.Bytes(), nil 96 | } 97 | -------------------------------------------------------------------------------- /02_TCP/06_simple_ftp/server/server.go: -------------------------------------------------------------------------------- 1 | /* FTP Server */ 2 | 3 | package main 4 | 5 | import ( 6 | "log" 7 | "net" 8 | "os" 9 | ) 10 | 11 | const ( 12 | // DIR command 13 | DIR = "DIR" 14 | // CD command 15 | CD = "CD" 16 | // PWD command 17 | PWD = "PWD" 18 | ) 19 | 20 | func main() { 21 | service := "0.0.0.0:1202" 22 | 23 | tcpAddr, err := net.ResolveTCPAddr("tcp", service) 24 | if err != nil { 25 | log.Fatalf("Ошибка ResolveIPAddr %v", err) 26 | } 27 | 28 | listener, err := net.ListenTCP("tcp", tcpAddr) 29 | if err != nil { 30 | log.Fatalf("Ошибка ListenTCP %v", err) 31 | } 32 | 33 | for { 34 | conn, err := listener.Accept() 35 | if err != nil { 36 | continue 37 | } 38 | go handleClient(conn) 39 | } 40 | } 41 | 42 | func handleClient(conn net.Conn) { 43 | defer conn.Close() 44 | 45 | var buf [512]byte 46 | 47 | for { 48 | n, err := conn.Read(buf[0:]) 49 | if err != nil { 50 | conn.Close() 51 | log.Printf("connect: %v FAILRUE", conn.RemoteAddr()) 52 | return 53 | } 54 | 55 | log.Printf("connect: %v", conn.RemoteAddr()) 56 | 57 | s := string(buf[0:n]) 58 | 59 | // decode request 60 | if s[0:2] == CD { 61 | chdir(conn, s[3:]) 62 | } else if s[0:3] == DIR { 63 | dirList(conn) 64 | } else if s[0:3] == PWD { 65 | pwd(conn) 66 | } 67 | } 68 | } 69 | 70 | func chdir(conn net.Conn, s string) { 71 | if os.Chdir(s) == nil { 72 | conn.Write([]byte("OK")) 73 | log.Printf("%v OK %v", conn.RemoteAddr(), CD) 74 | } else { 75 | conn.Write([]byte("ERROR")) 76 | log.Printf("%v FAILRUE %v", conn.RemoteAddr(), CD) 77 | } 78 | } 79 | 80 | func pwd(conn net.Conn) { 81 | s, err := os.Getwd() 82 | if err != nil { 83 | conn.Write([]byte("")) 84 | log.Printf("%v FAILRUE %v", conn.RemoteAddr(), PWD) 85 | return 86 | } 87 | conn.Write([]byte(s)) 88 | log.Printf("%v OK %v", conn.RemoteAddr(), PWD) 89 | } 90 | 91 | func dirList(conn net.Conn) { 92 | defer conn.Write([]byte("\r\n")) 93 | 94 | dir, err := os.Open(".") 95 | if err != nil { 96 | log.Printf("%v FAILRUE %v", conn.RemoteAddr(), DIR) 97 | return 98 | } 99 | 100 | names, err := dir.Readdirnames(-1) 101 | if err != nil { 102 | log.Printf("%v FAILRUE %v", conn.RemoteAddr(), DIR) 103 | return 104 | } 105 | 106 | for _, nm := range names { 107 | conn.Write([]byte(nm + "\r\n")) 108 | } 109 | 110 | log.Printf("%v OK %v", conn.RemoteAddr(), DIR) 111 | } 112 | -------------------------------------------------------------------------------- /02_TCP/06_simple_ftp/client/client.go: -------------------------------------------------------------------------------- 1 | /* FTPClient */ 2 | 3 | package main 4 | 5 | import ( 6 | "bufio" 7 | "bytes" 8 | "fmt" 9 | "log" 10 | "net" 11 | "os" 12 | "strings" 13 | ) 14 | 15 | // strings used by the user interface 16 | const ( 17 | uiDir = "dir" 18 | uiCd = "cd" 19 | uiPwd = "pwd" 20 | uiQuit = "quit" 21 | ) 22 | 23 | // strings used across the network 24 | const ( 25 | DIR = "DIR" 26 | CD = "CD" 27 | PWD = "PWD" 28 | ) 29 | 30 | func main() { 31 | if len(os.Args) != 2 { 32 | fmt.Println("Использование: ", os.Args[0], "host") 33 | os.Exit(1) 34 | } 35 | 36 | host := os.Args[1] 37 | 38 | conn, err := net.Dial("tcp", host+":1202") 39 | if err != nil { 40 | log.Fatalf("Ошибка net.Dial %v", err) 41 | } 42 | 43 | reader := bufio.NewReader(os.Stdin) 44 | fmt.Printf("Use commands: cd pwd dir quit\n") 45 | 46 | for { 47 | line, err := reader.ReadString('\n') 48 | 49 | // lose trailing whitespace 50 | line = strings.TrimRight(line, " \t\r\n") 51 | if err != nil { 52 | break 53 | } 54 | 55 | // split into command + arg 56 | strs := strings.SplitN(line, " ", 2) 57 | 58 | // decode user request 59 | switch strs[0] { 60 | case uiDir: 61 | dirRequest(conn) 62 | case uiCd: 63 | if len(strs) != 2 { 64 | fmt.Println("cd ") 65 | continue 66 | } 67 | fmt.Println("CD \"", strs[1], "\"") 68 | cdRequest(conn, strs[1]) 69 | case uiPwd: 70 | pwdRequest(conn) 71 | case uiQuit: 72 | conn.Close() 73 | os.Exit(0) 74 | default: 75 | fmt.Println("Unknown command") 76 | } 77 | } 78 | } 79 | 80 | func dirRequest(conn net.Conn) { 81 | conn.Write([]byte(DIR + " ")) 82 | 83 | var buf [512]byte 84 | 85 | result := bytes.NewBuffer(nil) 86 | 87 | for { 88 | // read till we hit a blank line 89 | n, _ := conn.Read(buf[0:]) 90 | result.Write(buf[0:n]) 91 | length := result.Len() 92 | contents := result.Bytes() 93 | if string(contents[length-4:]) == "\r\n\r\n" { 94 | fmt.Println(string(contents[0 : length-4])) 95 | return 96 | } 97 | } 98 | } 99 | 100 | func cdRequest(conn net.Conn, dir string) { 101 | conn.Write([]byte(CD + " " + dir)) 102 | 103 | var response [512]byte 104 | 105 | n, _ := conn.Read(response[0:]) 106 | 107 | s := string(response[0:n]) 108 | 109 | if s != "OK" { 110 | fmt.Println("Failed to change dir") 111 | } 112 | } 113 | 114 | func pwdRequest(conn net.Conn) { 115 | conn.Write([]byte(PWD)) 116 | 117 | var response [512]byte 118 | 119 | n, _ := conn.Read(response[0:]) 120 | 121 | s := string(response[0:n]) 122 | 123 | fmt.Println("Current dir \"" + s + "\"") 124 | } 125 | --------------------------------------------------------------------------------