When I send 127+ characters from chrome websocket, my golang server cannot see more than 126

I'm having a blast reinventing the wheel and playing with bits to implement a simple server. It's almost functional, but I'm not sure if this issue is my client or my server. Here is the function where I pass the resulting byte array from net.Conn Read

func readWsFrame(p []byte) {
// process first byte
b := p[0]
fmt.Printf("first byte: %b\n", b)
fin := b & 128 // hopefully 128, for fin
op := b & 15   // hopefully 1, for text
fmt.Printf("fin: %d\nop: %d\n", fin, op)
// process second byte
b = p[1]
fmt.Printf("second byte: %b\n", b)
masked := b & 128 // whether or not the payload is masked
length := b & 127 // payload length
fmt.Printf("masked: %d\nlength: %d\n", masked, length)
// process bytes 3-7 (masking key)
key := p[2:6]
// payload
d := p[6:]
if length == 126 {
key = p[4:8]
d = p[8:]
fmt.Println("med key")
} else if length == 127 {
key = p[10:14]
d = p[14:]
fmt.Println("big key")
} else {
fmt.Println("lil key")
}
fmt.Printf("masking key: %b\n", key)
fmt.Printf("masked data: %b\n", d)
var decoded []byte
for index := 0; index < int(length); index++ {
decoded = append(decoded, d[index]^key[index%4])
}
fmt.Printf("unmasked data: %b\n", decoded)
payload := string(decoded)
fmt.Println("payload: ", payload)
}

The client code is me having the dev console open right off this web page and running

var ws = new WebSocket("ws://localhost:16163");
ws.send("a".repeat(125))
ws.send("a".repeat(126))
ws.send("a".repeat(127))
ws.send("a".repeat(400))

My server is doing what I expect until I reach 127 characters. At that point, and every amount over 126, my 2nd byte is 11111110 and the length is 126. I can see the unmasked/encoded/magic message doesn't go beyond 126 a's.

I'm sure my go code is sub-par and there might be something obvious here, but I'm looking at the bits themselves, and I can see a 0 where I am expecting a 1, please help me, thank you!

I saw a similar question about writing messages larger than 126 bytes and how I'll need extra bytes for payload size, but in this case my client is the chrome web browser.

--edit:

I realize that I will never see more than 126 characters based on the loop I have there, but I should still see a 1 in the final bit in the second byte for these larger messages, right?

--edit:

Came across this https://stackoverflow.com/questions/18271598/how-to-work-out-payload-size-from-html5-websocket

I guess I misunderstood everything else I was searching for. Can someone confirm this? If the length is <126, the length is byte & 127. If the length is 126, the length is the value of the next 2 bytes. If the length is 127, the length is the next 4 bytes.

I thought initially that the length would be 127 if it payload length was 127+ hah, oops. So when the length is 126 or 127, the 2nd byte is not part of the actual length? I'll probably confirm all of this with testing, but I thank you all for resolving this issue before the weekend so I can finish this side project.

The code should update the length property after realizing it's 127 or 126 by reading the length data in the bytes that follow the initial length indicator.

I would consider those 7 "length" bits slightly differently. They don't really indicate length as much as they indicate encoding.

If the length is encoded using 64bits (8 bytes), than the length indicator == 127.

If the length is encoded in 2 bytes, than the indicator == 126.

Otherwise, the length is encoded in the 7 bits of the indicator itself.

For example, the length 60 can be encoded in all three ways (albeit, some use more space).

There's a C Websocket implementation here if you want to read an example decoding of the length.

Good Luck!