Error when decoding JSON

I have been experimenting with GO for the first time, over the last few days.

I have a HTML form that passes it's values to a server. This server in turn extracts the form keys/ values and places them inside a JSON. This JSON is then sent to another server.

The issue is: I get the following error when the second server attempts to decode the JSON:

Error decoding JSON: json: cannot unmarshal string into Go value of type main.NewContainerJSON

1: The original HTML form

<form method="post" action="http://127.0.0.1:8080/new-user" autocomplete ="on">
<table>
<tr>
<td colspan="2"><h1>Container Configuration</h1></td>
</tr>
<tr>
<td><h2>Container Name</h2></td>
<td><input type="text" name="containerName" placeholder = "My Container Name" required /></td>
</tr>
<tr>
<td><h2>Base Server</h2></td>
<td>
<select name="BaseServer">
<option value="Ubuntu 14.04">Ubuntu 14.04</option>
</td>
</tr>
<tr>
<td><h2>Content Management System</h2></td>
<td>
<select name="CMS">
<option value="Wordpress">Wordpress</option>
</td>
</tr>
<tr>
<td><h2>Website Name</h2></td>
<td><input type="text" name="websiteName" placeholder = "mysite.com" required /></td>
</tr>
<tr>
<td><h2>New Root Database Password</h2> </td>
<td><input type = "password" name = "dbRootPWD" placeholder = "password" required /></td>
</tr>
<tr>
<td><h2>Database Admin Username</h2></td>
<td><input type = "text" name = "dbAdminUname" placeholder = "Admin" required /></td>
</tr>
<tr>
<td><h2>Database Admin Password</h2></td>
<td><input type = "password" name = "dbAdminPwd" placeholder = "password" required /></td>
</tr>
<tr>
<td></td>
<td><input type = "submit" value = "submit"></td>
</tr>
</table>	

</form>

2: The first servers code

package main
import (
"fmt"
"encoding/json"
"net"
"net/http"
)
type newContainerJSON struct {
ContainerName string
BaseServer string
CMS string
WebsiteName string
DBrootPWD string
DBadminUname string
DBadminPWD string
}
func newUser(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
cName := r.FormValue("containerName")
sName := r.FormValue("BaseServer")
cmsName := r.FormValue("CMS")
wsName := r.FormValue("websiteName")
dbrootPwd := r.FormValue("dbRootPWD")
dbadmName := r.FormValue("dbAdminUname")
dbamdpwdName := r.FormValue("dbAdminPwd") 
c := newContainerJSON {
ContainerName: cName,
BaseServer: sName,
CMS: cmsName,
WebsiteName: wsName,
DBrootPWD: dbrootPwd,
DBadminUname: dbadmName,
DBadminPWD: dbamdpwdName,
}
d, _ := json.Marshal(c)
s := string(d)
fmt.Println(s)
conn, err := net.Dial("tcp", "127.0.0.1:8081")
checkError(err)
encoder := json.NewEncoder(conn)
encoder.Encode(d) 
}
func main() {
http.HandleFunc("/new-user", newUser)
err := http.ListenAndServe(":8080", nil) // setting listening port
checkError(err)
}
func checkError(err error) {
if err != nil {
fmt.Println("Fatal error ", err.Error())
}
}

3: The second servers code:

package main
import (
"fmt"
"net"
"encoding/json"
)
type NewContainerJSON struct {
ContainerName string	`json:",string"`
BaseServer string		`json:",string"`
CMS string				`json:",string"`
WebsiteName string		`json:",string"`
DBrootPWD string		`json:",string"`
DBadminUname string		`json:",string"`
DBadminPWD string		`json:",string"`
}
func main() {
service := "127.0.0.1:8081"
tcpAddr, err := net.ResolveTCPAddr("tcp", service)
checkError(err)
listener, err := net.ListenTCP("tcp", tcpAddr)
checkError(err)
conn, err := listener.Accept()
checkError(err)
decoder := json.NewDecoder(conn)
var b NewContainerJSON
err = decoder.Decode(&b)
checkError(err)
fmt.Println(b)
conn.Close() // we're finished
}
func checkError(err error) {
if err != nil {
fmt.Println("An error occurred: ", err.Error())
}
}

The error occurs with following code in the second servers code

var b NewContainerJSON
err = decoder.Decode(&b)
checkError(err)
fmt.Println(b)

I suspect I am not decoding the JSON properly or I am missing something very obvious.

The first server is double encoding the value. The result is a string.

d, _ := json.Marshal(c) // d is []byte containing the JSON
...
encoder.Encode(d)  // encoder writes base64 encoding of []byte as JSON string

Change the code to:

conn, err := net.Dial("tcp", "127.0.0.1:8081")
if err != nil {
// handle error
}
encoder := json.NewEncoder(conn)
if err := encoder.Encode(c); err != nil {
// handle error
}

When you do encoder.Encode(d), you are encoding the marshaled result from previous step. So when you decode it back you don't get the go object, but a string.

Instead you can do, encoder.Encode(c). (Directly encode the object c).

This should help you understand: http://play.golang.org/p/qNxqOJcj_a