初めての Golang

package main

import (
	. "fmt"
)

func main(){
	var a = [5]int{2,3,5,7,11}
	var b []int
	var c [5]int
	var n int
	c = a
	Println(a,c) // [2 3 5 7 11] [2 3 5 7 11]
	n = copy(b,a[1:4])
	Println(n,a,b) // 0 [2 3 5 7 11] []
	n = copy(c[3:],a[1:4])
	Println(n,a,c) // 2 [2 3 5 7 11] [2 3 5 3 5]
	n = copy(a[3:],a[1:4])
	Println(n,a) // 2 [2 3 5 3 5]
}

正規表現

Go の正規表現は Perl, Python などの unix でポピュラーなスクリプ言語のシンタックスを受け継いでいるが、これらの「正規表現」には問題があるとのことで[2]、全てがサポートされてはいない。詳しくは

	go doc regexp/syntax

	$GOROOT/src/regexp/regexp.go

プログラムサンプル

package main

import (
	. "fmt"
	. "regexp"
	"os"
	bio "bufio"
)

var usage = "usage: grep expression [file ...]"

func Error(s interface{}){
	Fprintln(os.Stderr,s)
	os.Exit(1)
}

func grep(re *Regexp, fd *os.File){
	var m bool
	rd := bio.NewReader(fd)
	line,err := rd.ReadString('\n')
	for err == nil {
		m = re.Match([]byte(line))
		if m {
			Print(line)
		}
		line,err = rd.ReadString('\n')
	}
	if len(line) > 0 { // input doesn't end with '\n'
		Println(line)
	}
}

func main(){
	args := os.Args[1:]
	if len(args) == 0 {
		Error(usage)
	}
	expr := args[0]
	re, err := Compile(expr)
	if err != nil {
		Error(err)
	}
	// Printf("re: %T\n",re) // *regexp.Regexp
	args = args[1:]
	if len(args) == 0 {
		// Printf("Stdin: %T\n",os.Stdin) // *os.File
		grep(re, os.Stdin)
		os.Exit(0)
	}

	var fd *os.File
	n := len(args)
	for k:=0; k < n; k++ {
		fd, err = os.Open(args[k])
		grep(re, fd)
		fd.Close()
	}
}

譜 grep.go

ここに現れた

	rd.ReadString('\n')

	re.Match([]byte(line))

	Match(expr, []byte(line))

これらの使い方は、Go のソースコードを直接調べなくても

hebe% go doc regexp.Match
package regexp // import "regexp"

func Match(pattern string, b []byte) (matched bool, err error)
    Match reports whether the byte slice b contains any match of the regular
    expression pattern. More complicated queries need to use Compile and the
    full Regexp interface.
hebe% go doc bufio.ReadString
package bufio // import "bufio"

func (b *Reader) ReadString(delim byte) (string, error)
    ReadString reads until the first occurrence of delim in the input, returning
    a string containing the data up to and including the delimiter. If
    ReadString encounters an error before finding a delimiter, it returns the
    data read before the error and the error itself (often io.EOF). ReadString
    returns err != nil if and only if the returned data does not end in delim.
    For simple uses, a Scanner may be more convenient.
hebe% 

	func (re *Regexp) Match(b []byte) bool
	func Match(pattern string, b []byte) (matched bool, err error)

このプログラムを書いていて気がついたことを記す。
import の中で

	bio "bufio"

	. "bufio"

プログラムの中で

	// Printf(....)

なお関数 grep を

func grep(re *Regexp, fd *File){
	var m bool
	rd := bio.NewReader(fd)
	line,err := rd.ReadString('\n')
	for err == nil {
		m = re.Match([]byte(line))
		if m {
    		Print(line)
		}
    		line,err = rd.ReadString('\n')
	}
}

	echo -n alice | ./grep ali

