root/apps/outlook/branches/1.6.1/DotTelSystem/Lookup/LookupTelname.cs @ 669

///<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.Net;
using System.Net.Sockets;
using System.Threading;

using DNS = org.telnic.outlook.dns.DNS;
using LookupWorkerCompletedListener = org.telnic.outlook.lookup.LookupWorkerCompletedListener;
using org.telnic.outlook.util;

namespace org.telnic.outlook.lookup
{

    /// <summary> Lookup all NAPTR and TXT records for a given telname.
    /// 
    /// </summary>
    /// <author>  Ben Dowling
    /// </author>
    /// <version>  $id$
    /// </version>
    public class LookupTelname : LookupWorkerCompletedListener
        {
        
        /// <summary> Sets the listener.
        /// 
        /// </summary>
        /// <param name="l">the listener
        /// </param>
        virtual public LookupTelnameCompleteListener Listener
        {
            set
            {
                completeListener = value;
            }

        }
        /// <summary> Gets the status.
        /// 
        /// </summary>
        /// <returns> the status
        /// </returns>
        virtual public int Status
        {
            get
            {
                return status;
            }

        }

        // is the lookup complete
        private bool complete;

        /// <summary> The telname.</summary>
        private System.String telname;

        /// <summary> The lw naptr.</summary>
        private LookupWorker lwNaptr;

        /// <summary> The lw naptr.</summary>
        private LookupWorker lwLoc;

        /// <summary> The lw txt.</summary>
        private LookupWorker lwTxt;

        /// <summary> The lw ninfo.</summary>
        private LookupWorker lwNInfo;

        /// <summary> The lw kw.</summary>
        private LookupWorker lwKeyword;

        /// <summary> The lw version.</summary>
        private LookupWorker lwVersion;

        /// <summary> The lookup result.</summary>
        private LookupResult lookupResult;

        /// <summary> The complete listener.</summary>
        private LookupTelnameCompleteListener completeListener;

        /// <summary> The cached result.</summary>
        private LookupResult cachedResult;

        /// <summary> The cancelled.</summary>
        private bool cancelled = false;

        /// <summary> The Constant STATUS_OK.</summary>
        public const int STATUS_OK = 0;

        /// <summary> The Constant STATUS_NX_DOMAIN.</summary>
        public const int STATUS_NX_DOMAIN = 1;

        /// <summary> The Constant STATUS_LOOKUP_ERROR.</summary>
        public const int STATUS_LOOKUP_ERROR = 2;

        /// <summary> The Constant STATUS_NO_NETWORK.</summary>
        public const int STATUS_NO_NETWORK = 3;

        /// <summary> The Constant STATUS_CANCELLED.</summary>
        public const int STATUS_CANCELLED = 4;

        /// <summary> The Constant STATUS_TIMEOUT.</summary>
        public const int STATUS_TIMEOUT = 5;

        /// <summary> The status.</summary>
        private int status = STATUS_OK;

        /// <summary> The version at which we change lookups</summary>
        private const int version_change = 12;

        private Thread naptrThread;
        private Thread locThread;
        private Thread txtThread;
        private Thread nInfoThread;
        private Thread keywordThread;
        private Thread versionThread;

        public LookupWorker.LookupStatus parentStatus;

        private IPAddress address;
        private int port;

        /// <summary> The Constructor.</summary>
        public LookupTelname(IPAddress address, int port)
        {
            this.address = address;
            this.port = port;
        }


        /// <summary> Perform lookup.
        /// 
        /// </summary>
        /// <param name="telname">the telname
        /// </param>
        public virtual void performLookup(string telname, string publicTelname)
        {
            if (completeListener == null)
            {
                // no point doing any work if nobody wants to know the result!
                Logger.Log(Logger.Section.Lookups, "performLookup called without a listener, returning");
                return;
            }

            this.telname = telname;
            this.lookupResult = new LookupResult(telname, publicTelname);

            complete = false;
            cancelled = false;


            // check the cache for lookup results
            if (!cancelled)
            {
                cachedResult = LookupCache.GetResult(telname);
            }

            // if we have a valid cache result return it
            if (!cancelled && cachedResult != null && cachedResult.Valid)
            {
                Logger.Log(Logger.Section.Lookups, "Using cached result for " +  telname);
                completeListener.LookupTelnameComplete(cachedResult);
            }
            // otherwise try and lookup a new result
            else if (!cancelled)
            {
                int version = GetVersion(publicTelname);

                if (version < version_change)
                {
                    Logger.Log(Logger.Section.Lookups, "version " + version );
                    if (publicTelname == telname)
                    {
                        Logger.Log(Logger.Section.Lookups, "public");
                        DoVersionOneLookupAndCache(publicTelname);
                    }
                    else
                    {
                        Logger.Log(Logger.Section.Lookups, "private ");
                        DoVersionOneLookupAndCachePrivate(publicTelname, telname);
                    }
                }
                else
                {
                    Logger.Log(Logger.Section.Lookups, "version " + version);
                    DoLookupAndCache(publicTelname, telname);
                }

            }
        }

