www.pudn.com > Tustena_CRM_OS_3.0.2_Stable.zip > Tracker.cs

/// TUSTENA PUBLIC LICENSE v1.0 
///  
/// Portions Copyright (c) 2003-2005 Digita S.r.l. All Rights Reserved. 
/// 
/// Tustena CRM is a trademark of: 
/// Digita S.r.l. 
/// Viale Enrico Fermi 14/z 
/// 31011 Asolo (Italy) 
/// Tel. +39-0423-951251 
/// Mail. info@digita.it 
/// 
/// This file contains Original Code and/or Modifications of Original Code 
/// as defined in and that are subject to the Tustena Public Source License 
/// Version 1.0 (the 'License'). You may not use this file except in 
/// compliance with the License. Please obtain a copy of the License at 
/// http://www.tustena.com/TPL/ and read it before using this 
// file. 
/// 
/// The Original Code and all software distributed under the License are 
/// distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
/// EXPRESS OR IMPLIED, AND DIGITA S.R.L. HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
/// INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 
/// FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
/// Please see the License for the specific language governing rights and 
/// limitations under the License. 
/// 
/// YOU MAY NOT REMOVE OR ALTER THIS COPYRIGHT NOTICE! 
///  
 
using System; 
using System.Collections; 
using System.IO; 
using System.Net; 
using System.Runtime.Serialization; 
using System.Text; 
using System.Web; 
using System.Xml; 
 
namespace Digita.Tustena 
{ 
	[Serializable] 
	public class SessionTracker : ISerializable 
	{ 
		private HttpContext _context; 
		private DateTime expires; 
		private int visitCount; 
		private string userHostAddress; 
		private string userAgent; 
		private string originalReferrer; 
		private string userGuid; 
		private string originalURL; 
		private string sessionReferrer; 
		private string sessionURL; 
		private ArrayList _pages = new ArrayList(); 
		private const string path = "C:\\Inetpub\\wwwroot\\tustena\\logs\\"; 
 
 
		public void GetObjectData(SerializationInfo Info, StreamingContext ctxt) 
		{ 
			Info.AddValue("_pages", this._pages, typeof(ArrayList)); 
			Info.AddValue("_sessionURL", this.sessionURL); 
			Info.AddValue("_sessionReferrer", this.sessionReferrer); 
			Info.AddValue("_originalURL", this.originalURL); 
			Info.AddValue("_userGuid", this.userGuid); 
			Info.AddValue("_originalReferrer", this.originalReferrer); 
			Info.AddValue("_userAgent", this.userAgent); 
			Info.AddValue("_userHostAddress", this.userHostAddress); 
			Info.AddValue("_visitCount", this.visitCount); 
			Info.AddValue("_expires", this.expires, typeof(DateTime)); 
			Info.AddValue("path", this.path); 
			Info.AddValue("_context", this._context, typeof(HttpContext)); 
			Info.AddValue("xmlDoc", this.xmlDoc, typeof(XmlDocument)); 
		} 
 
 
		public SessionTracker() 
		{ 
			_context = HttpContext.Current; 
			expires = DateTime.Now.AddYears(1); 
			SetGuid(); 
			IncrementVisitCount(); 
			userHostAddress = _context.Request.UserHostAddress.ToString(); 
			userAgent = _context.Request.UserAgent.ToString(); 
			if (_context.Request.UrlReferrer != null) 
			{ 
				sessionReferrer = _context.Request.UrlReferrer.ToString(); 
				SetOriginalReferrer(sessionReferrer); 
			} 
			if (_context.Request.Url != null) 
			{ 
				SetOriginalURL(_context.Request.Url.ToString()); 
				sessionURL = _context.Request.Url.ToString(); 
			} 
		} 
 
 
		private SessionTracker(SerializationInfo Info, StreamingContext context) 
		{ 
			this.originalURL = Info.GetString("_originalURL"); 
			this.userGuid = Info.GetString("_userGuid"); 
		} 
		public void AddPage(string pageName) 
		{ 
			SessionTrackerPage pti = new SessionTrackerPage(); 
			pti.PageName = pageName; 
			pti.Time = DateTime.Now; 
			_pages.Add(pti); 
		} 
 
 
 
