Crear un proyecto utilizando NetCAD es una oportunidad magnífica para aprender sobre conexiones de red y la transmisión de datos. NetCAD es una herramienta que permite escribir y leer a través de conexiones TCP o UDP, mostrándolo en una consola. En este proyecto, NetCAD funcionará como cliente para un servidor de chat, permitiendo el intercambio de mensajes.
¿Cómo se inicia la implementación de NetCAD?
Primero, creamos un nuevo archivo llamado netcad.go dentro de la carpeta net. Definimos el paquete principal con package main y creamos la función main, que establecerá una conexión usando el protocolo TCP.
package main
import("flag""fmt""log""net""os""os/exec")funcmain(){// Definición de flags para host y puerto port := flag.Int("p",3090,"el puerto") host := flag.String("h","localhost","el host") flag.Parse()// Creación de la conexión TCP connection, err := net.Dial("tcp", fmt.Sprintf("%s:%d",*host,*port))if err !=nil{ log.Fatal(err)}defer connection.Close()// Canal de control para manejo de concurrencia done :=make(chanstruct{})gofunc(){ io.Copy(os.Stdout, connection) done <-struct{}{}}()// Llamada a la función copyContentcopyContent(connection, os.Stdin)<-done
}// Función para copiar contenido entre el lector y el escritorfunccopyContent(dst net.Conn, src io.Reader){if_, err := io.Copy(dst, src); err !=nil{ log.Fatal(err)}}
¿Cómo se configura y utiliza la función main?
En la función main, se definen dos parámetros importantes mediante flags: el host y el port.
Host: Se representa con el flag -h y por defecto es localhost.
Puerto: Se configura con -p y su valor por defecto es 3090.
Estos flags permiten que los parámetros sean personalizables durante la ejecución del programa. Una vez establecidos, se establece la conexión. En caso de error, el programa termina su ejecución mediante log.Fatal(). Si no hay error, el programa procede a crear un canal que permitirá manejar las operaciones concurrentes.
¿Cómo se gestionan las operaciones concurrentes y el control de flujo?
La función anónima dentro de main se encarga de leer todo lo que se recibe a través de la conexión y mostrarlo en la consola. Utiliza io.Copy, que es una función eficiente del paquete io en Go, para copiar datos de un Reader a un Writer. Aquí, la consola actúa como el Writer y la conexión como el Reader.
Además, se envía un struct vacío a un canal para señalar que la lectura ha terminado. Esto es crucial para saber cuándo desbloquear el programa.
¿Qué sigue después de implementar NetCAD?
Finalmente, debemos recordar que NetCAD aun no está completo sin un servidor al cual conectarse. En las próximas etapas del proyecto, nos enfocaremos en construir el servidor que complementará a NetCAD, permitiendo una interacción bidireccional con el cliente/NetCAD.
Implementar NetCAD es un paso importante para adquirir experiencia en programación concurrente y manejo de conexiones en Go. No obstante, entender cómo crear y gestionar correctamente tanto el cliente como el servidor es clave para el éxito del proyecto. ¡Sigue adelante, sigue aprendiendo y completa tu proyecto con éxito!
Crear un proyecto utilizando NetCAD es una oportunidad magnífica para aprender sobre conexiones de red y la transmisión de datos. NetCAD es una herramienta que permite escribir y leer a través de conexiones TCP o UDP, mostrándolo en una consola. En este proyecto, NetCAD funcionará como cliente para un servidor de chat, permitiendo el intercambio de mensajes.
¿Cómo se inicia la implementación de NetCAD?
Primero, creamos un nuevo archivo llamado netcad.go dentro de la carpeta net. Definimos el paquete principal con package main y creamos la función main, que establecerá una conexión usando el protocolo TCP.
package main
import (
"flag"
"fmt"
"log"
"net"
"os"
"os/exec"
)
func main() {
// Definición de flags para host y puerto
port := flag.Int("p", 3090, "el puerto")
host := flag.String("h", "localhost", "el host")
flag.Parse()
// Creación de la conexión TCP
connection, err := net.Dial("tcp", fmt.Sprintf("%s:%d", *host, *port))
if err != nil {
log.Fatal(err)
}
defer connection.Close()
// Canal de control para manejo de concurrencia
done := make(chan struct{})
go func() {
io.Copy(os.Stdout, connection)
done <- struct{}{}
}()
// Llamada a la función copyContent
copyContent(connection, os.Stdin)
<-done
}
// Función para copiar contenido entre el lector y el escritor
func copyContent(dst net.Conn, src io.Reader) {
if _, err := io.Copy(dst, src); err != nil {
log.Fatal(err)
}
}
¿Cómo se configura y utiliza la función main?
En la función main, se definen dos parámetros importantes mediante flags: el host y el port.
Host: Se representa con el flag -h y por defecto es localhost.
Puerto: Se configura con -p y su valor por defecto es 3090.
Estos flags permiten que los parámetros sean personalizables durante la ejecución del programa. Una vez establecidos, se establece la conexión. En caso de error, el programa termina su ejecución mediante log.Fatal(). Si no hay error, el programa procede a crear un canal que permitirá manejar las operaciones concurrentes.
¿Cómo se gestionan las operaciones concurrentes y el control de flujo?
La función anónima dentro de main se encarga de leer todo lo que se recibe a través de la conexión y mostrarlo en la consola. Utiliza io.Copy, que es una función eficiente del paquete io en Go, para copiar datos de un Reader a un Writer. Aquí, la consola actúa como el Writer y la conexión como el Reader.
Además, se envía un struct vacío a un canal para señalar que la lectura ha terminado. Esto es crucial para saber cuándo desbloquear el programa.
¿Qué sigue después de implementar NetCAD?
Finalmente, debemos recordar que NetCAD aun no está completo sin un servidor al cual conectarse. En las próximas etapas del proyecto, nos enfocaremos en construir el servidor que complementará a NetCAD, permitiendo una interacción bidireccional con el cliente/NetCAD.
Implementar NetCAD es un paso importante para adquirir experiencia en programación concurrente y manejo de conexiones en Go. No obstante, entender cómo crear y gestionar correctamente tanto el cliente como el servidor es clave para el éxito del proyecto. ¡Sigue adelante, sigue aprendiendo y completa tu proyecto con éxito!
Para los que no sepan que es netcat, es una herramienta "simple" que nos sirve para hacer conexiones tcp o udp y enviar datos por las mismas, se puede enviar por ejemplo, una petición http (o si nos vamos a algo mas malvado, una reverse Shell).
Si quieren hacer una petición http solo tienen que levantar un server, y escribir las siguientes líneas en que programa que realizamos
Por que se queda escuchando si al lanzar la gorutina deberia funcionar solo para la primera vez que envia algo. Luego esperaria para enviar algo desde la terminal y en ese momento moriria, pero no el programa sigue escuchando, no me queda estoy muy claro, podrias por favor explicarlo de forma mas detallada?
Código con comentarios que explican el flujo del código esperado.
package main
import (
"flag"
"fmt"
"io"
"log"
"net"
"os"
)
var (
port = flag.Int("p", 3090, "Port to connect")
host = flag.String("h", "localhost", "Host to connect")
)
func main() {
flag.Parse() //Parse the flags
connection, err := net.Dial("tcp", fmt.Sprintf("%s:%d", *host, *port))
if err != nil {
log.Fatal(err) //If there is an error, print it and exit
}
done := make(chan struct{}) //Channel of control, we dont care about the value, just the signal
go func() {
io.Copy(os.Stdout, connection) //Copy the data from the connection to the standard output. If connection hasn't data, it will block. If connection is closed, it will return.
done <- struct{}{} //Send a signal to the channel
}()
CopyContent(connection, os.Stdin) //Copy the data from the standard input to the connection. It will block until the standard input has data. If the standard input is closed, it will return.
connection.Close() //Close the connection
<-done //Wait for the signal
}
func CopyContent(dst io.Writer, src io.Reader) {
_, err := io.Copy(dst, src)
if err != nil {
log.Fatal(err)
}
}
En el examen la pregunta "¿Cuáles son las interfaces muy utilizadas en Go que nos permitirá copiar contenido de una fuente a un destino?" da como incorrecta la opción io.Copy Estoy entendiendo mal esta clase?