        /// <summary>
        /// Performs both public and private lookup and caching for version 1.1 onwards
        /// </summary>
        /// <param name="publicTelname">the public telname</param>
        /// <param name="telname">the private telname</param>
        private void DoLookupAndCache(string publicTelname, string telname)
        {
             // do txt and naptr lookups in separate threads
            performTxtLookup(telname);
            performLocLookup(telname);
            performNaptrLookup(telname);
            performNInfoLookup(telname);
            performKeywordLookup("_kw." + publicTelname);
            
            // wait for those threads to finish
            naptrThread.Join();
            locThread.Join();
            txtThread.Join();
            nInfoThread.Join();
            keywordThread.Join();

            Logger.Log(Logger.Section.Lookups, "Lookup threads finished for " + telname);
            Logger.Log(Logger.Section.Lookups, "NAPTR Status: " + lookupResult.NaptrStatus);
            Logger.Log(Logger.Section.Lookups, "LOC Status: " + lookupResult.LocStatus);
            Logger.Log(Logger.Section.Lookups, "TXT Status: " + lookupResult.TxtStatus);
            Logger.Log(Logger.Section.Lookups, "NInfo Status: " + lookupResult.NInfoStatus);
            Logger.Log(Logger.Section.Lookups, "Keyword Status: " + lookupResult.KeywordStatus);
            Logger.Log(Logger.Section.Lookups, "Version Status: " + lookupResult.VersionStatus);

            // check if the lookup status was OK
            if (!cancelled && lookupResult.LocStatus == LookupWorker.LookupStatus.Ok &&
                                    lookupResult.TxtStatus == LookupWorker.LookupStatus.Ok && 
                                    lookupResult.NaptrStatus == LookupWorker.LookupStatus.Ok &&
                                    lookupResult.NInfoStatus == LookupWorker.LookupStatus.Ok &&
                                    lookupResult.KeywordStatus == LookupWorker.LookupStatus.Ok &&
                                    lookupResult.VersionStatus == LookupWorker.LookupStatus.Ok)
            {
                // store result in cache
                LookupCache.SetResult(telname, lookupResult);
                complete = true;
                completeListener.LookupTelnameComplete(lookupResult);
            }
            // if the result was NXDomain then remove the cache!
            else if (!cancelled && (lookupResult.NaptrStatus == LookupWorker.LookupStatus.Nxdomain || 
                                    lookupResult.LocStatus == LookupWorker.LookupStatus.Nxdomain ||
                                    lookupResult.TxtStatus == LookupWorker.LookupStatus.Nxdomain ||
                                    lookupResult.KeywordStatus == LookupWorker.LookupStatus.Nxdomain ||
                                    lookupResult.VersionStatus == LookupWorker.LookupStatus.Nxdomain ||
                                    lookupResult.NInfoStatus == LookupWorker.LookupStatus.Nxdomain))
            {
                LookupCache.RemoveResult(telname);
                complete = true;
                completeListener.LookupTelnameComplete(lookupResult);
            }
            // lookup result is not OK, return the cached result
            else if (!cancelled && cachedResult != null)
            {
                // return the cached result, but set the status to the status of the actual lookup
                // so that the user will know why they are seeing the cached results
                complete = true;
                cachedResult.TxtStatus = lookupResult.TxtStatus;
                cachedResult.NaptrStatus = lookupResult.NaptrStatus;
                cachedResult.LocStatus = lookupResult.LocStatus;
                cachedResult.NInfoStatus = lookupResult.NInfoStatus;
                cachedResult.KeywordStatus = lookupResult.KeywordStatus;
                cachedResult.VersionStatus = lookupResult.VersionStatus;
                completeListener.LookupTelnameComplete(cachedResult);
            }
            else if (!cancelled)
            {
                completeListener.LookupTelnameComplete(lookupResult);
            }
        }

