» Refactoring Teaser 2 » Managed Chaos by Naresh Jain

Refactoring Teaser 2

Here comes the second Refactoring Teaser.

The purpose of this code is to determine the sender domain and IP address of the email server used by the sender of an email.

Following tests explain the purpose in more detail:

public class IPAddressExtractorTest {
    private ArrayList header = new ArrayList();
 
    @Test
    public void mineSenderFromEdgeServerRecordInMailHeaders() {
        mail_from("67.205.47.130", "agileindia.org").RecievedBy("75.119.213.4", "mails.agileindia.org");
        mail_from(null, "mail-vw0-f172.google.com").RecievedBy("67.205.47.130", "agileindia.org");
        assertSenderIPIs("209.85.212.172");
    }
 
    @Test
    public void useSenderIPForInvalidSenderEdgeServerDomainName() {
        mail_from("67.205.47.130", "agileindia.org").RecievedBy("75.119.213.4", "mails.agileindia.org");
        mail_from("209.85.212.172", "cannot-exist.agilefaqs.com").RecievedBy("67.205.47.130", "agileindia.org");
        assertSenderIPIs("209.85.212.172");
    }
 
    @Test
    public void senderNameCanBeIPAddress() {
        mail_from(null, "209.85.212.172").RecievedBy("67.205.47.130", "agileindia.org");
        assertSenderIPIs("209.85.212.172");
    }
 
    @Test
    public void matchMXRecordIPWithReciever() {
        mail_from("", "mail-vw0-f172.google.com").RecievedBy("67.205.47.130", "apache2-echo.robin.dreamhost.com");
        assertSenderIPIs("209.85.212.172");
    }
 
    @Test
    public void skipHeaderRecordsThatDontCrossEdgeServers() {
        mail_from("192.168.1.47", "smtp.gmail.com").RecievedBy("75.119.213.4", "mail.gmail.com");
        mail_from("192.168.1.3", "192.168.6.242").RecievedBy("192.168.1.47", "smtp.gmail.com");
        assertSenderIPIs("");
 
    }
 
    private void RecievedBy(final String ip, final String domainName) {
        header.add(new ReceiveFromByHeaders(ip, fromIp, domainName, fromDomain));
    }
 
    private String fromIp;
    private String fromDomain;
 
    private IPAddressExtractorTest mail_from(final String ip, final String domainName) {
        fromIp = ip;
        fromDomain = domainName;
        return this;
    }
 
    private void assertSenderIPIs(final String senderIP) {
        IPAddressExtractor addressExtractor = new IPAddressExtractor(header, "gmail.com");
        assertEquals(senderIP, addressExtractor.getSenderIP());
    }
}

Following is our big ball of mud:

public class IPAddressExtractor {
    private static Pattern regexSLD = Pattern.compile("(.*\\.)?(.*\\..*)");
    private static Pattern regexIP = Pattern.compile(Constants.ValidIpAddressRegex);
    private static Logger logger = Logger.getLogger(IPAddressExtractor.class.getName());
 
    private List _receiveFromByHeaders;
    private String _recepientDomain;
 
    private String _senderIP;
    private int _distance;
 
    public IPAddressExtractor(final List receiveFromByHeaders, final String recepientDomain) {
        logger.info("Entering IPAddressExtractor");
        logger.info(recepientDomain);
 
        _receiveFromByHeaders = receiveFromByHeaders;
        _recepientDomain = recepientDomain;
 
        ExtractSenderIPfromReceiveHeadersFromTop();
 
        logger.info("Leaving IPAddressExtractor");
    }
 