		private static void writenode(XmlElement childNode, string name, string text, string elapsed) 
		{ 
			if ((text != null && text.Length != 0)) 
			{ 
				XmlElement childNode2 = xmlDoc.CreateElement(name); 
				if ((elapsed != null && elapsed.Length != 0)) childNode2.SetAttribute("ElapsedTime", elapsed); 
				XmlText textNode = xmlDoc.CreateTextNode(name); 
				textNode.Value = text; 
				childNode2.AppendChild(textNode); 
				childNode.AppendChild(childNode2); 
			} 
		} 
 
		public static XmlDocument xmlDoc = new XmlDocument(); 
 
		public void createTrackerXML(SessionTracker tracker, string cID) 
		{ 
			string fileName = path + "Company-" + cID + "-" + DateTime.Now.ToString("yyyyMMdd") + ".xml"; 
			try 
			{ 
				xmlDoc.Load(fileName); 
			} 
			catch (FileNotFoundException) 
			{ 
				XmlTextWriter xmlWriter = new XmlTextWriter(fileName, Encoding.UTF8); 
				xmlWriter.Formatting = Formatting.Indented; 
				xmlWriter.WriteProcessingInstruction("xml", "version='1.0' encoding='UTF-8'"); 
				xmlWriter.WriteProcessingInstruction("xml-stylesheet", "type='text/xsl' ref='visitors.xsl'"); 
				xmlWriter.WriteStartElement("Visits"); 
				xmlWriter.Close(); 
				xmlDoc.Load(fileName); 
			} 
			XmlNode root = xmlDoc.DocumentElement; 
			XmlElement childNode = xmlDoc.CreateElement("Visit"); 
			childNode.SetAttribute("Date", DateTime.Now.ToString()); 
			childNode.SetAttribute("Guid", tracker.userGuid); 
			if (tracker.SessionUserHostAddress == "81.72.92.130") 
				childNode.SetAttribute("Local", "Digita ASOLO"); 
			root.AppendChild(childNode); 
			CountryLookup cl = new CountryLookup(path + "GeoIP.dat"); 
			string Country = cl.lookupCountryName(tracker.SessionUserHostAddress); 
			root.AppendChild(childNode); 
			ReverseLookup lk = new ReverseLookup(); 
			writenode(childNode, "UserHostAddress", tracker.SessionUserHostAddress, ""); 
			writenode(childNode, "UserHostName", lk.LookUp(tracker.SessionUserHostAddress), ""); 
			writenode(childNode, "Country", Country, ""); 
			writenode(childNode, "UserAgent", tracker.SessionUserAgent, ""); 
			string agent = ""; 
			string spider = ""; 
			string os = ""; 
			getAgent(tracker.SessionUserAgent, out agent, out os, out spider); 
			writenode(childNode, "AgentName", agent, ""); 
			writenode(childNode, "OS", os, ""); 
			writenode(childNode, "Crawler", spider, ""); 
 
			writenode(childNode, "URL", tracker.SessionURL, ""); 
			if ((tracker.SessionReferrer) != null) 
			{ 
				string referer = ""; 
				referer = tracker.SessionReferrer; 
				writenode(childNode, "Referer", referer, ""); 
				string name = ""; 
				string phrase = ""; 
				getSE(referer, out name, out phrase); 
				writenode(childNode, "SearchEngine", name, ""); 
				writenode(childNode, "Phrase", phrase, ""); 
			} 
			writenode(childNode, "VisitCount", tracker.VisitCount.ToString(), ""); 
			writenode(childNode, "OriginalURL", tracker.OriginalURL, ""); 
			writenode(childNode, "OriginalReferrer", tracker.OriginalReferrer, ""); 
			TimeSpan ElapsedTime; 
			DateTime PreviousTime = DateTime.Now; 
			DateTime FirstTime = DateTime.Now; 
			bool first = true; 
			if (tracker.Pages != null) 
			{ 
				ArrayList pages = tracker.Pages; 
				string lastPage = ""; 
				writenode(childNode, "VisitedPagesCount", pages.Count.ToString(), ""); 
				XmlElement PageschildNode = xmlDoc.CreateElement("Pages"); 
				childNode.AppendChild(PageschildNode); 
				foreach (SessionTrackerPage pti in pages) 
				{ 
					if (first) 
					{ 
						FirstTime = pti.Time; 
						first = false; 
					} 
					else 
					{ 
						ElapsedTime = pti.Time.Subtract(PreviousTime); 
						writenode(PageschildNode, "Page", lastPage, ElapsedTime.ToString().Substring(0, 8)); 
					} 
					lastPage = pti.PageName; 
					PreviousTime = pti.Time; 
				} 
				writenode(PageschildNode, "Page", lastPage, ""); 
				ElapsedTime = PreviousTime.Subtract(FirstTime); 
				writenode(PageschildNode, "TotalTime", ElapsedTime.ToString().Substring(0, 8), ""); 
			} 
			else 
			{ 
				writenode(childNode, "VisitedPagesCount", "0", ""); 
			} 
			xmlDoc.Save(fileName); 
		} 
 