        /// <summary>
        /// Perform public lookup on version one
        /// </summary>
        /// <param name="publicTelname">the public telname</param>
        private void DoVersionOneLookupAndCache(string publicTelname)
        {
            // do txt and naptr lookups in separate threads
            performLocLookup(publicTelname);
            performNaptrLookup(publicTelname);
                   
            // wait for those threads to finish
            naptrThread.Join();
            locThread.Join();

            Logger.Log(Logger.Section.Lookups, "Lookup threads finished for " + telname);
            Logger.Log(Logger.Section.Lookups, "NAPTR Status: " + lookupResult.NaptrStatus);
            Logger.Log(Logger.Section.Lookups, "LOC Status: " + lookupResult.LocStatus);
                Logger.Log(Logger.Section.Lookups, "Version Status: " + lookupResult.VersionStatus);

            // check if the lookup status was OK
            if (!cancelled && lookupResult.LocStatus == LookupWorker.LookupStatus.Ok &&
                                     lookupResult.NaptrStatus == LookupWorker.LookupStatus.Ok &&
                                    lookupResult.VersionStatus == LookupWorker.LookupStatus.Ok)
            {
                // store result in cache
                LookupCache.SetResult(telname, lookupResult);
                complete = true;
                completeListener.LookupTelnameComplete(lookupResult);
            }
            // if the result was NXDomain then remove the cache!
            else if (!cancelled && (lookupResult.NaptrStatus == LookupWorker.LookupStatus.Nxdomain || 
                                    lookupResult.LocStatus == LookupWorker.LookupStatus.Nxdomain ||
                                    lookupResult.VersionStatus == LookupWorker.LookupStatus.Nxdomain))
            {
                LookupCache.RemoveResult(telname);
                complete = true;
                completeListener.LookupTelnameComplete(lookupResult);
            }
            // lookup result is not OK, return the cached result
            else if (!cancelled && cachedResult != null)
            {
                // return the cached result, but set the status to the status of the actual lookup
                // so that the user will know why they are seeing the cached results
                complete = true;
                cachedResult.TxtStatus = lookupResult.TxtStatus;
                cachedResult.NaptrStatus = lookupResult.NaptrStatus;
                cachedResult.LocStatus = lookupResult.LocStatus;
                cachedResult.VersionStatus = lookupResult.VersionStatus;
                completeListener.LookupTelnameComplete(cachedResult);
            }
            else if (!cancelled)
            {
                completeListener.LookupTelnameComplete(lookupResult);
            }
        }

        /// <summary>
        /// Performs private lookup on version 1
        /// </summary>
        /// <param name="publicTelname"> the public telname</param>
        /// <param name="telname">the private telname</param>
        private void DoVersionOneLookupAndCachePrivate(string publicTelname, string telname)
        {
            // do txt and naptr lookups in separate threads
            performTxtLookup(telname);
            performLocLookup(publicTelname);
            performNaptrLookup(telname);

            // wait for those threads to finish
            naptrThread.Join();
            locThread.Join();
            txtThread.Join();

            Logger.Log(Logger.Section.Lookups, "Lookup threads finished for " + telname);
            Logger.Log(Logger.Section.Lookups, "NAPTR Status: " + lookupResult.NaptrStatus);
            Logger.Log(Logger.Section.Lookups, "LOC Status: " + lookupResult.LocStatus);
            Logger.Log(Logger.Section.Lookups, "TXT Status: " + lookupResult.TxtStatus);
            Logger.Log(Logger.Section.Lookups, "Version Status: " + lookupResult.VersionStatus);

            // check if the lookup status was OK
            if (!cancelled && lookupResult.LocStatus == LookupWorker.LookupStatus.Ok &&
                                    lookupResult.TxtStatus == LookupWorker.LookupStatus.Ok &&
                                    lookupResult.NaptrStatus == LookupWorker.LookupStatus.Ok &&
                                    lookupResult.VersionStatus == LookupWorker.LookupStatus.Ok)
            {
                // store result in cache
                LookupCache.SetResult(telname, lookupResult);
                complete = true;
                completeListener.LookupTelnameComplete(lookupResult);
            }
            // if the result was NXDomain then remove the cache!
            else if (!cancelled && (lookupResult.NaptrStatus == LookupWorker.LookupStatus.Nxdomain ||
                                    lookupResult.LocStatus == LookupWorker.LookupStatus.Nxdomain ||
                                    lookupResult.TxtStatus == LookupWorker.LookupStatus.Nxdomain ||
                                    lookupResult.VersionStatus == LookupWorker.LookupStatus.Nxdomain))
            {
                LookupCache.RemoveResult(telname);
                complete = true;
                completeListener.LookupTelnameComplete(lookupResult);
            }
            // lookup result is not OK, return the cached result
            else if (!cancelled && cachedResult != null)
            {
                // return the cached result, but set the status to the status of the actual lookup
                // so that the user will know why they are seeing the cached results
                complete = true;
                cachedResult.TxtStatus = lookupResult.TxtStatus;
                cachedResult.NaptrStatus = lookupResult.NaptrStatus;
                cachedResult.LocStatus = lookupResult.LocStatus;
                cachedResult.VersionStatus = lookupResult.VersionStatus;
                completeListener.LookupTelnameComplete(cachedResult);
            }
            else if (!cancelled)
            {
                completeListener.LookupTelnameComplete(lookupResult);
            }
        }



