type BlockMode interface {
        // BlockSize returns the mode's block size.
        BlockSize() int

        // CryptBlocks encrypts or decrypts a number of blocks. The length of
        // src must be a multiple of the block size. Dst and src may point to
        // the same memory.
        CryptBlocks(dst, src []byte)
}

package main

import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/rand"
	"fmt"
	"io"
	"log"
)

func main() {
	// 平文。長さが 16 バイトの整数倍でない場合はパディングする必要がある
	plainText := []byte("secret text 9999")
	// 暗号化データ。先頭に初期化ベクトル (IV) を入れるため、1ブロック分余計に確保する
	encrypted := make([]byte, aes.BlockSize+len(plainText))

	// IV は暗号文の先頭に入れておくことが多い
	iv := encrypted[:aes.BlockSize]
	// IV としてランダムなビット列を生成する
	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
		log.Fatal(err)
	}

	// ブロック暗号として AES を使う場合
	key := []byte("secret-key-12345")
	block, err := aes.NewCipher(key)
	if err != nil {
		log.Fatal(err)
	}

	// CBC モードで暗号化する
	mode := cipher.NewCBCEncrypter(block, iv)
	mode.CryptBlocks(encrypted[aes.BlockSize:], plainText)
	fmt.Printf("encrypted: %x\n", encrypted)

	// 復号するには復号化用オブジェクトが別に必要
	mode = cipher.NewCBCDecrypter(block, iv)
	decrypted := make([]byte, len(plainText))
	// 先頭の IV を除いた部分を復号する
	mode.CryptBlocks(decrypted, encrypted[aes.BlockSize:])
	fmt.Printf("decrypted: %s\n", decrypted)
	// Output:
	// decrypted: secret text 9999
}

type cbc struct {
	b         Block
	blockSize int
	iv        []byte
	tmp       []byte
}

func newCBC(b Block, iv []byte) *cbc {
	return &cbc{
		b:         b,
		blockSize: b.BlockSize(),
		iv:        dup(iv),
		tmp:       make([]byte, b.BlockSize()),
	}
}

type cbcEncrypter cbc

// NewCBCEncrypter returns a BlockMode which encrypts in cipher block chaining
// mode, using the given Block. The length of iv must be the same as the
// Block's block size.
func NewCBCEncrypter(b Block, iv []byte) BlockMode {
	if len(iv) != b.BlockSize() {
		panic("cipher.NewCBCEncrypter: IV length must equal block size")
	}
	return (*cbcEncrypter)(newCBC(b, iv))
}

func (x *cbcEncrypter) CryptBlocks(dst, src []byte) {
	if len(src)%x.blockSize != 0 {
		panic("crypto/cipher: input not full blocks")
	}
	if len(dst) < len(src) {
		panic("crypto/cipher: output smaller than input")
	}

	iv := x.iv

	for len(src) > 0 {
		// Write the xor to dst, then encrypt in place.
		xorBytes(dst[:x.blockSize], src[:x.blockSize], iv)
		x.b.Encrypt(dst[:x.blockSize], dst[:x.blockSize])

		// Move to the next block with this block as the next iv.
		iv = dst[:x.blockSize]
		src = src[x.blockSize:]
		dst = dst[x.blockSize:]
	}

	// Save the iv for the next CryptBlocks call.
	copy(x.iv, iv)
}

type cbcDecrypter cbc

// NewCBCDecrypter returns a BlockMode which decrypts in cipher block chaining
// mode, using the given Block. The length of iv must be the same as the
// Block's block size and must match the iv used to encrypt the data.
func NewCBCDecrypter(b Block, iv []byte) BlockMode {
	if len(iv) != b.BlockSize() {
		panic("cipher.NewCBCDecrypter: IV length must equal block size")
	}
	return (*cbcDecrypter)(newCBC(b, iv))
}

func (x *cbcDecrypter) CryptBlocks(dst, src []byte) {
	if len(src)%x.blockSize != 0 {
		panic("crypto/cipher: input not full blocks")
	}
	if len(dst) < len(src) {
		panic("crypto/cipher: output smaller than input")
	}
	if len(src) == 0 {
		return
	}

	// For each block, we need to xor the decrypted data with the previous block's ciphertext (the iv).
	// To avoid making a copy each time, we loop over the blocks BACKWARDS.
	end := len(src)
	start := end - x.blockSize
	prev := start - x.blockSize

	// Copy the last block of ciphertext in preparation as the new iv.
	copy(x.tmp, src[start:end])

	// Loop over all but the first block.
	for start > 0 {
		x.b.Decrypt(dst[start:end], src[start:end])
		xorBytes(dst[start:end], dst[start:end], src[prev:start])

		end = start
		start = prev
		prev -= x.blockSize
	}

	// The first block is special because it uses the saved iv.
	x.b.Decrypt(dst[start:end], src[start:end])
	xorBytes(dst[start:end], dst[start:end], x.iv)

	// Set the new iv to the first block we copied earlier.
	x.iv, x.tmp = x.tmp, x.iv
}

