Fatal runtime panic upon reading from listner.accept connection. I believe it is failing to read from t connection after I write from a client

**Talk is cheap and English is my second language but I'll try my best

.runtime error: index out of range [1073741824] with length 1073741824
This is the error I'm getting specifically. I load up the server and then the client once I type in the username on the client side it panics. As long as I don't type in the username it works fine so I assume it is looping just fine before that. I believe it is breaking at read.conn because I set a break point after it and it never reached there.

I'm unfortunately unsure of what to put more here but it won't allow me to add the stack trace without adding more info . However I now believe it is definitely due to read/write.

Here is my stack trace:
panic: runtime error: index out of range [65536] with length 65536

goroutine 6 [running]:
IRC/ClientServer/Messages.getPacket({0xc000132000, 0x10000, 0x0})
/root/go/src/IRC/ClientServer/Messages/rawMessage.go:144 +0x1e
IRC/ClientServer/Messages.ExtractPackets({0xc000132000, 0x10000, 0x10000})
/root/go/src/IRC/ClientServer/Messages/rawMessage.go:114 +0x86
IRC/ClientServer/Server.handleClientRequest({0x5274a8, 0xc000010030})
/root/go/src/IRC/ClientServer/Server/Server.go:60 +0x1f5
created by IRC/ClientServer/Server.ServerStart
/root/go/src/IRC/ClientServer/Server/Server.go:33 +0x157
Process finished with the exit code 2

Here is my server.

'''

//Server starts the server
func ServerStart() {
listener, err := net.Listen("tcp", "0.0.0.0:9999")
if err != nil {
log.Fatalln(err)
}
defer listener.Close()
for {
con, err := listener.Accept()
if err != nil {
log.Println(err)
continue
}
// If you want, you can increment a counter here and inject to handleClientRequest below as client identifier
go handleClientRequest(con)
}
}
func handleClientRequest(conn net.Conn) {
defer conn.Close()
var previousData []byte //holds previous data from for loop
buffer := make([]byte, 1<<30) //create 1 mb buffer //make sure to zero out when finished
tracker := Newtrack(15 * time.Second) //create a new tracker and set the timer for 15 seconds
for {
_,err := conn.Read(buffer) //read into the buffer
fmt.Println(err)
packets, extra, err := Messages.ExtractPackets(append(previousData,buffer...))//extract the packets
//print the error
if err != nil {
fmt.Println(err)
}
previousData = extra //get the extra data if there is any
//turn the packets into IRC packets
IRCpackets := make([]Messages.IrcPacket, len(packets)) //create a list of IRC packets len of raw packets
for index,value := range packets {
IRC, err := Messages.CreateIrc(value)
if IRC != nil { //if IRC = nil then err likely does not = nil
IRCpackets[index] = *IRC //create IRCpackets's for every raw packet
}
if err != nil {
fmt.Println(err)
}
}
//Check if hello has been recieved
if !tracker.recievedHello() {
fail,errorType,err := tracker.SetHelloTrack(IRCpackets[0])
//if it is a failure
if !fail {
fmt.Println(err)
toSend, err := Messages.CreateRaw(Messages.CreateErrorMessage(errorType)) //send the error to client
if err != nil { fmt.Println(err,"in server hello check")}
_, err = conn.Write(toSend) //Write to the client the error
if err != nil {fmt.Println(err, "in server hello check 2")}
break //Break the for loop and therefore the connection
}
}
//This is to test it delete later
if tracker.hello {
fmt.Println("success")
}
}
}

'''
**I believe it panics on conn.read and it only happens after attempting to type in a username in the client.

Here is my client**

'''

func ClientStart() {
conn, err := net.Dial("tcp", "0.0.0.0:9999")
if err != nil {
log.Fatalln(err)
}
defer conn.Close()
//Create the hello message
//--------
IRCpack, err := Messages.CreateHello(createUsername())
packet,err := Messages.CreateRaw(IRCpack)
if	err != nil {fmt.Println(err)}
conn.Write(packet)
//-----
//The loop
for {
}
}

'''

**And here is get packet where it probably panics

'''

//getPacket grabs a packet from an array and returns a jump and indicates
//if the jump + len(pureraw) > pure raw data then the rest must be extra
//This function assumes you have kept the start deliminator in
//Return of -1 means the rest of the data is extra
func getPacket(data []byte) (int, []byte, error) {
//This means the rest of the packet may be in rest of buffer
if data[len(data)] < 9 {
return -1, data[:], nil
}
length := binary.BigEndian.Uint32(data[lenBegin:lenEnd]) //Grab what should be the length
if length == 0 {		//If the length is zero then it has no payload
return 9, data[:9], nil
}
//Check to see if everything is there
if len(data) < (int(length) + 11) {
return -1, data[:], nil
}
//Make sure the start packet delminator is there
if data[9] != STARTPACKET {
return -2, nil, errors.New("start packet delmi error")
}
//Now make sure there is an endPacket delminator
if data[length + 11 - 1] != ENDPACKET{ //Leaving in the -1 to show logic and improve readablity
return -2, nil, errors.New("end packet delmi error")
}
return int(length) + 11, data[:length + 11], nil // return the length + 11
}

'''

func getPacket(data []byte) (int, []byte, error) {
...
if data[len(data)] < 9 {

len(data) is the size of the array. Since the first array index is 0 the maximum index is len(data)-1. This means data[len(data)] is trying to access an element outside the array, thus causing the panic.