#605

pending completion

Build # #605

Build Type

push

github-actions

Committed by

web-flow

Commit Message

<a href="https://github.com/Badgerati/Pode/commit/<a class=hub.com/Badgerati/Pode/commit/0b8ce829e5c7801bdd0770e3903f72f29ec1c80e">0b8ce829e<a href="https://github.com/Badgerati/Pode/commit/0b8ce829e5c7801bdd0770e3903f72f29ec1c80e">">Merge </a><a class="double-link" href="https://github.com/Badgerati/Pode/commit/<a class="double-link" href="https://github.com/Badgerati/Pode/commit/bc420ca26a164f295d7a592b73c39341a18e9735">bc420ca26</a>">bc420ca26</a><a href="https://github.com/Badgerati/Pode/commit/0b8ce829e5c7801bdd0770e3903f72f29ec1c80e"> into f2d649bbe">f2d649bbe</a>

Run Details

45 of 45 new or added lines in 12 files covered. (100.0%)

2575 of 5767 relevant lines covered (44.65%)

1.15 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/Private/Sockets.ps1

function Initialize-PodeSocketListenerEndpoint
{
    param(
        [Parameter(Mandatory=$true)]
        [ValidateSet('Sockets', 'WebSockets')]
        [string]
        $Type,

        [Parameter(Mandatory=$true)]
        [ipaddress]
        $Address,

        [Parameter(Mandatory=$true)]
        [int]
        $Port,

        [Parameter()]
        [X509Certificate]
        $Certificate
    )

    $endpoint = [IPEndpoint]::new($Address, $Port)
    $socket = [System.Net.Sockets.Socket]::new($endpoint.AddressFamily, [System.Net.Sockets.SocketType]::Stream, [System.Net.Sockets.ProtocolType]::Tcp)
    $socket.SetSocketOption([System.Net.Sockets.SocketOptionLevel]::Socket, [System.Net.Sockets.SocketOptionName]::KeepAlive, $false)
    $socket.ReceiveTimeout = $PodeContext.Server.Sockets.ReceiveTimeout
    $socket.Bind($endpoint)
    $socket.Listen([int]::MaxValue)

    $protocol = (Resolve-PodeValue -Check ($null -eq $Certificate) -TrueValue 'http' -FalseValue 'https')
    if ($Type -ieq 'WebSockets') {
        $protocol = (Resolve-PodeValue -Check ($null -eq $Certificate) -TrueValue 'ws' -FalseValue 'wss')
    }

    return @{
        Type = $Type
        Socket = $socket
        Certificate = $Certificate
        Protocol = $protocol
    }
}

function New-PodeSocketListenerEvent
{
    param(
        [Parameter(Mandatory=$true)]
        $Listener,

        [Parameter()]
        [int]
        $Index = 0
    )

    Lock-PodeObject -Object $PodeContext.Server[$Listener.Type] -Return -ScriptBlock {
        $socketArgs = [System.Net.Sockets.SocketAsyncEventArgs]::new()

        if ($Index -eq 0) {
            $PodeContext.Server[$Listener.Type].MaxConnections++
            $Index = $PodeContext.Server[$Listener.Type].MaxConnections
        }

        $name = (Get-PodeSocketListenerConnectionEventName -Type $Listener.Type -Id $Index)
        Register-ObjectEvent -InputObject $socketArgs -EventName 'Completed' -SourceIdentifier $name -Action {
            Invoke-PodeSocketProcessAccept -Arguments $Event.SourceEventArgs
        } | Out-Null

        return $socketArgs
    }
}

function Start-PodeSocketListener
{
    param(
        [Parameter(Mandatory=$true)]
        [hashtable[]]
        $Listeners
    )

    foreach ($listener in $Listeners) {
        Invoke-PodeSocketAccept -Listener $listener
    }
}