    private void ExtractSenderIPfromReceiveHeadersFromTop() {
        String senderDomain = "";
        boolean gotSenderDomain = false;
 
        String[] mxRecords = null;
 
        try {
            mxRecords = DnsMx.GetMXRecords(_recepientDomain);
 
            if (mxRecords == null) {
                return;
            }
        } catch (Exception ex) {
            // no records found
            return;
        }
        // generally first MX record is considered;
        String mxRecordIP = ResolveIPAddress(mxRecords[0]);
        logger.info(mxRecords[0] + " " + mxRecordIP);
 
        String ipByRecipMXServer = "";
 
        // exact MX Match
        int counter = 0;
        for (ReceiveFromByHeaders rOBj : _receiveFromByHeaders) {
            counter++;
 
            if (rOBj.getReceiveByIpAddress() != null
                    &amp;&amp; (rOBj.getReceiveByIpAddress().equals(rOBj.getReceiveFromIpAddress()) || "127.0.0.1".equals(rOBj
                            .getReceiveFromIpAddress()))) {
                continue;
            }
 
            if (mxRecords[0].toLowerCase() == rOBj.getReceiveByHeader().toLowerCase()) {
                if (VerifyDomain(rOBj.getReceiveFromHeader()) &amp;&amp; !VerifyIPAddress(rOBj.getReceiveFromHeader())) {
                    senderDomain = rOBj.getReceiveFromHeader();
                    gotSenderDomain = true;
                    ipByRecipMXServer = rOBj.getReceiveFromIpAddress();
                    _distance = counter;
                    break;
                } else if (VerifyIPAddress(rOBj.getReceiveFromHeader()))// since somethimes theres an ipAddress instead
                // of domain
                {
                    senderDomain = GetHostName(rOBj.getReceiveFromHeader());
                    gotSenderDomain = true;
                    _distance = counter;
                    break;
                }
            }
        }
 
        // MX IP match
        if (!gotSenderDomain) {
            counter = 0;
 
            for (ReceiveFromByHeaders rOBj : _receiveFromByHeaders) {
                counter++;
                if (mxRecordIP.equals(rOBj.getReceiveByIpAddress())) {
                    if (VerifyDomain(rOBj.getReceiveFromHeader()) &amp;&amp; !VerifyIPAddress(rOBj.getReceiveFromHeader())) {
                        senderDomain = rOBj.getReceiveFromHeader();
                        gotSenderDomain = true;
                        ipByRecipMXServer = rOBj.getReceiveFromIpAddress();
                        _distance = counter;
                        break;
                    } else if (VerifyIPAddress(rOBj.getReceiveFromHeader()))// since somethimes theres an ipAddress
                    // instead of domain
                    {
                        senderDomain = GetHostName(rOBj.getReceiveFromHeader());
                        gotSenderDomain = true;
                        _distance = counter;
                        break;
                    }
                }
            }
        }
 
        // MX SLD match
        if (!gotSenderDomain) {
            counter = 0;
 
            for (ReceiveFromByHeaders rOBj : _receiveFromByHeaders) {
                counter++;
 
                Matcher mxRecordMatch = regexSLD.matcher(mxRecords[0]);
                Matcher rOBJMatch = regexSLD.matcher(rOBj.getReceiveByHeader());
 
                if (!(mxRecordMatch.find() &amp;&amp; rOBJMatch.find())) {
                    continue;
                }
 
                if (mxRecordMatch.group(2).toLowerCase() == rOBJMatch.group(2).toLowerCase()) {
                    if (VerifyDomain(rOBj.getReceiveFromHeader()) &amp;&amp; !VerifyIPAddress(rOBj.getReceiveFromHeader())) {
                        senderDomain = rOBj.getReceiveFromHeader();
                        gotSenderDomain = true;
                        ipByRecipMXServer = rOBj.getReceiveFromIpAddress();
                        _distance = counter;
                        break;
                    } else if (VerifyIPAddress(rOBj.getReceiveFromHeader()))// since somethimes theres an ipAddress
                    // instead of domain
                    {
                        String extractIP = ExtractIP(rOBj.getReceiveFromHeader());
                        senderDomain = GetHostName(extractIP);
                        gotSenderDomain = true;
                        _distance = counter;
                        break;
                    }
                }
            }
        }
 
        String ipAddress = "";
 
        try {
            if (senderDomain != null &amp;&amp; senderDomain.trim().length() &gt; 0) {
                ipAddress = ResolveIPAddress(senderDomain);
            }
        } catch (Exception e) {
        }
 
        if (ipAddress == null || ipAddress.trim().length() == 0) {
            ipAddress = ipByRecipMXServer;
        }
 
        _senderIP = ipAddress;
    }
 
    // sometimes IP can enclosed in brackets or extra chars
    private String ExtractIP(final String str) {
        logger.info("Entering ExtractIP");
        logger.info(str);
 
        return regexIP.matcher(str).group(1);
    }
 
