Exercises

Finger daemon

Write a finger daemon that works with the finger(1) command.

From the Debian package description:

Fingerd is a simple daemon based on RFC 1196 [RFC1196] that provides an interface to the “finger” program at most network sites. The program is supposed to return a friendly, human-oriented status report on either the system at the moment or a particular person in depth.

Stick to the basics and only support a username argument. If the user has a .plan fileshow the contents of that file. So your program needs to be able to figure out:

  • Does the user exist?
  • If the user exists, show the contents of the .plan file.

Answer

This solution is from Fabian Becker.

  1. package main
  3. import (
  4.     "bufio"
  5.     "errors"
  6.     "flag"
  7.     "io/ioutil"
  8.     "net"
  9.     "os/user"
  10. )
  12. func main() {
  13.     flag.Parse()
  14.     ln, err := net.Listen("tcp", ":79")
  15.     if err != nil {
  16.         panic(err)
  17.     }
  18.     for {
  19.         conn, err := ln.Accept()
  20.         if err != nil {
  21.             continue
  22.         }
  23.         go handleConnection(conn)
  24.     }
  25. }
  27. func handleConnection(conn net.Conn) {
  28.     defer conn.Close()
  29.     reader := bufio.NewReader(conn)
  30.     usr, _, _ := reader.ReadLine()
  32.     if info, err := getUserInfo(string(usr)); err != nil {
  33.         conn.Write([]byte(err.Error()))
  34.     } else {
  35.         conn.Write(info)
  36.     }
  37. }
  39. func getUserInfo(usr string) ([]byte, error) {
  40.     u, e := user.Lookup(usr)
  41.     if e != nil {
  42.         return nil, e
  43.     }
  44.     data, err := ioutil.ReadFile(u.HomeDir + ".plan")
  45.     if err != nil {
  46.         return data, errors.New("User doesn't have a .plan file!\n")
  47.     }
  48.     return data, nil
  49. }

Echo server

Write a simple echo server. Make it listen to TCP port number 8053 on localhost.It should be able to read a line (up to the newline), echo back that line andthen close the connection.

Make the server concurrent so that every request is taken care of in a separategoroutine.

Answer

A simple echo server might be:

  1. package main
  3. import (
  4.     "bufio"
  5.     "fmt"
  6.     "net"
  7. )
  9. func main() {
  10.     l, err := net.Listen("tcp", "127.0.0.1:8053")
  11.     if err != nil {
  12.         fmt.Printf("Failure to listen: %s\n", err.Error())
  13.     }
  14.     for {
  15.         if c, err := l.Accept(); err == nil {
  16.             Echo(c)
  17.         }
  18.     }
  19. }
  21. func Echo(c net.Conn) {
  22.     defer c.Close()
  23.     line, err := bufio.NewReader(c).ReadString('\n')
  24.     if err != nil {
  25.         fmt.Printf("Failure to read: %s\n", err.Error())
  26.         return
  27.     }
  28.     _, err = c.Write([]byte(line))
  29.     if err != nil {
  30.         fmt.Printf("Failure to write: %s\n", err.Error())
  31.         return
  32.     }
  33. }

When started you should see the following:

  1. % nc 127.0.0.1 8053
  2. Go is *awesome*
  3. Go is *awesome*

To make the connection handling concurrent we only need to change one line in ourecho server, the line:

  1. if c, err := l.Accept(); err == nil { Echo(c) }

becomes:

  1. if c, err := l.Accept(); err == nil { go Echo(c) }

Word and Letter Count

Write a small program that reads text from standard input and performs thefollowing actions:

  • Count the number of characters (including spaces).
  • Count the number of words.
  • Count the numbers of lines

In other words implement wc(1) (check you local manual page), however you onlyhave to read from standard input.

Answer