昔のようにテキストファイルが必ず改行コードで終わる時代は過ぎ去った。現在主に使われているテキストエディタは行エディタではなく文字エディタである。そしてコンピュータの利用者の裾野が広がった結果、改行コードで終わらないテキストファイルが氾濫している。そのようなテキストファイルに対しても正しく動くプログラムが求められる時代になっている。

	go env GOROOT

	$GOROOT/src/regexp/

	egrep '^func.* Match\(' $GOROOT/src/regexp/*.go

参考文献

[1] Syntax
https://github.com/google/re2/wiki/Syntax

[2] Russ Cox: Regular Expression Matching Can Be Simple And Fast
https://swtch.com/~rsc/regexp/regexp1.html

Net

Dial

package main

import (
	. "fmt"
	"os"
	"net"
	bio "bufio"
)

var args []string

var usage = "usage: dial addr:port (addr is sysname or IP address)"

func Error(s interface{}){
	Fprintln(os.Stderr,s)
	os.Exit(1)
}

func main() {
	args = os.Args
	if len(args) != 2 {
		Error(usage)
	}

	conn, err := net.Dial("tcp", args[1])
	if err != nil{
		Error(err)
	}
	rd := bio.NewReader(conn);
	b, err := rd.ReadString('\n')
	for ; err == nil; {
		Print(string(b))
		b, err = rd.ReadString('\n')
	}
	if len(b) > 0 {
		Println(string(b))
	}
}

譜 dial.go

このプログラムは相手サーバーに tcp で接続して、相手の応答を返す。例えば onamae.com は接続したクライアントの IP アドレスを教えてくれる:

	dial ddnsclient.onamae.com:65000

IPV4: 123.48.102.187
.

我が家のサーバー hebe も同様なサービスを、家庭内のクライアントに対して行っている。例えば

meg% dial hebe:8007
192.168.0.6!8007
192.168.0.10!47686
meg% dial hebe:8008
1642213304
meg% 

譜の dial.go はいくつかの問題がある。
(a) IPv4 と IPv6 の選択ができない
(b) 柔軟性を欠いている

Listen

package main

import (
	. "fmt"
	"os"
	"net"
	"io"
)

var usage = "usage: srv1"

func Error(s interface{}){
	Fprintln(os.Stderr,s)
	os.Exit(1)
}

//https://pkg.go.dev/net#example-Listener
func handleConn(conn net.Conn){
	_, err:= io.WriteString(conn,"Hello World\n")
	if err != nil {
		Fprint(os.Stderr,"#Error ",err)
	}
	conn.Close()
}

func main() {
	ln, err := net.Listen("tcp", ":8000")
	if err != nil {
		Error(err)
	}
	for {
		conn, err := ln.Accept()
		if err != nil {
			Error(err)
		}
		//Fprintf(os.Stderr,"%T\n",conn) // *net.TCPConn
		go handleConn(conn)
	}
}

譜 srv1.go

ln.Accept() の所で for ループになっているのは、クライアントから何回でもアクセスされるからである。

解せない箇所がある。ln.Accept() が返す conn の型を調べると *net.TCPConn となっている。ところが

	func handleConn(conn *net.TCPConn){

srv1 は次のように実行される。

meg% go build srv1.go
meg% srv1&
meg% dial meg:8000
Hello World
meg% 

今の場合には handleConn の負荷が小さい。そして dial は意地悪をしていない。このケースでは

	go handleConn(conn)

	handleConn(conn)

今度は srv2.go として、アクセスしたときに、ホスト側のアドレスとポート、およびクライアント側のアドレスとポートを教えてくれるサーバーを作成する。srv1.go からの変更点はただ一つ

	_, err:= io.WriteString(conn,"Hello World\n")

	_, err:= io.WriteString(conn,Sprint(conn.LocalAddr(),"\n",
		conn.RemoteAddr(),"\n"))

僕のように C に慣れきっている人間は、ここで手が止まってしまう。Sprint が生成したメモリーはどうなるのだ? このメモリーを開放できないではないか? と。C 言語であればアウトである。しかし Go はゴミ取りをやってくれる。ゴミ取りが正しく働いていれば WriteString が終了した段階でメモリーを開放してくれるはずである。Go を信頼しましょう。

最後に srv3.go として、現在の unix time を教えてくれるサーバープログラムを作成する。srv1.go との変更点は次の2点:

	_, err:= io.WriteString(conn,"Hello World\n")

	_, err:= io.WriteString(conn,Sprint(time.Now().Unix()))

補注: srv2.go のプログラム、なぜか Plan9 では動作が変である。Go のバグの可能性が高い。Linux では問題ない。なお Plan9 で同じことを行うには、数行のシェルスクリプトで足りる。ファイル t1 を

#!/bin/rc
cat $net/local
cat $net/remote

	aux/listen1 'tcp!*!8000' t1 &

文献

[1] Documentation
https://pkg.go.dev/net

HTTP

Hget

package main

import (
	. "fmt"
	"os"
	"io"
	"net/http"
)

var usage = "usage: hget1 url"

func Error(s interface{}){
	Fprintln(os.Stderr,s)
	os.Exit(1)
}

func main() {
	args := os.Args
	if len(args) != 2 {
		Error(usage)
	}
	resp,err := http.Get(args[1])
	if err != nil {
		Error(err)
	}
	defer resp.Body.Close()
	body,err := io.ReadAll(resp.Body)
	if err != nil {
		Error(err)
	}
	Print(string(body))
}

譜 hget1.go

詳しくは文献[1]を見よ。

• 名称を hget1 にしたのは Plan9 には既に hget があるから
  
• https の接続もサポートされている。
  
• HTTP2 は? Yes (注1 を見よ)
  
• IPv4/IPv6 フラグがない
  

hget よりも丁寧なエラーメッセージを出している

Web server

次に基礎的な Web サーバーのコードを示す。

package main

import (
	. "fmt"
	"os"
	"net/http"
)

var usage = "usage: hsrv1 dir [port]"

func Error(s interface{}){
	Fprintln(os.Stderr,s)
	os.Exit(1)
}

/*
Ref:
	$GOROOT/src/net/http/example_test.go:60
for this code
*/
func main() {
	var port = "80"
	// Simple static webserver:
	args := os.Args[1:]
	if len(args) == 0 || len(args) > 2 {
		Error(usage)
	}
	dir := args[0]
	if len(args) == 2 {
		port = args[1]
	}
	err := http.ListenAndServe(":"+port, http.FileServer(http.Dir(dir)))
	if err != nil {
		Fprintln(os.Stderr, err);
	}
}

