What is SPF

If you have not followed my rust series on deconstructing SPF you can check it out here.

Here is some back ground on SPF.

• What is SPF
• SPF Record syntax

What is a qualifier

A qualifier changes the way that a mechanism is interpreted, they are

• + Pass
• - Fail
• ~ SoftFail
• ? Neutral
  • Neutral is the default if no qualifier is matched.

What is a mechanism

An SPF mechanism can be one of several types

• Include
• A
• Mx
• Ip4
• Ip6
• All
• Ptr
• Exists
• Redirect (Technially this is a Modifier, but I will be using it as a Mechanism)

I will be attempting to just learn some of the basics of the Swift language. So I will be looking at things like:

• enum
• struct
• Optional variables
• Perhaps more if I find that I need them.

Swift: The building blocks

Qualifiers

So I need to have a way to handle qualifiers

enum Qualifier: String {
    case Pass = "+"
    case Fail = "-"
    case SoftFail = "~"
    case Neutral = "?"
    case None = ""
}

This enumeration will manage my qualifiers. I have added a None for the moment since in many cases, there is no qualifier provided, and I think I might want to be able to reproduce the mechanism in the future.

Mechanism

To handle these I will create a second enumeration

enum MechanismKind {
    case Redirect, Include, A, MX, Ip4, Ip6, All;
}

Although Redirect is a modifier, I am listing it here as a mechanism. I am also omitting ptr and exists. These may or may not be handled.

A mechanism is made up of a qualifier and some mechanism value. It also needs to have a kind. So a struct will probably work here.

struct Mechanism {
    var kind: MechanismKind;
    var qualifier: Qualifier;
    var mechanism: String;
}

Examples

Let's say we have an SPF record of the following type:

"v=spf1 a ip4:x.x.x.x ~all"

We want to have a struct that will represent A and another that represents Ip4

These are conceptual examples only.

A

struct {
  kind => MechanismKind.A
  qualifier => Qualifers.None
  mechanism => ""
}

Ip4

struct {
  kind => MechanismKind.Ip4
  qualifier => None
  mechanism => "x.x.x.x"
}

Seeing this I can see that there will be some good cases to make some variables Optional

SPF

This struct will probably look something like what follows.

struct SPF {
    var redirect: Mechanism?;
    var is_redirect: Bool = false;
    var include: Mechanism?;
    var a: Mechanism?;
    var mx: Mechanism?;
    var all: Mechanism?;
}

This is merely a rough outline. Most will need to be a list of records.
You might notice the use if the ? at the end of Mechanism. This denotes that the variable is optional and hence can have a nil value. That meaning it can be absent.

I refer you to the Swift Documentation

In the next article we will start to develop some code focused on the struct for a Mechanism