		private void getAgent(string agentstr, out string agent, out string os, out string spider) 
		{ 
			XmlDocument xmlDoc = new XmlDocument(); 
			xmlDoc.Load(path + "agent.xml"); 
 
			agent = ""; 
			os = ""; 
			spider = ""; 
			XmlNodeList SEpat = xmlDoc.SelectNodes("//browser"); 
			foreach (XmlNode pat in SEpat) 
				if (agentstr.IndexOf(pat.InnerText) > -1) 
				{ 
					agent = pat.Attributes["value"].Value.ToString(); 
					break; 
				} 
			SEpat = xmlDoc.SelectNodes("//os"); 
			foreach (XmlNode pat in SEpat) 
				if (agentstr.IndexOf(pat.InnerText) > -1) 
				{ 
					os = pat.Attributes["value"].Value.ToString(); 
					break; 
				} 
			SEpat = xmlDoc.SelectNodes("//spider"); 
			foreach (XmlNode pat in SEpat) 
				if (agentstr.IndexOf(pat.InnerText) > -1) 
				{ 
					spider = pat.Attributes["value"].Value.ToString(); 
					break; 
				} 
		} 
 
		private void getSE(string url, out string name, out string phrase) 
		{ 
			XmlDocument xmlDoc = new XmlDocument(); 
			xmlDoc.Load(path + "se.xml"); 
 
			name = ""; 
			phrase = ""; 
			string queryString = ""; 
			int pStart = 0; 
			if (url.IndexOf("?") > -1) 
			{ 
				queryString = url.Substring(url.IndexOf("?")); 
				url = url.Substring(0, url.IndexOf("?") - 1); 
			} 
			XmlNodeList SEpat = xmlDoc.SelectNodes("//ei"); 
			foreach (XmlNode pat in SEpat) 
				if (url.IndexOf(pat.InnerText) > -1) 
				{ 
					XmlNode SEnode = pat.ParentNode.SelectSingleNode("name"); 
					if (SEnode != null) 
					{ 
						name = SEnode.InnerText; 
						XmlNodeList Spi = pat.ParentNode.SelectNodes("spi"); 
						foreach (XmlNode sp in Spi) 
						{ 
							if (queryString.IndexOf(sp.InnerText.Replace("!", "&")) > 0) 
							{ 
								pStart = queryString.IndexOf(sp.InnerText.Replace("!", "&")) + sp.InnerText.Length; 
								phrase = queryString.Substring(pStart); 
								if (phrase.IndexOf("&") > 0) 
									phrase = phrase.Substring(0, phrase.IndexOf("&")); 
								phrase = phrase.Replace('+', ' '); 
								break; 
							} 
						} 
						break; 
					} 
				} 
		} 
 
		public void SetGuid() 
		{ 
			const string KEY = "Guid"; 
			if (_context.Request.Cookies.Get(KEY) == null) 
			{ 
				userGuid = Guid.NewGuid().ToString("N"); 
				addCookie(KEY, userGuid); 
			} 
			else 
			{ 
				userGuid = _context.Request.Cookies.Get(KEY).Value; 
			} 
		} 
 