function Close-PodeSocket
{
    param(
        [Parameter()]
        [System.Net.Sockets.Socket]
        $Socket,

        [switch]
        $Shutdown
    )

    if ($null -eq $Socket) {
        return
    }

    if ($Shutdown -and $Socket.Connected) {
        $Socket.Shutdown([System.Net.Sockets.SocketShutdown]::Both)
    }

    Close-PodeDisposable -Disposable $Socket -Close
}

function Close-PodeSocketListener
{
    param(
        [Parameter(Mandatory=$true)]
        [ValidateSet('Sockets', 'WebSockets')]
        [string]
        $Type
    )

    try {
        # close all open sockets
        if ($Type -ieq 'WebSockets') {
            for ($i = $PodeContext.Server[$Type].Queues.Sockets.Count - 1; $i -ge 0; $i--) {
                Close-PodeSocket -Socket $PodeContext.Server[$Type].Queues.Sockets[$i].Socket -Shutdown
            }

            $PodeContext.Server[$Type].Queues.Sockets.Clear()
        }

        # close all open listeners and unbind events
        for ($i = $PodeContext.Server[$Type].Listeners.Length - 1; $i -ge 0; $i--) {
            Close-PodeSocket -Socket $PodeContext.Server[$Type].Listeners[$i].Socket -Shutdown
        }

        $PodeContext.Server[$Type].Listeners = @()
    }
    catch {
        $_.Exception | Out-PodeHost
    }
}

function Invoke-PodeSocketAccept
{
    param(
        [Parameter(Mandatory=$true)]
        $Listener
    )

    # pop args from queue (or create a new one)
    $arguments = $null
    if (!$PodeContext.Server[$Listener.Type].Queues.Connections.TryDequeue([ref]$arguments)) {
        $arguments = New-PodeSocketListenerEvent -Listener $Listener
    }

    $arguments.AcceptSocket = $null
    $arguments.UserToken = $Listener
    $raised = $false

    try {
        $raised = $arguments.UserToken.Socket.AcceptAsync($arguments)
    }
    catch [System.ObjectDisposedException] {
        return
    }

    if (!$raised) {
        Invoke-PodeSocketProcessAccept -Arguments $arguments
    }
}

function Invoke-PodeSocketProcessAccept
{
    param(
        [Parameter(Mandatory=$true)]
        [System.Net.Sockets.SocketAsyncEventArgs]
        $Arguments
    )

    # get the socket and listener
    $accepted = $Arguments.AcceptSocket
    $listener = $Arguments.UserToken
    $errors = $Arguments.SocketError

    # reset the socket args
    $Arguments.AcceptSocket = $null
    $Arguments.UserToken = $null

    # start accepting connections again for the listener
    Invoke-PodeSocketAccept -Listener $listener

    # if not success, close this accept socket and accept again
    if (($null -eq $accepted) -or ($errors -ne [System.Net.Sockets.SocketError]::Success)) {
        # close socket
        if ($null -ne $accepted) {
            $accepted.Close()
        }

        # add args back to pool
        $PodeContext.Server[$listener.Type].Queues.Connections.Enqueue($Arguments)
        return
    }

    # add args back to pool
    $PodeContext.Server[$listener.Type].Queues.Connections.Enqueue($Arguments)

    switch ($listener.Type.ToLowerInvariant()) {
        'sockets' {
            Invoke-PodeSocketHandler -Context @{
                Socket = $accepted
                Certificate = $listener.Certificate
                Protocol = $listener.Protocol
            }
        }

        'websockets' {
            Invoke-PodeWebSocketHandler -Context @{
                Socket = $accepted
                Certificate = $listener.Certificate
                Protocol = $listener.Protocol
            }
        }
    }
}

