How to establish socket connection using the command line

Establishing Socket Connections from the Command Line

Learn how to create and test basic network socket connections using command-line tools on Windows, focusing on netcat and PowerShell.

Establishing socket connections is a fundamental aspect of network communication. While programming languages offer robust APIs for this, sometimes you need a quick way to test connectivity, debug network issues, or even transfer data directly from your command line. This article will guide you through using common command-line tools, primarily netcat (nc) and PowerShell, to create and interact with TCP and UDP sockets on Windows systems.

Understanding Sockets and Command-Line Tools

A socket is one endpoint of a two-way communication link between two programs running on the network. A socket is bound to a port number so that the TCP layer can identify the application that data is destined to be sent to. Command-line tools like netcat (often abbreviated as nc) are invaluable for working with sockets directly. Netcat is a feature-rich network utility that reads and writes data across network connections using TCP or UDP. While netcat is not natively installed on Windows, it's widely available as a third-party utility. PowerShell, on the other hand, is built into modern Windows versions and offers cmdlets for network operations.

flowchart TD
    A[Client Command Line] -->|Initiates Connection| B{Network}
    B -->|Connects to| C[Server Command Line]
    C -->|Listens on Port| D[Server Application/Service]
    A -- Data Flow --> C

Basic Client-Server Socket Connection Flow

Setting Up a Listener (Server Side)

Before a client can connect, there must be a server listening for incoming connections. We'll demonstrate how to set up a simple listener using both netcat and PowerShell. This listener will wait for a connection on a specified port and then display any data it receives.

Netcat Listener (TCP)

nc -lvp 12345

• nc: The netcat command.
• -l: Listen mode, for inbound connections.
• -v: Verbose output, shows connection details.
• -p 12345: Specifies port 12345 to listen on. (Note: some netcat versions might not require -p for listen port, just -l 12345)

PowerShell Listener (TCP)

$port = 12345
$listener = New-Object System.Net.Sockets.TcpListener([System.Net.IPAddress]::Any, $port)
$listener.Start()
Write-Host "Listening on port $port..."
$client = $listener.AcceptTcpClient()
$stream = $client.GetStream()
$reader = New-Object System.IO.StreamReader($stream)
$writer = New-Object System.IO.StreamWriter($stream)
$writer.AutoFlush = $true

Write-Host "Client connected!"

while ($true) {
    $data = $reader.ReadLine()
    if (-not $data) { break }
    Write-Host "Received: $data"
    $writer.WriteLine("Echo: $data")
}

$client.Close()
$listener.Stop()
Write-Host "Connection closed."

This PowerShell script creates a TCP listener, accepts a single client connection, reads lines of text, echoes them back, and then closes the connection when the client disconnects.

Connecting as a Client

Once your listener is running, you can connect to it from another command prompt (or another machine) using a client. This client will send data to the listener.

Netcat Client (TCP)

nc 127.0.0.1 12345

• nc: The netcat command.
• 127.0.0.1: The IP address of the listener (use localhost or the actual IP if on a different machine).
• 12345: The port the listener is on.

After running this, anything you type into the client's command prompt will be sent to the listener.

PowerShell Client (TCP)

$ip = "127.0.0.1"
$port = 12345
$client = New-Object System.Net.Sockets.TcpClient($ip, $port)
$stream = $client.GetStream()
$writer = New-Object System.IO.StreamWriter($stream)
$reader = New-Object System.IO.StreamReader($stream)
$writer.AutoFlush = $true

Write-Host "Connected to $ip:$port. Type messages and press Enter. Type 'exit' to quit."

while ($true) {
    $message = Read-Host "Send"
    if ($message -eq "exit") { break }
    $writer.WriteLine($message)
    $response = $reader.ReadLine()
    Write-Host "Received from server: $response"
}

$client.Close()
Write-Host "Disconnected."

This PowerShell script connects to the specified IP and port, allows you to send messages, and displays responses from the server.

Using UDP Sockets

While TCP provides reliable, ordered, and error-checked delivery of a stream of bytes, UDP (User Datagram Protocol) is a connectionless protocol that offers a simpler, faster, but unreliable service. It's often used for applications where speed is more critical than guaranteed delivery, like streaming media or online gaming. Both netcat and PowerShell can handle UDP connections.

Netcat UDP Listener

nc -luvp 12346

• -u: Specifies UDP mode.

Netcat UDP Client

nc -u 127.0.0.1 12346

• -u: Specifies UDP mode.

1. Download Netcat (if not available)

If you don't have netcat, you can download a Windows binary from various sources (e.g., Nmap's ncat or a standalone netcat build). Place the executable in a directory included in your system's PATH, or navigate to its directory in your command prompt.

2. Open Two Command Prompts

You'll need one command prompt (or PowerShell window) for the listener (server) and another for the client.

3. Start the Listener

In the first command prompt, run the netcat or PowerShell listener command (e.g., nc -lvp 12345). You should see a message indicating it's listening.

4. Connect with the Client

In the second command prompt, run the netcat or PowerShell client command (e.g., nc 127.0.0.1 12345).

5. Send and Receive Data

Type messages in the client window and press Enter. Observe them appearing in the listener window. If using the PowerShell TCP scripts, you'll also see echoes back to the client.

6. Close Connections

To close netcat connections, press Ctrl+C in both windows. For PowerShell scripts, follow their specific exit instructions (e.g., type 'exit' for the client).