    private String ResolveIPAddress(final String domain) {
        String ipAddress = "";
 
        if (!(domain.length() == 0 || domain.length() &gt; Constants.MaxDomainLength || !Pattern.matches(Constants.DomainNameRegex, domain))) {
            try {
                ipAddress = InetAddress.getByName(domain).getHostAddress();
            } catch (UnknownHostException e) {
                logger.log(Level.INFO, "Not a valid Domain Name " + domain);
            }
            logger.info("IPAddress " + ipAddress + " found for domain " + domain);
        } else {
            logger.log(Level.INFO, "Not a valid Domain Name " + domain);
        }
        return ipAddress;
    }
 
    private boolean VerifyDomain(final String senderDomain) {
 
        if (senderDomain != null &amp;&amp; senderDomain.trim().length() &gt; 0) {
            if (!(senderDomain.length() == 0 || senderDomain.length() &gt; Constants.MaxDomainLength || !Pattern.matches(
                    Constants.DomainNameRegex, senderDomain))) {
                logger.log(Level.FINE, "Sender domain identified as " + senderDomain);
                return true;
            } else {
                logger.log(Level.FINE, "Sender domain identified is not a valid Domain Name " + senderDomain);
                return false;
            }
        }
 
        return true;
    }
 
    private boolean VerifyIPAddress(final String ipAddress) {
        logger.info("Entering VerifyAddress");
        logger.info(ipAddress);
 
        if (ipAddress != null &amp;&amp; ipAddress.trim().length() &gt; 0) {
            return regexIP.matcher(ipAddress).find();
        }
 
        return false;
    }
 
    private String GetHostName(final String ipAddress) {
        try {
            InetAddress ip = InetAddress.getByName(ipAddress);
            return ip.getHostName();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        return "";
    }
 
    public String getSenderIP() {
        return _senderIP;
    }
 
    public int getDistance() {
        return _distance;
    }
}

This class depends on:

public class ReceiveFromByHeaders {
    private String receiveByIpAddress;
    private String receiveFromIpAddress;
    private String receiveByHeader;
    private String receiveFromHeader;
 
    public ReceiveFromByHeaders(final String receiveByIpAddress, final String receiveFromIpAddress, final String receiveByHeader,
            final String receiveFromHeader) {
        this.receiveByIpAddress = receiveByIpAddress;
        this.receiveFromIpAddress = receiveFromIpAddress;
        this.receiveByHeader = receiveByHeader;
        this.receiveFromHeader = receiveFromHeader;
    }
 
    public String getReceiveByIpAddress() {
        return receiveByIpAddress;
    }
 
    public void setReceiveByIpAddress(final String receiveByIpAddress) {
        this.receiveByIpAddress = receiveByIpAddress;
    }
 
    public String getReceiveFromIpAddress() {
        return receiveFromIpAddress;
    }
 
    public void setReceiveFromIpAddress(final String receiveFromIpAddress) {
        this.receiveFromIpAddress = receiveFromIpAddress;
    }
 
    public String getReceiveByHeader() {
        return receiveByHeader;
    }
 
    public void setReceiveByHeader(final String receiveByHeader) {
        this.receiveByHeader = receiveByHeader;
    }
 
    public String getReceiveFromHeader() {
        return receiveFromHeader;
    }
 
    public void setReceiveFromHeader(final String receiveFromHeader) {
        this.receiveFromHeader = receiveFromHeader;
    }
}

Some Contants:

public class Constants {
    public static final String ValidIpAddressRegex = "\\b(?:\\d{1,3}\\.){3}\\d{1,3}\\b";
    public static final int MaxDomainLength = 255;
    public static final String DomainNameRegex = "[\\w.-]+\\.[\\w-[0123456789]]{2,6}";
}

Finally, we’ve used the following class to stub out MxRecord look up:

public class DnsMx {
    public static String[] GetMXRecords(final String domain) {
        return new String[] { "agileindia.org", "alt2.gmail-smtp-in.l.google.com" };
    }
}

Download the Java Project or C# Version.

This entry was posted on Monday, July 20th, 2009 at 4:28 PM and is filed under Agile, Design, Programming. You can follow any responses to this entry through the RSS 2.0 feed. You can skip to the end and leave a response. Pinging is currently not allowed.

http://www.twitter.com/latebound LateBound

Here’s my solution. It’s still clunky in places, but to clean that, I’ll need to know the requirements, or the specifications from the rfc.

package problem;
 
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.List;
import java.util.regex.Pattern;
 
public class IPAddressExtractor {
	private static Pattern regexIP = Pattern
			.compile(Constants.ValidIpAddressRegex);
 
	private List _receivedHeaders;
	private String _recepientDomain;
 
	private String _senderIP = "";
	private int _distance = 0;
 