package main

import (
	"crypto/aes"
	"fmt"
)

func main() {
	// 鍵の長さは 16, 24, 32 バイトのどれかにしないとエラー
	key := []byte("aes-secret-key-1")
	// cipher.Block を実装している AES 暗号化オブジェクトを生成する
	c, err := aes.NewCipher(key)
	if err != nil {
		panic(err)
	}

	// 暗号化される平文の長さは 16 バイト (128 ビット)
	plainText := []byte("secret plain txt")
	// 暗号化されたバイト列を格納するスライスを用意する
	encrypted := make([]byte, aes.BlockSize)
	// AES で暗号化をおこなう
	c.Encrypt(encrypted, plainText)
	// 結果は暗号化されている
	fmt.Println(string(encrypted))
	// Output:
	// #^ϗ~:f9��˱�1�

	// 復号する
	decrypted := make([]byte, aes.BlockSize)
	c.Decrypt(decrypted, encrypted)
	// 結果は元の平文が得られる
	fmt.Println(string(decrypted))
	// Output:
	// secret plain txt
}

// A cipher is an instance of AES encryption using a particular key.
type aesCipher struct {
	enc []uint32
	dec []uint32
}

// NewCipher creates and returns a new cipher.Block.
// The key argument should be the AES key,
// either 16, 24, or 32 bytes to select
// AES-128, AES-192, or AES-256.
func NewCipher(key []byte) (cipher.Block, error) {
	k := len(key)
	switch k {
	default:
		return nil, KeySizeError(k)
	case 16, 24, 32:
		break
	}

	n := k + 28
	c := &aesCipher{make([]uint32, n), make([]uint32, n)}
	expandKey(key, c.enc, c.dec)
	return c, nil
}

// +build amd64

// defined in asm_$GOARCH.s
func hasAsm() bool
func expandKeyAsm(nr int, key *byte, enc *uint32, dec *uint32)

var useAsm = hasAsm()

func expandKey(key []byte, enc, dec []uint32) {
	if useAsm {
		rounds := 10
		switch len(key) {
		case 128 / 8:
			rounds = 10
		case 192 / 8:
			rounds = 12
		case 256 / 8:
			rounds = 14
		}
		expandKeyAsm(rounds, &key[0], &enc[0], &dec[0])
	} else {
		expandKeyGo(key, enc, dec)
	}
}

func (c *aesCipher) Encrypt(dst, src []byte) {
	if len(src) < BlockSize {
		panic("crypto/aes: input not full block")
	}
	if len(dst) < BlockSize {
		panic("crypto/aes: output not full block")
	}
	encryptBlock(c.enc, dst, src)
}

func (c *aesCipher) Decrypt(dst, src []byte) {
	if len(src) < BlockSize {
		panic("crypto/aes: input not full block")
	}
	if len(dst) < BlockSize {
		panic("crypto/aes: output not full block")
	}
	decryptBlock(c.dec, dst, src)
}

// +build amd64

// defined in asm_$GOARCH.s
func hasAsm() bool
func encryptBlockAsm(nr int, xk *uint32, dst, src *byte)
func decryptBlockAsm(nr int, xk *uint32, dst, src *byte)

var useAsm = hasAsm()

func encryptBlock(xk []uint32, dst, src []byte) {
	if useAsm {
		encryptBlockAsm(len(xk)/4-1, &xk[0], &dst[0], &src[0])
	} else {
		encryptBlockGo(xk, dst, src)
	}
}

func decryptBlock(xk []uint32, dst, src []byte) {
	if useAsm {
		decryptBlockAsm(len(xk)/4-1, &xk[0], &dst[0], &src[0])
	} else {
		decryptBlockGo(xk, dst, src)
	}
}

// +build !amd64

func encryptBlock(xk []uint32, dst, src []byte) {
	encryptBlockGo(xk, dst, src)
}

func decryptBlock(xk []uint32, dst, src []byte) {
	decryptBlockGo(xk, dst, src)
}

package cipher

type Block interface {
        // BlockSize returns the cipher's block size.
        BlockSize() int

        // Encrypt encrypts the first block in src into dst.
        // Dst and src may point at the same memory.
        Encrypt(dst, src []byte)

        // Decrypt decrypts the first block in src into dst.
        // Dst and src may point at the same memory.
        Decrypt(dst, src []byte)
}

