Example #1
0
        private void RecvData(IntPtr ptr)
        {
            this.DNS_LOG_INFO("recv data from DNS server");
            DnResult result = (DnResult)Marshal.PtrToStructure(ptr, typeof(DnResult));

            if (result.domainName.Length != 0)
            {
                if (this.callbackObjectDic.ContainsKey(result.domainName))
                {
                    this.DNS_LOG_INFO(string.Format("recive domainName is [{0}]", result.domainName));
                    this.ParseRecvData(result);
                }
                else
                {
                    this.DNS_LOG_ERROR(string.Format("no such domainName[{0}] in callback object dictionary", result.domainName));
                    this.mErrCode   = DNSErrCode.DNS_INPUT_PARAM_ERROR;
                    this.mErrString = "no domainName's delegate function in callback object dictionary";
                }
            }
            else
            {
                this.DNS_LOG_ERROR("the result domainName is empty");
                this.mErrCode   = DNSErrCode.DNS_INPUT_PARAM_ERROR;
                this.mErrString = "the result domainName is empty";
            }
        }
Example #2
0
 public DNSErrCode SetFileSys(IApolloDNSFileSys fileSys)
 {
     if (fileSys == null)
     {
         this.DNS_LOG_ERROR("input param error");
         this.mErrCode   = DNSErrCode.DNS_INPUT_PARAM_ERROR;
         this.mErrString = "the input file system pointer is empty";
         return(DNSErrCode.DNS_INPUT_PARAM_ERROR);
     }
     this.mFileSys = fileSys;
     return(DNSErrCode.DNS_NO_ERROR);
 }
Example #3
0
 public DNSErrCode SetCurrentAPN(string APN)
 {
     if ((APN == null) || (APN.Length == 0))
     {
         this.DNS_LOG_ERROR("input param error");
         this.mErrCode   = DNSErrCode.DNS_INPUT_PARAM_ERROR;
         this.mErrString = "the input APN string is illegal";
         return(DNSErrCode.DNS_INPUT_PARAM_ERROR);
     }
     this.mCurrentAPN      = APN;
     this.mUploadeUserInfo = APN;
     return(dns_SetCurrentAPN(base.ObjectId, APN));
 }
Example #4
0
        public DNSErrCode Init(bool callbackMode, int cacheTime)
        {
            if (this.mInitStatus == DNSErrCode.DNS_NO_ERROR)
            {
                this.DNS_LOG_INFO("init had been finished");
                return(DNSErrCode.DNS_NO_ERROR);
            }
            this.isCallbackMode = callbackMode;
            if (this.mFileSys != null)
            {
                this.ReadDNSverConfig();
            }
            this.mInitStatus = dns_Init(base.ObjectId, callbackMode, cacheTime);
            this.mErrCode    = dns_GetErrorCode(base.ObjectId);
            IntPtr ptr = dns_GetErrorString(base.ObjectId);

            this.mErrString = Marshal.PtrToStringAnsi(ptr);
            return(this.mInitStatus);
        }
