初めての Golang

package main
func main(){
  var d = map[int]string{1:"alice",2:"bob",6:"frank"}
  println(len(d))
  for k,v := range d {
    println(k,v)
  }
}

存在の確認

v,ok := d["david"]

package main
func main(){
  var d = map[string]int{"alice":12,"bob":18,"carol":22}
  v,ok := d["alice"]
  println(v,ok) // 12, true
  v,ok = d["david"]
  println(v,ok) // 0, false
}

なお、map に登録されていないキーの要素の値は Zero value (整数の場合には 0, 文字列の場合は "", ポインタの場合には nil) となる。Zero value だけを見て、登録の有無を判断できないのは、この例をみても明らかである。

式の中での map の参照

存在しないキーを使ってもエラーにならない!

package main
func main(){
  var d = map[string]int{"alice":12,"bob":18,"carol":22}
  n := d["alice"] + d["david"]
  println(n) // 12, not error
  //n,ok := d["alice"] + d["david"] // error, assignment count
  //println(n,ok)
}

構造を持つ変数

ここでは構造体 "struct" の使い方(宣言の方法、値の与え方など)を例題で示す:

// lesson to structured variables
package main

import (
	. "fmt"
)

var p [2] float64

type Point struct {
x,y float64
}

var q Point

type Person struct {
name string
age	int
}

var a1 = Person {"alice", 16}

type T struct {
name string
age int
etc U
}

type U struct {
mail string
tel	string
}

func main() {
	Println(p)
	p[0] = 2.1
	p[1] = 1.2
	//p[2] = 3.1	// this should be error
	Println(p)
	// which is same as:
	p = [2] float64 {2.1, 1.2}
	Println(p)

	Println(q)
	q.x = 2.1
	q.y = 1.2
	Println(q)
	// which is same as:
	q = Point{2.1, 1.2}
	Println(q)

	Println(a1)

	b := T{"bob",18,U{"bob@gmai.com","0123-456-789"}}
	Println(b)
}

output:

[0 0]
[2.1 1.2]
[2.1 1.2]
{0 0}
{2.1 1.2}
{2.1 1.2}
{alice 16}
{bob 18 {bob@gmai.com 0123-456-789}}

無名フィールド

package main

import (
	. "fmt"
)

type Foo struct{
	int
	x,y int
}

func main() {
	var a Foo
 	a.int = 5; a.x = 2; a.y = 3
	Println(a)
}

ここに現れた

type Foo struct{
	int
	x,y int
}

int int
x,y int

a.int = 5

コマンドインターフェース

os.Args

次の例は、コマンド引数の処理を示す。

package main
import "os"
func main(){
  for n:=0; n < len(os.Args); n++ {
    println(n,os.Args[n])
  }
}

range 修飾

package main
import "os"
func main(){
  for n,v := range os.Args {
    println(n,v)
  }
}

compile

go build xxx.go && ./xxx alice bob caro

なお、実行ファイル xxx.go の生成をしないならば、

go run xxx.go alice bob carol

実行ファイル xxx を $GOPATH/bin の中に生成したければ

go install xxx.go

大域変数の動的初期化

C の場合

#include <stdio.h>
int a = f(3); // compile error
int f(int x) {
  return 2*x;
}
int main(int argc,char **argv){
  printf("OK %d\n",a);
  return 0;
}

次のように、関数の中で初期化しなくてはならない。

#include <stdio.h>
int a;
int f(int x) {
  return 2*x;
}
int main(int argc,char **argv){
  a = f(3);
  printf("OK %d\n",a);
  return 0;
}

Python の場合

# a=f(3)	# error
def f(x):
  return 2*x
a=f(3)
print "OK",a

Python に限らず、大域変数が実行時に(関数の外で)初期化できることは、スクリプト言語の常識である。
ただし、a=f(3) が実行される時点で f(x) が定義されていなくてはならない。

Go の場合

package main
var a = f(3)
func f(x int) int {
  return 2*x
}
func main(){
  println("OK",a)
}

この仕組みを使うと、例えば、コマンド引数を基に大域変数を次のように初期化できる。

package main
import (
  "os"
  "strconv"
)
var b,err = strconv.Atoi(os.Args[1])
var a = f(b)
func f(x int) int {
  return 2*x
}
func main(){
  println("OK",a)
}

var の部分は次のように書いてもよい。

var (
   b,err = strconv.Atoi(os.Args[1])
   a = f(b)
)

flag package に応用の具体例が見られる。

コマンド引数の情報を、関数 main の引数ではなく、os.Args でプログラムに渡す設計にしたのは、このような事情があるのかも知れない。

ファイル

例題1. rd.Read(bs) ファイルの読み取り