package main

import (
	"crypto/des"
	"fmt"
)

func main() {
	// 鍵の長さは 8 バイト (64 ビット) にしないとエラー
	key := []byte("priv-key")
	// cipher.Block を実装している DES 暗号化オブジェクトを生成する
	c, err := des.NewCipher(key)
	if err != nil {
		panic(err)
	}

	// 平文も暗号化されるのは 8 バイト (64 ビット)
	plainText := []byte("plaintxt")
	// 暗号化されたバイト列を格納するスライスを用意する
	encrypted := make([]byte, des.BlockSize)
	// DES で暗号化をおこなう
	c.Encrypt(encrypted, plainText)
	// 結果は暗号化されている
	fmt.Println(string(encrypted)) //=> ����A�

	// 復号する
	decrypted := make([]byte, des.BlockSize)
	c.Decrypt(decrypted, encrypted)
	// 結果は元の平文が得られる
	fmt.Println(string(decrypted)) //=> plaintxt
}

// desCipher is an instance of DES encryption.
type desCipher struct {
	subkeys [16]uint64
}

// NewCipher creates and returns a new cipher.Block.
func NewCipher(key []byte) (cipher.Block, error) {
	if len(key) != 8 {
		return nil, KeySizeError(len(key))
	}

	c := new(desCipher)
	c.generateSubkeys(key)
	return c, nil
}

func (c *desCipher) Encrypt(dst, src []byte) { encryptBlock(c.subkeys[:], dst, src) }

func (c *desCipher) Decrypt(dst, src []byte) { decryptBlock(c.subkeys[:], dst, src) }

// Encrypt one block from src into dst, using the subkeys.
func encryptBlock(subkeys []uint64, dst, src []byte) {
	cryptBlock(subkeys, dst, src, false)
}

// Decrypt one block from src into dst, using the subkeys.
func decryptBlock(subkeys []uint64, dst, src []byte) {
	cryptBlock(subkeys, dst, src, true)
}

func cryptBlock(subkeys []uint64, dst, src []byte, decrypt bool) {
	b := binary.BigEndian.Uint64(src)
	b = permuteInitialBlock(b)
	left, right := uint32(b>>32), uint32(b)

	var subkey uint64
	for i := 0; i < 16; i++ {
		if decrypt {
			subkey = subkeys[15-i]
		} else {
			subkey = subkeys[i]
		}

		left, right = right, left^feistel(right, subkey)
	}
	// switch left & right and perform final permutation
	preOutput := (uint64(right) << 32) | uint64(left)
	binary.BigEndian.PutUint64(dst, permuteFinalBlock(preOutput))
}

package main

import (
	"crypto/des"
	"fmt"
)

func main() {
	// 鍵の長さは 24 バイトにしないとエラー
	key := []byte("this is 3des private key")

	// Triple DES 暗号化用オブジェクトを生成する
	c, err := des.NewTripleDESCipher(key)
	if err != nil {
		panic(err)
	}

	// 暗号化される平文の長さは 8 バイト
	plainText := []byte("plaintxt")
	// 暗号化された byte 列を格納する slice を用意する
	encrypted := make([]byte, des.BlockSize)
	// Triple DES で暗号化をおこなう
	c.Encrypt(encrypted, plainText)
	// 結果は暗号化されている
	fmt.Println(string(encrypted)) //=> �Y����4�

	// Triple DES で復号する
	decrypted := make([]byte, des.BlockSize)
	c.Decrypt(decrypted, encrypted)
	fmt.Println(string(decrypted)) //=> plaintxt
}

// A tripleDESCipher is an instance of TripleDES encryption.
type tripleDESCipher struct {
	cipher1, cipher2, cipher3 desCipher
}

// NewTripleDESCipher creates and returns a new cipher.Block.
func NewTripleDESCipher(key []byte) (cipher.Block, error) {
	if len(key) != 24 {
		return nil, KeySizeError(len(key))
	}

	c := new(tripleDESCipher)
	c.cipher1.generateSubkeys(key[:8])
	c.cipher2.generateSubkeys(key[8:16])
	c.cipher3.generateSubkeys(key[16:])
	return c, nil
}

func (c *tripleDESCipher) Encrypt(dst, src []byte) {
	c.cipher1.Encrypt(dst, src)
	c.cipher2.Decrypt(dst, dst)
	c.cipher3.Encrypt(dst, dst)
}

func (c *tripleDESCipher) Decrypt(dst, src []byte) {
	c.cipher3.Decrypt(dst, src)
	c.cipher2.Encrypt(dst, dst)
	c.cipher1.Decrypt(dst, dst)
}

  p := Person{Name: "Taro"}
  p.Greet("Hi")
  ↑