Example #5
0
        public DNSErrCode Query(string domainName, ProcessQueryResult process, string OId, string SId, string version, string userData)
        {
            QueryValue value2;

            if (this.mInitStatus != DNSErrCode.DNS_NO_ERROR)
            {
                this.DNS_LOG_ERROR("init failed or uninit");
                this.mErrCode   = this.mInitStatus;
                this.mErrString = "init failed or uninit";
                return(this.mInitStatus);
            }
            if ((domainName == null) || (domainName.Length == 0))
            {
                this.DNS_LOG_ERROR("domainName is null");
                this.mErrCode   = DNSErrCode.DNS_INPUT_PARAM_ERROR;
                this.mErrString = "domainName is null";
                return(DNSErrCode.DNS_INPUT_PARAM_ERROR);
            }
            if (process == null)
            {
                this.DNS_LOG_ERROR("delegate function is null");
                this.mErrCode   = DNSErrCode.DNS_INPUT_PARAM_ERROR;
                this.mErrString = "delegate function is null";
                return(DNSErrCode.DNS_INPUT_PARAM_ERROR);
            }
            this.DNS_LOG_INFO(string.Format("domainName is [{0}]", domainName));
            this.mUploadeDomainName = string.Empty;
            if ((((OId != null) || (version != null)) || (userData != null)) && ((SId == null) || (SId.Length == 0)))
            {
                this.DNS_LOG_ERROR("OId, version or userData is not null but the SId is null");
                this.mErrCode   = DNSErrCode.DNS_INPUT_PARAM_ERROR;
                this.mErrString = "OId, version or userData is not null but the SId is null";
                return(DNSErrCode.DNS_INPUT_PARAM_ERROR);
            }
            if ((OId != null) && (OId.Length != 0))
            {
                this.mUploadeUserInfo = this.mUploadeUserInfo + ":" + OId;
            }
            else
            {
                this.mUploadeUserInfo = this.mUploadeUserInfo + ":N";
            }
            if ((SId != null) && (SId.Length != 0))
            {
                this.mUploadeUserInfo = this.mUploadeUserInfo + ":" + SId;
            }
            else
            {
                this.mUploadeUserInfo = this.mUploadeUserInfo + ":N";
            }
            if ((version != null) && (version.Length != 0))
            {
                this.mUploadeUserInfo = this.mUploadeUserInfo + ":" + version;
            }
            else
            {
                this.mUploadeUserInfo = this.mUploadeUserInfo + ":N";
            }
            char[]        separator      = new char[] { '|' };
            string[]      strArray       = domainName.Split(separator);
            List <string> domainNameList = new List <string>();

            foreach (string str in strArray)
            {
                if ((str.Length != 0) && !domainNameList.Contains(str))
                {
                    domainNameList.Add(str);
                }
            }
            if (domainNameList.Count == 0)
            {
                this.DNS_LOG_ERROR("all domainNames is empty");
                this.mErrCode   = DNSErrCode.DNS_INPUT_PARAM_ERROR;
                this.mErrString = "all domainNames is empty";
                return(DNSErrCode.DNS_INPUT_PARAM_ERROR);
            }
            if (10 < domainNameList.Count)
            {
                this.DNS_LOG_ERROR("more then ten domainNames in the list");
                this.mErrCode   = DNSErrCode.DNS_TOOMANY_DOMAINNAMES;
                this.mErrString = "more then ten domainNames in the list";
                return(DNSErrCode.DNS_TOOMANY_DOMAINNAMES);
            }
            this.DNS_LOG_INFO("all param is legal");
            value2.errCode   = 0L;
            value2.errString = "no error";
            value2.value     = new ListView <DnValue>();
            List <string> subDomainNames = new List <string>();

            if ((this.mFileSys != null) && this.isCacheEnable)
            {
                this.DNS_LOG_INFO("search domainName in cache");
                this.SearchDomainNameInCache(domainNameList, ref value2, ref subDomainNames);
            }
            else
            {
                this.DNS_LOG_INFO("search all domainNames in DNS server");
                foreach (string str2 in domainNameList)
                {
                    subDomainNames.Add(str2);
                }
            }
            if (subDomainNames.Count == 0)
            {
                this.DNS_LOG_INFO("all domainName's IP exist in cache");
                this.UploadStatisticData();
                process(value2);
                return(DNSErrCode.DNS_NO_ERROR);
            }
            string str3 = string.Empty;

            for (int i = 0; i < (subDomainNames.Count - 1); i++)
            {
                str3 = str3 + subDomainNames[i] + "|";
            }
            str3 = str3 + subDomainNames[subDomainNames.Count - 1];
            this.DNS_LOG_INFO(string.Format("send to DNS server's domainNames are [{0}]", str3));
            DNSErrCode code = dns_Query(base.ObjectId, str3, OId, SId, version, userData);

            this.mErrCode = dns_GetErrorCode(base.ObjectId);
            IntPtr ptr = dns_GetErrorString(base.ObjectId);

            this.mErrString = Marshal.PtrToStringAnsi(ptr);
            if (code != DNSErrCode.DNS_NO_ERROR)
            {
                this.DNS_LOG_ERROR(string.Format("send request failed, error code is [{0}]", Convert.ToString(code)));
                foreach (string str4 in subDomainNames)
                {
                    DnValue value3;
                    value3.errCode    = 0x455L;
                    value3.errString  = "send request error";
                    value3.domainName = str4;
                    value3.IPList     = new List <string>();
                    value2.value.Add(value3);
                    if (0 < this.mUploadeDomainName.Length)
                    {
                        this.mUploadeDomainName = this.mUploadeDomainName + ":" + str4 + "_0";
                    }
                    else
                    {
                        this.mUploadeDomainName = this.mUploadeDomainName + str4 + "_0";
                    }
                }
                if (subDomainNames.Count == domainNameList.Count)
                {
                    value2.errCode   = 0x455L;
                    value2.errString = "send request error";
                }
                this.UploadStatisticData();
                process(value2);
                return(code);
            }
            if (this.callbackObjectDic.ContainsKey(str3))
            {
                this.callbackObjectDic[str3].Add(process);
            }
            else
            {
                ListView <ProcessQueryResult> view = new ListView <ProcessQueryResult>();
                view.Add(process);
                this.callbackObjectDic.Add(str3, view);
            }
            if (this.isCallbackMode)
            {
                process(value2);
                value2.value.Clear();
            }
            this.mInitDomainNameMap.Add(str3, value2);
            return(DNSErrCode.DNS_NO_ERROR);
        }
