Introduction
One of the best ways to understand TCP networking is by building a simple port scanner.
A port scanner attempts to connect to remote TCP ports and determines whether they are available. While the implementation may be small, it exposes several important networking concepts:
- TCP connections
- Client-server communication
- TCP handshakes
- Open and closed ports
- Exception handling
- Socket programming
- F# pattern matching
This article explores how a simple F# program can test TCP port availability and introduces the exception-handling syntax commonly used in networking applications.
What Is a TCP Port?
A TCP port is a logical communication endpoint.
Servers listen on ports waiting for incoming connections.
Examples:
| Service |
Port |
| HTTP |
80 |
| HTTPS |
443 |
| SSH |
22 |
| SMTP |
25 |
| FTP |
21 |
When a client wants to communicate with a service, it attempts to establish a TCP connection to the target port.
What Is Port Scanning?
Port scanning is the process of testing one or more ports to determine whether they are accepting connections.
A scanner typically reports:
| State |
Meaning |
| Open |
Service accepts connections |
| Closed |
Service rejects connections |
| Filtered |
Firewall blocks traffic |
| Unreachable |
Host cannot be reached |
Port scanners are widely used in:
- Network administration
- Security auditing
- Asset discovery
- Troubleshooting
- Cybersecurity assessments
Understanding TCP Connections
Before data can be exchanged, TCP establishes a connection between client and server.
The client sends a connection request.
The server responds.
Once both sides agree, communication begins.
If the connection succeeds, the port is considered open.
If the connection fails, the scanner can infer that the service is unavailable or inaccessible.
Connecting with TcpClient
The .NET networking library provides the TcpClient class.
A connection can be created using:
use client =
new TcpClient("scanme.nmap.org", 80)
This statement attempts to connect to:
- Host:
scanme.nmap.org
- Port:
80
If the connection succeeds, the object is created successfully.
A Minimal TCP Scanner
The entire scanner can fit into a few lines of code.
try
use client =
new TcpClient("scanme.nmap.org", 80)
printfn "Connection successful"
with
| :? SocketException ->
printfn "Connection failed"
The scanner attempts a TCP connection.
Success indicates an open port.
Failure generates a networking exception.
Why Error Handling Matters
Networks are unpredictable.
Many things can go wrong:
- Host offline
- Service unavailable
- Firewall blocking traffic
- DNS resolution failure
- Routing problems
Instead of crashing, the application should handle these failures gracefully.
That is where exception handling becomes important.
Understanding the try Block
The try keyword marks code that might fail.
Example:
try
connect()
Meaning:
Attempt this operation.
If an error occurs,
handle it below.
Networking operations are common candidates for try blocks because they depend on external systems.
Understanding the with Keyword
The with keyword begins exception handling.
Example:
try
connect()
with
Meaning:
If an exception occurs,
look for a matching handler.
The runtime compares the exception against each rule that follows.
Understanding the Pipe Operator
The pipe symbol introduces a pattern-matching case.
Example:
| pattern -> action
Each pipe represents a possible match.
Example:
with
| case1 -> ...
| case2 -> ...
| case3 -> ...
The first matching case executes.
Understanding the Type Test Operator
One of the most important operators in F# exception handling is:
:?
This performs a runtime type check.
Example:
:? SocketException
Meaning:
Is this exception a SocketException?
If yes, the match succeeds.
If no, F# continues searching for another handler.
Understanding SocketException
SocketException is a .NET exception used for networking errors.
Namespace:
System.Net.Sockets
Typical causes include:
| Error |
Description |
| Connection Refused |
Service not listening |
| Timeout |
No response received |
| Host Not Found |
DNS lookup failed |
| Network Unreachable |
Routing issue |
| Connection Reset |
Peer closed connection |
Because networking failures are common, SocketException appears frequently in TCP applications.
Understanding the Arrow Operator
The arrow operator is:
->
It means:
If this pattern matches,
execute the code on the right.
Example:
| :? SocketException ->
printfn "Connection failed"
Meaning:
If the exception is a SocketException,
print an error message.
Execution Flow
Let's walk through the scanner step by step.
Step 1
Attempt TCP connection.
new TcpClient(...)
Step 2
Connection succeeds.
Output:
Connection successful
or
Step 3
Connection fails.
A SocketException is thrown.
Step 4
The exception handler matches:
:? SocketException
Step 5
The failure message is displayed.
Connection failed
Why Port Scanners Use Exceptions
Port scanners depend heavily on connection outcomes.
Successful connection:
Port Open
Connection refused:
Port Closed
Timeout:
Port Filtered
Host unreachable:
Target Unreachable
Exceptions provide a simple way to classify these outcomes.
Real-World Applications
TCP scanning forms the foundation of:
- Vulnerability assessment
- Service discovery
- Asset inventory
- Penetration testing
- Network troubleshooting
- Security monitoring
Understanding how scanners work also helps administrators better understand firewall behavior and network exposure.
Key Takeaways
- TCP scanners determine port availability by attempting connections.
TcpClient provides a simple way to establish TCP sessions.- Successful connections indicate open ports.
- Failed connections generate exceptions.
SocketException represents common networking failures.try identifies code that may fail.with starts exception handling.| introduces pattern-matching cases.:? performs runtime type testing.-> specifies the action to execute after a successful match.- Concurrency is essential for high-performance scanning.
Conclusion
Building a TCP port scanner is an excellent introduction to networking and systems programming.
Even a small scanner demonstrates several foundational concepts, including TCP connections, port states, socket programming, exception handling, and pattern matching.
For F# developers, understanding how SocketException integrates with pattern matching provides a clean and expressive way to handle networking failures while building reliable network applications.