コイツ

type Person struct{ Name string }

// Person 型に対してメソッドを定義する
func (p Person) Greet(msg string) {
    fmt.Printf("%s, I'm %s.\n", msg, p.Name)
}

func main() {
    p := Person{Name: "Taro"} // 値型の変数を用意する
    p.Greet("Hi")             //=> Hi, I'm Taro.
}

type Person struct{ Name string }

// *Person 型に対してメソッドを定義する
func (pp *Person) Shout(msg string) {
    fmt.Printf("%s!!!\n", msg)
}

func main() {
    pp := &Person{Name: "Taro"} // ポインタ型の変数を用意する
    pp.Shout("OH MY GOD")       //=> OH MY GOD!!!
}

type Person struct{ Name string }

// Person 型に対してメソッドを定義する
func (p Person) Greet(msg string) {
    fmt.Printf("%s, I'm %s.\n", msg, p.Name)
}

func main() {
    pp := &Person{Name: "Taro"} // ポインタ型の変数を用意する
    (*pp).Greet("Hi")           //=> Hi, I'm Taro. | 当然呼び出せる
    pp.Greet("Hi")              //=> Hi, I'm Taro. | コンパイラが上のコードに変換してくれる
}

var nilp *Person // nil ポインタ変数だと...
nilp.Greet("Hi") //=> panic: runtime error: invalid memory address or nil pointer dereference

type Person struct{ Name string }

// *Person 型に対してメソッドを定義する
func (pp *Person) Shout(msg string) {
    fmt.Printf("%s!!!\n", msg)
}

func main() {
    p := Person{Name: "Taro"} // 値型の変数を用意する
    (&p).Shout("OH MY GOD")   //=> OH MY GOD!!! | 当然呼び出せる
    p.Shout("OH MY GOD")      //=> OH MY GOD!!! | コンパイラが上のコードに変換してくれる
}

var nilp *Person        // nil ポインタ変数でも...
nilp.Shout("OH MY GOD") //=> OH MY GOD!!! | ちゃんと呼び出せる

type Person struct{ Name string }

// *Person 型に対してメソッドを定義する
func (p *Person) ShoutName() {
    fmt.Printf("I'm %s!!!\n", p.Name) // p.Name フィールドを呼び出していると...
}

func main() {
    var nilp *Person // nil ポインタだと...
    nilp.ShoutName() //=> panic: runtime error: invalid memory address or nil pointer dereference
}

func (p Person) Greet(msg string) {
    // ...
}

func Person.Greet(p Person, msg string) {
    // ...
}

func (pp *Person) Shout(msg string) {
    // ...
}

func (*Person).Shout(pp *Person, msg string) {
    // ...
}

// n: メソッドを表す AST ノード
// t: メソッドをもつ型を表す AST ノード
func methodname1(n *Node, t *Node) *Node {
	star := ""
	if t.Op == OIND {
		star = "*"
		t = t.Left
	}

	if t.Sym == nil || isblank(n) {
		return newfuncname(n.Sym)
	}

	var p string
	if star != "" {
		p = fmt.Sprintf("(%s%v).%v", star, t.Sym, n.Sym) // (*Type).Method
	} else {
		p = fmt.Sprintf("%v.%v", t.Sym, n.Sym)           // Type.Method
	}

	if exportname(t.Sym.Name) {
		n = newfuncname(Lookup(p))
	} else {
		n = newfuncname(Pkglookup(p, t.Sym.Pkg))
	}

	return n
}

type Person struct{ Name string }

func (p Person) Greet(msg string) {
    fmt.Printf("%s, I'm %s.\n", msg, p.Name)
}

func (p *Person) Shout(msg string) {
    fmt.Printf("%s!!!\n", msg)
}

func main() {
    p := Person{Name: "Taro"}
    // 以下は等価
    p.Greet("Hi")         //=> Hi, I'm Taro.
    Person.Greet(p, "Hi") //=> Hi, I'm Taro.

    pp := &Person{Name: "Taro"}
    // 以下は等価
    pp.Shout("OH MY GOD")            //=> OH MY GOD!!!
    (*Person).Shout(pp, "OH MY GOD") //=> OH MY GOD!!!
}

type Person struct{ Name string }

func (p Person) Greet(msg string) {
    fmt.Printf("%s, I'm %s.\n", msg, p.Name)
}

func main() {
    p := Person{Name: "Taro"}
    f := Person.Greet
    g := p.Greet

    f(p, "Hello") //=> Hello, I'm Taro.
    g("Hello")    //=> Hello, I'm Taro.
}