package main
import (
  "os"
  "log"
)
func main(){
  var wr = os.Stdout
  var bs []byte
  bs = make([]byte,4*1024)
  for _,f := range os.Args[1:] {
    rd,err := os.Open(f)
    if err != nil {
      log.Fatal(err)
    }
    for n,err := rd.Read(bs) ; n > 0; {
      if err != nil {
        log.Fatal(err)
      }
      wr.Write(bs)
      n,err = rd.Read(bs)
    }
    rd.Close()
  }
}

複数 package の import

import ( "os"; "log" )

slice 変数の初期化 make()

var bs []byte
bs = make([]byte,4*1024)

var bs = make([]byte,4*1024)

変数 "_"

関数の外で定義された変数に関しては、それを利用していなくてもコンパイラは文句を言わない。

論理式

if err != nil {

log.Fatal()

注意

この例では for 文のブロックの中に ":=" が使われている。具体的には

rd,err := os.Open(f)

例題2. bufio

こり例題では

defer
bufio.NewReader()
bufio.ReadString()
os.WriteString()
err.Error()
for

package main
import (
  "os"
  "bufio"
  "log"
)

func parse(path string){
  var line string
  file,err := os.Open(path)
  if err != nil {
    log.Fatal(err)
  }
  defer file.Close()
  rd := bufio.NewReader(file)
  wr := os.Stdout
  line,_ = rd.ReadString('\n')
  for len(line) > 0 {
    // do something here, for example:
    wr.WriteString(line)
    line,_ = rd.ReadString('\n')
  }
}

func main(){
  parse(os.Args[1])
}

修飾子 defer

関数 parse() の中の

defer file.Close()

defer は複数指定してもよく、後に指定した後始末関数から順に実行される。

bufio.ReadString()

ReadString() が返す値はファイルに含まれる 1行の文字列であり、行の区切り文字(このケースでは '\n') を末尾に含む。
UNIX の伝統的なテキストファイルの形式では、ファイルに含まれる最後の文字は '\n' である。しかし、この形式に従わないテキストファイルが存在するので注意が必要である。

bufio.ReadString() は Plan9 の readstr() の Go での実装である。readstr() は C の関数であるために、得られた行は明示的に free() でメモリを解放する必要があった。しかし、bufio.ReadString() の場合は、メモリの解放はガーベッジコレクタが行っているはずである。

bufio.ReadLine()

• バッファサイズの制限を超えると、一度では読み取ってくれない(注1)。
  
• 返された結果は、次の ReadLine() で破棄される。
  

for 文の他の書き方

for len(line) > 0 {

for 論理式 {

もちろん、この部分は

for ; len(line)>0; {

テキストファイルが '\n' で終わらないケース

package main
import (
  "os"
  "bufio"
  "log"
)

func parse(path string){
  var line string
  file,err := os.Open(path)
  if err != nil {
    log.Fatal(err)
  }
  defer file.Close()
  rd := bufio.NewReader(file)
  wr := os.Stdout
  line,err = rd.ReadString('\n')
  for err == nil {
    // do something here, for example:
    wr.WriteString(line)
    line,err = rd.ReadString('\n')
  }
  if len(line) > 0 {
    wr.WriteString(line+"\n")
  }
}

func main(){
  parse(os.Args[1])
}

読み取った行のサイズが正であるにも係わらず、err が発生するのは '\n' で終わっていないからである。このケースでは err == io.EOF となっている。

例題3. os.ReadFile

普通のファイル、つまりファイルに含まれる文字数が判っているファイルでは、その情報を利用してファイルを読み取ることができる。この場合に簡便なのは os.ReadFile() である。次に例を示す。

package main
import(
	. "fmt"
	"os"
)

var usage = "usage: read1 file"

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

// look src/os/file.go for os.ReadFile()

func main(){
	args := os.Args[1:]
	if len(args) != 1 {
		Error(usage)
	}
	b,err := os.ReadFile(args[0])
	if err != nil{
		Error(err)
	}
	Print(string(b))
}

ファイルの内容を全てメモリーに蓄えるので、大きなファイルには向かない。
読み取った結果をメモリーに蓄えたいのだが、予め必要なメモリーのサイズが判らないことがある。例えば標準入力からの読み取りの場合である。そのような場合には os.ReadFile は役に立たない。しかし io.ReadAll(rd) が使える(次を見よ)。 この例は Hget でも使われている。

なお関数 Error() における interface{} については「型無し変数」を見よ。

io.ReadAll

package main

import(
	. "fmt"
	"os"
	"io"
	"crypto/sha256"
)

var usage = "sha256sum [file]"

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

func main(){
	var err error
	var bs []byte
	args := os.Args[1:]
	rd := os.Stdin

	switch(len(args)){
	case 0:
	case 1:
		f := args[0]
		rd,err = os.Open(f)
		if err != nil {
			Error(err)
		}
	default:
		Error(usage)
	}
	bs,err = io.ReadAll(rd)
	if err != nil {
		Error(err)
	}
    rd.Close()
	sum := sha256.Sum256(bs)
	Printf("%x\n",sum)
}

複数のファイルが指定された場合にも対応すべきだが、サボられている。

型無し変数

Interface

package main
import "fmt"
type typeless interface{}
func main(){
  var x typeless
  x = 3
  println(x)
  println(x.(int)) 	// 3
  fmt.Println(x)	// 3
  x = "alice"
  println(x)
  println(x.(string))	// alice
  fmt.Println(x)	// alice
}

var x interface{}

注: このプログラムでは、interface{} を typeless として定義している。これは僕の好みである。

型無し変数と演算

var x typeless
x = 2
println(x + 3)		// error

var x typeless
x = 2
println(x.(int) + 3)	// OK

関数

関数の戻り値

Golang では Python (あるいは現代的な言語)のように複数の戻り値を指定できる。これは非常にありがたいのである。2つの方法を関数 f(x,y) と関数 g(x,y) で示す。関数 f(x,y) は普通のスタイルである。他方 g(x,y) は他の言語に慣れているとちょっと奇っ怪であるが、エラーコードを返すのに便利なように設計されている。次にそのサンプルを示す。

package main

import (
	. "fmt"
	"os"
)

var usage = "usage: a1"

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

func f(x int,y int) (int, int) {
	return x+y, x*y
}

func g(x int, y int) (sum int, prod int) {
	sum = x+y
	prod = x*y
	return
}

func main() {
	Println(f(2,3)) // output: 5 6
	Println(g(2,3)) // output: 5 6
}

/* look
https://go.dev/ref/spec
for details
*/

可変個数の引数の関数

package main
func f(args ... int){
  for k,v := range args{
    println(k,v)
  }
}
func main(){
  f(2,3,5)
}

0 2
1 3
2 5

args ... int

この例では可変個数部分の全てが単一タイプ( int )であるが、型の部分も含めて自由にデータを関数に渡したい場合にはどうするか?

次のプログラムがヒントになる。

package main
import "fmt"
func f(args ... interface{}){
  for k,v := range args{
    println(k,v)
    fmt.Println(k,v)
  }
}
func main(){
  f(2,3,"alice")
}

0 (0x56820,0xf800000002)
0 2
1 (0x56820,0xf800000003)
1 3
2 (0x56a60,0xf840028220)
2 alice

error の返し方

package main
import(
	. "fmt"
	"errors"
)

// $GOROOT/src/errors/errors.go
func main(){
	err := errors.New("blah blah")
	Println(err)
}

Pointer と Slice 変数

基礎

ポインタ(pointer)は C と同様にメモリーのアドレスである。ポインタにおける "*" と "&" の使い方は C の方法を踏襲している。

他の言語に比べて C ではポインタを使えることが強力な武器になったが、他方では(コーディングミスによる)危険性を孕んでいた。この問題は、配列へのポインタとして slice 型を導入することによって回避している。

slice 変数とは(与えられた)配列の範囲を表す情報を含む変数で (ポインタ、長さ、容量) の3つから構成されている¹。例えば a を長さ7の配列とすると a[2:5] で a[2],a[3],a[4] から構成される a の部分配列が得られるが、このときのポインタは a[2] を指しており、長さは 3 、容量は 7 である。容量は許容されるインデックスの範囲を知るのに利用される。

Slice 変数は関数に部分配列を渡すのに使われることが多い。ポインタ変数も関数引数に使われることもあるが、使い方の例を次に示す。

package main

import (
	. "fmt"
	"unsafe"
)

func f(a []int){
	Println(a)
}

func g(a *[]int){
	Println(*a)
}

func main() {
	var n int
	var a [7]int
	var b []int
	n = 1
	for k:=0; k<7; k++ {
		n *= 2
		a[k] = n
	}
	b = a[2:5]
	Println(unsafe.Sizeof(b)) // output: 24
	Println(b) // output: [8 16 32]
	f(b) // output: [8 16 32]
	g(&b) // output: [8 16 32]
	// g(&a[2:5]) // NG
}

この output は

24
[8 16 32]
[8 16 32]
[8 16 32]

f(b) は f(a[2:5]) と置き換えても構わないが、g(&a[2:5]) は許されない。slice 変数は十分に軽量であるから、敢えてポインタで渡す必要はないのである。

look alse https://go.dev/ref/spec

配列のコピー

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