	public IPAddressExtractor(final List receiveFromByHeaders,
			final String recepientDomain) {
		_receivedHeaders = receiveFromByHeaders;
		_recepientDomain = recepientDomain;
 
		extractSenderIPfromReceiveHeadersFromTop();
	}
 
	private void extractSenderIPfromReceiveHeadersFromTop() {
		String mxRecord = DnsMx.firstMxRecord(_recepientDomain);
		if (mxRecord == null) {
			return;
		}
		MxMatcher[] matchers = new MxMatcher[] { new MxExactMatcher(mxRecord),
				new MxIpMatcher(mxRecord), new MxSldMatcher(mxRecord) };
 
		for (MxMatcher matcher : matchers) {
			int counter = 0;
			for (ReceivedHeader header : _receivedHeaders) {
				counter++;
				if (matcher.matches(header)) {
					if (assignIpAddress(header)) {
						_distance = counter;
						return;
					}
				}
			}
		}
	}
 
	private boolean assignIpAddress(ReceivedHeader header) {
		String receiveFromHeader = header.getReceiveFromHeader();
		if (verifyIPAddress(receiveFromHeader)) {
			try {
				_senderIP = resolveIPAddress(InetAddress.getByName(
						receiveFromHeader).getHostName());
			} catch (UnknownHostException e) {
				e.printStackTrace();
			}
			return true;
		} else if (verifyDomain(receiveFromHeader)) {
			try {
				_senderIP = resolveIPAddress(receiveFromHeader);
			} catch (UnknownHostException e) {
				_senderIP = header.getReceiveFromIpAddress();
			}
			return true;
		}
		return false;
	}
 
	// sometimes IP can enclosed in brackets or extra chars
	private String extractIP(final String str) {
		return regexIP.matcher(str).group(1);
	}
 
	public static String resolveIPAddress(final String domain)
			throws UnknownHostException {
		return InetAddress.getByName(domain).getHostAddress();
	}
 
	private static boolean verifyDomain(final String domain) {
		return domain != null &amp;&amp; domain.trim().length() &gt; 0
				&amp;&amp; domain.length()  0
				&amp;&amp; regexIP.matcher(ipAddress).find();
	}
 
	public String getSenderIP() {
		return _senderIP;
	}
 
	public int getDistance() {
		return _distance;
	}
}
 
 
 
package problem;
 
public class DnsMx {
    public static String[] GetMXRecords(final String domain) {
        // Faked for this example.
        return new String[] { "agileindia.org", "alt2.gmail-smtp-in.l.google.com" };
    }
 
	public static String firstMxRecord(String domain) {
	    try {
			String[] mxRecords = GetMXRecords(domain);
			if(mxRecords.length &gt; 0) {
				return mxRecords[0];
			}
	    } catch (Exception ex) {
	    }
	    return null;
	}
}
 
 
 
package problem;
 
public class MxExactMatcher implements MxMatcher {
 
	private final String mxRecord;
 
	public MxExactMatcher(String mxRecord) {
		this.mxRecord = mxRecord;
	}
 
	@Override
	public boolean matches(ReceivedHeader header) {
		return (header.getReceiveByIpAddress() == null || (!header
				.getReceiveByIpAddress().equals(
						header.getReceiveFromIpAddress()) &amp;&amp; !"127.0.0.1"
				.equals(header.getReceiveFromIpAddress())))
				&amp;&amp; mxRecord.toLowerCase() == header.getReceiveByHeader()
						.toLowerCase();
	}
 
}
 
 
 
package problem;
 
import java.net.InetAddress;
import java.net.UnknownHostException;
 
public class MxIpMatcher implements MxMatcher {
 
	private String mxIpAddress;
 
	public MxIpMatcher(String mxRecord) {
		try {
			this.mxIpAddress = InetAddress.getByName(mxRecord).getHostAddress();
		} catch (UnknownHostException e) {
			this.mxIpAddress = "";
		}
	}
 
	@Override
	public boolean matches(ReceivedHeader header) {
		return mxIpAddress.equals(header.getReceiveByIpAddress());
	}
}

package problem;
 
public interface MxMatcher {
	boolean matches(ReceivedHeader header);
}

package problem;
 
public class ReceivedHeader {
    private String receiveByIpAddress;
    private String receiveFromIpAddress;
    private String receiveByHeader;
    private String receiveFromHeader;
 