type Person struct{ Name string }

func (p Person) Greet(msg string) {
    fmt.Printf("%s, I'm %s.\n", msg, p.Name)
}

func (pp *Person) Shout(msg string) {
    fmt.Printf("%s!!!\n", msg)
}

func Person.Greet(p Person, msg string) {
    fmt.Printf("%s, I'm %s.\n", msg, p.Name)
}

func (*Person).Shout(pp *Person, msg string) {
    fmt.Printf("%s!!!\n", msg)
}

p := Person{Name: "Taro"}
Person.Greet(p, "Hi") // p の値はコピーされてメソッド内で使われます
p.Greet("Hi")         // p の値はコピーされてメソッド内で使われます

type Person struct{ name string }

func (p Person) Greet(msg string) {
    fmt.Printf("%s, I'm %s.\n", msg, p.name)
}

func (p Person) UnchangeName(name string) {
    p.name = name
}

func main() {
    p := Person{name: "Taro"}
    // p の値はコピーされるので、フィールドを書き換えても影響ない
    Person.UnchangeName(p, "Jiro")
    p.UnchangeName("Jiro")

    p.Greet("Hi") //=> Hi, I'm Taro.
}

type Person struct{ name string }

func NewPerson(name string) *Person {
    return &Person{name: name}
}

// p の値を変更したいのでポインタレシーバで定義する
func (p *Person) ChangeName(name string) {
    p.name = name
}

func main() {
    p := NewPerson("Taro")
    p.ChangeName("Jiro")

    p.Greet("Hi") //=> Hi, I'm Jiro.
}

type Person struct{ name string }

func (p *Person) ChangeNameUnsafe(name string) {
    // これだけだと危険
    p.name = name
}

func (p *Person) ChangeNameSafe(name string) {
    // 他の言語だと this == nil みたいなものだから変な感じがするが、
    // きちんとガード句を設けておけば安全
    if p == nil {
        return
    }
    p.name = name
}

func main() {
    var pp *Person              // nil ポインタ変数だと...
    pp.ChangeNameUnsafe("Jiro") //=> panic: runtime error: invalid memory address or nil pointer dereference
    pp.ChangeNameSafe("Jiro")   // こちらは安全
}

type Person struct{ name string }

// p の値を使わないときは書かない
//    ↓
func (*Person) Shout(msg string) {
    fmt.Printf("%s!!!\n", msg)
}

type RpcClientDriver struct {
	plugin          localbinary.DriverPlugin // プラグイン管理オブジェクト
	heartbeatDoneCh chan bool                // heartbeat 終了メッセージ送信チャンネル
	Client          *InternalClient          // Go の標準ライブラリの RPC クライアントをラップしたもの
}

// rawDriverData: ドライバに関する設定情報が JSON にシリアライズされたもの
//    driverName: "virtualbox", "amazonec2" などのドライバ名文字列
func NewRpcClientDriver(rawDriverData []byte, driverName string) (*RpcClientDriver, error) {
	mcnName := ""

	// バイナリプラグイン管理オブジェクトを生成する
	p, err := localbinary.NewLocalBinaryPlugin(driverName)
	if err != nil {
		return nil, err
	}

	// 非同期にドライバプラグイン (RPC サーバ) を起動する
	go func() {
		if err := p.Serve(); err != nil {
			// TODO: Is this best approach?
			log.Warn(err)
			return
		}
	}()

	// プラグインへの接続情報を取得する
	addr, err := p.Address()
	if err != nil {
		return nil, fmt.Errorf("Error attempting to get plugin server address for RPC: %s", err)
	}

	// プラグインへ接続する
	rpcclient, err := rpc.DialHTTP("tcp", addr)
	if err != nil {
		return nil, err
	}

	// RPC クライアントオブジェクトを生成する
	c := &RpcClientDriver{
		Client:          NewInternalClient(rpcclient),
		heartbeatDoneCh: make(chan bool),
	}

	// 定期的にプラグインへ heartbeat を送信する goroutine を生成する
	go func(c *RpcClientDriver) {
		for {
			select {
			case <-c.heartbeatDoneCh:
				return
			default:
				if err := c.Client.Call("RpcServerDriver.Heartbeat", struct{}{}, nil); err != nil {
					log.Warnf("Error attempting heartbeat call to plugin server: %s", err)
					c.Close()
					return
				}
				time.Sleep(heartbeatInterval)
			}
		}
	}(c)

	// サーバのバージョンを確認する
	var version int
	if err := c.Client.Call("RpcServerDriver.GetVersion", struct{}{}, &version); err != nil {
		return nil, err
	}
	log.Debug("Using API Version ", version)

	// プラグイン情報をクライアントに設定する
	if err := c.SetConfigRaw(rawDriverData); err != nil {
		return nil, err
	}

	mcnName = c.GetMachineName()
	p.MachineName = mcnName
	c.Client.MachineName = mcnName
	c.plugin = p

	return c, nil
}

