Go: deep copy slices

I would like to read a slice of strings representing hexadecimal numbers, and decode them to a slice of byte slices ([]string --> [][]byte). This is my code so far:

func (self *algo_t) decode_args(args []string) ([][]byte, error) {
	var data [][]byte
	for i := uint32(0); i < self.num_args; i++ {
		data = make([][]byte, self.num_args)
		tmp, err := hex.DecodeString(args[i])
		fmt.Printf("i = %d\ttmp = %x\n", i, tmp)
		data[i] = make([]byte, len(tmp))
		copy(data[i], tmp)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Error decoding hex string %s: %s\n", args[i], err.Error())
			return nil, err
		}
	}
	fmt.Printf("line 69\tdata[0] = %x\tdata[1] = %x\tdata[2] = %x\n",data[0], data[1], data[2])
	return data, nil
}

calling this code and passing args = []string{"010203","040506","070809"} yields the following output:

i = 0    tmp = 010203
i = 1    tmp = 040506
i = 3    tmp = 070809
line 69 data[0] =     data[1] =     data[2] = 070809

Presumably the function returns [][]byte{[]byte{}, []byte{}, []byte{0x07, 0x08, 0x09}}.

I understand that this is because of the pointer behavior of Go; what is the best practice for doing a deep copy of this kind?

For example,

package main

import (
	"encoding/hex"
	"fmt"
)

// Decode hex []string to [][]byte
func decode(s []string) ([][]byte, error) {
	b := make([][]byte, len(s))
	for i, ss := range s {
		h, err := hex.DecodeString(ss)
		if err != nil {
			err = fmt.Errorf(
				"Error decoding hex string %s: %s\n",
				ss, err.Error(),
			)
			return nil, err
		}
		b[i] = h
	}
	return b, nil
}

func main() {
	s := []string{"010203", "040506", "070809"}
	fmt.Println(s)
	b, err := decode(s)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(b)
	}
	s = []string{"ABCDEF", "012345", "09AF"}
	fmt.Println(s)
	b, err = decode(s)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(b)
	}
	s = []string{"01", "123XYZ"}
	fmt.Println(s)
	b, err = decode(s)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(b)
	}
}

Output:

[010203 040506 070809]
[[1 2 3] [4 5 6] [7 8 9]]
[ABCDEF 012345 09AF]
[[171 205 239] [1 35 69] [9 175]]
[01 123XYZ]
Error decoding hex string 123XYZ: encoding/hex: invalid byte: U+0058 'X'

There is a package built specifically to handle deep copy: http://godoc.org/code.google.com/p/rog-go/exp/deepcopy

You can look at the source here: https://code.google.com/p/rog-go/source/browse/exp/deepcopy/deepcopy.go. It covers copying slices and pointers, so it should cover your case.