Example #6
0
        private void ParseRecvData(DnResult result)
        {
            QueryValue value2;

            this.DNS_LOG_INFO("ParseRecvData begin");
            value2.errCode   = 0L;
            value2.errString = "no error";
            value2.value     = new ListView <DnValue>();
            foreach (KeyValuePair <string, QueryValue> pair in this.mInitDomainNameMap)
            {
                if (pair.Key == result.domainName)
                {
                    QueryValue value3 = pair.Value;
                    if (value3.value.Count != 0)
                    {
                        foreach (DnValue value4 in value3.value)
                        {
                            value2.value.Add(value4);
                        }
                    }
                }
            }
            if (result.errCode == 0)
            {
                this.DNS_LOG_INFO("result is success");
                if (this.ParseJsonValue(ref result.value, ref value2) == DNSErrCode.DNS_NO_ERROR)
                {
                    this.DNS_LOG_INFO("json parse success");
                }
                else
                {
                    this.DNS_LOG_ERROR("parse json date return from DNS server error");
                    this.mErrCode   = DNSErrCode.DNS_JSON_PARSE_ERROR;
                    this.mErrString = "parse json date return from DNS server error";
                    if (value2.value.Count == 0)
                    {
                        value2.errCode   = 0x452L;
                        value2.errString = "json parse error";
                    }
                }
            }
            else
            {
                this.DNS_LOG_ERROR("result is failed");
                this.mErrCode = dns_GetErrorCode(base.ObjectId);
                IntPtr ptr = dns_GetErrorString(base.ObjectId);
                this.mErrString = Marshal.PtrToStringAnsi(ptr);
                if (value2.value.Count == 0)
                {
                    value2.errCode   = result.errCode;
                    value2.errString = result.errString;
                }
                char[] separator = new char[] { '|' };
                foreach (string str in result.domainName.Split(separator))
                {
                    DnValue value5;
                    value5.errCode    = result.errCode;
                    value5.errString  = result.errString;
                    value5.domainName = str;
                    value5.IPList     = new List <string>();
                    value2.value.Add(value5);
                    if (0 < this.mUploadeDomainName.Length)
                    {
                        this.mUploadeDomainName = this.mUploadeDomainName + ":" + str + "_0";
                    }
                    else
                    {
                        this.mUploadeDomainName = this.mUploadeDomainName + str + "_0";
                    }
                }
            }
            foreach (KeyValuePair <string, ListView <ProcessQueryResult> > pair2 in this.callbackObjectDic)
            {
                if (pair2.Key == result.domainName)
                {
                    ListView <ProcessQueryResult> view = pair2.Value;
                    if (view.Count != 0)
                    {
                        this.DNS_LOG_INFO(string.Format("process delegate function for domainNames[{0}]", result.domainName));
                        ProcessQueryResult result2 = view[0];
                        this.UploadStatisticData();
                        result2(value2);
                        view.RemoveAt(0);
                        if (view.Count == 0)
                        {
                            this.mInitDomainNameMap.Remove(result.domainName);
                            this.callbackObjectDic.Remove(result.domainName);
                        }
                    }
                    else
                    {
                        this.DNS_LOG_INFO(string.Format("no delegate function for domainName[{0}]", result.domainName));
                        this.mErrCode   = DNSErrCode.DNS_HANDLE_FAILED;
                        this.mErrString = "no delegate function for domainName";
                    }
                    return;
                }
            }
            this.DNS_LOG_INFO(string.Format("no such domainName[{0}] in dictionary", result.domainName));
            this.mErrCode   = DNSErrCode.DNS_HANDLE_FAILED;
            this.mErrString = "no such domainName in dictionary";
        }