    public ReceivedHeader(final String receiveByIpAddress, final String receiveFromIpAddress, final String receiveByHeader,
            final String receiveFromHeader) {
        this.receiveByIpAddress = receiveByIpAddress;
        this.receiveFromIpAddress = receiveFromIpAddress;
        this.receiveByHeader = receiveByHeader;
        this.receiveFromHeader = receiveFromHeader;
    }
 
    public String getReceiveByIpAddress() {
        return receiveByIpAddress;
    }
 
    public String getReceiveFromIpAddress() {
        return receiveFromIpAddress;
    }
 
    public String getReceiveByHeader() {
        return receiveByHeader;
    }
 
    public String getReceiveFromHeader() {
        return receiveFromHeader;
    }
}

http://www.twitter.com/latebound LateBound

Here’s my solution. It’s still clunky in places, but to clean that, I’ll need to know the requirements, or the specifications from the rfc.

package problem;
 
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.List;
import java.util.regex.Pattern;
 
public class IPAddressExtractor {
	private static Pattern regexIP = Pattern
			.compile(Constants.ValidIpAddressRegex);
 
	private List _receivedHeaders;
	private String _recepientDomain;
 
	private String _senderIP = "";
	private int _distance = 0;
 
	public IPAddressExtractor(final List receiveFromByHeaders,
			final String recepientDomain) {
		_receivedHeaders = receiveFromByHeaders;
		_recepientDomain = recepientDomain;
 
		extractSenderIPfromReceiveHeadersFromTop();
	}
 
	private void extractSenderIPfromReceiveHeadersFromTop() {
		String mxRecord = DnsMx.firstMxRecord(_recepientDomain);
		if (mxRecord == null) {
			return;
		}
		MxMatcher[] matchers = new MxMatcher[] { new MxExactMatcher(mxRecord),
				new MxIpMatcher(mxRecord), new MxSldMatcher(mxRecord) };
 
		for (MxMatcher matcher : matchers) {
			int counter = 0;
			for (ReceivedHeader header : _receivedHeaders) {
				counter++;
				if (matcher.matches(header)) {
					if (assignIpAddress(header)) {
						_distance = counter;
						return;
					}
				}
			}
		}
	}
 
	private boolean assignIpAddress(ReceivedHeader header) {
		String receiveFromHeader = header.getReceiveFromHeader();
		if (verifyIPAddress(receiveFromHeader)) {
			try {
				_senderIP = resolveIPAddress(InetAddress.getByName(
						receiveFromHeader).getHostName());
			} catch (UnknownHostException e) {
				e.printStackTrace();
			}
			return true;
		} else if (verifyDomain(receiveFromHeader)) {
			try {
				_senderIP = resolveIPAddress(receiveFromHeader);
			} catch (UnknownHostException e) {
				_senderIP = header.getReceiveFromIpAddress();
			}
			return true;
		}
		return false;
	}
 
	// sometimes IP can enclosed in brackets or extra chars
	private String extractIP(final String str) {
		return regexIP.matcher(str).group(1);
	}
 
	public static String resolveIPAddress(final String domain)
			throws UnknownHostException {
		return InetAddress.getByName(domain).getHostAddress();
	}
 
	private static boolean verifyDomain(final String domain) {
		return domain != null &amp;&amp; domain.trim().length() &gt; 0
				&amp;&amp; domain.length()  0
				&amp;&amp; regexIP.matcher(ipAddress).find();
	}
 
	public String getSenderIP() {
		return _senderIP;
	}
 
	public int getDistance() {
		return _distance;
	}
}
 
 
 
package problem;
 
public class DnsMx {
    public static String[] GetMXRecords(final String domain) {
        // Faked for this example.
        return new String[] { "agileindia.org", "alt2.gmail-smtp-in.l.google.com" };
    }
 
	public static String firstMxRecord(String domain) {
	    try {
			String[] mxRecords = GetMXRecords(domain);
			if(mxRecords.length &gt; 0) {
				return mxRecords[0];
			}
	    } catch (Exception ex) {
	    }
	    return null;
	}
}
 
 
 
package problem;
 
public class MxExactMatcher implements MxMatcher {
 
	private final String mxRecord;
 
	public MxExactMatcher(String mxRecord) {
		this.mxRecord = mxRecord;
	}
 
