root/apps/outlook/branches/1.5/DotTelSystem/Lookup/Lookup.cs @ 588

///<summary>
/// Author: Ben Dowling & Nick Brunwin
///------------------------
///Copyright (c) 2008, Telnic Ltd.
///
///All rights reserved.
///
///Redistribution and use in source and binary forms, with or 
///without modification, are permitted provided that the following 
///conditions are met:
///
///*    Redistributions of source code must retain the above 
///     copyright notice, this list of conditions and the 
///     following disclaimer. 
///*    Redistributions in binary form must reproduce the above 
///     copyright notice, this list of conditions and the following
///     disclaimer in the documentation and/or other materials 
///     provided with the distribution. 
///*    Neither the name of the Telnic Ltd. nor the names of its 
///     contributors may be used to endorse or promote products 
///     derived from this software without specific prior written
///     permission. 
///
///THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
///CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
///INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
///MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
///DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
///CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
///SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
///LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
///USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 
///AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
///LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
///IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
///THE POSSIBILITY OF SUCH DAMAGE.
///--------------------------
///</summary>
using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using org.telnic.outlook.lookup;
using org.telnic.outlook.dns;
using org.telnic.outlook.util;
using System.Collections;
using System.Threading;
using org.telnic.outlook.prefs;
using org.telnic.outlook.friending;
using org.telnic.outlook.dns.records;
using org.telnic.outlook.friending.messaging;
using org.telnic.outlook.prefs.publishers;
using org.telnic.outlook.uri;

namespace org.telnic.outlook.lookup
{
    public class Lookup : LookupTelnameCompleteListener
    {
        private static IMissingPublishersDialog missingPublishersDialog;
        public static IMissingPublishersDialog MissingPublishersDialog
        {
            set
            {
                missingPublishersDialog = value;
            }
        }

        private static string X_Crypto_ServiceType = "x-crypto";

        private static string X_Note_ServiceType = "x-note";

        private static string X_User_ServiceType = "x-user";

        private static string Unknown_ServiceType = "unknown";

        private LookupTelnameCompleteListener completeListener;

        /// <summary>
        /// Remove the given publisher from the publishers list
        /// </summary>
        /// <param name="telname">The publisher to remove</param>
        private void RemovePublisher(string telname)
        {
            Thread t = new Thread(delegate() {
                Messaging.Instance.RemoveFriend(telname);
            });
            t.Start();
        }

        /// <summary>
        /// Decrypt encrypted NAPTRs and then call the passed completion listener
        /// </summary>
        /// <param name="lr">The result of the lookup</param>
        public void LookupTelnameComplete(LookupResult lr)
        {
            if (completeListener == null)
            {
                Logger.Log(Logger.Section.Lookups, "Lookup completed, but listener is null");
                return;
            }
            // if the domain doesn't exist make sure we didn't lookup something 
            // from the publishers list
            if (lr != null && lr.NaptrStatus == LookupWorker.LookupStatus.Nxdomain)
            {
                // have we looked up a publishers subdomain?
                string privateTelname = lr.Telname;

                Logger.Log(Logger.Section.Lookups, "Telname is: " + privateTelname);

                string publicTelname = lr.PublicTelname;
                //string subDomain = telname.Substring(0, endOfSubdomain - 1);
                Logger.Log(Logger.Section.Lookups, "Private telname is is: " + privateTelname + " Public telname is: " + publicTelname);
                if (Publishers.Instance.GetPrivateTelname(publicTelname) != publicTelname
                        && Publishers.Instance.GetPrivateTelname(publicTelname) == privateTelname)
                {
                    // we have looked up a sumdomain from the publishers list, and it doesn't exist!

                    string pref = Preferences.GetPreference("publisher.missing");
                    if (pref == "prompt")
                    {
                        if (missingPublishersDialog.Ask() == RemovePublisherChoice.Yes)
                        {
                            // remove the publisher
                            RemovePublisher(publicTelname);
                        }

                    }
                    else if (pref == "remove")
                    {
                        // remove the publisher
                        RemovePublisher(publicTelname);
                    }

                    PerformLookup(publicTelname, publicTelname);
                    return;
                }
            }

            if (lr == null)
            {
                Logger.Log(Logger.Section.Lookups, "Lookup completed - null result returned");
            }
            else
            {
                Logger.Log(Logger.Section.Lookups, "Lookup completed for " + lr.Telname);
            }

            DecryptAndCache(lr);
            ExtractUnlinkedNaptr(lr);

            completeListener.LookupTelnameComplete(lr);
        }

        public Lookup() { }

        /// <summary>
        /// perform a lookup on telname - add a subdomain to telname if it is in 
        /// the publishers list, and decrypt results once they are back, then call lc
        /// </summary>
        /// <param name="telname">The telname to perform the lookup on</param>
        /// <param name="lc">The listener to call on completion of the lookup</param>
        public virtual void PerformLookup(string telname, LookupTelnameCompleteListener lc)
        {
            Logger.Log(Logger.Section.Lookups, "Lookup called with " + telname);
            if (lc == null)
            {
                Logger.Log(Logger.Section.Lookups, "Perform lookup called without a listener.");
                return;
            }
            completeListener = lc;
            string privateTelname = Publishers.Instance.GetPrivateTelname(telname);
            this.PerformLookup(privateTelname, telname);
        }