        /// <summary> Perform naptr lookup.
        /// 
        /// </summary>
        /// <param name="telname">the telname
        /// </param>
        private void performNaptrLookup(string telnameVal)
        {
            if (!cancelled)
            {
                lwNaptr = new LookupWorker(telnameVal, DNS.DnsQueryType.Naptr, address, port, TelnicLookupType.Naptr);
            }
            if (!cancelled)
            {
                lwNaptr.LookupWorkerCompletedListener = this;
            }
            if (!cancelled)
            {
                naptrThread = new Thread(lwNaptr.Run);
                naptrThread.Name = "NAPTR Thread";
                naptrThread.Start();
            }
        }

        /// <summary> Perform LOC lookup.
        /// 
        /// </summary>
        /// <param name="telname">the telname
        /// </param>
        private void performLocLookup(string telnameVal)
        {
            if (!cancelled)
            {
                lwLoc = new LookupWorker(telnameVal, DNS.DnsQueryType.Loc, address, port, TelnicLookupType.Location);
            }
            if (!cancelled)
            {
                lwLoc.LookupWorkerCompletedListener = this;
            }
            if (!cancelled)
            {
                locThread = new Thread(lwLoc.Run);
                locThread.Name = "Loc Thread";
                locThread.Start();
            }
        }

        /// <summary> Perform txt lookup.
        /// 
        /// </summary>
        /// <param name="telname">the telname
        /// </param>
        private void performTxtLookup(string telnameVal)
        {
            if (!cancelled)
            {
                lwTxt = new LookupWorker(telnameVal, DNS.DnsQueryType.Txt, address, port, TelnicLookupType.LongLabelAndServiceMessage);
            }
            if (!cancelled)
            {
                lwTxt.LookupWorkerCompletedListener = this;
            }
            if (!cancelled)
            {
                txtThread = new Thread(lwTxt.Run);
                txtThread.Name = "TXT Thread";
                txtThread.Start();

            }
        }


        /// <summary> Perform Version lookup.
        /// 
        /// </summary>
        /// <param name="telname">the telname
        /// </param>
        private void performVersionLookup(string telnameVal)
        {
            if (!cancelled)
            {
                lwVersion = new LookupWorker(telnameVal, DNS.DnsQueryType.Txt, address, port, TelnicLookupType.Version);
            }
            if (!cancelled)
            {
                lwVersion.LookupWorkerCompletedListener = this;
            }
            if (!cancelled)
            {
                versionThread = new Thread(lwVersion.Run);
                versionThread.Name = "Version Thread";
                versionThread.Start();
            }
        }

        /// <summary>
        /// Perform Ninfo Lookup
        /// </summary>
        /// <param name="telnameVal"> the telname</param>
        private void performNInfoLookup(string telnameVal)
        {
            if (!cancelled)
            {
                lwNInfo = new LookupWorker(telnameVal, DNS.DnsQueryType.Ninfo, address, port, TelnicLookupType.HeaderText);
            }
            if (!cancelled)
            {
                lwNInfo.LookupWorkerCompletedListener = this;
            }
            if (!cancelled)
            {
                nInfoThread = new Thread(lwNInfo.Run);
                nInfoThread.Name = "NInfo Thread";
                nInfoThread.Start();

            }
        }

        /// <summary>
        /// Perform keyword lookup
        /// </summary>
        /// <param name="telnameVal">the telname</param>
        private void performKeywordLookup(string telnameVal)
        {
            if (!cancelled)
            {
                lwKeyword = new LookupWorker(telnameVal, DNS.DnsQueryType.Txt, address, port, TelnicLookupType.Keyword);
            }
            if (!cancelled)
            {
                lwKeyword.LookupWorkerCompletedListener = this;
            }
            if (!cancelled)
            {
                keywordThread = new Thread(lwKeyword.Run);
                keywordThread.Name = "Keyword Thread";
                keywordThread.Start();

            }
        }