The following program is an implementation of wc(1).

  1. package main
  3. import (
  4.     "bufio"
  5.     "fmt"
  6.     "os"
  7.     "strings"
  8. )
  10. func main() {
  11.     var chars, words, lines int
  12.     r := bufio.NewReader(os.Stdin) 1
  13.     for {
  14.         switch s, ok := r.ReadString('\n'); true { 2
  15.         case ok != nil: 3
  16.             fmt.Printf("%d %d %d\n", chars, words, lines)
  17.             return
  18.         default: 4
  19.             chars += len(s)
  20.             words += len(strings.Fields(s))
  21.             lines++
  22.         }
  23.     }
  24. }

At 1 we create a new reader that reads from standard input, we then read fromthe input at 2. And at 3 we check the value of ok and if we received anerror, we assume it was because of a EOF, So we print the current values;.Otherwise 4 we count the charaters, words and increment the number lines.

Uniq

Write a Go program that mimics the function of the Unix uniq command. Thisprogram should work as follows, given a list with the following items:

  1. 'a' 'b' 'a' 'a' 'a' 'c' 'd' 'e' 'f' 'g'

it should print only those items which don’t have the same successor:

  1. 'a' 'b' 'a' 'c' 'd' 'e' 'f' 'g'

The next listing is a Perl implementation of the algorithm.

  1. #!/usr/bin/perl
  2. my @a = qw/a b a a a c d e f g/;
  3. print my $first = shift @a;
  4. foreach (@a) {
  5.     if ($first ne $_) { print; $first = $_; }
  6. }

Answer

The following is a uniq implementation in Go.

  1. package main
  3. import "fmt"
  5. func main() {
  6.     list := []string{"a", "b", "a", "a", "c", "d", "e", "f"}
  7.     first := list[0]
  9.     fmt.Printf("%s ", first)
  10.     for _, v := range list[1:] {
  11.         if first != v {
  12.             fmt.Printf("%s ", v)
  13.             first = v
  14.         }
  15.     }
  16. }

Quine

A Quine is a program that prints itself. Write a Quine in Go.

Answer

This solution is from Russ Cox. It was posted to the Go Nuts mailing list.

  1. /* Go quine */
  2. package main
  3. import "fmt"
  4. func main() {
  5.  fmt.Printf("%s%c%s%c\n", q, 0x60, q, 0x60)
  6. }
  7. var q = `/* Go quine */
  8. package main
  9. import "fmt"
  10. func main() {
  11.  fmt.Printf("%s%c%s%c\n", q, 0x60, q, 0x60)
  12. }
  13. var q = `

Processes

Write a program that takes a list of all running processes and prints how manychild processes each parent has spawned. The output should look like:

  1. Pid 0 has 2 children: [1 2]
  2. Pid 490 has 2 children: [1199 26524]
  3. Pid 1824 has 1 child: [7293]
  • For acquiring the process list, you’ll need to capture the output of ps -e -opid,ppid,comm. This output looks like:
  1.   PID  PPID COMMAND
  2.  9024  9023 zsh
  3. 19560  9024 ps

  • If a parent has one child you must print child, if there is more than oneprint children.

  • The process list must be numerically sorted, so you start with pid 0 and workyour way up.