type LocalBinaryExecutor struct {
	pluginStdout, pluginStderr io.ReadCloser
	DriverName                 string
	binaryPath                 string
}

func (lbe *LocalBinaryExecutor) Start() (*bufio.Scanner, *bufio.Scanner, error) {
	var err error

	log.Debugf("Launching plugin server for driver %s", lbe.DriverName)

	// プラグインのプロセスを起動するための exec.Cmd を生成する
	cmd := exec.Command(lbe.binaryPath)

	lbe.pluginStdout, err = cmd.StdoutPipe()
	if err != nil {
		return nil, nil, fmt.Errorf("Error getting cmd stdout pipe: %s", err)
	}

	lbe.pluginStderr, err = cmd.StderrPipe()
	if err != nil {
		return nil, nil, fmt.Errorf("Error getting cmd stderr pipe: %s", err)
	}

	outScanner := bufio.NewScanner(lbe.pluginStdout)
	errScanner := bufio.NewScanner(lbe.pluginStderr)

	// 環境変数 $MACHINE_PLUGIN_TOKEN に 42 を設定する
	os.Setenv(PluginEnvKey, PluginEnvVal)

	// プロセスを起動する
	if err := cmd.Start(); err != nil {
		return nil, nil, fmt.Errorf("Error starting plugin binary: %s", err)
	}

	return outScanner, errScanner, nil
}

const (
	PluginEnvKey = "MACHINE_PLUGIN_TOKEN"
	PluginEnvVal = "42"
)

func (c *RpcClientDriver) Create() error {
	return c.Client.Call("RpcServerDriver.Create", struct{}{}, nil)
}

func (c *RpcClientDriver) Remove() error {
	return c.Client.Call("RpcServerDriver.Remove", struct{}{}, nil)
}

func (c *RpcClientDriver) Start() error {
	return c.Client.Call("RpcServerDriver.Start", struct{}{}, nil)
}

func (c *RpcClientDriver) Stop() error {
	return c.Client.Call("RpcServerDriver.Stop", struct{}{}, nil)
}

// docker-machine-driver-virtualbox の main 関数
func main() {
	plugin.RegisterDriver(virtualbox.NewDriver("", ""))
}

var (
	// heartbeat の猶予時間
	heartbeatTimeout = 500 * time.Millisecond
)

func RegisterDriver(d drivers.Driver) {
	// $MACHINE_PLUGIN_TOKEN != 42 の場合は終了する
	if os.Getenv(localbinary.PluginEnvKey) != localbinary.PluginEnvVal {
		fmt.Fprintln(os.Stderr, `This is a Docker Machine plugin binary.
Plugin binaries are not intended to be invoked directly.
Please use this plugin through the main 'docker-machine' binary.`)
		os.Exit(1)
	}

	libmachine.SetDebug(true)

	// RPC サーバオブジェクトを生成し、登録処理をおこなう
	rpcd := rpcdriver.NewRpcServerDriver(d)
	rpc.Register(rpcd)
	rpc.HandleHTTP()

	// ポート番号ランダムで TCP リスナを生成する
	listener, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error loading RPC server: %s\n", err)
		os.Exit(1)
	}
	defer listener.Close()

	fmt.Println(listener.Addr())

	// リクエストを待ち受ける
	go http.Serve(listener, nil)

	for {
		select {
		case <-rpcd.CloseCh:
			os.Exit(0)
		// heartbeat が送られてきてる間はプロセス継続
		case <-rpcd.HeartbeatCh:
			continue
		// 500ms 以内の間隔で heartbeat が送られてこなければ終了する
		case <-time.After(heartbeatTimeout):
			os.Exit(1)
		}
	}
}

type RpcServerDriver struct {
	ActualDriver drivers.Driver // 実際の処理をおこなう Driver インターフェース
	CloseCh      chan bool
	HeartbeatCh  chan bool
}

func (r *RpcServerDriver) Create(_, _ *struct{}) error {
	return r.ActualDriver.Create()
}

func (r *RpcServerDriver) Remove(_ *struct{}, _ *struct{}) error {
	return r.ActualDriver.Remove()
}

func (r *RpcServerDriver) Start(_ *struct{}, _ *struct{}) error {
	return r.ActualDriver.Start()
}

func (r *RpcServerDriver) Stop(_ *struct{}, _ *struct{}) error {
	return r.ActualDriver.Stop()
}

