net

Package standar net bahasa Go adalah package yang sangat kuat, menyediakan fungsi untuk menangani tugas-tugas umum seperti komunikasi jaringan, alamat IP, resolusi DNS, protokol TCP/UDP, protokol HTTP, dll. Karena karakteristik konkurensi bahasa Go itu sendiri, berkat ini, Go sangat ringkas dan efisien saat menangani IO jaringan.

Parsing Alamat

Go menyediakan empat fungsi untuk parsing alamat jaringan, akan dijelaskan satu per satu di bawah ini.

Alamat MAC

Signature

func ParseMAC(s string) (hw HardwareAddr, err error)

Contoh

package main

import (
  "fmt"
  "net"
)

func main() {
  hw, err := net.ParseMAC("00:1A:2B:3C:4D:5E")
  if err != nil {
    panic(err)
  }
  fmt.Println(hw)
}

CIDR

Signature

func ParseCIDR(s string) (IP, *IPNet, error)

Contoh

package main

import (
    "fmt"
    "log"
    "net"
)

func main() {
    ipv4Addr, ipv4Net, err := net.ParseCIDR("192.0.2.1/24")
    if err != nil {
       log.Fatal(err)
    }
    fmt.Println(ipv4Addr)
    fmt.Println(ipv4Net)
}

Alamat IP

Alamat IP mendukung parsing ipv4, ipv6, signature fungsi adalah sebagai berikut

func ResolveIPAddr(network, address string) (*IPAddr, error)

Contoh penggunaan adalah sebagai berikut

package main

import (
  "fmt"
  "net"
)

func main() {
  ipv4Addr, err := net.ResolveIPAddr("ip4", "192.168.2.1")
  if err != nil {
    panic(err)
  }
  fmt.Println(ipv4Addr)

  ipv6Addr, err := net.ResolveIPAddr("ip6", "2001:0db8:85a3:0000:0000:8a2e:0370:7334")
  if err != nil {
    panic(err)
  }
  fmt.Println(ipv6Addr)
}

Alamat TCP

Alamat TCP mendukung tcp4, tcp6, signature adalah sebagai berikut

func ResolveTCPAddr(network, address string) (*TCPAddr, error)

Contoh penggunaan adalah sebagai berikut

package main

import (
  "fmt"
  "net"
)

func main() {
  tcp4Addr, err := net.ResolveTCPAddr("tcp4", "0.0.0.0:2020")
  if err != nil {
    panic(err)
  }
  fmt.Println(tcp4Addr)
  tcp6Addr, err := net.ResolveTCPAddr("tcp6", "[::1]:8080")
  if err != nil {
    panic(err)
  }
  fmt.Println(tcp6Addr)
}

Alamat UDP

Alamat UDP mendukung udp4, udp6, signature adalah sebagai berikut

func ResolveUDPAddr(network, address string) (*UDPAddr, error)

Contoh penggunaan adalah sebagai berikut

package main

import (
  "fmt"
  "net"
)

func main() {
  udp4Addr, err := net.ResolveUDPAddr("udp4", "0.0.0.0:2020")
  if err != nil {
    panic(err)
  }
  fmt.Println(udp4Addr)
  udp6Addr, err := net.ResolveUDPAddr("udp6", "[::1]:8080")
  if err != nil {
    panic(err)
  }
  fmt.Println(udp6Addr)
}

Alamat Unix

Alamat Unix mendukung unix, unixgram, unixpacket, signature adalah sebagai berikut

func ResolveUnixAddr(network, address string) (*UnixAddr, error)

Contoh penggunaan adalah sebagai berikut

package main

import (
    "fmt"
    "net"
)

func main() {
    unixAddr, err := net.ResolveUnixAddr("unix", "/tmp/mysocket")
    if err != nil {
       panic(err)
    }
    fmt.Println(unixAddr)
}

DNS

Go juga menyediakan banyak fungsi untuk query DNS, berikut adalah contoh untuk parsing alamat IP domain

package main

import (
  "fmt"
  "net"
)

func main() {
  addrs, err := net.LookupHost("github.com")
  if err != nil {
    panic(err)
  }
  fmt.Println(addrs)
}

Query nilai record MX

package main

import (
  "fmt"
  "net"
)

func main() {
  mxs, err := net.LookupMX("github.com")
  if err != nil {
    panic(err)
  }
  fmt.Println(mxs)
}

Pemrograman Jaringan

Logika pemrograman tcp sangat sederhana, untuk klien adalah

1. Membangun koneksi
2. Mengirim data atau membaca data
3. Keluar

Untuk server adalah

1. Mendengarkan alamat
2. Mendapatkan koneksi
3. Membuat goroutine baru untuk menangani koneksi tersebut

Berikut adalah contoh sederhana, kode klien

package main

import (
  "net"
)

func main() {
  // Membangun koneksi
  conn, err := net.Dial("tcp", "0.0.0.0:1234")
  if err != nil {
    panic(err)
  }
  defer conn.Close()

  // Mengirim data
  for i := range 10 {
    _, err := conn.Write([]byte{'a' + byte(i)})
    if err != nil {
      panic(err)
    }
  }
}

Kode server

package main

import (
  "errors"
  "fmt"
  "io"
  "net"
  "sync"
)

func main() {
  // Mendengarkan alamat
  listener, err := net.Listen("tcp", "0.0.0.0:1234")
  if err != nil {
    panic(err)
  }
  defer listener.Close()

  var wg sync.WaitGroup

  for {
    // Memblokir menunggu koneksi berikutnya terbentuk
    conn, err := listener.Accept()
    if err != nil {
      panic(err)
    }

    // Membuka goroutine baru untuk menangani koneksi tersebut secara asinkron
    wg.Add(1)
    go func() {
      defer wg.Done()
      buf := make([]byte, 4096)
      for {
        // Membaca data dari koneksi
        n, err := conn.Read(buf)
        if errors.Is(err, io.EOF) {
          break
        } else if err != nil {
          panic(err)
        }

        data := string(buf[:n])
        fmt.Println(data)
      }
    }()
  }

  wg.Wait()
}

Klien mengirim data, server menerima data, contoh ini sangat sederhana, saat server membangun koneksi baru, cukup membuka goroutine baru untuk menanganinya, tidak perlu memblokir, UDP secara umum juga ditulis dengan cara yang serupa.