Here is a Perl version to help you on your way (or to create complete and utter confusion).

  1. #!/usr/bin/perl -l
  2. my (%child, $pid, $parent);
  3. my @ps=`ps -e -opid,ppid,comm`;      # capture the output from `ps`
  4. foreach (@ps[1..$#ps]) {      # discard the header line
  5.   ($pid, $parent, undef) = split; # split the line, discard 'comm'
  6.   push @{$child{$parent}}, $pid;  # save the child PIDs on a list
  7. }
  8. # Walk through the sorted PPIDs
  9. foreach (sort { $a <=> $b } keys %child) {
  10.   print "Pid ", $_, " has ", @{$child{$_}}+0, " child",
  11.     @{$child{$_}} == 1 ? ": " : "ren: ", "[@{$child{$_}}]";
  12. }

Answer

There is lots of stuff to do here. We can divide our programup in the following sections:

  • Starting ps and capturing the output.
  • Parsing the output and saving the child PIDs for each PPID.
  • Sorting the PPID list.
  • Printing the sorted list to the screen.

In the solution presented below, we’ve used a map[int][]int, i.e. a mapindexed with integers, pointing to a slice of ints – which holds the PIDs. Thebuiltin append is used to grow the integer slice.

A possible program is:

  1. package main
  3. import (
  4.     "fmt"
  5.     "os/exec"
  6.     "sort"
  7.     "strconv"
  8.     "strings"
  9. )
  11. func main() {
  12.     ps := exec.Command("ps", "-e", "-opid,ppid,comm")
  13.     output, _ := ps.Output()
  14.     child := make(map[int][]int)
  15.     for i, s := range strings.Split(string(output), "\n") {
  16.         if i == 0 { // kill first line
  17.             continue
  18.         }
  19.         if len(s) == 0 { // kill last line
  20.             continue
  21.         }
  22.         f := strings.Fields(s)
  23.         fpp, _ := strconv.Atoi(f[1]) // parent's pid
  24.         fp, _ := strconv.Atoi(f[0])  // child's pid
  25.         child[fpp] = append(child[fpp], fp)
  26.     }
  27.     schild := make([]int, len(child))
  28.     i := 0
  29.     for k, _ := range child {
  30.         schild[i] = k
  31.         i++
  32.     }
  33.     sort.Ints(schild)
  34.     for _, ppid := range schild {
  35.         fmt.Printf("Pid %d has %d child", ppid, len(child[ppid]))
  36.         if len(child[ppid]) == 1 {
  37.             fmt.Printf(": %v\n", child[ppid])
  38.             continue
  39.         }
  40.         fmt.Printf("ren: %v\n", child[ppid])
  41.     }
  42. }

Number cruncher

  • Pick six (6) random numbers from this list: (1, 2, 3, 4, 5, 6, 7, 8, 9, 10,25, 50, 75, 100) Numbers may be picked multiple times.
  • Pick one (1) random number ((i)) in the range: (1 \ldots 1000).
  • Tell how, by combining the first 6 numbers (or a subset thereof)with the operators +,-,* and /, you can make (i).

An example. We have picked the numbers: 1, 6, 7, 8, 8 and 75. And (i) is977. This can be done in many different ways, one way is:( ((((1 6) 8) + 75) 8) - 7 = 977)or( (8(75+(8*6)))-(7/1) = 977)

Implement a number cruncher that works like that. Make it print the solution ina similar format (i.e. output should be infix with parenthesis) as used above.

Calculate all possible solutions and show them (or only show how many thereare). In the example above there are 544 ways to do it.

Answer

The following is one possibility. It uses recursion and backtracking to getan answer. When starting permrec we give 977 as the first argument:

  1. % ./permrec 977
  2. 1+(((6+7)*75)+(8/8)) = 977  #1
  3. ...                         ...
  4. ((75+(8*6))*8)-7 = 977      #542
  5. (((75+(8*6))*8)-7)*1 = 977  #543
  6. (((75+(8*6))*8)-7)/1 = 977  #544
  1. package main
  3. import (
  4.     "flag"
  5.     "fmt"
  6.     "strconv"
  7. )
  9. const (
  10.     _ = 1000 * iota
  11.     ADD
  12.     SUB
  13.     MUL
  14.     DIV
  15.     MAXPOS = 11
  16. )
  18. var mop = map[int]string{ADD: "+", SUB: "-", MUL: "*", DIV: "/"}
  19. var (
  20.     ok    bool
  21.     value int
  22. )
  24. type Stack struct {
  25.     i    int
  26.     data [MAXPOS]int
  27. }
  29. func (s *Stack) Reset()     { s.i = 0 }
  30. func (s *Stack) Len() int   { return s.i }
  31. func (s *Stack) Push(k int) { s.data[s.i] = k; s.i++ }
  32. func (s *Stack) Pop() int   { s.i--; return s.data[s.i] }
  34. var found int
  35. var stack = new(Stack)
  37. func main() {
  38.     flag.Parse()
  39.     list := []int{1, 6, 7, 8, 8, 75, ADD, SUB, MUL, DIV}
  40.     magic, ok := strconv.Atoi(flag.Arg(0)) // Arg0 is i
  41.     if ok != nil {
  42.         return
  43.     }
  44.     f := make([]int, MAXPOS)
  45.     solve(f, list, 0, magic)
  46. }
  48. func solve(form, numberop []int, index, magic int) {
  49.     var tmp int
  50.     for i, v := range numberop {
  51.         if v == 0 {
  52.             goto NEXT
  53.         }
  54.         if v < ADD { // it's a number, save it
  55.             tmp = numberop[i]
  56.             numberop[i] = 0
  57.         }
  58.         form[index] = v
  59.         value, ok = rpncalc(form[0 : index+1])
  61.         if ok && value == magic {
  62.             if v < ADD {
  63.                 numberop[i] = tmp // reset and go on
  64.             }
  65.             found++
  66.             fmt.Printf("%s = %d  #%d\n", rpnstr(form[0:index+1]), value, found)
  67.         }
  69.         if index == MAXPOS-1 {
  70.             if v < ADD {
  71.                 numberop[i] = tmp // reset and go on
  72.             }
  73.             goto NEXT
  74.         }
  75.         solve(form, numberop, index+1, magic)
  76.         if v < ADD {
  77.             numberop[i] = tmp // reset and go on
  78.         }
  79.     NEXT:
  80.     }
  81. }
  83. func rpnstr(r []int) (ret string) { // Convert rpn to infix notation
  84.     s := make([]string, 0) // Still memory intensive
  85.     for k, t := range r {
  86.         switch t {
  87.         case ADD, SUB, MUL, DIV:
  88.             var a, b string
  89.             a, s = s[len(s)-1], s[:len(s)-1]
  90.             b, s = s[len(s)-1], s[:len(s)-1]
  91.             if k == len(r)-1 {
  92.                 s = append(s, b+mop[t]+a)
  93.             } else {
  94.                 s = append(s, "("+b+mop[t]+a+")")
  95.             }
  96.         default:
  97.             s = append(s, strconv.Itoa(t))
  98.         }
  99.     }
  100.     for _, v := range s {
  101.         ret += v
  102.     }
  103.     return
  104. }
  106. func rpncalc(r []int) (int, bool) {
  107.     stack.Reset()
  108.     for _, t := range r {
  109.         switch t {
  110.         case ADD, SUB, MUL, DIV:
  111.             if stack.Len() < 2 {
  112.                 return 0, false
  113.             }
  114.             a := stack.Pop()
  115.             b := stack.Pop()
  116.             if t == ADD {
  117.                 stack.Push(b + a)
  118.             }
  119.             if t == SUB {
  120.                 // disallow negative subresults
  121.                 if b-a < 0 {
  122.                     return 0, false
  123.                 }
  124.                 stack.Push(b - a)
  125.             }
  126.             if t == MUL {
  127.                 stack.Push(b * a)
  128.             }
  129.             if t == DIV {
  130.                 if a == 0 {
  131.                     return 0, false
  132.                 }
  133.                 // disallow fractions
  134.                 if b%a != 0 {
  135.                     return 0, false
  136.                 }
  137.                 stack.Push(b / a)
  138.             }
  139.         default:
  140.             stack.Push(t)
  141.         }
  142.     }
  143.     if stack.Len() == 1 { // there is only one!
  144.         return stack.Pop(), true
  145.     }
  146.     return 0, false
  147. }