// Driver defines how a host is created and controlled. Different types of
// driver represent different ways hosts can be created (e.g. different
// hypervisors, different cloud providers)
type Driver interface {
	// Create a host using the driver's config
	Create() error

	// DriverName returns the name of the driver as it is registered
	DriverName() string

	// GetCreateFlags returns the mcnflag.Flag slice representing the flags
	// that can be set, their descriptions and defaults.
	GetCreateFlags() []mcnflag.Flag

	// GetIP returns an IP or hostname that this host is available at
	// e.g. 1.2.3.4 or docker-host-d60b70a14d3a.cloudapp.net
	GetIP() (string, error)

	// GetMachineName returns the name of the machine
	GetMachineName() string

	// GetSSHHostname returns hostname for use with ssh
	GetSSHHostname() (string, error)

	// GetSSHKeyPath returns key path for use with ssh
	GetSSHKeyPath() string

	// GetSSHPort returns port for use with ssh
	GetSSHPort() (int, error)

	// GetSSHUsername returns username for use with ssh
	GetSSHUsername() string

	// GetURL returns a Docker compatible host URL for connecting to this host
	// e.g. tcp://1.2.3.4:2376
	GetURL() (string, error)

	// GetState returns the state that the host is in (running, stopped, etc)
	GetState() (state.State, error)

	// Kill stops a host forcefully
	Kill() error

	// PreCreateCheck allows for pre-create operations to make sure a driver is ready for creation
	PreCreateCheck() error

	// Remove a host
	Remove() error

	// Restart a host. This may just call Stop(); Start() if the provider does not
	// have any special restart behaviour.
	Restart() error

	// SetConfigFromFlags configures the driver with the object that was returned
	// by RegisterCreateFlags
	SetConfigFromFlags(opts DriverOptions) error

	// Start a host
	Start() error

	// Stop a host gracefully
	Stop() error
}

type Driver struct {
	VBoxManager                // vbm(), vbmOut(), vbmOutErr() をもつインターフェース
	*drivers.BaseDriver
	CPU                 int    // デフォルト 1
	Memory              int    // デフォルト 1024 MB
	DiskSize            int    // デフォルト 20000 MB
	Boot2DockerURL      string // Boot2Docker のダウンロード URL
	Boot2DockerImportVM string // Boot2Docker の ISO のパス
	...
	NoShare             bool   // 共有ディレクトリをつくるかどうか
}

func (v *VBoxCmdManager) vbmOutErr(args ...string) (string, string, error) {
	// `VBoxManage args...` コマンドを実行する
	cmd := exec.Command(vboxManageCmd, args...)
	log.Debugf("COMMAND: %v %v", vboxManageCmd, strings.Join(args, " "))
	var stdout bytes.Buffer
	var stderr bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr
	err := cmd.Run()
	...
}