function Get-PodeSocketCertifcateCallback
{
    return ([System.Net.Security.RemoteCertificateValidationCallback]{
        param(
            [Parameter()]
            [object]
            $Sender,

            [Parameter()]
            [X509Certificate]
            $Certificate,

            [Parameter()]
            [System.Security.Cryptography.X509Certificates.X509Chain]
            $Chain,

            [Parameter()]
            [System.Net.Security.SslPolicyErrors]
            $SslPolicyErrors
        )

        # if there is no client cert, just allow it
        if ($null -eq $Certificate) {
            return $true
        }

        # if we have a cert, but there are errors, fail
        return ($SslPolicyErrors -ne [System.Net.Security.SslPolicyErrors]::None)
    })
}

function Get-PodeSocketListenerConnectionEventName
{
    param (
        [Parameter(Mandatory=$true)]
        [ValidateSet('Sockets', 'WebSockets')]
        [string]
        $Type,

        [Parameter(Mandatory=$true)]
        [int]
        $Id
    )

    return "PodeListenerConnection$($Type)Completed_$($Id)"
}

function Get-PodeServerRequestDetails
{
    param(
        [Parameter()]
        [byte[]]
        $Bytes,

        [Parameter(Mandatory=$true)]
        [string]
        $Protocol
    )

    # convert array to string
    $Content = $PodeContext.Server.Encoding.GetString($Bytes, 0, $Bytes.Length)

    # parse the request headers
    $newLine = "`r`n"
    if (!$Content.Contains($newLine)) {
        $newLine = "`n"
    }

    $req_lines = ($Content -isplit $newLine)

    # first line is the request info
    $req_line_info = ($req_lines[0].Trim() -isplit '\s+')
    if ($req_line_info.Length -ne 3) {
        throw [System.Net.Http.HttpRequestException]::new("Invalid request line: $($req_lines[0]) [$($req_line_info.Length)]")
    }

    $req_method = $req_line_info[0].Trim()
    if (@('DELETE', 'GET', 'HEAD', 'MERGE', 'OPTIONS', 'PATCH', 'POST', 'PUT', 'TRACE') -inotcontains $req_method) {
        throw [System.Net.Http.HttpRequestException]::new("Invalid request HTTP method: $($req_method)")
    }

    $req_query = $req_line_info[1].Trim()
    $req_proto = $req_line_info[2].Trim()
    if (!$req_proto.StartsWith('HTTP/')) {
        throw [System.Net.Http.HttpRequestException]::new("Invalid request version: $($req_proto)")
    }

    # then, read the headers
    $req_headers = @{}
    $req_body_index = 0
    for ($i = 1; $i -le $req_lines.Length -1; $i++) {
        $line = $req_lines[$i].Trim()
        if ([string]::IsNullOrWhiteSpace($line)) {
            $req_body_index = $i + 1
            break
        }

        $index = $line.IndexOf(':')
        $name = $line.Substring(0, $index).Trim()
        $value = $line.Substring($index + 1).Trim()
        $req_headers[$name] = $value
    }

    # attempt to get content length, and see if content is chunked
    $contentLength = $req_headers['Content-Length']
    if (![string]::IsNullOrWhiteSpace($contentLength)) {
        $contentLength = 0
    }

    $transferEncoding = $req_headers['Transfer-Encoding']
    if (![string]::IsNullOrWhiteSpace($transferEncoding)) {
        $isChunked = $transferEncoding.Contains('chunked')
    }

    # if chunked, and we have a content-length, fail
    if ($isChunked -and ($contentLength -gt 0)) {
        throw [System.Net.Http.HttpRequestException]::new("Cannot supply a Content-Length and a chunked Transfer-Encoding")
    }

    # then set the request body
    $req_body = ($req_lines[($req_body_index)..($req_lines.Length - 1)] -join $newLine)

    # then set the raw bytes of the request body
    $start = 0

    $lines = $req_lines[0..($req_body_index - 1)]
    foreach ($line in $lines) {
        $start += $line.Length
    }

    $start += ($lines.Length * $newLine.Length)

    # if chunked
    if ($isChunked) {
        $length = -1
        $req_body_bytes = [byte[]]@()

        while ($length -ne 0) {
            # get index of newline char, read start>index bytes as HEX for length
            $index = [array]::IndexOf($Bytes, [byte]$newLine[0], $start)
            $hexBytes = $Bytes[$start..($index - 1)]

            $hex = [string]::Empty
            foreach ($b in $hexBytes) {
                $hex += ([char]$b)
            }

            # if length is 0, end
            $length = [System.Convert]::ToInt32($hex, 16)
            if ($length -eq 0) {
                continue
            }

            # read those X hex bytes from (newline index + newline length)
            $start = $index + $newLine.Length
            $end = $start + $length - 1
            $req_body_bytes += $Bytes[$start..$end]

            # skip bytes for ending newline, and set new start
            $start = ($end + $newLine.Length + 1)
        }
    }

    # else if content-length
    elseif ($contentLength -gt 0) {
        $req_body_bytes = $Bytes[$start..($start + $contentLength)]
    }

    # else read all
    else {
        $req_body_bytes = $Bytes[$start..($Bytes.Length - 1)]
    }

    # build required URI details
    $req_uri = [uri]::new("$($Protocol)://$($req_headers['Host'])$($req_query)")

    # return the details
    return @{
        Method = $req_method
        Query = $req_query
        Protocol = $req_proto
        Headers = $req_headers
        Body = $req_body
        RawBody = $req_body_bytes
        Uri = $req_uri
    }
}