		public void IncrementVisitCount() 
		{ 
			const string KEY = "VisitCount"; 
			if (_context.Request.Cookies.Get(KEY) == null) 
			{ 
				visitCount = 1; 
			} 
			else 
			{ 
				visitCount = Convert.ToInt32(_context.Request.Cookies.Get(KEY).Value) + 1; 
			} 
 
			addCookie(KEY, visitCount.ToString()); 
		} 
 
 
		public void SetOriginalReferrer(string val) 
		{ 
			const string KEY = "OriginalReferrer"; 
			if (_context.Request.Cookies.Get(KEY) != null) 
			{ 
				originalReferrer = _context.Request.Cookies.Get(KEY).Value; 
			} 
			else 
			{ 
				addCookie(KEY, val); 
				originalReferrer = val; 
			} 
		} 
 
 
		public void SetOriginalURL(string val) 
		{ 
			const string KEY = "OriginalURL"; 
			if (_context.Request.Cookies.Get(KEY) != null) 
			{ 
				originalURL = _context.Request.Cookies.Get(KEY).Value; 
			} 
			else 
			{ 
				addCookie(KEY, val); 
				originalURL = val; 
			} 
		} 
 
		private void addCookie(string key, string value) 
		{ 
			HttpCookie cookie; 
			cookie = new HttpCookie(key, value); 
			cookie.Expires = expires; 
			_context.Response.Cookies.Set(cookie); 
		} 
 
		#region Properties 
 
 
		private int VisitCount 
		{ 
			get { return visitCount; } 
		} 
 
 
		private string userGuid 
		{ 
			get { return userGuid; } 
		} 
 
 
		private string OriginalReferrer 
		{ 
			get { return originalReferrer; } 
		} 
 
 
		private string OriginalURL 
		{ 
			get { return originalURL; } 
		} 
 
 
		private string SessionReferrer 
		{ 
			get { return sessionReferrer; } 
		} 
 
 
		private string SessionURL 
		{ 
			get { return sessionURL; } 
		} 
 
 
		private string SessionUserHostAddress 
		{ 
			get { return userHostAddress; } 
		} 
 
 
		private string SessionUserAgent 
		{ 
			get { return userAgent; } 
		} 
 
 
		private ArrayList Pages 
		{ 
			get { return _pages; } 
		} 
 
		#endregion 
 
	} 
 
	public class SessionTrackerPage 
	{ 
		public string PageName; 
		public DateTime Time; 
	} 
 
	public class ReverseLookup 
	{ 
		public string LookUp(string iP) 
		{ 
			try 
			{ 
				IPHostEntry ipEntry; 
				ipEntry = Dns.Resolve(iP); 
				return ipEntry.HostName; 
			} 
			catch //(System.Net.Sockets.SocketException se) 
			{ 
				return "n/A"; 
			} 
		} 
	} 
 
	public class CountryLookup 
	{ 
		private FileStream fileInput; 
		private static long Country = 16776960; 
 
		private static string[] countryCode = 
			{ 
				"--", "AP", "EU", "AD", "AE", "AF", "AG", "AI", "AL", "AM", "AN", "AO", "AQ", "AR", "AS", "AT", "AU", "AW", "AZ", "BA", "BB", "BD", "BE", "BF", "BG", "BH", "BI", "BJ", "BM", "BN", "BO", "BR", "BS", "BT", "BV", "BW", "BY", "BZ", "CA", "CC", "CD", "CF", "CG", "CH", "CI", "CK", "CL", "CM", "CN", "CO", "CR", "CU", "CV", "CX", "CY", "CZ", "DE", "DJ", "DK", "DM", "DO", "DZ", 
				"EC", "EE", "EG", "EH", "ER", "ES", "ET", "FI", "FJ", "FK", "FM", "FO", "FR", "FX", "GA", "GB", "GD", "GE", "GF", "GH", "GI", "GL", "GM", "GN", "GP", "GQ", "GR", "GS", "GT", "GU", "GW", "GY", "HK", "HM", "HN", "HR", "HT", "HU", "ID", "IE", "IL", "IN", "IO", "IQ", "IR", "IS", "IT", "JM", "JO", "JP", "KE", "KG", "KH", "KI", "KM", "KN", "KP", "KR", "KW", "KY", "KZ", 
				"LA", "LB", "LC", "LI", "LK", "LR", "LS", "LT", "LU", "LV", "LY", "MA", "MC", "MD", "MG", "MH", "MK", "ML", "MM", "MN", "MO", "MP", "MQ", "MR", "MS", "MT", "MU", "MV", "MW", "MX", "MY", "MZ", "NA", "NC", "NE", "NF", "NG", "NI", "NL", "NO", "NP", "NR", "NU", "NZ", "OM", "PA", "PE", "PF", "PG", "PH", "PK", "PL", "PM", "PN", "PR", "PS", "PT", "PW", "PY", "QA", 
				"RE", "RO", "RU", "RW", "SA", "SB", "SC", "SD", "SE", "SG", "SH", "SI", "SJ", "SK", "SL", "SM", "SN", "SO", "SR", "ST", "SV", "SY", "SZ", "TC", "TD", "TF", "TG", "TH", "TJ", "TK", "TM", "TN", "TO", "TP", "TR", "TT", "TV", "TW", "TZ", "UA", "UG", "UM", "US", "UY", "UZ", "VA", "VC", "VE", "VG", "VI", "VN", "VU", "WF", "WS", "YE", "YT", "YU", "ZA", "ZM", "ZR", "ZW", "A1", "A2" 
			}; 
 
