diff --git a/ch05/binTree.go b/ch05/binTree.go new file mode 100644 index 0000000..1d61b03 --- /dev/null +++ b/ch05/binTree.go @@ -0,0 +1,61 @@ +package main + +import ( + "fmt" + "math/rand" + "time" +) + +type Tree struct { + Left *Tree + Value int + Right *Tree +} + +func traverse(t *Tree) { + if t == nil { + return + } + traverse(t.Left) + fmt.Print(t.Value, " ") + traverse(t.Right) +} + +func create(n int) *Tree { + var t *Tree + rand.Seed(time.Now().Unix()) + for i := 0; i < 2*n; i++ { + temp := rand.Intn(n * 2) + t = insert(t, temp) + } + return t +} + +func insert(t *Tree, v int) *Tree { + if t == nil { + return &Tree{nil, v, nil} + } + + if v == t.Value { + return t + } + + if v < t.Value { + t.Left = insert(t.Left, v) + return t + } + t.Right = insert(t.Right, v) + return t +} + +func main() { + tree := create(10) + fmt.Println("The value of the root of the tree is", tree.Value) + traverse(tree) + fmt.Println() + tree = insert(tree, -10) + tree = insert(tree, -2) + traverse(tree) + fmt.Println() + fmt.Println("The value of the root of the tree is", tree.Value) +} diff --git a/ch05/conHeap.go b/ch05/conHeap.go new file mode 100644 index 0000000..6580c12 --- /dev/null +++ b/ch05/conHeap.go @@ -0,0 +1,46 @@ +package main + +import ( + "container/heap" + "fmt" +) + +type heapFloat32 []float32 + +func (n *heapFloat32) Pop() interface{} { + old := *n + x := old[len(old)-1] + new := old[0 : len(old)-1] + *n = new + return x +} + +func (n *heapFloat32) Push(x interface{}) { + *n = append(*n, x.(float32)) +} + +func (n heapFloat32) Len() int { + return len(n) +} + +func (n heapFloat32) Less(a, b int) bool { + return n[a] < n[b] +} + +func (n heapFloat32) Swap(a, b int) { + n[a], n[b] = n[b], n[a] +} + +func main() { + myHeap := &heapFloat32{1.2, 2.1, 3.1, -100.1} + heap.Init(myHeap) + size := len(*myHeap) + fmt.Printf("Heap size: %d\n", size) + fmt.Printf("%v\n", myHeap) + myHeap.Push(float32(-100.2)) + myHeap.Push(float32(0.2)) + fmt.Printf("Heap size: %d\n", len(*myHeap)) + fmt.Printf("%v\n", myHeap) + heap.Init(myHeap) + fmt.Printf("%v\n", myHeap) +} diff --git a/ch05/conList.go b/ch05/conList.go new file mode 100644 index 0000000..97a84fa --- /dev/null +++ b/ch05/conList.go @@ -0,0 +1,46 @@ +package main + +import ( + "container/list" + "fmt" + "strconv" +) + +func printList(l *list.List) { + for t := l.Back(); t != nil; t = t.Prev() { + fmt.Print(t.Value, " ") + } + fmt.Println() + + for t := l.Front(); t != nil; t = t.Next() { + fmt.Print(t.Value, " ") + } + + fmt.Println() +} + +func main() { + + values := list.New() + + e1 := values.PushBack("One") + e2 := values.PushBack("Two") + values.PushFront("Three") + values.InsertBefore("Four", e1) + values.InsertAfter("Five", e2) + values.Remove(e2) + values.Remove(e2) + values.InsertAfter("FiveFive", e2) + values.PushBackList(values) + + printList(values) + + values.Init() + fmt.Printf("After Init(): %v\n", values) + + for i := 0; i < 20; i++ { + values.PushFront(strconv.Itoa(i)) + } + + printList(values) +} diff --git a/ch05/conRing.go b/ch05/conRing.go new file mode 100644 index 0000000..d404778 --- /dev/null +++ b/ch05/conRing.go @@ -0,0 +1,33 @@ +package main + +import ( + "container/ring" + "fmt" +) + +var size int = 10 + +func main() { + myRing := ring.New(size + 1) + fmt.Println("Empty ring:", *myRing) + + for i := 0; i < myRing.Len()-1; i++ { + myRing.Value = i + myRing = myRing.Next() + } + + myRing.Value = 2 + + sum := 0 + myRing.Do(func(x interface{}) { + t := x.(int) + sum = sum + t + }) + fmt.Println("Sum:", sum) + + for i := 0; i < myRing.Len()+2; i++ { + myRing = myRing.Next() + fmt.Print(myRing.Value, " ") + } + fmt.Println() +} diff --git a/ch05/doublyLList.go b/ch05/doublyLList.go new file mode 100644 index 0000000..898ea94 --- /dev/null +++ b/ch05/doublyLList.go @@ -0,0 +1,115 @@ +package main + +import ( + "fmt" +) + +type Node struct { + Value int + Previous *Node + Next *Node +} + +func addNode(t *Node, v int) int { + if root == nil { + t = &Node{v, nil, nil} + root = t + return 0 + } + + if v == t.Value { + fmt.Println("Node already exists:", v) + return -1 + } + + if t.Next == nil { + temp := t + t.Next = &Node{v, temp, nil} + return -2 + } + + return addNode(t.Next, v) +} + +func traverse(t *Node) { + if t == nil { + fmt.Println("-> Empty list!") + return + } + + for t != nil { + fmt.Printf("%d -> ", t.Value) + t = t.Next + } + fmt.Println() +} + +func reverse(t *Node) { + if t == nil { + fmt.Println("-> Empty list!") + return + } + + temp := t + for t != nil { + temp = t + t = t.Next + } + + for temp.Previous != nil { + fmt.Printf("%d -> ", temp.Value) + temp = temp.Previous + } + fmt.Printf("%d -> ", temp.Value) + fmt.Println() +} + +func size(t *Node) int { + if t == nil { + fmt.Println("-> Empty list!") + return 0 + } + + n := 0 + for t != nil { + n++ + t = t.Next + } + return n +} + +func lookupNode(t *Node, v int) bool { + if root == nil { + return false + } + + if v == t.Value { + return true + } + + if t.Next == nil { + return false + } + + return lookupNode(t.Next, v) +} + +var root = new(Node) + +func main() { + fmt.Println(root) + root = nil + traverse(root) + addNode(root, 1) + addNode(root, 1) + traverse(root) + addNode(root, 10) + addNode(root, 5) + addNode(root, 0) + addNode(root, 0) + traverse(root) + addNode(root, 100) + fmt.Println("Size:", size(root)) + traverse(root) + reverse(root) +} diff --git a/ch05/generatePassword.go b/ch05/generatePassword.go new file mode 100644 index 0000000..251488c --- /dev/null +++ b/ch05/generatePassword.go @@ -0,0 +1,43 @@ +package main + +import ( + "fmt" + "math/rand" + "os" + "strconv" + "time" +) + +func random(min, max int) int { + return rand.Intn(max-min) + min +} + +func main() { + MIN := 0 + MAX := 94 + SEED := time.Now().Unix() + var LENGTH int64 = 8 + + arguments := os.Args + switch len(arguments) { + case 2: + LENGTH, _ = strconv.ParseInt(os.Args[1], 10, 64) + default: + fmt.Println("Using default values!") + } + + rand.Seed(SEED) + + startChar := "!" + var i int64 = 1 + for { + myRand := random(MIN, MAX) + newChar := string(startChar[0] + byte(myRand)) + fmt.Print(newChar) + if i == LENGTH { + break + } + i++ + } + fmt.Println() +} diff --git a/ch05/hashTable.go b/ch05/hashTable.go new file mode 100644 index 0000000..a004036 --- /dev/null +++ b/ch05/hashTable.go @@ -0,0 +1,51 @@ +package main + +import ( + "fmt" +) + +const SIZE = 15 + +type Node struct { + Value int + Next *Node +} + +type HashTable struct { + Table map[int]*Node + Size int +} + +func hashFunction(i, size int) int { + return (i % size) +} + +func insert(hash *HashTable, value int) int { + index := hashFunction(value, hash.Size) + element := Node{Value: value, Next: hash.Table[index]} + hash.Table[index] = &element + return index +} + +func traverse(hash *HashTable) { + for k := range hash.Table { + if hash.Table[k] != nil { + t := hash.Table[k] + for t != nil { + fmt.Printf("%d -> ", t.Value) + t = t.Next + } + fmt.Println() + } + } +} + +func main() { + table := make(map[int]*Node, SIZE) + hash := &HashTable{Table: table, Size: SIZE} + fmt.Println("Number of spaces:", hash.Size) + for i := 0; i < 120; i++ { + insert(hash, i) + } + traverse(hash) +} diff --git a/ch05/hashTableLookup.go b/ch05/hashTableLookup.go new file mode 100644 index 0000000..944fda2 --- /dev/null +++ b/ch05/hashTableLookup.go @@ -0,0 +1,69 @@ +package main + +import ( + "fmt" +) + +const SIZE = 15 + +type Node struct { + Value int + Next *Node +} + +type HashTable struct { + Table map[int]*Node + Size int +} + +func hashFunction(i, size int) int { + return (i % size) +} + +func insert(hash *HashTable, value int) int { + index := hashFunction(value, hash.Size) + element := Node{Value: value, Next: hash.Table[index]} + hash.Table[index] = &element + return index +} + +func traverse(hash *HashTable) { + for k := range hash.Table { + if hash.Table[k] != nil { + t := hash.Table[k] + for t != nil { + fmt.Printf("%d -> ", t.Value) + t = t.Next + } + fmt.Println() + } + } +} + +func lookup(hash *HashTable, value int) bool { + index := hashFunction(value, hash.Size) + if hash.Table[index] != nil { + t := hash.Table[index] + for t != nil { + if t.Value == value { + return true + } + t = t.Next + } + } + return false +} + +func main() { + table := make(map[int]*Node, SIZE) + hash := &HashTable{Table: table, Size: SIZE} + for i := 0; i < 120; i++ { + insert(hash, i) + } + + for i := 10; i < 125; i++ { + if !lookup(hash, i) { + fmt.Println(i, "is not in the hash table!") + } + } +} diff --git a/ch05/linkedList.go b/ch05/linkedList.go new file mode 100644 index 0000000..f8a3a19 --- /dev/null +++ b/ch05/linkedList.go @@ -0,0 +1,106 @@ +package main + +import ( + "fmt" +) + +type Node struct { + Value int + Next *Node +} + +var root = new(Node) + +func addNode(t *Node, v int) int { + if root == nil { + t = &Node{v, nil} + root = t + return 0 + } + + if v == t.Value { + fmt.Println("Node already exists:", v) + return -1 + } + + if t.Next == nil { + t.Next = &Node{v, nil} + return -2 + } + + return addNode(t.Next, v) +} + +func traverse(t *Node) { + if t == nil { + fmt.Println("-> Empty list!") + return + } + + for t != nil { + fmt.Printf("%d -> ", t.Value) + t = t.Next + } + fmt.Println() +} + +func lookupNode(t *Node, v int) bool { + if root == nil { + t = &Node{v, nil} + root = t + return false + } + + if v == t.Value { + return true + } + + if t.Next == nil { + return false + } + + return lookupNode(t.Next, v) +} + +func size(t *Node) int { + if t == nil { + fmt.Println("-> Empty list!") + return 0 + } + + i := 0 + for t != nil { + i++ + t = t.Next + } + return i +} + +func main() { + fmt.Println(root) + root = nil + traverse(root) + addNode(root, 1) + addNode(root, -1) + traverse(root) + addNode(root, 10) + addNode(root, 5) + addNode(root, 45) + addNode(root, 5) + addNode(root, 5) + traverse(root) + addNode(root, 100) + traverse(root) + + if lookupNode(root, 100) { + fmt.Println("Node exists!") + } else { + fmt.Println("Node does not exist!") + } + + if lookupNode(root, -100) { + fmt.Println("Node exists!") + } else { + fmt.Println("Node does not exist!") + } +} diff --git a/ch05/queue.go b/ch05/queue.go new file mode 100644 index 0000000..074887f --- /dev/null +++ b/ch05/queue.go @@ -0,0 +1,97 @@ +package main + +import ( + "fmt" +) + +type Node struct { + Value int + Next *Node +} + +var size = 0 +var queue = new(Node) + +func Push(t *Node, v int) bool { + if queue == nil { + queue = &Node{v, nil} + size++ + return true + } + + t = &Node{v, nil} + t.Next = queue + queue = t + size++ + + return true +} + +func Pop(t *Node) (int, bool) { + if size == 0 { + return 0, false + } + + if size == 1 { + queue = nil + size-- + return t.Value, true + } + + temp := t + for (t.Next) != nil { + temp = t + t = t.Next + } + + v := (temp.Next).Value + temp.Next = nil + + size-- + return v, true +} + +func traverse(t *Node) { + if size == 0 { + fmt.Println("Empty Queue!") + return + } + + for t != nil { + fmt.Printf("%d -> ", t.Value) + t = t.Next + } + fmt.Println() +} + +func main() { + queue = nil + Push(queue, 10) + fmt.Println("Size:", size) + traverse(queue) + + v, b := Pop(queue) + if b { + fmt.Println("Pop:", v) + } + fmt.Println("Size:", size) + + for i := 0; i < 5; i++ { + Push(queue, i) + } + traverse(queue) + fmt.Println("Size:", size) + + v, b = Pop(queue) + if b { + fmt.Println("Pop:", v) + } + fmt.Println("Size:", size) + + v, b = Pop(queue) + if b { + fmt.Println("Pop:", v) + } + fmt.Println("Size:", size) + traverse(queue) +} diff --git a/ch05/randomNumbers.go b/ch05/randomNumbers.go new file mode 100644 index 0000000..0c2d349 --- /dev/null +++ b/ch05/randomNumbers.go @@ -0,0 +1,52 @@ +package main + +import ( + "fmt" + "math/rand" + "os" + "strconv" + "time" +) + +func random(min, max int) int { + return rand.Intn(max-min) + min +} + +func main() { + MIN := 0 + MAX := 100 + TOTAL := 100 + SEED := time.Now().Unix() + + arguments := os.Args + switch len(arguments) { + case 2: + fmt.Println("Usage: ./randomNumbers MIN MAX TOTAL SEED") + MIN, _ = strconv.Atoi(arguments[1]) + MAX = MIN + 100 + case 3: + fmt.Println("Usage: ./randomNumbers MIN MAX TOTAL SEED") + MIN, _ = strconv.Atoi(arguments[1]) + MAX, _ = strconv.Atoi(arguments[2]) + case 4: + fmt.Println("Usage: ./randomNumbers MIN MAX TOTAL SEED") + MIN, _ = strconv.Atoi(arguments[1]) + MAX, _ = strconv.Atoi(arguments[2]) + TOTAL, _ = strconv.Atoi(arguments[3]) + case 5: + MIN, _ = strconv.Atoi(arguments[1]) + MAX, _ = strconv.Atoi(arguments[2]) + TOTAL, _ = strconv.Atoi(arguments[3]) + SEED, _ = strconv.ParseInt(arguments[4], 10, 64) + default: + fmt.Println("Using default values!") + } + + rand.Seed(SEED) + for i := 0; i < TOTAL; i++ { + myrand := random(MIN, MAX) + fmt.Print(myrand) + fmt.Print(" ") + } + fmt.Println() +} diff --git a/ch05/stack.go b/ch05/stack.go new file mode 100644 index 0000000..8fa4ae0 --- /dev/null +++ b/ch05/stack.go @@ -0,0 +1,87 @@ +package main + +import ( + "fmt" +) + +type Node struct { + Value int + Next *Node +} + +var size = 0 +var stack = new(Node) + +func Push(v int) bool { + if stack == nil { + stack = &Node{v, nil} + size = 1 + return true + } + + temp := &Node{v, nil} + temp.Next = stack + stack = temp + size++ + return true +} + +func Pop(t *Node) (int, bool) { + if size == 0 { + return 0, false + } + + if size == 1 { + size = 0 + stack = nil + return t.Value, true + } + + stack = stack.Next + size-- + return t.Value, true +} + +func traverse(t *Node) { + if size == 0 { + fmt.Println("Empty Stack!") + return + } + + for t != nil { + fmt.Printf("%d -> ", t.Value) + t = t.Next + } + fmt.Println() +} + +func main() { + + stack = nil + v, b := Pop(stack) + if b { + fmt.Print(v, " ") + } else { + fmt.Println("Pop() failed!") + } + + Push(100) + traverse(stack) + Push(200) + traverse(stack) + + for i := 0; i < 10; i++ { + Push(i) + } + + for i := 0; i < 15; i++ { + v, b := Pop(stack) + if b { + fmt.Print(v, " ") + } else { + break + } + } + fmt.Println() + traverse(stack) +} diff --git a/ch06/a.go b/ch06/a.go new file mode 100644 index 0000000..5022e56 --- /dev/null +++ b/ch06/a.go @@ -0,0 +1,13 @@ +package a + +import ( + "fmt" +) + +func init() { + fmt.Println("init() a") +} + +func FromA() { + fmt.Println("fromA()") +} diff --git a/ch06/aPackage.go b/ch06/aPackage.go new file mode 100644 index 0000000..74de426 --- /dev/null +++ b/ch06/aPackage.go @@ -0,0 +1,16 @@ +package aPackage + +import ( + "fmt" +) + +func A() { + fmt.Println("This is function A!") +} + +func B() { + fmt.Println("privateConstant:", privateConstant) +} + +const MyConstant = 123 +const privateConstant = 21 diff --git a/ch06/b.go b/ch06/b.go new file mode 100644 index 0000000..37f2b9a --- /dev/null +++ b/ch06/b.go @@ -0,0 +1,15 @@ +package b + +import ( + "a" + "fmt" +) + +func init() { + fmt.Println("init() b") +} + +func FromB() { + fmt.Println("fromB()") + a.FromA() +} diff --git a/ch06/funFun.go b/ch06/funFun.go new file mode 100644 index 0000000..9db0558 --- /dev/null +++ b/ch06/funFun.go @@ -0,0 +1,21 @@ +package main + +import "fmt" + +func function1(i int) int { + return i + i +} + +func function2(i int) int { + return i * i +} + +func funFun(f func(int) int, v int) int { + return f(v) +} + +func main() { + fmt.Println("function1:", funFun(function1, 123)) + fmt.Println("function2:", funFun(function2, 123)) + fmt.Println("Inline", funFun(func(i int) int { return i * i * i }, 123)) +} diff --git a/ch06/functions.go b/ch06/functions.go new file mode 100644 index 0000000..9465377 --- /dev/null +++ b/ch06/functions.go @@ -0,0 +1,39 @@ +package main + +import ( + "fmt" + "os" + "strconv" +) + +func doubleSquare(x int) (int, int) { + return x * 2, x * x +} + +func main() { + arguments := os.Args + if len(arguments) != 2 { + fmt.Println("The program needs 1 argument!") + return + } + + y, err := strconv.Atoi(arguments[1]) + if err != nil { + fmt.Println(err) + return + } + + square := func(s int) int { + return s * s + } + fmt.Println("The square of", y, "is", square(y)) + + double := func(s int) int { + return s + s + } + fmt.Println("The double of", y, "is", double(y)) + + fmt.Println(doubleSquare(y)) + d, s := doubleSquare(y) + fmt.Println(d, s) +} diff --git a/ch06/html.gohtml b/ch06/html.gohtml new file mode 100644 index 0000000..048018b --- /dev/null +++ b/ch06/html.gohtml @@ -0,0 +1,38 @@ + + +
+ +| Number | +Double | +Square | +
|---|---|---|
| {{ .Number }} | +{{ .Double }} | +{{ .Square }} | +
}", color="gray" ];
+ node2 [label = "{ }" ];
+ node3 [label = "{ }" ];
+ node4 [label = "{ }" ];
+ node5 [label = "{ }" ];
+ node6 [label = "{ }" ];
+ node7 [label = "{ }" ];
+
+ node0:p0 -> node1:e [dir=both color="red:blue"];
+ node0:p1 -> node2:e [dir=back arrowhead=diamond];
+ node2:p -> node3:e;
+ node3:p -> node4:e [dir=both arrowtail=box color="red"];
+ node4:p -> node5:e [dir=forward];
+ node0:p2 -> node6:e [dir=none color="orange"];
+ node0:p4 -> node7:e;
+}
diff --git a/ch11/profileMe.go b/ch11/profileMe.go
new file mode 100644
index 0000000..ee4c55f
--- /dev/null
+++ b/ch11/profileMe.go
@@ -0,0 +1,116 @@
+package main
+
+import (
+ "fmt"
+ "math"
+ "os"
+ "runtime"
+ "runtime/pprof"
+ "time"
+)
+
+func fibo1(n int) int64 {
+ if n == 0 || n == 1 {
+ return int64(n)
+ }
+ time.Sleep(time.Millisecond)
+ return int64(fibo2(n-1)) + int64(fibo2(n-2))
+}
+
+func fibo2(n int) int {
+ fn := make(map[int]int)
+ for i := 0; i <= n; i++ {
+ var f int
+ if i <= 2 {
+ f = 1
+ } else {
+ f = fn[i-1] + fn[i-2]
+ }
+ fn[i] = f
+ }
+ time.Sleep(50 * time.Millisecond)
+ return fn[n]
+}
+
+func N1(n int) bool {
+ k := math.Floor(float64(n/2 + 1))
+ for i := 2; i < int(k); i++ {
+ if (n % i) == 0 {
+ return false
+ }
+ }
+ return true
+}
+
+func N2(n int) bool {
+ for i := 2; i < n; i++ {
+ if (n % i) == 0 {
+ return false
+ }
+ }
+ return true
+}
+
+func main() {
+ cpuFile, err := os.Create("/tmp/cpuProfile.out")
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ pprof.StartCPUProfile(cpuFile)
+ defer pprof.StopCPUProfile()
+
+ total := 0
+ for i := 2; i < 100000; i++ {
+ n := N1(i)
+ if n {
+ total = total + 1
+ }
+ }
+ fmt.Println("Total primes:", total)
+
+ total = 0
+ for i := 2; i < 100000; i++ {
+ n := N2(i)
+ if n {
+ total = total + 1
+ }
+ }
+ fmt.Println("Total primes:", total)
+
+ for i := 1; i < 90; i++ {
+ n := fibo1(i)
+ fmt.Print(n, " ")
+ }
+ fmt.Println()
+
+ for i := 1; i < 90; i++ {
+ n := fibo2(i)
+ fmt.Print(n, " ")
+ }
+ fmt.Println()
+
+ runtime.GC()
+
+ // Memory profiling!
+ memory, err := os.Create("/tmp/memoryProfile.out")
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ defer memory.Close()
+
+ for i := 0; i < 10; i++ {
+ s := make([]byte, 50000000)
+ if s == nil {
+ fmt.Println("Operation failed!")
+ }
+ time.Sleep(50 * time.Millisecond)
+ }
+
+ err = pprof.WriteHeapProfile(memory)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+}
diff --git a/ch11/testMe.go b/ch11/testMe.go
new file mode 100644
index 0000000..f9d73df
--- /dev/null
+++ b/ch11/testMe.go
@@ -0,0 +1,37 @@
+package testMe
+
+func f1(n int) int {
+ if n == 0 {
+ return 0
+ }
+ if n == 1 {
+ return 1
+ }
+ return f1(n-1) + f1(n-2)
+}
+
+func f2(n int) int {
+ if n == 0 {
+ return 0
+ }
+ if n == 1 {
+ return 2
+ }
+
+ return f2(n-1) + f2(n-2)
+}
+
+func s1(s string) int {
+ if s == "" {
+ return 0
+ }
+ n := 1
+ for range s {
+ n++
+ }
+ return n
+}
+
+func s2(s string) int {
+ return len(s)
+}
diff --git a/ch11/testMe_test.go b/ch11/testMe_test.go
new file mode 100644
index 0000000..04c1772
--- /dev/null
+++ b/ch11/testMe_test.go
@@ -0,0 +1,60 @@
+package testMe
+
+import "testing"
+
+func TestS1(t *testing.T) {
+ if s1("123456789") != 9 {
+ t.Error(`s1("123456789") != 9`)
+ }
+
+ if s1("") != 0 {
+ t.Error(`s1("") != 0`)
+ }
+}
+
+func TestS2(t *testing.T) {
+ if s2("123456789") != 9 {
+ t.Error(`s2("123456789") != 9`)
+ }
+
+ if s2("") != 0 {
+ t.Error(`s2("") != 0`)
+ }
+}
+
+func TestF1(t *testing.T) {
+ if f1(0) != 0 {
+ t.Error(`f1(0) != 0`)
+ }
+
+ if f1(1) != 1 {
+ t.Error(`f1(1) != 1`)
+ }
+
+ if f1(2) != 1 {
+ t.Error(`f1(2) != 1`)
+ }
+
+ if f1(10) != 55 {
+ t.Error(`f1(10) != 55`)
+ }
+
+}
+
+func TestF2(t *testing.T) {
+ if f2(0) != 0 {
+ t.Error(`f2(0) != 0`)
+ }
+
+ if f2(1) != 1 {
+ t.Error(`f2(1) != 1`)
+ }
+
+ if f2(2) != 1 {
+ t.Error(`f2(2) != 1`)
+ }
+
+ if f2(10) != 55 {
+ t.Error(`f2(10) != 55`)
+ }
+}
diff --git a/ch11/writingBU.go b/ch11/writingBU.go
new file mode 100644
index 0000000..4d20a5d
--- /dev/null
+++ b/ch11/writingBU.go
@@ -0,0 +1,82 @@
+package main
+
+import (
+ "fmt"
+ "math/rand"
+ "os"
+ "strconv"
+)
+
+var BUFFERSIZE int
+var FILESIZE int
+
+func random(min, max int) int {
+ return rand.Intn(max-min) + min
+}
+
+func createBuffer(buf *[]byte, count int) {
+ *buf = make([]byte, count)
+ if count == 0 {
+ return
+ }
+
+ for i := 0; i < count; i++ {
+ intByte := byte(random(0, 100))
+ if len(*buf) > count {
+ return
+ }
+ *buf = append(*buf, intByte)
+ }
+}
+
+func Create(dst string, b, f int) error {
+ _, err := os.Stat(dst)
+ if err == nil {
+ return fmt.Errorf("File %s already exists.", dst)
+ }
+
+ destination, err := os.Create(dst)
+ if err != nil {
+ return err
+ }
+ defer destination.Close()
+
+ if err != nil {
+ panic(err)
+ }
+
+ buf := make([]byte, 0)
+ for {
+ createBuffer(&buf, b)
+ buf = buf[:b]
+ if _, err := destination.Write(buf); err != nil {
+ return err
+ }
+
+ if f < 0 {
+ break
+ }
+ f = f - len(buf)
+ }
+ return err
+}
+
+func main() {
+ if len(os.Args) != 3 {
+ fmt.Println("Need BUFFERSIZE FILESIZE!")
+ return
+ }
+
+ output := "/tmp/randomFile"
+ BUFFERSIZE, _ = strconv.Atoi(os.Args[1])
+ FILESIZE, _ = strconv.Atoi(os.Args[2])
+ err := Create(output, BUFFERSIZE, FILESIZE)
+ if err != nil {
+ fmt.Println(err)
+ }
+
+ err = os.Remove(output)
+ if err != nil {
+ fmt.Println(err)
+ }
+}
diff --git a/ch11/writingBU_test.go b/ch11/writingBU_test.go
new file mode 100644
index 0000000..531fe50
--- /dev/null
+++ b/ch11/writingBU_test.go
@@ -0,0 +1,42 @@
+package main
+
+import (
+ "fmt"
+ "os"
+ "testing"
+)
+
+var ERR error
+
+func benchmarkCreate(b *testing.B, buffer, filesize int) {
+ var err error
+ for i := 0; i < b.N; i++ {
+ err = Create("/tmp/random", buffer, filesize)
+ }
+ ERR = err
+
+ err = os.Remove("/tmp/random")
+ if err != nil {
+ fmt.Println(err)
+ }
+}
+
+func Benchmark1Create(b *testing.B) {
+ benchmarkCreate(b, 1, 1000000)
+}
+
+func Benchmark2Create(b *testing.B) {
+ benchmarkCreate(b, 2, 1000000)
+}
+
+func Benchmark4Create(b *testing.B) {
+ benchmarkCreate(b, 4, 1000000)
+}
+
+func Benchmark10Create(b *testing.B) {
+ benchmarkCreate(b, 10, 1000000)
+}
+
+func Benchmark1000Create(b *testing.B) {
+ benchmarkCreate(b, 1000, 1000000)
+}
diff --git a/ch11/xCompile.go b/ch11/xCompile.go
new file mode 100644
index 0000000..9f3a913
--- /dev/null
+++ b/ch11/xCompile.go
@@ -0,0 +1,12 @@
+package main
+
+import (
+ "fmt"
+ "runtime"
+)
+
+func main() {
+ fmt.Print("You are using ", runtime.Compiler, " ")
+ fmt.Println("on a", runtime.GOARCH, "machine")
+ fmt.Println("with Go version", runtime.Version())
+}
diff --git a/ch12/DNS.go b/ch12/DNS.go
new file mode 100644
index 0000000..e5f439f
--- /dev/null
+++ b/ch12/DNS.go
@@ -0,0 +1,50 @@
+package main
+
+import (
+ "fmt"
+ "net"
+ "os"
+)
+
+func lookIP(address string) ([]string, error) {
+ hosts, err := net.LookupAddr(address)
+ if err != nil {
+ return nil, err
+ }
+ return hosts, nil
+}
+
+func lookHostname(hostname string) ([]string, error) {
+ IPs, err := net.LookupHost(hostname)
+ if err != nil {
+ return nil, err
+ }
+ return IPs, nil
+}
+
+func main() {
+ arguments := os.Args
+ if len(arguments) == 1 {
+ fmt.Println("Please provide an argument!")
+ return
+ }
+
+ input := arguments[1]
+ IPaddress := net.ParseIP(input)
+
+ if IPaddress == nil {
+ IPs, err := lookHostname(input)
+ if err == nil {
+ for _, singleIP := range IPs {
+ fmt.Println(singleIP)
+ }
+ }
+ } else {
+ hosts, err := lookIP(input)
+ if err == nil {
+ for _, hostname := range hosts {
+ fmt.Println(hostname)
+ }
+ }
+ }
+}
diff --git a/ch12/MXrecords.go b/ch12/MXrecords.go
new file mode 100644
index 0000000..74d4070
--- /dev/null
+++ b/ch12/MXrecords.go
@@ -0,0 +1,26 @@
+package main
+
+import (
+ "fmt"
+ "net"
+ "os"
+)
+
+func main() {
+ arguments := os.Args
+ if len(arguments) == 1 {
+ fmt.Println("Need a domain name!")
+ return
+ }
+
+ domain := arguments[1]
+ MXs, err := net.LookupMX(domain)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ for _, MX := range MXs {
+ fmt.Println(MX.Host)
+ }
+}
diff --git a/ch12/NSrecords.go b/ch12/NSrecords.go
new file mode 100644
index 0000000..543c36c
--- /dev/null
+++ b/ch12/NSrecords.go
@@ -0,0 +1,26 @@
+package main
+
+import (
+ "fmt"
+ "net"
+ "os"
+)
+
+func main() {
+ arguments := os.Args
+ if len(arguments) == 1 {
+ fmt.Println("Need a domain name!")
+ return
+ }
+
+ domain := arguments[1]
+ NSs, err := net.LookupNS(domain)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ for _, NS := range NSs {
+ fmt.Println(NS.Host)
+ }
+}
diff --git a/ch12/advancedWebClient.go b/ch12/advancedWebClient.go
new file mode 100644
index 0000000..9a7d113
--- /dev/null
+++ b/ch12/advancedWebClient.go
@@ -0,0 +1,69 @@
+package main
+
+import (
+ "fmt"
+ "net/http"
+ "net/http/httputil"
+ "net/url"
+ "os"
+ "path/filepath"
+ "strings"
+ "time"
+)
+
+func main() {
+ if len(os.Args) != 2 {
+ fmt.Printf("Usage: %s URL\n", filepath.Base(os.Args[0]))
+ return
+ }
+
+ URL, err := url.Parse(os.Args[1])
+ if err != nil {
+ fmt.Println("Error in parsing:", err)
+ return
+ }
+
+ c := &http.Client{
+ Timeout: 15 * time.Second,
+ }
+ request, err := http.NewRequest("GET", URL.String(), nil)
+ if err != nil {
+ fmt.Println("Get:", err)
+ return
+ }
+
+ httpData, err := c.Do(request)
+ if err != nil {
+ fmt.Println("Error in Do():", err)
+ return
+ }
+
+ fmt.Println("Status code:", httpData.Status)
+ header, _ := httputil.DumpResponse(httpData, false)
+ fmt.Print(string(header))
+
+ contentType := httpData.Header.Get("Content-Type")
+ characterSet := strings.SplitAfter(contentType, "charset=")
+ if len(characterSet) > 1 {
+ fmt.Println("Character Set:", characterSet[1])
+ }
+
+ if httpData.ContentLength == -1 {
+ fmt.Println("ContentLength is unknown!")
+ } else {
+ fmt.Println("ContentLength:", httpData.ContentLength)
+ }
+
+ length := 0
+ var buffer [1024]byte
+ r := httpData.Body
+ for {
+ n, err := r.Read(buffer[0:])
+ if err != nil {
+ fmt.Println(err)
+ break
+ }
+ length = length + n
+ }
+ fmt.Println("Calculated response data length:", length)
+}
diff --git a/ch12/anotherTimeOut.go b/ch12/anotherTimeOut.go
new file mode 100644
index 0000000..beccb1c
--- /dev/null
+++ b/ch12/anotherTimeOut.go
@@ -0,0 +1,48 @@
+package main
+
+import (
+ "fmt"
+ "io"
+ "net/http"
+ "os"
+ "strconv"
+ "time"
+)
+
+var timeout = time.Duration(time.Second)
+
+func main() {
+ if len(os.Args) == 1 {
+ fmt.Println("Please provide a URL")
+ return
+ }
+
+ if len(os.Args) == 3 {
+ temp, err := strconv.Atoi(os.Args[2])
+ if err != nil {
+ fmt.Println("Using Default Timeout!")
+ } else {
+ timeout = time.Duration(time.Duration(temp) * time.Second)
+ }
+ }
+
+ URL := os.Args[1]
+
+ client := http.Client{
+ Timeout: timeout,
+ }
+ client.Get(URL)
+
+ data, err := client.Get(URL)
+ if err != nil {
+ fmt.Println(err)
+ return
+ } else {
+ defer data.Body.Close()
+ _, err := io.Copy(os.Stdout, data.Body)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ }
+}
diff --git a/ch12/clientTimeOut.go b/ch12/clientTimeOut.go
new file mode 100644
index 0000000..8c1af06
--- /dev/null
+++ b/ch12/clientTimeOut.go
@@ -0,0 +1,61 @@
+package main
+
+import (
+ "fmt"
+ "io"
+ "net"
+ "net/http"
+ "os"
+ "path/filepath"
+ "strconv"
+ "time"
+)
+
+var timeout = time.Duration(time.Second)
+
+func Timeout(network, host string) (net.Conn, error) {
+ conn, err := net.DialTimeout(network, host, timeout)
+ if err != nil {
+ return nil, err
+ }
+ conn.SetDeadline(time.Now().Add(timeout))
+ return conn, nil
+}
+
+func main() {
+ if len(os.Args) == 1 {
+ fmt.Printf("Usage: %s URL TIMEOUT\n", filepath.Base(os.Args[0]))
+ return
+ }
+
+ if len(os.Args) == 3 {
+ temp, err := strconv.Atoi(os.Args[2])
+ if err != nil {
+ fmt.Println("Using Default Timeout!")
+ } else {
+ timeout = time.Duration(time.Duration(temp) * time.Second)
+ }
+ }
+
+ URL := os.Args[1]
+ t := http.Transport{
+ Dial: Timeout,
+ }
+
+ client := http.Client{
+ Transport: &t,
+ }
+
+ data, err := client.Get(URL)
+ if err != nil {
+ fmt.Println(err)
+ return
+ } else {
+ defer data.Body.Close()
+ _, err := io.Copy(os.Stdout, data.Body)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ }
+}
diff --git a/ch12/home.gohtml b/ch12/home.gohtml
new file mode 100644
index 0000000..052e2d4
--- /dev/null
+++ b/ch12/home.gohtml
@@ -0,0 +1,17 @@
+
+
+Welcome to the Go KV store!
+
+
+
diff --git a/ch12/httpTrace.go b/ch12/httpTrace.go
new file mode 100644
index 0000000..014335f
--- /dev/null
+++ b/ch12/httpTrace.go
@@ -0,0 +1,57 @@
+package main
+
+import (
+ "fmt"
+ "io"
+ "net/http"
+ "net/http/httptrace"
+ "os"
+)
+
+func main() {
+ if len(os.Args) != 2 {
+ fmt.Printf("Usage: URL\n")
+ return
+ }
+
+ URL := os.Args[1]
+ client := http.Client{}
+
+ req, _ := http.NewRequest("GET", URL, nil)
+ trace := &httptrace.ClientTrace{
+ GotFirstResponseByte: func() {
+ fmt.Println("First response byte!")
+ },
+ GotConn: func(connInfo httptrace.GotConnInfo) {
+ fmt.Printf("Got Conn: %+v\n", connInfo)
+ },
+ DNSDone: func(dnsInfo httptrace.DNSDoneInfo) {
+ fmt.Printf("DNS Info: %+v\n", dnsInfo)
+ },
+ ConnectStart: func(network, addr string) {
+ fmt.Println("Dial start")
+ },
+ ConnectDone: func(network, addr string, err error) {
+ fmt.Println("Dial done")
+ },
+ WroteHeaders: func() {
+ fmt.Println("Wrote headers")
+ },
+ }
+
+ req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace))
+ fmt.Println("Requesting data from server!")
+ _, err := http.DefaultTransport.RoundTrip(req)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ response, err := client.Do(req)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ io.Copy(os.Stdout, response.Body)
+}
diff --git a/ch12/insert.gohtml b/ch12/insert.gohtml
new file mode 100644
index 0000000..3148701
--- /dev/null
+++ b/ch12/insert.gohtml
@@ -0,0 +1,32 @@
+
+
+
+
+ Element inserted!
+{{else}}
+ Please fill in the fields:
+
+{{end}}
+
+
+
diff --git a/ch12/kvWeb.go b/ch12/kvWeb.go
new file mode 100644
index 0000000..9992368
--- /dev/null
+++ b/ch12/kvWeb.go
@@ -0,0 +1,198 @@
+package main
+
+import (
+ "encoding/gob"
+ "fmt"
+ "html/template"
+ "net/http"
+ "os"
+)
+
+type myElement struct {
+ Name string
+ Surname string
+ Id string
+}
+
+var DATA = make(map[string]myElement)
+var DATAFILE = "/tmp/dataFile.gob"
+
+func save() error {
+ fmt.Println("Saving", DATAFILE)
+ err := os.Remove(DATAFILE)
+ if err != nil {
+ fmt.Println(err)
+ }
+
+ saveTo, err := os.Create(DATAFILE)
+ if err != nil {
+ fmt.Println("Cannot create", DATAFILE)
+ return err
+ }
+ defer saveTo.Close()
+
+ encoder := gob.NewEncoder(saveTo)
+ err = encoder.Encode(DATA)
+ if err != nil {
+ fmt.Println("Cannot save to", DATAFILE)
+ return err
+ }
+ return nil
+}
+
+func load() error {
+ fmt.Println("Loading", DATAFILE)
+ loadFrom, err := os.Open(DATAFILE)
+ defer loadFrom.Close()
+ if err != nil {
+ fmt.Println("Empty key/value store!")
+ return err
+ }
+
+ decoder := gob.NewDecoder(loadFrom)
+ decoder.Decode(&DATA)
+ return nil
+}
+
+func ADD(k string, n myElement) bool {
+ if k == "" {
+ return false
+ }
+
+ if LOOKUP(k) == nil {
+ DATA[k] = n
+ return true
+ }
+ return false
+}
+
+func DELETE(k string) bool {
+ if LOOKUP(k) != nil {
+ delete(DATA, k)
+ return true
+ }
+ return false
+}
+
+func LOOKUP(k string) *myElement {
+ _, ok := DATA[k]
+ if ok {
+ n := DATA[k]
+ return &n
+ } else {
+ return nil
+ }
+}
+
+func CHANGE(k string, n myElement) bool {
+ DATA[k] = n
+ return true
+}
+
+func PRINT() {
+ for k, d := range DATA {
+ fmt.Printf("key: %s value: %v\n", k, d)
+ }
+}
+
+func homePage(w http.ResponseWriter, r *http.Request) {
+ fmt.Println("Serving", r.Host, "for", r.URL.Path)
+ myT := template.Must(template.ParseGlob("home.gohtml"))
+ myT.ExecuteTemplate(w, "home.gohtml", nil)
+}
+
+func listAll(w http.ResponseWriter, r *http.Request) {
+ fmt.Println("Listing the contents of the KV store!")
+
+ fmt.Fprintf(w, "Home sweet home!")
+ fmt.Fprintf(w, "List all elements!")
+ fmt.Fprintf(w, "Change an element!")
+ fmt.Fprintf(w, "Insert new element!")
+
+ fmt.Fprintf(w, "The contents of the KV store are:
")
+ fmt.Fprintf(w, "")
+ for k, v := range DATA {
+ fmt.Fprintf(w, "
")
+}
+
+func changeElement(w http.ResponseWriter, r *http.Request) {
+ fmt.Println("Changing an element of the KV store!")
+ tmpl := template.Must(template.ParseFiles("update.gohtml"))
+ if r.Method != http.MethodPost {
+ tmpl.Execute(w, nil)
+ return
+ }
+
+ key := r.FormValue("key")
+ n := myElement{
+ Name: r.FormValue("name"),
+ Surname: r.FormValue("surname"),
+ Id: r.FormValue("id"),
+ }
+
+ if !CHANGE(key, n) {
+ fmt.Println("Update operation failed!")
+ } else {
+ err := save()
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ tmpl.Execute(w, struct{ Success bool }{true})
+ }
+}
+
+func insertElement(w http.ResponseWriter, r *http.Request) {
+ fmt.Println("Inserting an element to the KV store!")
+ tmpl := template.Must(template.ParseFiles("insert.gohtml"))
+ if r.Method != http.MethodPost {
+ tmpl.Execute(w, nil)
+ return
+ }
+
+ key := r.FormValue("key")
+ n := myElement{
+ Name: r.FormValue("name"),
+ Surname: r.FormValue("surname"),
+ Id: r.FormValue("id"),
+ }
+
+ if !ADD(key, n) {
+ fmt.Println("Add operation failed!")
+ } else {
+ err := save()
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ tmpl.Execute(w, struct{ Success bool }{true})
+ }
+}
+
+func main() {
+ err := load()
+ if err != nil {
+ fmt.Println(err)
+ }
+
+ PORT := ":8001"
+ arguments := os.Args
+ if len(arguments) != 1 {
+ PORT = ":" + arguments[1]
+ }
+ fmt.Println("Using port number: ", PORT)
+
+ http.HandleFunc("/", homePage)
+ http.HandleFunc("/change", changeElement)
+ http.HandleFunc("/list", listAll)
+ http.HandleFunc("/insert", insertElement)
+ err = http.ListenAndServe(PORT, nil)
+ if err != nil {
+ fmt.Println(err)
+ }
+}
diff --git a/ch12/netCapabilities.go b/ch12/netCapabilities.go
new file mode 100644
index 0000000..be6cffe
--- /dev/null
+++ b/ch12/netCapabilities.go
@@ -0,0 +1,24 @@
+package main
+
+import (
+ "fmt"
+ "net"
+)
+
+func main() {
+ interfaces, err := net.Interfaces()
+
+ if err != nil {
+ fmt.Print(err)
+ return
+ }
+
+ for _, i := range interfaces {
+ fmt.Printf("Name : %v\n", i.Name)
+ fmt.Println("Interface Flags:", i.Flags.String())
+ fmt.Println("Interface MTU:", i.MTU)
+ fmt.Println("Interface Hardware Address:", i.HardwareAddr)
+
+ fmt.Println()
+ }
+}
diff --git a/ch12/netConfig.go b/ch12/netConfig.go
new file mode 100644
index 0000000..fe8f7c5
--- /dev/null
+++ b/ch12/netConfig.go
@@ -0,0 +1,28 @@
+package main
+
+import (
+ "fmt"
+ "net"
+)
+
+func main() {
+ interfaces, err := net.Interfaces()
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ for _, i := range interfaces {
+ fmt.Printf("Interface: %v\n", i.Name)
+ byName, err := net.InterfaceByName(i.Name)
+ if err != nil {
+ fmt.Println(err)
+ }
+
+ addresses, err := byName.Addrs()
+ for k, v := range addresses {
+ fmt.Printf("Interface Address #%v : %v\n", k, v.String())
+ }
+ fmt.Println()
+ }
+}
diff --git a/ch12/serverTimeOut.go b/ch12/serverTimeOut.go
new file mode 100644
index 0000000..d913099
--- /dev/null
+++ b/ch12/serverTimeOut.go
@@ -0,0 +1,48 @@
+package main
+
+import (
+ "fmt"
+ "net/http"
+ "os"
+ "time"
+)
+
+func myHandler(w http.ResponseWriter, r *http.Request) {
+ fmt.Fprintf(w, "Serving: %s\n", r.URL.Path)
+ fmt.Printf("Served: %s\n", r.Host)
+}
+
+func timeHandler(w http.ResponseWriter, r *http.Request) {
+ t := time.Now().Format(time.RFC1123)
+ Body := "The current time is:"
+ fmt.Fprintf(w, "%s
", Body)
+ fmt.Fprintf(w, "%s
\n", t)
+ fmt.Fprintf(w, "Serving: %s\n", r.URL.Path)
+ fmt.Printf("Served time for: %s\n", r.Host)
+}
+
+func main() {
+ PORT := ":8001"
+ arguments := os.Args
+ if len(arguments) != 1 {
+ PORT = ":" + arguments[1]
+ }
+ fmt.Println("Using port number: ", PORT)
+
+ m := http.NewServeMux()
+ srv := &http.Server{
+ Addr: PORT,
+ Handler: m,
+ ReadTimeout: 3 * time.Second,
+ WriteTimeout: 3 * time.Second,
+ }
+
+ m.HandleFunc("/time", timeHandler)
+ m.HandleFunc("/", myHandler)
+
+ err := srv.ListenAndServe()
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+}
diff --git a/ch12/testWWW.go b/ch12/testWWW.go
new file mode 100644
index 0000000..6db25f4
--- /dev/null
+++ b/ch12/testWWW.go
@@ -0,0 +1,41 @@
+package main
+
+import (
+ "fmt"
+ "net/http"
+ "os"
+)
+
+func CheckStatusOK(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusOK)
+ fmt.Fprintf(w, `Fine!`)
+}
+
+func StatusNotFound(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusNotFound)
+}
+
+func MyHandler(w http.ResponseWriter, r *http.Request) {
+ fmt.Fprintf(w, "Serving: %s\n", r.URL.Path)
+ fmt.Printf("Served: %s\n", r.Host)
+}
+
+func main() {
+ PORT := ":8001"
+ arguments := os.Args
+ if len(arguments) == 1 {
+ fmt.Println("Using default port number: ", PORT)
+ } else {
+ PORT = ":" + arguments[1]
+ }
+
+ http.HandleFunc("/CheckStatusOK", CheckStatusOK)
+ http.HandleFunc("/StatusNotFound", StatusNotFound)
+ http.HandleFunc("/", MyHandler)
+
+ err := http.ListenAndServe(PORT, nil)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+}
diff --git a/ch12/testWWW_test.go b/ch12/testWWW_test.go
new file mode 100644
index 0000000..6fa8cd4
--- /dev/null
+++ b/ch12/testWWW_test.go
@@ -0,0 +1,47 @@
+package main
+
+import (
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+)
+
+func TestCheckStatusOK(t *testing.T) {
+ req, err := http.NewRequest("GET", "/CheckStatusOK", nil)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ rr := httptest.NewRecorder()
+ handler := http.HandlerFunc(CheckStatusOK)
+ handler.ServeHTTP(rr, req)
+
+ status := rr.Code
+ if status != http.StatusOK {
+ t.Errorf("handler returned %v", status)
+ }
+
+ expect := `Fine!`
+ if rr.Body.String() != expect {
+ t.Errorf("handler returned %v", rr.Body.String())
+ }
+}
+
+func TestStatusNotFound(t *testing.T) {
+ req, err := http.NewRequest("GET", "/StatusNotFound", nil)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ rr := httptest.NewRecorder()
+ handler := http.HandlerFunc(StatusNotFound)
+ handler.ServeHTTP(rr, req)
+
+ status := rr.Code
+ if status != http.StatusNotFound {
+ t.Errorf("handler returned %v", status)
+ }
+}
diff --git a/ch12/update.gohtml b/ch12/update.gohtml
new file mode 100644
index 0000000..89af750
--- /dev/null
+++ b/ch12/update.gohtml
@@ -0,0 +1,32 @@
+
+
+
+
+ Element updated!
+{{else}}
+ Please fill in the fields:
+
+{{end}}
+
+
+
diff --git a/ch12/webClient.go b/ch12/webClient.go
new file mode 100644
index 0000000..4032134
--- /dev/null
+++ b/ch12/webClient.go
@@ -0,0 +1,31 @@
+package main
+
+import (
+ "fmt"
+ "io"
+ "net/http"
+ "os"
+ "path/filepath"
+)
+
+func main() {
+ if len(os.Args) != 2 {
+ fmt.Printf("Usage: %s URL\n", filepath.Base(os.Args[0]))
+ return
+ }
+
+ URL := os.Args[1]
+ data, err := http.Get(URL)
+
+ if err != nil {
+ fmt.Println(err)
+ return
+ } else {
+ defer data.Body.Close()
+ _, err := io.Copy(os.Stdout, data.Body)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ }
+}
diff --git a/ch12/www.go b/ch12/www.go
new file mode 100644
index 0000000..7e0e443
--- /dev/null
+++ b/ch12/www.go
@@ -0,0 +1,40 @@
+package main
+
+import (
+ "fmt"
+ "net/http"
+ "os"
+ "time"
+)
+
+func myHandler(w http.ResponseWriter, r *http.Request) {
+ fmt.Fprintf(w, "Serving: %s\n", r.URL.Path)
+ fmt.Printf("Served: %s\n", r.Host)
+}
+
+func timeHandler(w http.ResponseWriter, r *http.Request) {
+ t := time.Now().Format(time.RFC1123)
+ Body := "The current time is:"
+ fmt.Fprintf(w, "%s
", Body)
+ fmt.Fprintf(w, "%s
\n", t)
+ fmt.Fprintf(w, "Serving: %s\n", r.URL.Path)
+ fmt.Printf("Served time for: %s\n", r.Host)
+}
+
+func main() {
+ PORT := ":8001"
+ arguments := os.Args
+ if len(arguments) != 1 {
+ PORT = ":" + arguments[1]
+ }
+ fmt.Println("Using port number: ", PORT)
+
+ http.HandleFunc("/time", timeHandler)
+ http.HandleFunc("/", myHandler)
+
+ err := http.ListenAndServe(PORT, nil)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+}
diff --git a/ch12/wwwProfile.go b/ch12/wwwProfile.go
new file mode 100644
index 0000000..0cd49b2
--- /dev/null
+++ b/ch12/wwwProfile.go
@@ -0,0 +1,50 @@
+package main
+
+import (
+ "fmt"
+ "net/http"
+ "net/http/pprof"
+ "os"
+ "time"
+)
+
+func myHandler(w http.ResponseWriter, r *http.Request) {
+ fmt.Fprintf(w, "Serving: %s\n", r.URL.Path)
+ fmt.Printf("Served: %s\n", r.Host)
+}
+
+func timeHandler(w http.ResponseWriter, r *http.Request) {
+ t := time.Now().Format(time.RFC1123)
+ Body := "The current time is:"
+ fmt.Fprintf(w, "%s
", Body)
+ fmt.Fprintf(w, "%s
\n", t)
+ fmt.Fprintf(w, "Serving: %s\n", r.URL.Path)
+ fmt.Printf("Served time for: %s\n", r.Host)
+}
+
+func main() {
+ PORT := ":8001"
+ arguments := os.Args
+ if len(arguments) == 1 {
+ fmt.Println("Using default port number: ", PORT)
+ } else {
+ PORT = ":" + arguments[1]
+ fmt.Println("Using port number: ", PORT)
+ }
+
+ r := http.NewServeMux()
+ r.HandleFunc("/time", timeHandler)
+ r.HandleFunc("/", myHandler)
+
+ r.HandleFunc("/debug/pprof/", pprof.Index)
+ r.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
+ r.HandleFunc("/debug/pprof/profile", pprof.Profile)
+ r.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
+ r.HandleFunc("/debug/pprof/trace", pprof.Trace)
+
+ err := http.ListenAndServe(PORT, r)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+}
diff --git a/ch13/RPCclient.go b/ch13/RPCclient.go
new file mode 100644
index 0000000..00ab960
--- /dev/null
+++ b/ch13/RPCclient.go
@@ -0,0 +1,40 @@
+package main
+
+import (
+ "fmt"
+ "net/rpc"
+ "os"
+ "sharedRPC"
+)
+
+func main() {
+ arguments := os.Args
+ if len(arguments) == 1 {
+ fmt.Println("Please provide a host:port string!")
+ return
+ }
+
+ CONNECT := arguments[1]
+ c, err := rpc.Dial("tcp", CONNECT)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ args := sharedRPC.MyFloats{16, -0.5}
+ var reply float64
+
+ err = c.Call("MyInterface.Multiply", args, &reply)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ fmt.Printf("Reply (Multiply): %f\n", reply)
+
+ err = c.Call("MyInterface.Power", args, &reply)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ fmt.Printf("Reply (Power): %f\n", reply)
+}
diff --git a/ch13/RPCserver.go b/ch13/RPCserver.go
new file mode 100644
index 0000000..4133bbc
--- /dev/null
+++ b/ch13/RPCserver.go
@@ -0,0 +1,56 @@
+package main
+
+import (
+ "fmt"
+ "math"
+ "net"
+ "net/rpc"
+ "os"
+ "sharedRPC"
+)
+
+type MyInterface struct{}
+
+func Power(x, y float64) float64 {
+ return math.Pow(x, y)
+}
+
+func (t *MyInterface) Multiply(arguments *sharedRPC.MyFloats, reply *float64) error {
+ *reply = arguments.A1 * arguments.A2
+ return nil
+}
+
+func (t *MyInterface) Power(arguments *sharedRPC.MyFloats, reply *float64) error {
+ *reply = Power(arguments.A1, arguments.A2)
+ return nil
+}
+
+func main() {
+ PORT := ":1234"
+ arguments := os.Args
+ if len(arguments) != 1 {
+ PORT = ":" + arguments[1]
+ }
+
+ myInterface := new(MyInterface)
+ rpc.Register(myInterface)
+ t, err := net.ResolveTCPAddr("tcp4", PORT)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ l, err := net.ListenTCP("tcp4", t)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ for {
+ c, err := l.Accept()
+ if err != nil {
+ continue
+ }
+ fmt.Printf("%s\n", c.RemoteAddr())
+ rpc.ServeConn(c)
+ }
+}
diff --git a/ch13/TCPclient.go b/ch13/TCPclient.go
new file mode 100644
index 0000000..c04804b
--- /dev/null
+++ b/ch13/TCPclient.go
@@ -0,0 +1,38 @@
+package main
+
+import (
+ "bufio"
+ "fmt"
+ "net"
+ "os"
+ "strings"
+)
+
+func main() {
+ arguments := os.Args
+ if len(arguments) == 1 {
+ fmt.Println("Please provide host:port.")
+ return
+ }
+
+ CONNECT := arguments[1]
+ c, err := net.Dial("tcp", CONNECT)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ for {
+ reader := bufio.NewReader(os.Stdin)
+ fmt.Print(">> ")
+ text, _ := reader.ReadString('\n')
+ fmt.Fprintf(c, text+"\n")
+
+ message, _ := bufio.NewReader(c).ReadString('\n')
+ fmt.Print("->: " + message)
+ if strings.TrimSpace(string(text)) == "STOP" {
+ fmt.Println("TCP client exiting...")
+ return
+ }
+ }
+}
diff --git a/ch13/TCPserver.go b/ch13/TCPserver.go
new file mode 100644
index 0000000..d0dbcb9
--- /dev/null
+++ b/ch13/TCPserver.go
@@ -0,0 +1,49 @@
+package main
+
+import (
+ "bufio"
+ "fmt"
+ "net"
+ "os"
+ "strings"
+ "time"
+)
+
+func main() {
+ arguments := os.Args
+ if len(arguments) == 1 {
+ fmt.Println("Please provide port number")
+ return
+ }
+
+ PORT := ":" + arguments[1]
+ l, err := net.Listen("tcp", PORT)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ defer l.Close()
+
+ c, err := l.Accept()
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ for {
+ netData, err := bufio.NewReader(c).ReadString('\n')
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ if strings.TrimSpace(string(netData)) == "STOP" {
+ fmt.Println("Exiting TCP server!")
+ return
+ }
+
+ fmt.Print("-> ", string(netData))
+ t := time.Now()
+ myTime := t.Format(time.RFC3339) + "\n"
+ c.Write([]byte(myTime))
+ }
+}
diff --git a/ch13/UDPclient.go b/ch13/UDPclient.go
new file mode 100644
index 0000000..0465c7d
--- /dev/null
+++ b/ch13/UDPclient.go
@@ -0,0 +1,54 @@
+package main
+
+import (
+ "bufio"
+ "fmt"
+ "net"
+ "os"
+ "strings"
+)
+
+func main() {
+ arguments := os.Args
+ if len(arguments) == 1 {
+ fmt.Println("Please provide a host:port string")
+ return
+ }
+ CONNECT := arguments[1]
+
+ s, err := net.ResolveUDPAddr("udp4", CONNECT)
+ c, err := net.DialUDP("udp4", nil, s)
+
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ fmt.Printf("The UDP server is %s\n", c.RemoteAddr().String())
+ defer c.Close()
+
+ for {
+ reader := bufio.NewReader(os.Stdin)
+ fmt.Print(">> ")
+ text, _ := reader.ReadString('\n')
+ data := []byte(text + "\n")
+ _, err = c.Write(data)
+ if strings.TrimSpace(string(data)) == "STOP" {
+ fmt.Println("Exiting UDP client!")
+ return
+ }
+
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ buffer := make([]byte, 1024)
+ n, _, err := c.ReadFromUDP(buffer)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ fmt.Printf("Reply: %s\n", string(buffer[0:n]))
+ }
+}
diff --git a/ch13/UDPserver.go b/ch13/UDPserver.go
new file mode 100644
index 0000000..68007fa
--- /dev/null
+++ b/ch13/UDPserver.go
@@ -0,0 +1,58 @@
+package main
+
+import (
+ "fmt"
+ "math/rand"
+ "net"
+ "os"
+ "strconv"
+ "strings"
+ "time"
+)
+
+func random(min, max int) int {
+ return rand.Intn(max-min) + min
+}
+
+func main() {
+ arguments := os.Args
+ if len(arguments) == 1 {
+ fmt.Println("Please provide a port number!")
+ return
+ }
+ PORT := ":" + arguments[1]
+
+ s, err := net.ResolveUDPAddr("udp4", PORT)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ connection, err := net.ListenUDP("udp4", s)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ defer connection.Close()
+ buffer := make([]byte, 1024)
+ rand.Seed(time.Now().Unix())
+
+ for {
+ n, addr, err := connection.ReadFromUDP(buffer)
+ fmt.Print("-> ", string(buffer[0:n-1]))
+
+ if strings.TrimSpace(string(buffer[0:n])) == "STOP" {
+ fmt.Println("Exiting UDP server!")
+ return
+ }
+
+ data := []byte(strconv.Itoa(random(1, 1001)))
+ fmt.Printf("data: %s\n", string(data))
+ _, err = connection.WriteToUDP(data, addr)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ }
+}
diff --git a/ch13/fiboTCP.go b/ch13/fiboTCP.go
new file mode 100644
index 0000000..12ddd29
--- /dev/null
+++ b/ch13/fiboTCP.go
@@ -0,0 +1,74 @@
+package main
+
+import (
+ "bufio"
+ "fmt"
+ "net"
+ "os"
+ "strconv"
+ "strings"
+ "time"
+)
+
+func f(n int) int {
+ fn := make(map[int]int)
+ for i := 0; i <= n; i++ {
+ var f int
+ if i <= 2 {
+ f = 1
+ } else {
+ f = fn[i-1] + fn[i-2]
+ }
+ fn[i] = f
+ }
+ return fn[n]
+}
+
+func handleConnection(c net.Conn) {
+ for {
+ netData, err := bufio.NewReader(c).ReadString('\n')
+ if err != nil {
+ fmt.Println(err)
+ os.Exit(100)
+ }
+
+ temp := strings.TrimSpace(string(netData))
+ if temp == "STOP" {
+ break
+ }
+
+ fibo := "-1\n"
+ n, err := strconv.Atoi(temp)
+ if err == nil {
+ fibo = strconv.Itoa(f(n)) + "\n"
+ }
+ c.Write([]byte(string(fibo)))
+ }
+ time.Sleep(5 * time.Second)
+ c.Close()
+}
+
+func main() {
+ arguments := os.Args
+ if len(arguments) == 1 {
+ fmt.Println("Please provide a port number!")
+ return
+ }
+
+ PORT := ":" + arguments[1]
+ l, err := net.Listen("tcp4", PORT)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ defer l.Close()
+
+ for {
+ c, err := l.Accept()
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ go handleConnection(c)
+ }
+}
diff --git a/ch13/kvTCP.go b/ch13/kvTCP.go
new file mode 100644
index 0000000..417a403
--- /dev/null
+++ b/ch13/kvTCP.go
@@ -0,0 +1,220 @@
+package main
+
+import (
+ "bufio"
+ "encoding/gob"
+ "fmt"
+ "net"
+ "os"
+ "strings"
+)
+
+type myElement struct {
+ Name string
+ Surname string
+ Id string
+}
+
+const welcome = "Welcome to the Key Value store!\n"
+
+var DATA = make(map[string]myElement)
+var DATAFILE = "/tmp/dataFile.gob"
+
+func handleConnection(c net.Conn) {
+ c.Write([]byte(welcome))
+ for {
+ netData, err := bufio.NewReader(c).ReadString('\n')
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ command := strings.TrimSpace(string(netData))
+ tokens := strings.Fields(command)
+ switch len(tokens) {
+ case 0:
+ continue
+ case 1:
+ tokens = append(tokens, "")
+ tokens = append(tokens, "")
+ tokens = append(tokens, "")
+ tokens = append(tokens, "")
+ case 2:
+ tokens = append(tokens, "")
+ tokens = append(tokens, "")
+ tokens = append(tokens, "")
+ case 3:
+ tokens = append(tokens, "")
+ tokens = append(tokens, "")
+ case 4:
+ tokens = append(tokens, "")
+ }
+
+ switch tokens[0] {
+ case "STOP":
+ err = save()
+ if err != nil {
+ fmt.Println(err)
+ }
+ c.Close()
+ return
+ case "PRINT":
+ PRINT(c)
+ case "DELETE":
+ if !DELETE(tokens[1]) {
+ netData := "Delete operation failed!\n"
+ c.Write([]byte(netData))
+ } else {
+ netData := "Delete operation successful!\n"
+ c.Write([]byte(netData))
+ }
+ case "ADD":
+ n := myElement{tokens[2], tokens[3], tokens[4]}
+ if !ADD(tokens[1], n) {
+ netData := "Add operation failed!\n"
+ c.Write([]byte(netData))
+ } else {
+ netData := "Add operation successful!\n"
+ c.Write([]byte(netData))
+ }
+ err = save()
+ if err != nil {
+ fmt.Println(err)
+ }
+ case "LOOKUP":
+ n := LOOKUP(tokens[1])
+ if n != nil {
+ netData := fmt.Sprintf("%v\n", *n)
+ c.Write([]byte(netData))
+ } else {
+ netData := "Did not find key!\n"
+ c.Write([]byte(netData))
+ }
+ case "CHANGE":
+ n := myElement{tokens[2], tokens[3], tokens[4]}
+ if !CHANGE(tokens[1], n) {
+ netData := "Update operation failed!\n"
+ c.Write([]byte(netData))
+ } else {
+ netData := "Update operation successful!\n"
+ c.Write([]byte(netData))
+ }
+ err = save()
+ if err != nil {
+ fmt.Println(err)
+ }
+ default:
+ netData := "Unknown command – please try again!\n"
+ c.Write([]byte(netData))
+ }
+ }
+}
+
+func save() error {
+ fmt.Println("Saving", DATAFILE)
+ err := os.Remove(DATAFILE)
+ if err != nil {
+ fmt.Println(err)
+ }
+
+ saveTo, err := os.Create(DATAFILE)
+ if err != nil {
+ fmt.Println("Cannot create", DATAFILE)
+ return err
+ }
+ defer saveTo.Close()
+
+ encoder := gob.NewEncoder(saveTo)
+ err = encoder.Encode(DATA)
+ if err != nil {
+ fmt.Println("Cannot save to", DATAFILE)
+ return err
+ }
+ return nil
+}
+
+func load() error {
+ fmt.Println("Loading", DATAFILE)
+ loadFrom, err := os.Open(DATAFILE)
+ defer loadFrom.Close()
+ if err != nil {
+ fmt.Println("Empty key/value store!")
+ return err
+ }
+
+ decoder := gob.NewDecoder(loadFrom)
+ decoder.Decode(&DATA)
+ return nil
+}
+
+func ADD(k string, n myElement) bool {
+ if k == "" {
+ return false
+ }
+
+ if LOOKUP(k) == nil {
+ DATA[k] = n
+ return true
+ }
+ return false
+}
+
+func DELETE(k string) bool {
+ if LOOKUP(k) != nil {
+ delete(DATA, k)
+ return true
+ }
+ return false
+}
+
+func LOOKUP(k string) *myElement {
+ _, ok := DATA[k]
+ if ok {
+ n := DATA[k]
+ return &n
+ } else {
+ return nil
+ }
+}
+
+func CHANGE(k string, n myElement) bool {
+ DATA[k] = n
+ return true
+}
+
+func PRINT(c net.Conn) {
+ for k, d := range DATA {
+ netData := fmt.Sprintf("key: %s value: %v\n", k, d)
+ c.Write([]byte(netData))
+ }
+}
+
+func main() {
+ arguments := os.Args
+ if len(arguments) == 1 {
+ fmt.Println("Please provide a port number!")
+ return
+ }
+
+ PORT := ":" + arguments[1]
+ l, err := net.Listen("tcp", PORT)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ defer l.Close()
+
+ err = load()
+ if err != nil {
+ fmt.Println(err)
+ }
+
+ for {
+ c, err := l.Accept()
+ if err != nil {
+ fmt.Println(err)
+ os.Exit(100)
+ }
+ go handleConnection(c)
+ }
+}
diff --git a/ch13/lowLevel.go b/ch13/lowLevel.go
new file mode 100644
index 0000000..341b7a3
--- /dev/null
+++ b/ch13/lowLevel.go
@@ -0,0 +1,28 @@
+package main
+
+import (
+ "fmt"
+ "net"
+)
+
+func main() {
+ netaddr, err := net.ResolveIPAddr("ip4", "127.0.0.1")
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ conn, err := net.ListenIP("ip4:icmp", netaddr)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ buffer := make([]byte, 1024)
+ n, _, err := conn.ReadFrom(buffer)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ fmt.Printf("% X\n", buffer[0:n])
+}
diff --git a/ch13/otherTCPclient.go b/ch13/otherTCPclient.go
new file mode 100644
index 0000000..57dcd6d
--- /dev/null
+++ b/ch13/otherTCPclient.go
@@ -0,0 +1,46 @@
+package main
+
+import (
+ "bufio"
+ "fmt"
+ "net"
+ "os"
+ "strings"
+)
+
+func main() {
+ arguments := os.Args
+ if len(arguments) == 1 {
+ fmt.Println("Please provide a server:port string!")
+ return
+ }
+
+ CONNECT := arguments[1]
+
+ tcpAddr, err := net.ResolveTCPAddr("tcp4", CONNECT)
+ if err != nil {
+ fmt.Println("ResolveTCPAddr:", err.Error())
+ return
+ }
+
+ conn, err := net.DialTCP("tcp4", nil, tcpAddr)
+ if err != nil {
+ fmt.Println("DialTCP:", err.Error())
+ return
+ }
+
+ for {
+ reader := bufio.NewReader(os.Stdin)
+ fmt.Print(">> ")
+ text, _ := reader.ReadString('\n')
+ fmt.Fprintf(conn, text+"\n")
+
+ message, _ := bufio.NewReader(conn).ReadString('\n')
+ fmt.Print("->: " + message)
+ if strings.TrimSpace(string(text)) == "STOP" {
+ fmt.Println("TCP client exiting...")
+ conn.Close()
+ return
+ }
+ }
+}
diff --git a/ch13/otherTCPserver.go b/ch13/otherTCPserver.go
new file mode 100644
index 0000000..cd5dc4f
--- /dev/null
+++ b/ch13/otherTCPserver.go
@@ -0,0 +1,58 @@
+package main
+
+import (
+ "fmt"
+ "net"
+ "os"
+ "strings"
+)
+
+func main() {
+ arguments := os.Args
+ if len(arguments) == 1 {
+ fmt.Println("Please provide a port number!")
+ return
+ }
+
+ SERVER := "localhost" + ":" + arguments[1]
+
+ s, err := net.ResolveTCPAddr("tcp", SERVER)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ l, err := net.ListenTCP("tcp", s)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ buffer := make([]byte, 1024)
+ conn, err := l.Accept()
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ for {
+ n, err := conn.Read(buffer)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ if strings.TrimSpace(string(buffer[0:n])) == "STOP" {
+ fmt.Println("Exiting TCP server!")
+ conn.Close()
+ return
+ }
+
+ fmt.Print("> ", string(buffer[0:n-1]))
+ _, err = conn.Write(buffer)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ }
+}
diff --git a/ch13/sharedRPC.go b/ch13/sharedRPC.go
new file mode 100644
index 0000000..32a300c
--- /dev/null
+++ b/ch13/sharedRPC.go
@@ -0,0 +1,10 @@
+package sharedRPC
+
+type MyFloats struct {
+ A1, A2 float64
+}
+
+type MyInterface interface {
+ Multiply(arguments *MyFloats, reply *float64) error
+ Power(arguments *MyFloats, reply *float64) error
+}
diff --git a/ch13/syscallNet.go b/ch13/syscallNet.go
new file mode 100644
index 0000000..1d9d0f7
--- /dev/null
+++ b/ch13/syscallNet.go
@@ -0,0 +1,36 @@
+package main
+
+import (
+ "fmt"
+ "os"
+ "syscall"
+)
+
+func main() {
+ fd, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_RAW, syscall.IPPROTO_ICMP)
+ if err != nil {
+ fmt.Println("Error in syscall.Socket:", err)
+ return
+ }
+
+ f := os.NewFile(uintptr(fd), "captureICMP")
+ if f == nil {
+ fmt.Println("Error in os.NewFile:", err)
+ return
+ }
+
+ err = syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_RCVBUF, 256)
+ if err != nil {
+ fmt.Println("Error in syscall.Socket:", err)
+ return
+ }
+
+ for {
+ buf := make([]byte, 1024)
+ numRead, err := f.Read(buf)
+ if err != nil {
+ fmt.Println(err)
+ }
+ fmt.Printf("% X\n", buf[:numRead])
+ }
+}