1	function Initialize-PodeSocketListenerEndpoint
2	{
3	param(
4	[Parameter(Mandatory=$true)]
5	[ValidateSet('Sockets', 'WebSockets')]
6	[string]
7	$Type,
8
9	[Parameter(Mandatory=$true)]
10	[ipaddress]
11	$Address,
12
13	[Parameter(Mandatory=$true)]
14	[int]
15	$Port,
16
17	[Parameter()]
18	[X509Certificate]
19	$Certificate
20	)
21
22	$endpoint = [IPEndpoint]::new($Address, $Port)	×
23	$socket = [System.Net.Sockets.Socket]::new($endpoint.AddressFamily, [System.Net.Sockets.SocketType]::Stream, [System.Net.Sockets.ProtocolType]::Tcp)	×
24	$socket.SetSocketOption([System.Net.Sockets.SocketOptionLevel]::Socket, [System.Net.Sockets.SocketOptionName]::KeepAlive, $false)	×
25	$socket.ReceiveTimeout = $PodeContext.Server.Sockets.ReceiveTimeout	×
26	$socket.Bind($endpoint)	×
27	$socket.Listen([int]::MaxValue)	×
28
29	$protocol = (Resolve-PodeValue -Check ($null -eq $Certificate) -TrueValue 'http' -FalseValue 'https')	×
30	if ($Type -ieq 'WebSockets') {	×
31	$protocol = (Resolve-PodeValue -Check ($null -eq $Certificate) -TrueValue 'ws' -FalseValue 'wss')	×
32	}
33
34	return @{	×
35	Type = $Type	×
36	Socket = $socket	×
37	Certificate = $Certificate	×
38	Protocol = $protocol	×
39	}
40	}
41
42	function New-PodeSocketListenerEvent
43	{
44	param(
45	[Parameter(Mandatory=$true)]
46	$Listener,
47
48	[Parameter()]
49	[int]
50	$Index = 0
51	)
52
53	Lock-PodeObject -Object $PodeContext.Server[$Listener.Type] -Return -ScriptBlock {	×
54	$socketArgs = [System.Net.Sockets.SocketAsyncEventArgs]::new()	×
55
56	if ($Index -eq 0) {	×
57	$PodeContext.Server[$Listener.Type].MaxConnections++	×
58	$Index = $PodeContext.Server[$Listener.Type].MaxConnections	×
59	}
60
61	$name = (Get-PodeSocketListenerConnectionEventName -Type $Listener.Type -Id $Index)	×
62	Register-ObjectEvent -InputObject $socketArgs -EventName 'Completed' -SourceIdentifier $name -Action {	×
63	Invoke-PodeSocketProcessAccept -Arguments $Event.SourceEventArgs	×
64	} \| Out-Null	×
65
66	return $socketArgs	×
67	}
68	}
69
70	function Start-PodeSocketListener
71	{
72	param(
73	[Parameter(Mandatory=$true)]
74	[hashtable[]]
75	$Listeners
76	)
77
78	foreach ($listener in $Listeners) {	×
79	Invoke-PodeSocketAccept -Listener $listener	×
80	}
81	}
82
83	function Close-PodeSocket
84	{
85	param(
86	[Parameter()]
87	[System.Net.Sockets.Socket]
88	$Socket,
89
90	[switch]
91	$Shutdown
92	)
93
94	if ($null -eq $Socket) {	×
95	return
96	}
97
98	if ($Shutdown -and $Socket.Connected) {	×
99	$Socket.Shutdown([System.Net.Sockets.SocketShutdown]::Both)	×
100	}
101
102	Close-PodeDisposable -Disposable $Socket -Close	×
103	}
104
105	function Close-PodeSocketListener
106	{
107	param(
108	[Parameter(Mandatory=$true)]
109	[ValidateSet('Sockets', 'WebSockets')]
110	[string]
111	$Type
112	)
113
114	try {
115	# close all open sockets
116	if ($Type -ieq 'WebSockets') {	×
117	for ($i = $PodeContext.Server[$Type].Queues.Sockets.Count - 1; $i -ge 0; $i--) {	×
118	Close-PodeSocket -Socket $PodeContext.Server[$Type].Queues.Sockets[$i].Socket -Shutdown	×
119	}
120
121	$PodeContext.Server[$Type].Queues.Sockets.Clear()	×
122	}
123
124	# close all open listeners and unbind events
125	for ($i = $PodeContext.Server[$Type].Listeners.Length - 1; $i -ge 0; $i--) {	×
126	Close-PodeSocket -Socket $PodeContext.Server[$Type].Listeners[$i].Socket -Shutdown	×
127	}
128
129	$PodeContext.Server[$Type].Listeners = @()	×
130	}
131	catch {
132	$_.Exception \| Out-PodeHost	×
133	}
134	}
135
136	function Invoke-PodeSocketAccept
137	{
138	param(
139	[Parameter(Mandatory=$true)]
140	$Listener
141	)
142
143	# pop args from queue (or create a new one)
144	$arguments = $null	×
145	if (!$PodeContext.Server[$Listener.Type].Queues.Connections.TryDequeue([ref]$arguments)) {	×
146	$arguments = New-PodeSocketListenerEvent -Listener $Listener	×
147	}
148
149	$arguments.AcceptSocket = $null	×
150	$arguments.UserToken = $Listener	×
151	$raised = $false	×
152
153	try {
154	$raised = $arguments.UserToken.Socket.AcceptAsync($arguments)	×
155	}
156	catch [System.ObjectDisposedException] {
157	return
158	}
159
160	if (!$raised) {	×
161	Invoke-PodeSocketProcessAccept -Arguments $arguments	×
162	}
163	}
164
165	function Invoke-PodeSocketProcessAccept
166	{
167	param(
168	[Parameter(Mandatory=$true)]
169	[System.Net.Sockets.SocketAsyncEventArgs]
170	$Arguments
171	)
172
173	# get the socket and listener
174	$accepted = $Arguments.AcceptSocket	×
175	$listener = $Arguments.UserToken	×
176	$errors = $Arguments.SocketError	×
177
178	# reset the socket args
179	$Arguments.AcceptSocket = $null	×
180	$Arguments.UserToken = $null	×
181
182	# start accepting connections again for the listener
183	Invoke-PodeSocketAccept -Listener $listener	×
184
185	# if not success, close this accept socket and accept again
186	if (($null -eq $accepted) -or ($errors -ne [System.Net.Sockets.SocketError]::Success)) {	×
187	# close socket
188	if ($null -ne $accepted) {	×
189	$accepted.Close()	×
190	}
191
192	# add args back to pool
193	$PodeContext.Server[$listener.Type].Queues.Connections.Enqueue($Arguments)	×
194	return
195	}
196
197	# add args back to pool
198	$PodeContext.Server[$listener.Type].Queues.Connections.Enqueue($Arguments)	×
199
200	switch ($listener.Type.ToLowerInvariant()) {	×
201	'sockets' {
202	Invoke-PodeSocketHandler -Context @{	×
203	Socket = $accepted	×
204	Certificate = $listener.Certificate	×
205	Protocol = $listener.Protocol	×
206	}
207	}
208
209	'websockets' {
210	Invoke-PodeWebSocketHandler -Context @{	×
211	Socket = $accepted	×
212	Certificate = $listener.Certificate	×
213	Protocol = $listener.Protocol	×
214	}
215	}
216	}
217	}
218
219	function Get-PodeSocketCertifcateCallback
220	{
221	return ([System.Net.Security.RemoteCertificateValidationCallback]{	×
222	param(
223	[Parameter()]
224	[object]
225	$Sender,
226
227	[Parameter()]
228	[X509Certificate]
229	$Certificate,
230
231	[Parameter()]
232	[System.Security.Cryptography.X509Certificates.X509Chain]
233	$Chain,
234
235	[Parameter()]
236	[System.Net.Security.SslPolicyErrors]
237	$SslPolicyErrors
238	)
239
240	# if there is no client cert, just allow it
241	if ($null -eq $Certificate) {	×
242	return $true	×
243	}
244
245	# if we have a cert, but there are errors, fail
246	return ($SslPolicyErrors -ne [System.Net.Security.SslPolicyErrors]::None)	×
247	})
248	}
249
250	function Get-PodeSocketListenerConnectionEventName
251	{
252	param (
253	[Parameter(Mandatory=$true)]
254	[ValidateSet('Sockets', 'WebSockets')]
255	[string]
256	$Type,
257
258	[Parameter(Mandatory=$true)]
259	[int]
260	$Id
261	)
262
263	return "PodeListenerConnection$($Type)Completed_$($Id)"	×
264	}
265
266	function Get-PodeServerRequestDetails
267	{
268	param(
269	[Parameter()]
270	[byte[]]
271	$Bytes,
272
273	[Parameter(Mandatory=$true)]
274	[string]
275	$Protocol
276	)
277
278	# convert array to string
279	$Content = $PodeContext.Server.Encoding.GetString($Bytes, 0, $Bytes.Length)	×
280
281	# parse the request headers
282	$newLine = "`r`n"	×
283	if (!$Content.Contains($newLine)) {	×
284	$newLine = "`n"	×
285	}
286
287	$req_lines = ($Content -isplit $newLine)	×
288
289	# first line is the request info
290	$req_line_info = ($req_lines[0].Trim() -isplit '\s+')	×
291	if ($req_line_info.Length -ne 3) {	×
292	throw [System.Net.Http.HttpRequestException]::new("Invalid request line: $($req_lines[0]) [$($req_line_info.Length)]")	×
293	}
294
295	$req_method = $req_line_info[0].Trim()	×
296	if (@('DELETE', 'GET', 'HEAD', 'MERGE', 'OPTIONS', 'PATCH', 'POST', 'PUT', 'TRACE') -inotcontains $req_method) {	×
297	throw [System.Net.Http.HttpRequestException]::new("Invalid request HTTP method: $($req_method)")	×
298	}
299
300	$req_query = $req_line_info[1].Trim()	×
301	$req_proto = $req_line_info[2].Trim()	×
302	if (!$req_proto.StartsWith('HTTP/')) {	×
303	throw [System.Net.Http.HttpRequestException]::new("Invalid request version: $($req_proto)")	×
304	}
305
306	# then, read the headers
307	$req_headers = @{}	×
308	$req_body_index = 0	×
309	for ($i = 1; $i -le $req_lines.Length -1; $i++) {	×
310	$line = $req_lines[$i].Trim()	×
311	if ([string]::IsNullOrWhiteSpace($line)) {	×
312	$req_body_index = $i + 1	×
313	break
314	}
315
316	$index = $line.IndexOf(':')	×
317	$name = $line.Substring(0, $index).Trim()	×
318	$value = $line.Substring($index + 1).Trim()	×
319	$req_headers[$name] = $value	×
320	}
321
322	# attempt to get content length, and see if content is chunked
323	$contentLength = $req_headers['Content-Length']	×
324	if (![string]::IsNullOrWhiteSpace($contentLength)) {	×
325	$contentLength = 0	×
326	}
327
328	$transferEncoding = $req_headers['Transfer-Encoding']	×
329	if (![string]::IsNullOrWhiteSpace($transferEncoding)) {	×
330	$isChunked = $transferEncoding.Contains('chunked')	×
331	}
332
333	# if chunked, and we have a content-length, fail
334	if ($isChunked -and ($contentLength -gt 0)) {	×
335	throw [System.Net.Http.HttpRequestException]::new("Cannot supply a Content-Length and a chunked Transfer-Encoding")	×
336	}
337
338	# then set the request body
339	$req_body = ($req_lines[($req_body_index)..($req_lines.Length - 1)] -join $newLine)	×
340
341	# then set the raw bytes of the request body
342	$start = 0	×
343
344	$lines = $req_lines[0..($req_body_index - 1)]	×
345	foreach ($line in $lines) {	×
346	$start += $line.Length	×
347	}
348
349	$start += ($lines.Length * $newLine.Length)	×
350
351	# if chunked
352	if ($isChunked) {	×
353	$length = -1	×
354	$req_body_bytes = [byte[]]@()	×
355
356	while ($length -ne 0) {	×
357	# get index of newline char, read start>index bytes as HEX for length
358	$index = [array]::IndexOf($Bytes, [byte]$newLine[0], $start)	×
359	$hexBytes = $Bytes[$start..($index - 1)]	×
360
361	$hex = [string]::Empty	×
362	foreach ($b in $hexBytes) {	×
363	$hex += ([char]$b)	×
364	}
365
366	# if length is 0, end
367	$length = [System.Convert]::ToInt32($hex, 16)	×
368	if ($length -eq 0) {	×
369	continue
370	}
371
372	# read those X hex bytes from (newline index + newline length)
373	$start = $index + $newLine.Length	×
374	$end = $start + $length - 1	×
375	$req_body_bytes += $Bytes[$start..$end]	×
376
377	# skip bytes for ending newline, and set new start
378	$start = ($end + $newLine.Length + 1)	×
379	}
380	}
381
382	# else if content-length
383	elseif ($contentLength -gt 0) {	×
384	$req_body_bytes = $Bytes[$start..($start + $contentLength)]	×
385	}
386
387	# else read all
388	else {
389	$req_body_bytes = $Bytes[$start..($Bytes.Length - 1)]	×
390	}
391
392	# build required URI details
393	$req_uri = [uri]::new("$($Protocol)://$($req_headers['Host'])$($req_query)")	×
394
395	# return the details
396	return @{	×
397	Method = $req_method	×
398	Query = $req_query	×
399	Protocol = $req_proto	×
400	Headers = $req_headers	×
401	Body = $req_body	×
402	RawBody = $req_body_bytes	×
403	Uri = $req_uri	×
404	}
405	}

Badgerati / Pode / #605

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous