PoshCode Logo PowerShell Code Repository

Test-Port by stratafs01file 6 weeks ago (modification of post by Boe Prox view diff)
diff | embed code: <script type="text/javascript" src="http://PoshCode.org/embed/6663"></script>download | new post

Advanced function used to test UDP or TCP port/s on one or more systems to determine if it is open or not.

  1. function Test-Port{
  2. <#  
  3. .SYNOPSIS  
  4.     Tests port on computer.
  5. .DESCRIPTION
  6.     Tests port on computer.
  7. .PARAMETER computer
  8.     Name of server to test the port connection on.
  9. .PARAMETER port
  10.     Port to test  
  11. .PARAMETER tcp
  12.     Use tcp port  
  13. .PARAMETER udp
  14.     Use udp port  
  15. .PARAMETER UDPTimeOut
  16.     Sets a timeout for UDP port query. (In milliseconds, Default is 1000)  
  17. .PARAMETER TCPTimeOut
  18.     Sets a timeout for TCP port query. (In milliseconds, Default is 1000)            
  19. .NOTES  
  20.     Name: Test-Port.ps1
  21.     Author: Boe Prox
  22.     DateCreated: 18Aug2010  
  23.     List of Ports: http://www.iana.org/assignments/port-numbers
  24.      
  25.     To Do:
  26.         Add capability to run background jobs for each host to shorten the time to scan.        
  27. .LINK  
  28.     https://boeprox.wordpress.org
  29. .EXAMPLE  
  30.     Test-Port -computer 'server' -port 80
  31.     Checks port 80 on server 'server' to see if it is listening
  32. .EXAMPLE  
  33.     'server' | Test-Port -port 80
  34.     Checks port 80 on server 'server' to see if it is listening  
  35. .EXAMPLE  
  36.     Test-Port -computer @("server1","server2") -port 80
  37.     Checks port 80 on server1 and server2 to see if it is listening    
  38. .EXAMPLE  
  39.     @("server1","server2") | Test-Port -port 80
  40.     Checks port 80 on server1 and server2 to see if it is listening  
  41. .EXAMPLE  
  42.     (Get-Content hosts.txt) | Test-Port -port 80
  43.     Checks port 80 on servers in host file to see if it is listening
  44. .EXAMPLE  
  45.     Test-Port -computer (Get-Content hosts.txt) -port 80
  46.     Checks port 80 on servers in host file to see if it is listening    
  47. .EXAMPLE  
  48.     Test-Port -computer (Get-Content hosts.txt) -port @(1..59)
  49.     Checks a range of ports from 1-59 on all servers in the hosts.txt file    
  50.            
  51. #>  
  52. [cmdletbinding(
  53.     DefaultParameterSetName = '',
  54.     ConfirmImpact = 'low'
  55. )]
  56.     Param(
  57.         [Parameter(
  58.             Mandatory = $True,
  59.             Position = 0,
  60.             ParameterSetName = '',
  61.             ValueFromPipeline = $True)]
  62.             [array]$computer,
  63.         [Parameter(
  64.             Position = 1,
  65.             Mandatory = $True,
  66.             ParameterSetName = '')]
  67.             [array]$port,
  68.         [Parameter(
  69.             Mandatory = $False,
  70.             ParameterSetName = '')]
  71.             [int]$TCPtimeout=1000,
  72.         [Parameter(
  73.             Mandatory = $False,
  74.             ParameterSetName = '')]
  75.             [int]$UDPtimeout=1000,            
  76.         [Parameter(
  77.             Mandatory = $False,
  78.             ParameterSetName = '')]
  79.             [switch]$TCP,
  80.         [Parameter(
  81.             Mandatory = $False,
  82.             ParameterSetName = '')]
  83.             [switch]$UDP            
  84.                          
  85.         )
  86.     Begin {
  87.         If (!$tcp -AND !$udp) {$tcp = $True}
  88.         #Typically you never do this, but in this case I felt it was for the benefit of the function
  89.         #as any errors will be noted in the output of the report        
  90.         $ErrorActionPreference = "SilentlyContinue"
  91.         $report = @()
  92.         }
  93.     Process {    
  94.         ForEach ($c in $computer) {
  95.             ForEach ($p in $port) {
  96.                 If ($tcp) {  
  97.                     #Create temporary holder  
  98.                     $temp = "" | Select Server, Port, TypePort, Open, Notes
  99.                     #Create object for connecting to port on computer
  100.                     $tcpobject = new-Object system.Net.Sockets.TcpClient
  101.                     #Connect to remote machine's port              
  102.                     $connect = $tcpobject.BeginConnect($c,$p,$null,$null)
  103.                     #Configure a timeout before quitting
  104.                     $wait = $connect.AsyncWaitHandle.WaitOne($TCPtimeout,$false)
  105.                     #If timeout
  106.                     If(!$wait) {
  107.                         #Close connection
  108.                         $tcpobject.Close()
  109.                         Write-Verbose "Connection Timeout"
  110.                         #Build report
  111.                         $temp.Server = $c
  112.                         $temp.Port = $p
  113.                         $temp.TypePort = "TCP"
  114.                         $temp.Open = "False"
  115.                         $temp.Notes = "Connection to Port Timed Out"
  116.                         }
  117.                     Else {
  118.                         $error.Clear()
  119.                         $tcpobject.EndConnect($connect) | out-Null
  120.                         #If error
  121.                         If($error[0]){
  122.                             #Begin making error more readable in report
  123.                             [string]$string = ($error[0].exception).message
  124.                             $message = (($string.split(":")[1]).replace('"',"")).TrimStart()
  125.                             $failed = $true
  126.                             }
  127.                         #Close connection    
  128.                         $tcpobject.Close()
  129.                         #If unable to query port to due failure
  130.                         If($failed){
  131.                             #Build report
  132.                             $temp.Server = $c
  133.                             $temp.Port = $p
  134.                             $temp.TypePort = "TCP"
  135.                             $temp.Open = "False"
  136.                             $temp.Notes = "$message"
  137.                             }
  138.                         #Successfully queried port    
  139.                         Else{
  140.                             #Build report
  141.                             $temp.Server = $c
  142.                             $temp.Port = $p
  143.                             $temp.TypePort = "TCP"
  144.                             $temp.Open = "True"  
  145.                             $temp.Notes = ""
  146.                             }
  147.                         }    
  148.                     #Reset failed value
  149.                     $failed = $Null    
  150.                     #Merge temp array with report            
  151.                     $report += $temp
  152.                     }    
  153.                 If ($udp) {
  154.                     #Create temporary holder  
  155.                     $temp = "" | Select Server, Port, TypePort, Open, Notes                                    
  156.                     #Create object for connecting to port on computer
  157.                     $udpobject = new-Object system.Net.Sockets.Udpclient($p)
  158.                     #Set a timeout on receiving message
  159.                     $udpobject.client.ReceiveTimeout = $UDPTimeout
  160.                     #Connect to remote machine's port              
  161.                     Write-Verbose "Making UDP connection to remote server"
  162.                     $udpobject.Connect("$c",$p)
  163.                     #Sends a message to the host to which you have connected.
  164.                     Write-Verbose "Sending message to remote host"
  165.                     $a = new-object system.text.asciiencoding
  166.                     $byte = $a.GetBytes("$(Get-Date)")
  167.                     [void]$udpobject.Send($byte,$byte.length)
  168.                     #IPEndPoint object will allow us to read datagrams sent from any source.
  169.                     Write-Verbose "Creating remote endpoint"
  170.                     $remoteendpoint = New-Object system.net.ipendpoint([system.net.ipaddress]::Any,0)
  171.                    
  172.                     Try {
  173.                         #Blocks until a message returns on this socket from a remote host.
  174.                         Write-Verbose "Waiting for message return"
  175.                         $receivebytes = $udpobject.Receive([ref]$remoteendpoint)
  176.                         [string]$returndata = $a.GetString($receivebytes)
  177.                         }
  178.  
  179.                     Catch {
  180.                         If ($Error[0].ToString() -match "\bRespond after a period of time\b") {
  181.                             #Close connection
  182.                             $udpobject.Close()
  183.                             #Make sure that the host is online and not a false positive that it is open
  184.                             If (Test-Connection -comp $c -count 1 -quiet) {
  185.                                 Write-Verbose "Connection Open"
  186.                                 #Build report
  187.                                 $temp.Server = $c
  188.                                 $temp.Port = $p
  189.                                 $temp.TypePort = "UDP"
  190.                                 $temp.Open = "True"
  191.                                 $temp.Notes = ""
  192.                                 }
  193.                             Else {
  194.                                 <#
  195.                                 It is possible that the host is not online or that the host is online,
  196.                                 but ICMP is blocked by a firewall and this port is actually open.
  197.                                 #>
  198.                                 Write-Verbose "Host maybe unavailable"
  199.                                 #Build report
  200.                                 $temp.Server = $c
  201.                                 $temp.Port = $p
  202.                                 $temp.TypePort = "UDP"
  203.                                 $temp.Open = "False"
  204.                                 $temp.Notes = "Unable to verify if port is open or if host is unavailable."                                
  205.                                 }                        
  206.                             }
  207.                         ElseIf ($Error[0].ToString() -match "forcibly closed by the remote host" ) {
  208.                             #Close connection
  209.                             $udpobject.Close()
  210.                             Write-Verbose "Connection Timeout"
  211.                             #Build report
  212.                             $temp.Server = $c
  213.                             $temp.Port = $p
  214.                             $temp.TypePort = "UDP"
  215.                             $temp.Open = "False"
  216.                             $temp.Notes = "Connection to Port Timed Out"                        
  217.                             }
  218.                         Else {
  219.                             $udpobject.close()
  220.                             }
  221.                         }    
  222.                     #Merge temp array with report            
  223.                     $report += $temp
  224.                     }                                
  225.                 }
  226.             }                
  227.         }
  228.     End {
  229.         #Generate Report
  230.         $report
  231.         }        
  232. }

Submit a correction or amendment below (
click here to make a fresh posting)
After submitting an amendment, you'll be able to view the differences between the old and new posts easily.

Syntax highlighting:


Remember me