	@Override
	public boolean matches(ReceivedHeader header) {
		return (header.getReceiveByIpAddress() == null || (!header
				.getReceiveByIpAddress().equals(
						header.getReceiveFromIpAddress()) &amp;&amp; !"127.0.0.1"
				.equals(header.getReceiveFromIpAddress())))
				&amp;&amp; mxRecord.toLowerCase() == header.getReceiveByHeader()
						.toLowerCase();
	}
 
}
 
 
 
package problem;
 
import java.net.InetAddress;
import java.net.UnknownHostException;
 
public class MxIpMatcher implements MxMatcher {
 
	private String mxIpAddress;
 
	public MxIpMatcher(String mxRecord) {
		try {
			this.mxIpAddress = InetAddress.getByName(mxRecord).getHostAddress();
		} catch (UnknownHostException e) {
			this.mxIpAddress = "";
		}
	}
 
	@Override
	public boolean matches(ReceivedHeader header) {
		return mxIpAddress.equals(header.getReceiveByIpAddress());
	}
}

package problem;
 
public interface MxMatcher {
	boolean matches(ReceivedHeader header);
}


package problem;
 
public class ReceivedHeader {
    private String receiveByIpAddress;
    private String receiveFromIpAddress;
    private String receiveByHeader;
    private String receiveFromHeader;
 
    public ReceivedHeader(final String receiveByIpAddress, final String receiveFromIpAddress, final String receiveByHeader,
            final String receiveFromHeader) {
        this.receiveByIpAddress = receiveByIpAddress;
        this.receiveFromIpAddress = receiveFromIpAddress;
        this.receiveByHeader = receiveByHeader;
        this.receiveFromHeader = receiveFromHeader;
    }
 
    public String getReceiveByIpAddress() {
        return receiveByIpAddress;
    }
 
    public String getReceiveFromIpAddress() {
        return receiveFromIpAddress;
    }
 
    public String getReceiveByHeader() {
        return receiveByHeader;
    }
 