譜 hsrv1.go

文献[1]と[2]を参考にしたが、いくつか修正されている。修正点は

• document root と port を実行時に指定できるようにしたこと
  
• 起動時のエラーが判るようにしたこと
  

文献[2]では

	log.Fatal(http.ListenAndServe(":8080", http.FileServer(http.Dir("/usr/share/doc"))))

	if err != nil {
		Fprintln(os.Stderr, err);
		log.Fatal(err)
	}

Go の開発者たちはセキュリティに敏感である。指定された document root からアクセスがはみ出さないように細心の注意が払われていると想像する。(彼らの開発した Plan9 の Web サーバーのコードを見ると、そうであった)

このサーバーでは

• アクセス先が directory の場合には "/index.html" を追加する
  
• "." で始まるファイルは隠しファイルである。
  

問題点:

• アクセスログをサポートすべきである
  

CGI のサポート

CGI をサポートしたい場合には次のようになる:

package main

import (
	. "fmt"
	"os"
	"io"
	"net/http"
	"html"
	bio "bufio"
)

type typeless interface{}

var usage = "usage: hsrv2 dir [port]"

func Error(s interface{}){
	Fprintln(os.Stderr,s)
	os.Exit(1)
}

func fooHandler(w http.ResponseWriter, r *http.Request) {
	io.WriteString(w, "こんにちは!\n")
}

func barHandler(w http.ResponseWriter, r *http.Request) {
	Fprintf(w, "Hello, %q\n", html.EscapeString(r.URL.Path))
}

var dir = ""

/*
look
	https://pkg.go.dev/net/http
	$GOROOT/src/net/http/example_handle_test.go
	$GOROOT/src/net/http/example_test.go:68
for http.Handle and http.HandleFunc
*/
func main() {
	var port = "80"
	args := os.Args[1:]
	if len(args) == 0 || len(args) > 2 {
		Error(usage)
	}
	dir = args[0] // document root
	if len(args) == 2 {
		port = args[1]
	}
	if dir[0] != '/' {
		Error(`need dir to start with "/"`)
	}
	if len(dir) == 1 {
		Error(`dir must not be "/"`)
	}

	http.HandleFunc("/foo", fooHandler)
	http.HandleFunc("/bar", barHandler)
	http.Handle("/", http.FileServer(http.Dir(dir)))

	err := http.ListenAndServe(":"+port, nil)
	if err != nil {
		Fprintln(os.Stderr, err);
	}
}

譜 hsrv2.go