        // internal lookup call
        /// <summary>
        /// Performs a lookup on the given telname under the guise of the lookup being on the public telname
        /// </summary>
        /// <param name="telname">The telname to perform the lookup on</param>
        /// <param name="publicTelname">The telname to display to the user</param>
        private void PerformLookup(string telname , string publicTelname)
        {
            Logger.Log(Logger.Section.Lookups, "Looking up " + telname);
            try
            {
                if (TelnameChecker.IsEnum(telname))
                {
                    Logger.Log(Logger.Section.Lookups, telname + " identified as an Enum");
                    // TODO: we will need to use the system DNS, not the one in preferences!
                }
                LookupTelname lt = new LookupTelname(IPAddress.Parse(Preferences.GetPreference("dns")), 
                                                                        int.Parse(Preferences.GetPreference("dnsport")));
                lt.Listener = this;
                lt.performLookup(telname, publicTelname);
            }
            catch (Exception ex)
            {
                Logger.Log(Logger.Section.Lookups, "Exception caught during lookup: " + ex);
                throw new Exception(String.Format(DotTelSystem.Properties.Resources.Lookup_ErrorDuringLookup, ex.Message));
            }
        }

        /// <summary>
        /// Decrypt any encrypted NAPTRs and cache the result
        /// </summary>
        /// <param name="lr"></param>
        private void DecryptAndCache(LookupResult lr)
        {
            if (lr == null || lr.NaptrRecords == null) return;

            // set to true if we do any decryption
            bool modified = false;

            ArrayList modifiedNaptrs = new ArrayList();
            foreach (DNSTelnameNaptrResourceRecord record in lr.NaptrRecords)
            {
                DNSTelnameNaptrResourceRecord r = record;

                if (r.ServiceType != null && r.ServiceType.StartsWith(X_Crypto_ServiceType))
                {
                    modified = true;

                    try
                    {
                        string decrypted = Friending.Instance.Crypto.DecryptNaptr(r.Uri);
                        byte[] data = new System.Text.UTF8Encoding().GetBytes(decrypted);

                        DNSInputStream dnsInputStream = new DNSInputStream(data, 0, data.Length);
                        string flags;
                        string service;
                        string regexpstr;
                        string replacestr;
                        dnsInputStream.ReadNaptrBody(out flags, out service, out regexpstr, out replacestr);

                        // create a telname naptr
                        DNSNaptrResourceRecord tempNaptr = new DNSNaptrResourceRecord(r.TTL, r.Order, r.Preference, flags, service, regexpstr, replacestr, true);
                        string applicationUniqueString = r.Query;
                        if (TelnameChecker.IsEnum(r.Query))
                        {
                            applicationUniqueString = UriHandler.getInstance().EnumToNumber(r.Query);
                        }
                        DNSTelnameNaptrResourceRecord[] records = DNSTelnameNaptrResourceRecord.parseTelnameNaptr(tempNaptr, r.Query, applicationUniqueString);
                        /* not sure what purpose this code serves
                        if (records.Length > 1)
                        {
                            int length = records.Length;
                        }*/
                        r = records[0];

                        // we've successfully modified a NAPTR - we will need to update NaptrRecords

                    }
                    catch (Exception e)
                    {
                        // problem with decryption - exclude result
                        Logger.Log(Logger.Section.Lookups, "Could not decrypt NAPTR: " + r.ToString());
                        Logger.Log(Logger.Section.Lookups, "Reason was: " + e.Message);
                        continue;
                    }
                }
                modifiedNaptrs.Add(r);
            }

            // if we've made any changes to the NAPTRs then update the cache
            if (modified)
            {
                lr.NaptrRecords = modifiedNaptrs;
                LookupCache.SetResult(lr.Telname, lr);
            }
        }

        /// <summary>
        /// If Naptr is not laucnhable, makes it an unlinked Naptr
        /// </summary>
        /// <param name="lr"></param>
        private void ExtractUnlinkedNaptr(LookupResult lr)
        {
            if (lr == null || lr.NaptrRecords == null) return;

            // set to true if we do any decryption
            bool modified = false;

            ArrayList modifiedNaptrs = new ArrayList();
            foreach (DNSTelnameNaptrResourceRecord record in lr.NaptrRecords)
            {
                DNSTelnameNaptrResourceRecord r = record;
                if (r.ServiceType != null && 
                    //(r.ServiceType.StartsWith(X_User_ServiceType) || r.ServiceType.StartsWith(X_Note_ServiceType) || r.ServiceType.StartsWith(Unknown_ServiceType)))
                    !UriHandler.getInstance().Launchable(r.ServiceType))
                {
                    modified = true;
                    DNSUnlinkedTelnameNaptrResourceRecord unlinkedNaptr = new DNSUnlinkedTelnameNaptrResourceRecord(r);
                    modifiedNaptrs.Add(unlinkedNaptr);
                }
                else
                {
                    modifiedNaptrs.Add(r);
                }
            }

            // if we've made any changes to the NAPTRs then update the cache
            if (modified)
            {
                lr.NaptrRecords = modifiedNaptrs;
                LookupCache.SetResult(lr.Telname, lr);
            }
        }

    }
}