		private static string[] countryName = 
			{ 
				"N/A", "Asia/Pacific Region", "Europe", "Andorra", "United Arab Emirates", "Afghanistan", "Antigua and Barbuda", "Anguilla", "Albania", "Armenia", "Netherlands Antilles", "Angola", "Antarctica", "Argentina", "American Samoa", "Austria", "Australia", "Aruba", "Azerbaijan", "Bosnia and Herzegovina", "Barbados", "Bangladesh", "Belgium", 
				"Burkina Faso", "Bulgaria", "Bahrain", "Burundi", "Benin", "Bermuda", "Brunei Darussalam", "Bolivia", "Brazil", "Bahamas", "Bhutan", "Bouvet Island", "Botswana", "Belarus", "Belize", "Canada", "Cocos (Keeling) Islands", "Congo, The Democratic Republic of the", "Central African Republic", "Congo", "Switzerland", "Cote D'Ivoire", 
				"Cook Islands", "Chile", "Cameroon", "China", "Colombia", "Costa Rica", "Cuba", "Cape Verde", "Christmas Island", "Cyprus", "Czech Republic", "Germany", "Djibouti", "Denmark", "Dominica", "Dominican Republic", "Algeria", "Ecuador", "Estonia", "Egypt", "Western Sahara", "Eritrea", "Spain", "Ethiopia", "Finland", "Fiji", "Falkland Islands (Malvinas)", 
				"Micronesia, Federated States of", "Faroe Islands", "France", "France, Metropolitan", "Gabon", "United Kingdom", "Grenada", "Georgia", "French Guiana", "Ghana", "Gibraltar", "Greenland", "Gambia", "Guinea", "Guadeloupe", "Equatorial Guinea", "Greece", "South Georgia and the South Sandwich Islands", "Guatemala", "Guam", "Guinea-Bissau", "Guyana", 
				"Hong Kong", "Heard Island and McDonald Islands", "Honduras", "Croatia", "Haiti", "Hungary", "Indonesia", "Ireland", "Israel", "India", "British Indian Ocean Territory", "Iraq", "Iran, Islamic Republic of", "Iceland", "Italy", "Jamaica", "Jordan", "Japan", "Kenya", "Kyrgyzstan", "Cambodia", "Kiribati", "Comoros", "Saint Kitts and Nevis", 
				"Korea, Democratic People's Republic of", "Korea, Republic of", "Kuwait", "Cayman Islands", "Kazakstan", "Lao People's Democratic Republic", "Lebanon", "Saint Lucia", "Liechtenstein", "Sri Lanka", "Liberia", "Lesotho", "Lithuania", "Luxembourg", "Latvia", "Libyan Arab Jamahiriya", "Morocco", "Monaco", "Moldova, Republic of", "Madagascar", 
				"Marshall Islands", "Macedonia, the Former Yugoslav Republic of", "Mali", "Myanmar", "Mongolia", "Macau", "Northern Mariana Islands", "Martinique", "Mauritania", "Montserrat", "Malta", "Mauritius", "Maldives", "Malawi", "Mexico", "Malaysia", "Mozambique", "Namibia", "New Caledonia", "Niger", "Norfolk Island", "Nigeria", "Nicaragua", "Netherlands", 
				"Norway", "Nepal", "Nauru", "Niue", "New Zealand", "Oman", "Panama", "Peru", "French Polynesia", "Papua New Guinea", "Philippines", "Pakistan", "Poland", "Saint Pierre and Miquelon", "Pitcairn", "Puerto Rico", "Palestinian Territory, Occupied", "Portugal", "Palau", "Paraguay", "Qatar", "Reunion", "Romania", "Russian Federation", "Rwanda", "Saudi Arabia", 
				"Solomon Islands", "Seychelles", "Sudan", "Sweden", "Singapore", "Saint Helena", "Slovenia", "Svalbard and Jan Mayen", "Slovakia", "Sierra Leone", "San Marino", "Senegal", "Somalia", "Suriname", "Sao Tome and Principe", "El Salvador", "Syrian Arab Republic", "Swaziland", "Turks and Caicos Islands", "Chad", "French Southern Territories", "Togo", 
				"Thailand", "Tajikistan", "Tokelau", "Turkmenistan", "Tunisia", "Tonga", "East Timor", "Turkey", "Trinidad and Tobago", "Tuvalu", "Taiwan, Province of China", "Tanzania, United Republic of", "Ukraine", "Uganda", "United States Minor Outlying Islands", "United States", "Uruguay", "Uzbekistan", "Holy See (Vatican City State)", "Saint Vincent and the Grenadines", 
				"Venezuela", "Virgin Islands, British", "Virgin Islands, U.S.", "Vietnam", "Vanuatu", "Wallis and Futuna", "Samoa", "Yemen", "Mayotte", "Yugoslavia", "South Africa", "Zambia", "Zaire", "Zimbabwe", "Anonymous Proxy", "Satellite Provider" 
			}; 
 
 
		public CountryLookup(string fileName) 
		{ 
			try 
			{ 
				fileInput = new FileStream(fileName, FileMode.Open, FileAccess.Read); 
			} 
			catch (FileNotFoundException e) 
			{ 
				Console.WriteLine("File " + fileName + " not found." + e.ToString()); 
			} 
		} 
 