    public String getReceiveFromHeader() {
        return receiveFromHeader;
    }
}

Joel Rosario

Here’s a first cut in python. I added a test for the third approach to determining a sender ip. I might not have cleaned up all the names. But I’ve replaced the big ball of class mud with a functional implementation.

******* TESTS *******

import unittestimport ipaddressextractorclass IPAddressExtractorTests(unittest.TestCase): def setUp(self): self.header = [] def test_mineSenderFromEdgeServerRecordInMailHeaders(self): self.mail_from(“67.205.47.130″, “agileindia.org”).ReceivedBy(“75.119.213.4″, “mails.agileindia.org”) self.mail_from(None, “mail-vw0-f172.google.com”).ReceivedBy(“67.205.47.130″, “agileindia.org”) self.assertSenderIPIs(“209.85.212.172″, “agileindia.org”) def test_mineSenderFromEdgeServerRecordIdentifiedBySldMatchOfRecipientDomain(self): self.mail_from(“67.205.47.130″, “agileindia.org”).ReceivedBy(“75.119.213.4″, “mails.agileindia.org”) self.mail_from(None, “mail-vw0-f172.google.com”).ReceivedBy(“67.205.47.131″, “mx1.agileindia.org”) self.assertSenderIPIs(“209.85.212.172″, “agileindia.org”) def test_useSenderIPForInvalidSenderEdgeServerDomainName(self): self.mail_from(“67.205.47.130″, “agileindia.org”).ReceivedBy(“75.119.213.4″, “mails.agileindia.org”) self.mail_from(“209.85.212.172″, “cannot-exist.agilefaqs.com”).ReceivedBy(“67.205.47.130″, “agileindia.org”) self.assertSenderIPIs(“209.85.212.172″, “cannot-exist.agilefaqs.com”) def test_senderNameCanBeIPAddress(self): self.mail_from(None, “209.85.212.172″).ReceivedBy(“67.205.47.130″, “agileindia.org”) self.assertSenderIPIs(“209.85.212.172″, “agileindia.org”) def test_matchMXRecordIPWithReceiver(self): self.mail_from(“”, “mail-vw0-f172.google.com”).ReceivedBy(“67.205.47.130″, “apache2-echo.robin.dreamhost.com”) self.assertSenderIPIs(“209.85.212.172″, “apache2-echo.robin.dreamhost.com”) def test_skipHeaderRecordsThatDontCrossEdgeServers(self): self.mail_from(“192.168.1.47″, “smtp.gmail.com”).ReceivedBy(“75.119.213.4″, “mail.gmail.com”) self.mail_from(“192.168.1.3″, “192.168.6.242″).ReceivedBy(“192.168.1.47″, “smtp.gmail.com”) self.assertSenderIPIs(None, “gmail.com”) def ReceivedBy(self, ip, domainName): self.header.append(ipaddressextractor.ReceiveFromByHeaders(ip, self.fromIp, domainName, self.fromDomain)) def mail_from(self, ip, domainName): self.fromIp = ip self.fromDomain = domainName return self def assertSenderIPIs(self, senderIP, recipientDomain): senderIp = ipaddressextractor.extractSenderIP(self.header, recipientDomain) self.assertEquals(senderIP, senderIp)if __name__ == ‘__main__’: suite = unittest.TestLoader().loadTestsFromTestCase(IPAddressExtractorTests) unittest.TextTestRunner(verbosity=2).run(suite)

******* CODE *******

import reMAX_DOMAIN_LENGTH = 255def is_valid_ip(ip): return re.search(“([0-9]+.[0-9]+.[0-9]+.[0-9]+)”, ip) is not Nonedef is_valid_domain(domain): return domain is not None and len(domain) > 0 and len(domain) <= MAX_DOMAIN_LENGTH and re.search("([0-9a-zA-Z-]+.)*([0-9a-zA-Z-]+.)+([a-zA-Z-]+)$", "test.com") is not Nonedef get_mx_records(domain): return ["agileindia.org", "alt2.gmail-smtp-in.l.google.com"]def domain_to_ip(domain): if domain == 'agileindia.org': return '67.205.47.130' if domain == 'mails.agileindia.org': return '75.119.213.4' if domain == 'apache2-echo.robin.dreamhost.com': return '67.205.47.130' if domain == 'mail-vw0-f172.google.com': return '209.85.212.172' if domain == 'smtp.gmail.com': return '192.168.1.47' if domain == 'mail.gmail.com': return '75.119.213.4' if domain == 'gmail.com': return '209.85.212.172' if domain == 'mx1.agileindia.org': return '67.205.47.131' return Nonedef ip_to_domain(ip): if ip == "209.85.212.172": return "gmail.com" if ip == '67.205.47.131': return 'mx1.agileindia.org' passclass ReceiveFromByHeaders: def __init__(self, receiveByIpAddress, receiveFromIpAddress, receiveByHeader, receiveFromHeader): self.receiveByIpAddress = receiveByIpAddress self.receiveFromIpAddress = receiveFromIpAddress self.receiveByHeader = receiveByHeader self.receiveFromHeader = receiveFromHeaderdef extractSenderIP(receiveFromByHeaders, recipientDomain): mx_records = get_mx_records(recipientDomain) if mx_records is None: return mx_record = mx_records[0].lower() mx_record_ip = domain_to_ip(mx_record) def get_recipient_ip_from_header(header): if is_valid_domain(header.receiveFromHeader) and not is_valid_ip(header.receiveFromHeader): return domain_to_ip(header.receiveFromHeader) or header.receiveFromIpAddress elif is_valid_ip(header.receiveFromHeader): return domain_to_ip(ip_to_domain(header.receiveFromHeader)) def _extract_sender_ip(headers): for header in headers: ip = get_recipient_ip_from_header(header) if ip is not None: return ip def recipient_mx_domain_match(): def header_to_include(header): return not (header.receiveByIpAddress is not None and header.receiveByIpAddress == header.receiveFromIpAddress or header.receiveFromIpAddress == '127.0.0.1') and mx_record == header.receiveByHeader return _extract_sender_ip(filter(header_to_include, receiveFromByHeaders)) def recipient_mx_domain_ip_match(): def header_to_include(header): return mx_record_ip == header.receiveByIpAddress return _extract_sender_ip(filter(header_to_include, receiveFromByHeaders)) def recipient_mx_domain_sld_match_algo(): def get_sld(domain): match = re.search('([0-9a-z-]+).([0-9a-z-]+)$', domain) return None if match is None else match.group(0) mx_domain_sld = get_sld(mx_record) def header_to_include(header): recipient_domain_sld = get_sld(header.receiveByHeader) return recipient_domain_sld == mx_domain_sld and recipient_domain_sld != get_sld(header.receiveFromHeader) return _extract_sender_ip(filter(header_to_include, receiveFromByHeaders)) return recipient_mx_domain_match() or recipient_mx_domain_ip_match() or recipient_mx_domain_sld_match_algo()