Sending a message from one port to another

I have a server and 2 clients each using their own port. When a client sends a message to the server, the server echoes it back to the sender. Then, the server is supposed to send the message to the other client as well. This is where I'm having issues.

I believe I may be setting up the connection wrong in writeMessage(), but I am not entirely sure. At the moment, I have the function just trying to write to client 2 on port 8080 for debugging purposes.

Server:

package main
import (
"fmt"
"log"
"net"
)
var message string = ""
func main() {
fmt.Println("The server is listening on Port 3000 and 8080")
listener, err := net.Listen("tcp", "localhost:3000")
if err != nil {
log.Fatal(err) 
}
listener2, err := net.Listen("tcp", "localhost:8080")
if err != nil {
log.Fatal(err)
}
go acceptLoop(listener)
acceptLoop(listener2)
}
func acceptLoop(l net.Listener) {
defer l.Close()
for {
c, err := l.Accept()
if err != nil {
log.Fatal(err)
}
fmt.Println("New connection found!")
listenConnection(c)
}
}
func listenConnection(conn net.Conn) {
for {
buffer := make([]byte, 1400)
dataSize, err := conn.Read(buffer)
if err != nil {
fmt.Println("Connection has closed")
return
}
//This is the message you received
data := buffer[:dataSize]
fmt.Print(string(data))
conn.Write(data)
message = string(data)
writeMessage()
}
}
func writeMessage(){
conn2, e := net.Dial("tcp", "localhost:8080")
if e != nil {
log.Fatalln(e)
}
defer conn2.Close()
conn2.Write([]byte(message))
}

Client 1:

package main
import (
"fmt"
"log"
"net"
"bufio"
"os"
)
func main() {
conn, err := net.Dial("tcp", "localhost:3000")
if err != nil {
log.Fatalln(err)
}
go listenConnection(conn, err)
writeMessage(conn, err)
}
func listenConnection(conn net.Conn, err error){
for {
buffer := make([]byte, 1400)
dataSize, err := conn.Read(buffer)
if err != nil {
fmt.Println("connection closed")
return
}
data := buffer[:dataSize]
fmt.Print("Server: ", string(data))
}
}
func writeMessage(conn net.Conn, err error){
for {
reader := bufio.NewReader(os.Stdin)
//fmt.Print("Enter message: ")
text, _ := reader.ReadString('\n')
text = "3000: " + text
_, err = conn.Write([]byte(text))
if err != nil {
log.Fatalln(err)
}
}
}

(My second client is the same as my first except port 3000 is replaced with 8080.)

In order to replicate the problem, the user has to run the server code and then both of the clients. The clients can then send messages to the server.

Any help with this would be greatly appreciated. I cannot figure this out at all. Hopefully some more experienced Go users will be able to help!

your logic seems to have flaws, where acceptloop calls for listenconnection, it creates an infinite loop inside an infinite loop. I think you need to reconstruct the system with use cases and scenarios.

If my understanding is right, you like to have a server waiting for clients to connect. First, client1 comes in, sends some data. The server accepts this connection, and it only needs to accept once for each client. At this point, if the client2 is online, send data to client2. All of this happens in an infinite loop.

Checkout this code
https://play.golang.org/p/_5AREG3jnG