Handler は用途に応じて各自コードを修正すること。

文献

[2] $GOROOT/src/net/http/example_test.go

HTTPS

https サーバー

package main

import (
	. "fmt"
	"flag"
	"os"
	"io"
	"net/http"
	"html"
)

type typeless interface{}

var usage = "usage: hsrv3 -c cert.pem -k key.pem dir [port]"

func Error(s interface{}){
	Fprintln(os.Stderr,s)
	os.Exit(1)
}

func fooHandler(w http.ResponseWriter, r *http.Request) {
	io.WriteString(w, "こんにちは!\n")
}

func barHandler(w http.ResponseWriter, r *http.Request) {
	Fprintf(w, "Hello, %q\n", html.EscapeString(r.URL.Path))
}

var dir = ""

func main() {
	var port = "443"
	cert := flag.String("c","","cert.pem")
	key := flag.String("k","","key.pem")
    flag.Parse()
	if *cert == "" || *key == "" {
		Error(usage)
	}
	args := flag.Args()
	if len(args) == 0 || len(args) > 2 {
		Error(usage)
	}
	dir = args[0] // document root
	if len(args) == 2 {
		port = args[1]
	}
	if dir[0] != '/' {
		Error(`need dir to start with "/"`)
	}
	if len(dir) == 1 {
		Error(`dir must not be "/"`)
	}

	http.HandleFunc("/foo", fooHandler)
	http.HandleFunc("/bar", barHandler)
	http.Handle("/", http.FileServer(http.Dir(dir)))

	err := http.ListenAndServeTLS(":"+port, *cert, *key, nil)
	if err != nil {
		Fprintln(os.Stderr, err);
	}
}
/*
example
in one window
	hsrv3 -c cert.pem -k key.pem $home/www/doc 8443
in another window
	hget2 -f https://meg.local:8443
*/

譜 hsrv3.go

実行例はコードの中にコメントとして与えられている。meg.local は実験用のサーバーである。cert.pem と key.pem の作り方は次の Certificate に示す。

Certificate

自己証明書は次のように作成できる。

gcert=$GOROOT/src/crypto/tls/generate_cert.go
go run $gcert -host meg.local 

譜 gencert

ここに meg.local はサーバーのドメイン名で、各自の環境に応じて設定する。
何回も実行する必要がないので、go run で充分だろう。

Ref:
https://go.dev/src/crypto/tls/generate_cert.go

Hget for https

今度の hget は、相手が自己証明の場合に対応している。force flag "-f" がそれである。このフラグを与えてない場合には hget1.go と同じ動作になるはずである。

package main

import (
	. "fmt"
	"os"
	"io"
	"net/http"
	"crypto/tls"
)

var usage = "usage: hget2 [-f] url"	

func Error(s interface{}){
	Fprintln(os.Stderr,s)
	os.Exit(1)
}

func main() {
	var force = false
	args := os.Args[1:]
	if args[0] == "-f" {
		force = true
		args = args[1:]
	}
	if len(args) != 1 {
		Error(usage)
	}
	tr := &http.Transport{
		TLSClientConfig: &tls.Config{InsecureSkipVerify: force},
	}
	client := &http.Client{Transport: tr}
	resp, err := client.Get(args[0])
	if err != nil {
		Error(err)
	}

	defer resp.Body.Close()
	body,err := io.ReadAll(resp.Body)
	if err != nil {
		Error(err)
	}
	Print(string(body))
}

譜 hget2.go

通信のトランスポート層に対する制御は

	tr := &http.Transport{
		TLSClientConfig: &tls.Config{InsecureSkipVerify: force},
	}

次は hget2.go を作成するにあたって、僕が調べたことのメモ。

for http.Client look

	https://github.com/golang/go/blob/master/src/net/http/transport.go

	type Transport struct {
	...
	TLSClientConfig *tls.Config
	...
	}

and in https://pkg.go.dev/crypto/tls, we have:

	type Config struct {
	...
	InsecureSkipVerify bool
	...
	}

コードを書くにあたって、記事[2]が参考になった。
https://stackoverflow.com/questions/12122159/how-to-do-a-https-request-with-bad-certificate
基になっている文献は[1]にある。

文献

[2] How to get x509 Certificate from http Client in Go
https://stackoverflow.com/questions/12122159/how-to-do-a-https-request-with-bad-certificate