Example #7
0
        private DNSErrCode ParseJsonValue(ref string valueString, ref QueryValue queryValue)
        {
            if (valueString.Length == 0)
            {
                this.DNS_LOG_ERROR("input param error");
                this.mErrCode   = DNSErrCode.DNS_INPUT_PARAM_ERROR;
                this.mErrString = "the input json value string is empty";
                return(DNSErrCode.DNS_INPUT_PARAM_ERROR);
            }
            this.DNS_LOG_INFO(string.Format("json value is [{0}]", valueString));
            Dictionary <string, object> dictionary = Json.Deserialize(valueString) as Dictionary <string, object>;

            if ((dictionary != null) && (dictionary.Count != 0))
            {
                long num = (long)dictionary["ErrCode"];
                if (num == 0)
                {
                    List <object> list = dictionary["Results"] as List <object>;
                    foreach (object obj2 in list)
                    {
                        long          num2     = 0L;
                        string        str      = "no error";
                        string        str2     = string.Empty;
                        List <string> dataList = new List <string>();
                        Dictionary <string, object> dictionary2 = obj2 as Dictionary <string, object>;
                        str2 = (string)dictionary2["Dn"];
                        long num3 = (long)dictionary2["ErrCode"];
                        num2 = num3;
                        if (num3 == 0)
                        {
                            this.DNS_LOG_INFO(string.Format("domainName[{0}] is success", str2));
                            List <object> list3 = dictionary2["Ips"] as List <object>;
                            foreach (object obj3 in list3)
                            {
                                Dictionary <string, object> dictionary3 = obj3 as Dictionary <string, object>;
                                dataList.Add((string)dictionary3["Ip"]);
                            }
                            if (0 < this.mUploadeDomainName.Length)
                            {
                                this.mUploadeDomainName = this.mUploadeDomainName + ":" + str2 + "_2";
                            }
                            else
                            {
                                this.mUploadeDomainName = this.mUploadeDomainName + str2 + "_2";
                            }
                        }
                        else
                        {
                            this.DNS_LOG_INFO(string.Format("domainName[{0}] is error", str2));
                            str = (string)dictionary2["ErrStr"];
                            if (0 < this.mUploadeDomainName.Length)
                            {
                                this.mUploadeDomainName = this.mUploadeDomainName + ":" + str2 + "_0";
                            }
                            else
                            {
                                this.mUploadeDomainName = this.mUploadeDomainName + str2 + "_0";
                            }
                        }
                        int cacheTime = 0;
                        if ((this.mDNSvrDomainName == str2) || (this.mDNSvrPortName == str2))
                        {
                            this.DNS_LOG_INFO("current domainName is DNS server's domainName or port");
                        }
                        else
                        {
                            DnValue value2;
                            value2.errCode    = num2;
                            value2.errString  = str;
                            value2.domainName = str2;
                            value2.IPList     = dataList;
                            queryValue.value.Add(value2);
                            cacheTime = 1;
                        }
                        this.UpdateIPListIntoCacheDate(str2, dataList, cacheTime);
                    }
                    return(DNSErrCode.DNS_NO_ERROR);
                }
                this.mErrCode        = (DNSErrCode)((int)num);
                this.mErrString      = (string)dictionary["ErrStr"];
                queryValue.errCode   = num;
                queryValue.errString = (string)dictionary["ErrStr"];
                return(DNSErrCode.DNS_NO_ERROR);
            }
            this.mErrCode   = DNSErrCode.DNS_JSON_PARSE_ERROR;
            this.mErrString = "parse the json value error";
            return(DNSErrCode.DNS_JSON_PARSE_ERROR);
        }