        /// <summary>
        /// Adds the results to the lookup results according to the type of the query
        /// </summary>
        /// <param name="statusVal">The status of the DNS lookup</param>
        /// <param name="type">The type of lookup performed</param>
        /// <param name="answers"></param>
        public virtual void lookupWorkerCompleted(LookupWorker.LookupStatus statusVal, DNS.DnsQueryType type, System.Collections.ArrayList answers, TelnicLookupType telnicType)
        {
            if (type == DNS.DnsQueryType.Txt)
            {
                if (telnicType == TelnicLookupType.Keyword)
                {
                    if (statusVal == LookupWorker.LookupStatus.Ok)
                    {
                        lookupResult.KeywordRecords = answers;
                    }
                    else
                    {
                        lookupResult.KeywordRecords = new System.Collections.ArrayList();
                    }

                    lookupResult.KeywordStatus = statusVal;
                    return;
                }
                else if (telnicType == TelnicLookupType.Version)
                {
                    if (statusVal == LookupWorker.LookupStatus.Ok)
                    {
                        lookupResult.VersionRecords = answers;
                    }
                    else
                    {
                        lookupResult.VersionRecords = new System.Collections.ArrayList();
                    }

                    lookupResult.VersionStatus = statusVal;
                    return;
                }
                else
                {
                    if (statusVal == LookupWorker.LookupStatus.Ok)
                    {
                        lookupResult.TxtRecords = answers;
                    }
                    else
                    {
                        lookupResult.TxtRecords = new System.Collections.ArrayList();
                    }

                    lookupResult.TxtStatus = statusVal;
                    return;
                }
            }
            else if (type == DNS.DnsQueryType.Loc)
            {
                if (statusVal == LookupWorker.LookupStatus.Ok)
                {
                    lookupResult.LocRecords = answers;
                }
                else
                {
                    lookupResult.LocRecords = new System.Collections.ArrayList();
                }
                lookupResult.LocStatus = statusVal;
                return;
            }
            else if (type == DNS.DnsQueryType.Naptr)
            {
                if (statusVal == LookupWorker.LookupStatus.Ok)
                {
                    lookupResult.NaptrRecords = answers;
                }
                else
                {
                    lookupResult.NaptrRecords = new System.Collections.ArrayList();
                }
                lookupResult.NaptrStatus = statusVal;
                return;
            }
            else if (type == DNS.DnsQueryType.Ninfo)
            {
                if (statusVal == LookupWorker.LookupStatus.Ok)
                {
                    lookupResult.NInfoRecords = answers;
                }
                else
                {
                    lookupResult.NInfoRecords = new System.Collections.ArrayList();
                }
                lookupResult.NInfoStatus = statusVal;
                return;
            }
        }

        /// <summary> Cancel the lookup.
        /// 
        /// </summary>
        /// <seealso cref="org.telnic.outlook.util.Cancellable.cancel()">
        /// </seealso>
        public virtual void cancel()
        {
            cancelled = true;
            if (lwNaptr != null)
            {
                //lwNaptr.Interrupt();
                lwNaptr = null;
            }
            if (lwTxt != null)
            {
                //lwTxt.Interrupt();
                lwTxt = null;
            }
            if (lwLoc != null)
            {
                lwLoc = null;
            }
            if (lwNInfo != null)
            {
                lwNInfo = null;
            }
            if (lwKeyword != null)
            {
                lwKeyword = null;
            }
            if (lwVersion != null)
            {
                lwVersion = null;
            }

            this.status = STATUS_CANCELLED;
            if (completeListener != null)
            {
                completeListener.LookupTelnameComplete(null);
            }
        }

        /// <summary>
        /// Do a public text lookup to get the pddx version to decide what further lookups to do
        /// </summary>
        /// <param name="telname">the public telname</param>
        /// <returns>the pddx version eg "1" or "11"</returns>
        private int GetVersion(string telname)
        {
            performVersionLookup(telname);
            versionThread.Join();
            Logger.Log(Logger.Section.Lookups, "Version Status: " + lookupResult.VersionStatus);
            if (lookupResult.VersionStatus == LookupWorker.LookupStatus.Ok)
            {
                Logger.Log(Logger.Section.Lookups, "PDDX Version (in getVersion) is: " + lookupResult.PddxVersion);
                string pddx = lookupResult.PddxVersion;
                if (pddx.Length == 1)
                    pddx = pddx + "0";
                try
                {
                    return int.Parse(pddx);
                }
                catch (Exception e)
                {
                    return version_change;
                }

            }
            return version_change;
        }
    }
}