#451

pending completion

Build # #451

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/42d7eceeab9a597888083275fe3a955780c934c0">42d7eceea<a href="https://github.com/Badgerati/Pode/commit/42d7eceeab9a597888083275fe3a955780c934c0">">Merge </a><a class="double-link" href="https://github.com/Badgerati/Pode/commit/<a class="double-link" href="https://github.com/Badgerati/Pode/commit/7663ed0aa0ec59d9af4419fd484c1aec2423e376">7663ed0aa</a>">7663ed0aa</a><a href="https://github.com/Badgerati/Pode/commit/42d7eceeab9a597888083275fe3a955780c934c0"> into 536b5448e">536b5448e</a>

Run Details

262 of 262 new or added lines in 11 files covered. (100.0%)

2260 of 4562 relevant lines covered (49.54%)

1.27 hits per line

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

0.0

/src/Private/SmtpServer.ps1

function Start-PodeSmtpServer
{
    # ensure we have smtp handlers
    if (Test-IsEmpty (Get-PodeHandler -Type Smtp)) {
        throw 'No SMTP handlers have been defined'
    }

    # grab the relavant port
    $port = $PodeContext.Server.Endpoints[0].Port
    if ($port -eq 0) {
        $port = 25
    }

    # get the IP address for the server
    $ipAddress = $PodeContext.Server.Endpoints[0].Address
    if (Test-PodeHostname -Hostname $ipAddress) {
        $ipAddress = (Get-PodeIPAddressesForHostname -Hostname $ipAddress -Type All | Select-Object -First 1)
        $ipAddress = (Get-PodeIPAddress $ipAddress)
    }

    try
    {
        # create the listener for smtp
        $endpoint = New-Object System.Net.IPEndPoint($ipAddress, $port)
        $listener = New-Object System.Net.Sockets.TcpListener -ArgumentList $endpoint

        # start listener
        $listener.Start()
    }
    catch {
        if ($null -ne $listener) {
            $listener.Stop()
        }

        throw $_.Exception
    }

    # script for listening out of for incoming requests
    $listenScript = {
        param (
            [Parameter(Mandatory=$true)]
            [ValidateNotNull()]
            $Listener,

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

        # scriptblock for the core smtp message processing logic
        $process = {
            # if there's no client, just return
            if ($null -eq $SmtpEvent.Client) {
                return
            }

            # variables to store data for later processing
            $mail_from = [string]::Empty
            $rcpt_tos = @()
            $data = [string]::Empty

            # open response to smtp request
            Write-PodeTcpClient -Message "220 $($PodeContext.Server.Endpoints[0].HostName) -- Pode Proxy Server"
            $msg = [string]::Empty

            # respond to smtp request
            while ($true)
            {
                try { $msg = (Read-PodeTcpClient) }
                catch {
                    $_ | Write-PodeErrorLog
                    break
                }

                try {
                    if (!(Test-IsEmpty $msg)) {
                        if ($msg.StartsWith('QUIT')) {
                            Write-PodeTcpClient -Message '221 Bye'
                            Close-PodeTcpConnection
                            break
                        }

                        if ($msg.StartsWith('EHLO') -or $msg.StartsWith('HELO')) {
                            Write-PodeTcpClient -Message '250 OK'
                        }

                        if ($msg.StartsWith('RCPT TO')) {
                            Write-PodeTcpClient -Message '250 OK'
                            $rcpt_tos += (Get-PodeSmtpEmail $msg)
                        }

                        if ($msg.StartsWith('MAIL FROM')) {
                            Write-PodeTcpClient -Message '250 OK'
                            $mail_from = (Get-PodeSmtpEmail $msg)
                        }

                        if ($msg.StartsWith('DATA'))
                        {
                            Write-PodeTcpClient -Message '354 Start mail input; end with <CR><LF>.<CR><LF>'
                            $data = (Read-PodeTcpClient)
                            Write-PodeTcpClient -Message '250 OK'

                            # set event data/headers
                            $SmtpEvent.Email.From = $mail_from
                            $SmtpEvent.Email.To = $rcpt_tos
                            $SmtpEvent.Email.Data = $data
                            $SmtpEvent.Email.Headers = (Get-PodeSmtpHeadersFromData $data)

                            # set the subject/priority/content-types
                            $SmtpEvent.Email.Subject = $SmtpEvent.Headers['Subject']
                            $SmtpEvent.Email.IsUrgent = (($SmtpEvent.Headers['Priority'] -ieq 'urgent') -or ($SmtpEvent.Headers['Importance'] -ieq 'high'))
                            $SmtpEvent.Email.ContentType = $SmtpEvent.Headers['Content-Type']
                            $SmtpEvent.Email.ContentEncoding = $SmtpEvent.Headers['Content-Transfer-Encoding']

                            # set the email body
                            $SmtpEvent.Email.Body = (Get-PodeSmtpBody -Data $data -ContentType $SmtpEvent.ContentType -ContentEncoding $SmtpEvent.ContentEncoding)

                            # call user handlers for processing smtp data
                            $handlers = Get-PodeHandler -Type Smtp
                            foreach ($name in $handlers.Keys) {
                                $handler = $handlers[$name]
                                Invoke-PodeScriptBlock -ScriptBlock $handler.Logic -Arguments (@($SmtpEvent) + @($handler.Arguments)) -Scoped -Splat
                            }

                            # reset the to list
                            $rcpt_tos = @()
                        }
                    }
                }
                catch [exception] {
                    $_ | Write-PodeErrorLog
                    throw $_.exception
                }
            }
        }

        try
        {
            while (!$PodeContext.Tokens.Cancellation.IsCancellationRequested)
            {
                # get an incoming request
                $client = (Wait-PodeTask -Task $Listener.AcceptTcpClientAsync())

                # convert the ip
                $ip = (ConvertTo-PodeIPAddress -Endpoint $client.Client.RemoteEndPoint)

                # ensure the request ip is allowed
                if (!(Test-PodeIPAccess -IP $ip) -or !(Test-PodeIPLimit -IP $ip)) {
                    Close-PodeTcpConnection -Quit
                }

                # deal with smtp call
                else {
                    $SmtpEvent = @{
                        Client = $client
                        Lockable = $PodeContext.Lockable
                        Email = $null
                    }

                    Invoke-PodeScriptBlock -ScriptBlock $process
                    Close-PodeTcpConnection -Quit
                }
            }
        }
        catch [System.OperationCanceledException] {
            Close-PodeTcpConnection -Quit
        }
        catch {
            $_ | Write-PodeErrorLog
            throw $_.Exception
        }
    }

    # start the runspace for listening on x-number of threads
    1..$PodeContext.Threads | ForEach-Object {
        Add-PodeRunspace -Type 'Main' -ScriptBlock $listenScript `
            -Parameters @{ 'Listener' = $listener; 'ThreadId' = $_ }
    }

    # script to keep smtp server listening until cancelled
    $waitScript = {
        param (
            [Parameter(Mandatory=$true)]
            [ValidateNotNull()]
            $Listener
        )

        try
        {
            while (!$PodeContext.Tokens.Cancellation.IsCancellationRequested)
            {
                Start-Sleep -Seconds 1
            }
        }
        catch [System.OperationCanceledException] {}
        catch {
            $_ | Write-PodeErrorLog
            throw $_.Exception
        }
        finally {
            if ($null -ne $Listener) {
                $Listener.Stop()
            }
        }
    }

    Add-PodeRunspace -Type 'Main' -ScriptBlock $waitScript -Parameters @{ 'Listener' = $listener }

    # state where we're running
    return @("smtp://$($PodeContext.Server.Endpoints[0].HostName):$($port)")
}


function Get-PodeSmtpEmail
{
    param (
        [Parameter()]
        [string]
        $Value
    )

    $tmp = @($Value -isplit ':')
    if ($tmp.Length -gt 1) {
        return $tmp[1].Trim().Trim(' <>')
    }

    return [string]::Empty
}

function Get-PodeSmtpBody
{
    param (
        [Parameter()]
        [string]
        $Data,

        [Parameter()]
        [string]
        $ContentType,

        [Parameter()]
        [string]
        $ContentEncoding
    )

    # split the message up
    $dataSplit = @($Data -isplit [System.Environment]::NewLine)

    # get the index of the first blank line, and last dot
    $indexOfBlankLine = $dataSplit.IndexOf([string]::Empty)
    $indexOfLastDot = [array]::LastIndexOf($dataSplit, '.')

    # get the body
    $body = ($dataSplit[($indexOfBlankLine + 1)..($indexOfLastDot - 2)] -join [System.Environment]::NewLine)

    # if there's no body, just return
    if (($indexOfLastDot -eq -1) -or (Test-IsEmpty $body)) {
        return $body
    }

    # decode body based on encoding
    switch ($ContentEncoding.ToLowerInvariant()) {
        'base64' {
            $body = [System.Convert]::FromBase64String($body)
        }
    }

    # only if body is bytes, first decode based on type
    switch ($ContentType) {
        { $_ -ilike '*utf-7*' } {
            $body = [System.Text.Encoding]::UTF7.GetString($body)
        }

        { $_ -ilike '*utf-8*' } {
            $body = [System.Text.Encoding]::UTF8.GetString($body)
        }

        { $_ -ilike '*utf-16*' } {
            $body = [System.Text.Encoding]::Unicode.GetString($body)
        }

        { $_ -ilike '*utf-32*' } {
            $body = [System.Text.Encoding]::UTF32.GetString($body)
        }
    }

    return $body
}

function Get-PodeSmtpHeadersFromData
{
    param (
        [Parameter()]
        [string]
        $Data
    )

    $headers = @{}
    $lines = @($Data -isplit [System.Environment]::NewLine)

    foreach ($line in $lines) {
        if ([string]::IsNullOrWhiteSpace($line)) {
            break
        }

        if ($line -imatch '^(?<name>.*?)\:\s+(?<value>.*?)$') {
            $headers[$Matches['name'].Trim()] = $Matches['value'].Trim()
        }
    }

    return $headers
}

1	function Start-PodeSmtpServer
2	{
3	# ensure we have smtp handlers
4	if (Test-IsEmpty (Get-PodeHandler -Type Smtp)) {	×
5	throw 'No SMTP handlers have been defined'	×
6	}
7
8	# grab the relavant port
9	$port = $PodeContext.Server.Endpoints[0].Port	×
10	if ($port -eq 0) {	×
11	$port = 25	×
12	}
13
14	# get the IP address for the server
15	$ipAddress = $PodeContext.Server.Endpoints[0].Address	×
16	if (Test-PodeHostname -Hostname $ipAddress) {	×
17	$ipAddress = (Get-PodeIPAddressesForHostname -Hostname $ipAddress -Type All \| Select-Object -First 1)	×
18	$ipAddress = (Get-PodeIPAddress $ipAddress)	×
19	}
20
21	try
22	{
23	# create the listener for smtp
24	$endpoint = New-Object System.Net.IPEndPoint($ipAddress, $port)	×
25	$listener = New-Object System.Net.Sockets.TcpListener -ArgumentList $endpoint	×
26
27	# start listener
28	$listener.Start()	×
29	}
30	catch {
31	if ($null -ne $listener) {	×
32	$listener.Stop()	×
33	}
34
35	throw $_.Exception	×
36	}
37
38	# script for listening out of for incoming requests
39	$listenScript = {	×
40	param (
41	[Parameter(Mandatory=$true)]
42	[ValidateNotNull()]
43	$Listener,
44
45	[Parameter(Mandatory=$true)]
46	[int]
47	$ThreadId
48	)
49
50	# scriptblock for the core smtp message processing logic
51	$process = {	×
52	# if there's no client, just return
53	if ($null -eq $SmtpEvent.Client) {	×
54	return
55	}
56
57	# variables to store data for later processing
58	$mail_from = [string]::Empty	×
59	$rcpt_tos = @()	×
60	$data = [string]::Empty	×
61
62	# open response to smtp request
63	Write-PodeTcpClient -Message "220 $($PodeContext.Server.Endpoints[0].HostName) -- Pode Proxy Server"	×
64	$msg = [string]::Empty	×
65
66	# respond to smtp request
67	while ($true)	×
68	{
69	try { $msg = (Read-PodeTcpClient) }	×
70	catch {
71	$_ \| Write-PodeErrorLog	×
72	break
73	}
74
75	try {
76	if (!(Test-IsEmpty $msg)) {	×
77	if ($msg.StartsWith('QUIT')) {	×
78	Write-PodeTcpClient -Message '221 Bye'	×
79	Close-PodeTcpConnection	×
80	break
81	}
82
83	if ($msg.StartsWith('EHLO') -or $msg.StartsWith('HELO')) {	×
84	Write-PodeTcpClient -Message '250 OK'	×
85	}
86
87	if ($msg.StartsWith('RCPT TO')) {	×
88	Write-PodeTcpClient -Message '250 OK'	×
89	$rcpt_tos += (Get-PodeSmtpEmail $msg)	×
90	}
91
92	if ($msg.StartsWith('MAIL FROM')) {	×
93	Write-PodeTcpClient -Message '250 OK'	×
94	$mail_from = (Get-PodeSmtpEmail $msg)	×
95	}
96
97	if ($msg.StartsWith('DATA'))	×
98	{
99	Write-PodeTcpClient -Message '354 Start mail input; end with <CR><LF>.<CR><LF>'	×
100	$data = (Read-PodeTcpClient)	×
101	Write-PodeTcpClient -Message '250 OK'	×
102
103	# set event data/headers
104	$SmtpEvent.Email.From = $mail_from	×
105	$SmtpEvent.Email.To = $rcpt_tos	×
106	$SmtpEvent.Email.Data = $data	×
107	$SmtpEvent.Email.Headers = (Get-PodeSmtpHeadersFromData $data)	×
108
109	# set the subject/priority/content-types
110	$SmtpEvent.Email.Subject = $SmtpEvent.Headers['Subject']	×
111	$SmtpEvent.Email.IsUrgent = (($SmtpEvent.Headers['Priority'] -ieq 'urgent') -or ($SmtpEvent.Headers['Importance'] -ieq 'high'))	×
112	$SmtpEvent.Email.ContentType = $SmtpEvent.Headers['Content-Type']	×
113	$SmtpEvent.Email.ContentEncoding = $SmtpEvent.Headers['Content-Transfer-Encoding']	×
114
115	# set the email body
116	$SmtpEvent.Email.Body = (Get-PodeSmtpBody -Data $data -ContentType $SmtpEvent.ContentType -ContentEncoding $SmtpEvent.ContentEncoding)	×
117
118	# call user handlers for processing smtp data
119	$handlers = Get-PodeHandler -Type Smtp	×
120	foreach ($name in $handlers.Keys) {	×
121	$handler = $handlers[$name]	×
122	Invoke-PodeScriptBlock -ScriptBlock $handler.Logic -Arguments (@($SmtpEvent) + @($handler.Arguments)) -Scoped -Splat	×
123	}
124
125	# reset the to list
126	$rcpt_tos = @()	×
127	}
128	}
129	}
130	catch [exception] {
131	$_ \| Write-PodeErrorLog	×
132	throw $_.exception	×
133	}
134	}
135	}
136
137	try
138	{
139	while (!$PodeContext.Tokens.Cancellation.IsCancellationRequested)	×
140	{
141	# get an incoming request
142	$client = (Wait-PodeTask -Task $Listener.AcceptTcpClientAsync())	×
143
144	# convert the ip
145	$ip = (ConvertTo-PodeIPAddress -Endpoint $client.Client.RemoteEndPoint)	×
146
147	# ensure the request ip is allowed
148	if (!(Test-PodeIPAccess -IP $ip) -or !(Test-PodeIPLimit -IP $ip)) {	×
149	Close-PodeTcpConnection -Quit	×
150	}
151
152	# deal with smtp call
153	else {
154	$SmtpEvent = @{	×
155	Client = $client	×
156	Lockable = $PodeContext.Lockable	×
157	Email = $null	×
158	}
159
160	Invoke-PodeScriptBlock -ScriptBlock $process	×
161	Close-PodeTcpConnection -Quit	×
162	}
163	}
164	}
165	catch [System.OperationCanceledException] {
166	Close-PodeTcpConnection -Quit	×
167	}
168	catch {
169	$_ \| Write-PodeErrorLog	×
170	throw $_.Exception	×
171	}
172	}
173
174	# start the runspace for listening on x-number of threads
175	1..$PodeContext.Threads \| ForEach-Object {	×
176	Add-PodeRunspace -Type 'Main' -ScriptBlock $listenScript `	×
177	-Parameters @{ 'Listener' = $listener; 'ThreadId' = $_ }	×
178	}
179
180	# script to keep smtp server listening until cancelled
181	$waitScript = {	×
182	param (
183	[Parameter(Mandatory=$true)]
184	[ValidateNotNull()]
185	$Listener
186	)
187
188	try
189	{
190	while (!$PodeContext.Tokens.Cancellation.IsCancellationRequested)	×
191	{
192	Start-Sleep -Seconds 1	×
193	}
194	}
195	catch [System.OperationCanceledException] {}
196	catch {
197	$_ \| Write-PodeErrorLog	×
198	throw $_.Exception	×
199	}
200	finally {
201	if ($null -ne $Listener) {	×
202	$Listener.Stop()	×
203	}
204	}
205	}
206
207	Add-PodeRunspace -Type 'Main' -ScriptBlock $waitScript -Parameters @{ 'Listener' = $listener }	×
208
209	# state where we're running
210	return @("smtp://$($PodeContext.Server.Endpoints[0].HostName):$($port)")	×
211	}
212
213
214	function Get-PodeSmtpEmail
215	{
216	param (
217	[Parameter()]
218	[string]
219	$Value
220	)
221
222	$tmp = @($Value -isplit ':')	×
223	if ($tmp.Length -gt 1) {	×
224	return $tmp[1].Trim().Trim(' <>')	×
225	}
226
227	return [string]::Empty	×
228	}
229
230	function Get-PodeSmtpBody
231	{
232	param (
233	[Parameter()]
234	[string]
235	$Data,
236
237	[Parameter()]
238	[string]
239	$ContentType,
240
241	[Parameter()]
242	[string]
243	$ContentEncoding
244	)
245
246	# split the message up
247	$dataSplit = @($Data -isplit [System.Environment]::NewLine)	×
248
249	# get the index of the first blank line, and last dot
250	$indexOfBlankLine = $dataSplit.IndexOf([string]::Empty)	×
251	$indexOfLastDot = [array]::LastIndexOf($dataSplit, '.')	×
252
253	# get the body
254	$body = ($dataSplit[($indexOfBlankLine + 1)..($indexOfLastDot - 2)] -join [System.Environment]::NewLine)	×
255
256	# if there's no body, just return
257	if (($indexOfLastDot -eq -1) -or (Test-IsEmpty $body)) {	×
258	return $body	×
259	}
260
261	# decode body based on encoding
262	switch ($ContentEncoding.ToLowerInvariant()) {	×
263	'base64' {
264	$body = [System.Convert]::FromBase64String($body)	×
265	}
266	}
267
268	# only if body is bytes, first decode based on type
269	switch ($ContentType) {	×
270	{ $_ -ilike 'utf-7' } {	×
271	$body = [System.Text.Encoding]::UTF7.GetString($body)	×
272	}
273
274	{ $_ -ilike 'utf-8' } {	×
275	$body = [System.Text.Encoding]::UTF8.GetString($body)	×
276	}
277
278	{ $_ -ilike 'utf-16' } {	×
279	$body = [System.Text.Encoding]::Unicode.GetString($body)	×
280	}
281
282	{ $_ -ilike 'utf-32' } {	×
283	$body = [System.Text.Encoding]::UTF32.GetString($body)	×
284	}
285	}
286
287	return $body	×
288	}
289
290	function Get-PodeSmtpHeadersFromData
291	{
292	param (
293	[Parameter()]
294	[string]
295	$Data
296	)
297
298	$headers = @{}	×
299	$lines = @($Data -isplit [System.Environment]::NewLine)	×
300
301	foreach ($line in $lines) {	×
302	if ([string]::IsNullOrWhiteSpace($line)) {	×
303	break
304	}
305
306	if ($line -imatch '^(?<name>.?)\:\s+(?<value>.?)$') {	×
307	$headers[$Matches['name'].Trim()] = $Matches['value'].Trim()	×
308	}
309	}
310
311	return $headers	×
312	}

Badgerati / Pode / #451

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