func (d *Driver) Create() error {
	// Boot2Docker の ISO を読み込む
	b2dutils := mcnutils.NewB2dUtils(d.StorePath)
	if err := b2dutils.CopyIsoToMachineDir(d.Boot2DockerURL, d.MachineName); err != nil {
		return err
	}

	// CPU レベルでの仮想化機能が有効化チェックする
	if d.IsVTXDisabled() {
		// Let's log a warning to warn the user. When the vm is started, logs
		// will be checked for an error anyway.
		// We could fail right here but the method to check didn't prove being
		// bulletproof.
		log.Warn("This computer doesn't have VT-X/AMD-v enabled. Enabling it in the BIOS is mandatory.")
	}

	log.Infof("Creating VirtualBox VM...")

	// import b2d VM if requested
	if d.Boot2DockerImportVM != "" {
		name := d.Boot2DockerImportVM

		// make sure vm is stopped
		_ = d.vbm("controlvm", name, "poweroff")

		diskInfo, err := d.getVMDiskInfo()
		if err != nil {
			return err
		}

		if _, err := os.Stat(diskInfo.Path); err != nil {
			return err
		}

		if err := d.vbm("clonehd", diskInfo.Path, d.diskPath()); err != nil {
			return err
		}

		log.Debugf("Importing VM settings...")
		vmInfo, err := d.getVMInfo()
		if err != nil {
			return err
		}

		d.CPU = vmInfo.CPUs
		d.Memory = vmInfo.Memory

		log.Debugf("Importing SSH key...")
		keyPath := filepath.Join(mcnutils.GetHomeDir(), ".ssh", "id_boot2docker")
		if err := mcnutils.CopyFile(keyPath, d.GetSSHKeyPath()); err != nil {
			return err
		}
	} else {
		log.Infof("Creating SSH key...")
		if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil {
			return err
		}

		log.Debugf("Creating disk image...")
		if err := d.generateDiskImage(d.DiskSize); err != nil {
			return err
		}
	}

	// `VBoxManage createvm` コマンドで VM を作成する
	if err := d.vbm("createvm",
		"--basefolder", d.ResolveStorePath("."),
		"--name", d.MachineName,
		"--register"); err != nil {
		return err
	}

	log.Debugf("VM CPUS: %d", d.CPU)
	log.Debugf("VM Memory: %d", d.Memory)

	cpus := d.CPU
	if cpus < 1 {
		cpus = int(runtime.NumCPU())
	}
	if cpus > 32 {
		cpus = 32
	}

	// `VBoxManage modifyvm` コマンドで VM に各種設定を反映させる
	if err := d.vbm("modifyvm", d.MachineName,
		"--firmware", "bios",
		"--bioslogofadein", "off",
		"--bioslogofadeout", "off",
		"--bioslogodisplaytime", "0",
		"--biosbootmenu", "disabled",
		"--ostype", "Linux26_64",
		"--cpus", fmt.Sprintf("%d", cpus),
		"--memory", fmt.Sprintf("%d", d.Memory),
		"--acpi", "on",
		"--ioapic", "on",
		"--rtcuseutc", "on",
		"--natdnshostresolver1", "off",
		"--natdnsproxy1", "off",
		"--cpuhotplug", "off",
		"--pae", "on",
		"--hpet", "on",
		"--hwvirtex", "on",
		"--nestedpaging", "on",
		"--largepages", "on",
		"--vtxvpid", "on",
		"--accelerate3d", "off",
		"--boot1", "dvd"); err != nil {
		return err
	}

	if err := d.vbm("modifyvm", d.MachineName,
		"--nic1", "nat",
		"--nictype1", "82540EM",
		"--cableconnected1", "on"); err != nil {
		return err
	}

	if err := d.setupHostOnlyNetwork(d.MachineName); err != nil {
		return err
	}

	// `VBoxManage storagectl` コマンドでストレージコントローラを付加する
	if err := d.vbm("storagectl", d.MachineName,
		"--name", "SATA",
		"--add", "sata",
		"--hostiocache", "on"); err != nil {
		return err
	}

	// `VBoxManage storageattach` コマンドでストレージを VM にアタッチする
	if err := d.vbm("storageattach", d.MachineName,
		"--storagectl", "SATA",
		"--port", "0",
		"--device", "0",
		"--type", "dvddrive",
		"--medium", d.ResolveStorePath("boot2docker.iso")); err != nil {
		return err
	}

	if err := d.vbm("storageattach", d.MachineName,
		"--storagectl", "SATA",
		"--port", "1",
		"--device", "0",
		"--type", "hdd",
		"--medium", d.diskPath()); err != nil {
		return err
	}

	// let VBoxService do nice magic automounting (when it's used)
	if err := d.vbm("guestproperty", "set", d.MachineName, "/VirtualBox/GuestAdd/SharedFolders/MountPrefix", "/"); err != nil {
		return err
	}
	if err := d.vbm("guestproperty", "set", d.MachineName, "/VirtualBox/GuestAdd/SharedFolders/MountDir", "/"); err != nil {
		return err
	}

	// 共有ディレクトリ名を設定する
	var shareName, shareDir string // TODO configurable at some point
	switch runtime.GOOS {
	case "windows":
		shareName = "c/Users"
		shareDir = "c:\\Users"
	case "darwin":
		shareName = "Users"
		shareDir = "/Users"
		// TODO "linux"
	}

	// 共有ディレクトリをマウントする
	if shareDir != "" && !d.NoShare {
		log.Debugf("setting up shareDir")
		if _, err := os.Stat(shareDir); err != nil && !os.IsNotExist(err) {
			return err
		} else if !os.IsNotExist(err) {
			if shareName == "" {
				// parts of the VBox internal code are buggy with share names that start with "/"
				shareName = strings.TrimLeft(shareDir, "/")
				// TODO do some basic Windows -> MSYS path conversion
				// ie, s!^([a-z]+):[/\\]+!\1/!; s!\\!/!g
			}

			// woo, shareDir exists!  let's carry on!
			if err := d.vbm("sharedfolder", "add", d.MachineName, "--name", shareName, "--hostpath", shareDir, "--automount"); err != nil {
				return err
			}

			// enable symlinks
			if err := d.vbm("setextradata", d.MachineName, "VBoxInternal2/SharedFoldersEnableSymlinksCreate/"+shareName, "1"); err != nil {
				return err
			}
		}
	}

	log.Infof("Starting VirtualBox VM...")

	return d.Start()
}