		public string lookupCountryCode(string str) 
		{ 
			IPAddress addr; 
			try 
			{ 
				addr = IPAddress.Parse(str); 
			} 
			catch //(FormatException e) 
			{ 
				return "--"; 
			} 
			return lookupCountryCode(addr); 
		} 
 
		private long addrToNum(IPAddress addr) 
		{ 
			long ipNum = 0; 
			byte[] b = addr.GetAddressBytes(); 
			for (int i = 0; i < 4; ++i) 
			{ 
				long y = b[i]; 
				if (y < 0) 
				{ 
					y += 256; 
				} 
				ipNum += y << ((3 - i)*8); 
			} 
			Console.WriteLine(ipNum); 
			return ipNum; 
		} 
 
		public string lookupCountryCode(IPAddress addr) 
		{ 
			return (countryCode[(int) seekCountry(0, addrToNum(addr), 31)]); 
		} 
 
		public string lookupCountryName(string str) 
		{ 
			IPAddress addr; 
			try 
			{ 
				addr = IPAddress.Parse(str); 
			} 
			catch //(FormatException e) 
			{ 
				return "N/A"; 
			} 
			return lookupCountryName(addr); 
		} 
 
		public string lookupCountryName(IPAddress addr) 
		{ 
			return (countryName[(int) seekCountry(0, addrToNum(addr), 31)]); 
		} 
 
		private long seekCountry(long offset, long ipNum, int depth) 
		{ 
			byte[] buf = new byte[6]; 
			long[] x = new long[2]; 
			if (depth == 0) 
			{ 
				Console.WriteLine("Error seeking Country."); 
			} 
			try 
			{ 
				fileInput.Seek(6*offset, 0); 
				fileInput.Read(buf, 0, 6); 
			} 
			catch //(IOException e) 
			{ 
				Console.WriteLine("IO Exception"); 
			} 
			for (int i = 0; i < 2; i++) 
			{ 
				x[i] = 0; 
				for (int j = 0; j < 3; j++) 
				{ 
					int y = buf[i*3 + j]; 
					if (y < 0) 
					{ 
						y += 256; 
					} 
					x[i] += (y << (j*8)); 
				} 
			} 
 
			if ((ipNum & (1 << depth)) > 0) 
			{ 
				if (x[1] >= country) 
				{ 
					return x[1] - country; 
				} 
				return seekCountry(x[1], ipNum, depth - 1); 
			} 
			else 
			{ 
				if (x[0] >= country) 
				{ 
					return x[0] - country; 
				} 
				return seekCountry(x[0], ipNum, depth - 1); 
			} 
		} 
	} 
 
 
}