/* * Copyright (c) Contributors, http://opensimulator.org/ * See CONTRIBUTORS.TXT for a full list of copyright holders. * * 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 OpenSimulator Project 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 DEVELOPERS ``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 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. */ using System; using System.Collections; using System.Collections.Generic; using System.Data; using System.Diagnostics; using System.Globalization; using System.IO; using System.IO.Compression; using System.Net; using System.Net.Sockets; using System.Reflection; using System.Runtime.InteropServices; using System.Runtime.Serialization; using System.Runtime.Serialization.Formatters.Binary; using System.Security.Cryptography; using System.Text; using System.Text.RegularExpressions; using System.Xml; using System.Threading; using log4net; using log4net.Appender; using Nini.Config; using Nwc.XmlRpc; using OpenMetaverse; using OpenMetaverse.StructuredData; using Amib.Threading; using System.Collections.Concurrent; namespace OpenSim.Framework { [Flags] public enum PermissionMask : uint { None = 0, Transfer = 1 << 13, Modify = 1 << 14, Copy = 1 << 15, Export = 1 << 16, Move = 1 << 19, Damage = 1 << 20, // All does not contain Export, which is special and must be // explicitly given All = (1 << 13) | (1 << 14) | (1 << 15) | (1 << 19) } /// /// The method used by Util.FireAndForget for asynchronously firing events /// /// /// None is used to execute the method in the same thread that made the call. It should only be used by regression /// test code that relies on predictable event ordering. /// RegressionTest is used by regression tests. It fires the call synchronously and does not catch any exceptions. /// public enum FireAndForgetMethod { None, RegressionTest, UnsafeQueueUserWorkItem, QueueUserWorkItem, BeginInvoke, SmartThreadPool, Thread, } /// /// Class for delivering SmartThreadPool statistical information /// /// /// We do it this way so that we do not directly expose STP. /// public class STPInfo { public string Name { get; set; } public STPStartInfo STPStartInfo { get; set; } public WIGStartInfo WIGStartInfo { get; set; } public bool IsIdle { get; set; } public bool IsShuttingDown { get; set; } public int MaxThreads { get; set; } public int MinThreads { get; set; } public int InUseThreads { get; set; } public int ActiveThreads { get; set; } public int WaitingCallbacks { get; set; } public int MaxConcurrentWorkItems { get; set; } } /// /// Miscellaneous utility functions /// public static class Util { private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); /// /// Log-level for the thread pool: /// 0 = no logging /// 1 = only first line of stack trace; don't log common threads /// 2 = full stack trace; don't log common threads /// 3 = full stack trace, including common threads /// public static int LogThreadPool { get; set; } public static readonly int MAX_THREADPOOL_LEVEL = 3; static Util() { LogThreadPool = 0; } private static uint nextXferID = 5000; private static Random randomClass = new Random(); // Get a list of invalid file characters (OS dependent) private static string regexInvalidFileChars = "[" + new String(Path.GetInvalidFileNameChars()) + "]"; private static string regexInvalidPathChars = "[" + new String(Path.GetInvalidPathChars()) + "]"; private static object XferLock = new object(); /// /// Thread pool used for Util.FireAndForget if FireAndForgetMethod.SmartThreadPool is used /// private static SmartThreadPool m_ThreadPool; // Watchdog timer that aborts threads that have timed-out private static Timer m_threadPoolWatchdog; // Unix-epoch starts at January 1st 1970, 00:00:00 UTC. And all our times in the server are (or at least should be) in UTC. public static readonly DateTime UnixEpoch = DateTime.ParseExact("1970-01-01 00:00:00 +0", "yyyy-MM-dd hh:mm:ss z", DateTimeFormatInfo.InvariantInfo).ToUniversalTime(); private static readonly string rawUUIDPattern = "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"; public static readonly Regex PermissiveUUIDPattern = new Regex(rawUUIDPattern); public static readonly Regex UUIDPattern = new Regex(string.Format("^{0}$", rawUUIDPattern)); public static FireAndForgetMethod DefaultFireAndForgetMethod = FireAndForgetMethod.SmartThreadPool; public static FireAndForgetMethod FireAndForgetMethod = DefaultFireAndForgetMethod; public static bool IsPlatformMono { get { return Type.GetType("Mono.Runtime") != null; } } /// /// Gets the name of the directory where the current running executable /// is located /// /// Filesystem path to the directory containing the current /// executable public static string ExecutingDirectory() { return Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); } /// /// Linear interpolates B<->C using percent A /// /// /// /// /// public static double lerp(double a, double b, double c) { return (b*a) + (c*(1 - a)); } /// /// Bilinear Interpolate, see Lerp but for 2D using 'percents' X & Y. /// Layout: /// A B /// C D /// A<->C = Y /// C<->D = X /// /// /// /// /// /// /// /// public static double lerp2D(double x, double y, double a, double b, double c, double d) { return lerp(y, lerp(x, a, b), lerp(x, c, d)); } public static Encoding UTF8 = Encoding.UTF8; public static Encoding UTF8NoBomEncoding = new UTF8Encoding(false); /// /// Well known UUID for the blank texture used in the Linden SL viewer version 1.20 (and hopefully onwards) /// public static UUID BLANK_TEXTURE_UUID = new UUID("5748decc-f629-461c-9a36-a35a221fe21f"); #region Vector Equations /// /// Get the distance between two 3d vectors /// /// A 3d vector /// A 3d vector /// The distance between the two vectors public static double GetDistanceTo(Vector3 a, Vector3 b) { float dx = a.X - b.X; float dy = a.Y - b.Y; float dz = a.Z - b.Z; return Math.Sqrt(dx * dx + dy * dy + dz * dz); } /// /// Returns true if the distance beween A and B is less than amount. Significantly faster than GetDistanceTo since it eliminates the Sqrt. /// /// /// /// /// public static bool DistanceLessThan(Vector3 a, Vector3 b, double amount) { float dx = a.X - b.X; float dy = a.Y - b.Y; float dz = a.Z - b.Z; return (dx*dx + dy*dy + dz*dz) < (amount*amount); } /// /// Get the magnitude of a 3d vector /// /// A 3d vector /// The magnitude of the vector public static double GetMagnitude(Vector3 a) { return Math.Sqrt((a.X * a.X) + (a.Y * a.Y) + (a.Z * a.Z)); } /// /// Get a normalized form of a 3d vector /// /// A 3d vector /// A new vector which is normalized form of the vector /// The vector paramater cannot be <0,0,0> public static Vector3 GetNormalizedVector(Vector3 a) { if (IsZeroVector(a)) throw new ArgumentException("Vector paramater cannot be a zero vector."); float Mag = (float) GetMagnitude(a); return new Vector3(a.X / Mag, a.Y / Mag, a.Z / Mag); } /// /// Returns if a vector is a zero vector (has all zero components) /// /// public static bool IsZeroVector(Vector3 v) { if (v.X == 0 && v.Y == 0 && v.Z == 0) { return true; } return false; } # endregion public static Quaternion Axes2Rot(Vector3 fwd, Vector3 left, Vector3 up) { float s; float tr = (float) (fwd.X + left.Y + up.Z + 1.0); if (tr >= 1.0) { s = (float) (0.5 / Math.Sqrt(tr)); return new Quaternion( (left.Z - up.Y) * s, (up.X - fwd.Z) * s, (fwd.Y - left.X) * s, (float) 0.25 / s); } else { float max = (left.Y > up.Z) ? left.Y : up.Z; if (max < fwd.X) { s = (float) (Math.Sqrt(fwd.X - (left.Y + up.Z) + 1.0)); float x = (float) (s * 0.5); s = (float) (0.5 / s); return new Quaternion( x, (fwd.Y + left.X) * s, (up.X + fwd.Z) * s, (left.Z - up.Y) * s); } else if (max == left.Y) { s = (float) (Math.Sqrt(left.Y - (up.Z + fwd.X) + 1.0)); float y = (float) (s * 0.5); s = (float) (0.5 / s); return new Quaternion( (fwd.Y + left.X) * s, y, (left.Z + up.Y) * s, (up.X - fwd.Z) * s); } else { s = (float) (Math.Sqrt(up.Z - (fwd.X + left.Y) + 1.0)); float z = (float) (s * 0.5); s = (float) (0.5 / s); return new Quaternion( (up.X + fwd.Z) * s, (left.Z + up.Y) * s, z, (fwd.Y - left.X) * s); } } } public static Random RandomClass { get { return randomClass; } } public static ulong UIntsToLong(uint X, uint Y) { return Utils.UIntsToLong(X, Y); } // Regions are identified with a 'handle' made up of its region coordinates packed into a ulong. // Several places rely on the ability to extract a region's location from its handle. // Note the location is in 'world coordinates' (see below). // Region handles are based on the lowest coordinate of the region so trim the passed x,y to be the regions 0,0. public static ulong RegionWorldLocToHandle(uint X, uint Y) { return Utils.UIntsToLong(X, Y); } public static ulong RegionLocToHandle(uint X, uint Y) { return Utils.UIntsToLong(Util.RegionToWorldLoc(X), Util.RegionToWorldLoc(Y)); } public static void RegionHandleToWorldLoc(ulong handle, out uint X, out uint Y) { X = (uint)(handle >> 32); Y = (uint)(handle & (ulong)uint.MaxValue); } public static void RegionHandleToRegionLoc(ulong handle, out uint X, out uint Y) { uint worldX, worldY; RegionHandleToWorldLoc(handle, out worldX, out worldY); X = WorldToRegionLoc(worldX); Y = WorldToRegionLoc(worldY); } // A region location can be 'world coordinates' (meters from zero) or 'region coordinates' // (number of regions from zero). This measurement of regions relies on the legacy 256 region size. // These routines exist to make what is being converted explicit so the next person knows what was meant. // Convert a region's 'world coordinate' to its 'region coordinate'. public static uint WorldToRegionLoc(uint worldCoord) { return worldCoord / Constants.RegionSize; } // Convert a region's 'region coordinate' to its 'world coordinate'. public static uint RegionToWorldLoc(uint regionCoord) { return regionCoord * Constants.RegionSize; } public static T Clamp(T x, T min, T max) where T : IComparable { return x.CompareTo(max) > 0 ? max : x.CompareTo(min) < 0 ? min : x; } // Clamp the maximum magnitude of a vector public static Vector3 ClampV(Vector3 x, float max) { float lenSq = x.LengthSquared(); if (lenSq > (max * max)) { x = x / x.Length() * max; } return x; } // Inclusive, within range test (true if equal to the endpoints) public static bool InRange(T x, T min, T max) where T : IComparable { return x.CompareTo(max) <= 0 && x.CompareTo(min) >= 0; } public static uint GetNextXferID() { uint id = 0; lock (XferLock) { id = nextXferID; nextXferID++; } return id; } public static string GetFileName(string file) { // Return just the filename on UNIX platforms // TODO: this should be customisable with a prefix, but that's something to do later. if (Environment.OSVersion.Platform == PlatformID.Unix) { return file; } // Return %APPDATA%/OpenSim/file for 2K/XP/NT/2K3/VISTA // TODO: Switch this to System.Enviroment.SpecialFolders.ApplicationData if (Environment.OSVersion.Platform == PlatformID.Win32NT) { if (!Directory.Exists("%APPDATA%\\OpenSim\\")) { Directory.CreateDirectory("%APPDATA%\\OpenSim"); } return "%APPDATA%\\OpenSim\\" + file; } // Catch all - covers older windows versions // (but those probably wont work anyway) return file; } /// /// Debug utility function to convert OSD into formatted XML for debugging purposes. /// /// /// A /// /// /// A /// public static string GetFormattedXml(OSD osd) { return GetFormattedXml(OSDParser.SerializeLLSDXmlString(osd)); } /// /// Debug utility function to convert unbroken strings of XML into something human readable for occasional debugging purposes. /// /// /// Please don't delete me even if I appear currently unused! /// /// /// public static string GetFormattedXml(string rawXml) { XmlDocument xd = new XmlDocument(); xd.LoadXml(rawXml); StringBuilder sb = new StringBuilder(); StringWriter sw = new StringWriter(sb); XmlTextWriter xtw = new XmlTextWriter(sw); xtw.Formatting = Formatting.Indented; try { xd.WriteTo(xtw); } finally { xtw.Close(); } return sb.ToString(); } /// /// Is the platform Windows? /// /// true if so, false otherwise public static bool IsWindows() { PlatformID platformId = Environment.OSVersion.Platform; return (platformId == PlatformID.Win32NT || platformId == PlatformID.Win32S || platformId == PlatformID.Win32Windows || platformId == PlatformID.WinCE); } public static bool LoadArchSpecificWindowsDll(string libraryName) { // We do this so that OpenSimulator on Windows loads the correct native library depending on whether // it's running as a 32-bit process or a 64-bit one. By invoking LoadLibary here, later DLLImports // will find it already loaded later on. // // This isn't necessary for other platforms (e.g. Mac OSX and Linux) since the DLL used can be // controlled in config files. string nativeLibraryPath; if (Util.Is64BitProcess()) nativeLibraryPath = "lib64/" + libraryName; else nativeLibraryPath = "lib32/" + libraryName; m_log.DebugFormat("[UTIL]: Loading native Windows library at {0}", nativeLibraryPath); if (Util.LoadLibrary(nativeLibraryPath) == IntPtr.Zero) { m_log.ErrorFormat( "[UTIL]: Couldn't find native Windows library at {0}", nativeLibraryPath); return false; } else { return true; } } public static bool IsEnvironmentSupported(ref string reason) { // Must have .NET 2.0 (Generics / libsl) if (Environment.Version.Major < 2) { reason = ".NET 1.0/1.1 lacks components that is used by OpenSim"; return false; } // Windows 95/98/ME are unsupported if (Environment.OSVersion.Platform == PlatformID.Win32Windows && Environment.OSVersion.Platform != PlatformID.Win32NT) { reason = "Windows 95/98/ME will not run OpenSim"; return false; } // Windows 2000 / Pre-SP2 XP if (Environment.OSVersion.Version.Major == 5 && Environment.OSVersion.Version.Minor == 0) { reason = "Please update to Windows XP Service Pack 2 or Server2003"; return false; } return true; } public static int UnixTimeSinceEpoch() { return ToUnixTime(DateTime.UtcNow); } public static int ToUnixTime(DateTime stamp) { TimeSpan t = stamp.ToUniversalTime() - UnixEpoch; return (int)t.TotalSeconds; } public static DateTime ToDateTime(ulong seconds) { return UnixEpoch.AddSeconds(seconds); } public static DateTime ToDateTime(int seconds) { return UnixEpoch.AddSeconds(seconds); } /// /// Return an md5 hash of the given string /// /// /// public static string Md5Hash(string data) { byte[] dataMd5 = ComputeMD5Hash(data); StringBuilder sb = new StringBuilder(); for (int i = 0; i < dataMd5.Length; i++) sb.AppendFormat("{0:x2}", dataMd5[i]); return sb.ToString(); } private static byte[] ComputeMD5Hash(string data) { MD5 md5 = MD5.Create(); return md5.ComputeHash(Encoding.Default.GetBytes(data)); } /// /// Return an SHA1 hash /// /// /// public static string SHA1Hash(string data) { return SHA1Hash(Encoding.Default.GetBytes(data)); } /// /// Return an SHA1 hash /// /// /// public static string SHA1Hash(byte[] data) { byte[] hash = ComputeSHA1Hash(data); return BitConverter.ToString(hash).Replace("-", String.Empty); } private static byte[] ComputeSHA1Hash(byte[] src) { SHA1CryptoServiceProvider SHA1 = new SHA1CryptoServiceProvider(); return SHA1.ComputeHash(src); } public static int fast_distance2d(int x, int y) { x = Math.Abs(x); y = Math.Abs(y); int min = Math.Min(x, y); return (x + y - (min >> 1) - (min >> 2) + (min >> 4)); } /// /// Determines whether a point is inside a bounding box. /// /// /// /// /// public static bool IsInsideBox(Vector3 v, Vector3 min, Vector3 max) { return v.X >= min.X & v.Y >= min.Y && v.Z >= min.Z && v.X <= max.X && v.Y <= max.Y && v.Z <= max.Z; } /// /// Are the co-ordinates of the new region visible from the old region? /// /// Old region x-coord /// New region x-coord /// Old region y-coord /// New region y-coord /// public static bool IsOutsideView(float drawdist, uint oldx, uint newx, uint oldy, uint newy) { int dd = (int)((drawdist + Constants.RegionSize - 1) / Constants.RegionSize); int startX = (int)oldx - dd; int startY = (int)oldy - dd; int endX = (int)oldx + dd; int endY = (int)oldy + dd; return (newx < startX || endX < newx || newy < startY || endY < newy); } public static string FieldToString(byte[] bytes) { return FieldToString(bytes, String.Empty); } /// /// Convert a variable length field (byte array) to a string, with a /// field name prepended to each line of the output /// /// If the byte array has unprintable characters in it, a /// hex dump will be put in the string instead /// The byte array to convert to a string /// A field name to prepend to each line of output /// An ASCII string or a string containing a hex dump, minus /// the null terminator public static string FieldToString(byte[] bytes, string fieldName) { // Check for a common case if (bytes.Length == 0) return String.Empty; StringBuilder output = new StringBuilder(); bool printable = true; for (int i = 0; i < bytes.Length; ++i) { // Check if there are any unprintable characters in the array if ((bytes[i] < 0x20 || bytes[i] > 0x7E) && bytes[i] != 0x09 && bytes[i] != 0x0D && bytes[i] != 0x0A && bytes[i] != 0x00) { printable = false; break; } } if (printable) { if (fieldName.Length > 0) { output.Append(fieldName); output.Append(": "); } output.Append(CleanString(Util.UTF8.GetString(bytes, 0, bytes.Length - 1))); } else { for (int i = 0; i < bytes.Length; i += 16) { if (i != 0) output.Append(Environment.NewLine); if (fieldName.Length > 0) { output.Append(fieldName); output.Append(": "); } for (int j = 0; j < 16; j++) { if ((i + j) < bytes.Length) output.Append(String.Format("{0:X2} ", bytes[i + j])); else output.Append(" "); } for (int j = 0; j < 16 && (i + j) < bytes.Length; j++) { if (bytes[i + j] >= 0x20 && bytes[i + j] < 0x7E) output.Append((char) bytes[i + j]); else output.Append("."); } } } return output.ToString(); } /// /// Converts a URL to a IPAddress /// /// URL Standard Format /// A resolved IP Address public static IPAddress GetHostFromURL(string url) { return GetHostFromDNS(url.Split(new char[] {'/', ':'})[3]); } /// /// Returns a IP address from a specified DNS, favouring IPv4 addresses. /// /// DNS Hostname /// An IP address, or null public static IPAddress GetHostFromDNS(string dnsAddress) { // Is it already a valid IP? No need to look it up. IPAddress ipa; if (IPAddress.TryParse(dnsAddress, out ipa)) return ipa; IPAddress[] hosts = null; // Not an IP, lookup required try { hosts = Dns.GetHostEntry(dnsAddress).AddressList; } catch (Exception e) { m_log.WarnFormat("[UTIL]: An error occurred while resolving host name {0}, {1}", dnsAddress, e); // Still going to throw the exception on for now, since this was what was happening in the first place throw e; } foreach (IPAddress host in hosts) { if (host.AddressFamily == AddressFamily.InterNetwork) { return host; } } if (hosts.Length > 0) return hosts[0]; return null; } public static Uri GetURI(string protocol, string hostname, int port, string path) { return new UriBuilder(protocol, hostname, port, path).Uri; } /// /// Gets a list of all local system IP addresses /// /// public static IPAddress[] GetLocalHosts() { return Dns.GetHostAddresses(Dns.GetHostName()); } public static IPAddress GetLocalHost() { IPAddress[] iplist = GetLocalHosts(); if (iplist.Length == 0) // No accessible external interfaces { IPAddress[] loopback = Dns.GetHostAddresses("localhost"); IPAddress localhost = loopback[0]; return localhost; } foreach (IPAddress host in iplist) { if (!IPAddress.IsLoopback(host) && host.AddressFamily == AddressFamily.InterNetwork) { return host; } } if (iplist.Length > 0) { foreach (IPAddress host in iplist) { if (host.AddressFamily == AddressFamily.InterNetwork) return host; } // Well all else failed... return iplist[0]; } return null; } /// /// Removes all invalid path chars (OS dependent) /// /// path /// safe path public static string safePath(string path) { return Regex.Replace(path, regexInvalidPathChars, String.Empty); } /// /// Removes all invalid filename chars (OS dependent) /// /// filename /// safe filename public static string safeFileName(string filename) { return Regex.Replace(filename, regexInvalidFileChars, String.Empty); ; } // // directory locations // public static string homeDir() { string temp; // string personal=(Environment.GetFolderPath(Environment.SpecialFolder.Personal)); // temp = Path.Combine(personal,".OpenSim"); temp = "."; return temp; } public static string assetsDir() { return Path.Combine(configDir(), "assets"); } public static string inventoryDir() { return Path.Combine(configDir(), "inventory"); } public static string configDir() { return "."; } public static string dataDir() { return "."; } public static string logFile() { foreach (IAppender appender in LogManager.GetRepository().GetAppenders()) { if (appender is FileAppender) { return ((FileAppender)appender).File; } } return "./OpenSim.log"; } public static string logDir() { return Path.GetDirectoryName(logFile()); } // From: http://coercedcode.blogspot.com/2008/03/c-generate-unique-filenames-within.html public static string GetUniqueFilename(string FileName) { int count = 0; string Name; if (File.Exists(FileName)) { FileInfo f = new FileInfo(FileName); if (!String.IsNullOrEmpty(f.Extension)) { Name = f.FullName.Substring(0, f.FullName.LastIndexOf('.')); } else { Name = f.FullName; } while (File.Exists(FileName)) { count++; FileName = Name + count + f.Extension; } } return FileName; } #region Nini (config) related Methods public static IConfigSource ConvertDataRowToXMLConfig(DataRow row, string fileName) { if (!File.Exists(fileName)) { // create new file } XmlConfigSource config = new XmlConfigSource(fileName); AddDataRowToConfig(config, row); config.Save(); return config; } public static void AddDataRowToConfig(IConfigSource config, DataRow row) { config.Configs.Add((string) row[0]); for (int i = 0; i < row.Table.Columns.Count; i++) { config.Configs[(string) row[0]].Set(row.Table.Columns[i].ColumnName, row[i]); } } /// /// Gets the value of a configuration variable by looking into /// multiple sections in order. The latter sections overwrite /// any values previously found. /// /// Type of the variable /// The configuration object /// The configuration variable /// Ordered sequence of sections to look at /// public static T GetConfigVarFromSections(IConfigSource config, string varname, string[] sections) { return GetConfigVarFromSections(config, varname, sections, default(T)); } /// /// Gets the value of a configuration variable by looking into /// multiple sections in order. The latter sections overwrite /// any values previously found. /// /// /// If no value is found then the given default value is returned /// /// Type of the variable /// The configuration object /// The configuration variable /// Ordered sequence of sections to look at /// Default value /// public static T GetConfigVarFromSections(IConfigSource config, string varname, string[] sections, object val) { foreach (string section in sections) { IConfig cnf = config.Configs[section]; if (cnf == null) continue; if (typeof(T) == typeof(String)) val = cnf.GetString(varname, (string)val); else if (typeof(T) == typeof(Boolean)) val = cnf.GetBoolean(varname, (bool)val); else if (typeof(T) == typeof(Int32)) val = cnf.GetInt(varname, (int)val); else if (typeof(T) == typeof(float)) val = cnf.GetFloat(varname, (float)val); else m_log.ErrorFormat("[UTIL]: Unhandled type {0}", typeof(T)); } return (T)val; } public static void MergeEnvironmentToConfig(IConfigSource ConfigSource) { IConfig enVars = ConfigSource.Configs["Environment"]; // if section does not exist then user isn't expecting them, so don't bother. if( enVars != null ) { // load the values from the environment EnvConfigSource envConfigSource = new EnvConfigSource(); // add the requested keys string[] env_keys = enVars.GetKeys(); foreach ( string key in env_keys ) { envConfigSource.AddEnv(key, string.Empty); } // load the values from environment envConfigSource.LoadEnv(); // add them in to the master ConfigSource.Merge(envConfigSource); ConfigSource.ExpandKeyValues(); } } public static T ReadSettingsFromIniFile(IConfig config, T settingsClass) { Type settingsType = settingsClass.GetType(); FieldInfo[] fieldInfos = settingsType.GetFields(); foreach (FieldInfo fieldInfo in fieldInfos) { if (!fieldInfo.IsStatic) { if (fieldInfo.FieldType == typeof(System.String)) { fieldInfo.SetValue(settingsClass, config.Get(fieldInfo.Name, (string)fieldInfo.GetValue(settingsClass))); } else if (fieldInfo.FieldType == typeof(System.Boolean)) { fieldInfo.SetValue(settingsClass, config.GetBoolean(fieldInfo.Name, (bool)fieldInfo.GetValue(settingsClass))); } else if (fieldInfo.FieldType == typeof(System.Int32)) { fieldInfo.SetValue(settingsClass, config.GetInt(fieldInfo.Name, (int)fieldInfo.GetValue(settingsClass))); } else if (fieldInfo.FieldType == typeof(System.Single)) { fieldInfo.SetValue(settingsClass, config.GetFloat(fieldInfo.Name, (float)fieldInfo.GetValue(settingsClass))); } else if (fieldInfo.FieldType == typeof(System.UInt32)) { fieldInfo.SetValue(settingsClass, Convert.ToUInt32(config.Get(fieldInfo.Name, ((uint)fieldInfo.GetValue(settingsClass)).ToString()))); } } } PropertyInfo[] propertyInfos = settingsType.GetProperties(); foreach (PropertyInfo propInfo in propertyInfos) { if ((propInfo.CanRead) && (propInfo.CanWrite)) { if (propInfo.PropertyType == typeof(System.String)) { propInfo.SetValue(settingsClass, config.Get(propInfo.Name, (string)propInfo.GetValue(settingsClass, null)), null); } else if (propInfo.PropertyType == typeof(System.Boolean)) { propInfo.SetValue(settingsClass, config.GetBoolean(propInfo.Name, (bool)propInfo.GetValue(settingsClass, null)), null); } else if (propInfo.PropertyType == typeof(System.Int32)) { propInfo.SetValue(settingsClass, config.GetInt(propInfo.Name, (int)propInfo.GetValue(settingsClass, null)), null); } else if (propInfo.PropertyType == typeof(System.Single)) { propInfo.SetValue(settingsClass, config.GetFloat(propInfo.Name, (float)propInfo.GetValue(settingsClass, null)), null); } if (propInfo.PropertyType == typeof(System.UInt32)) { propInfo.SetValue(settingsClass, Convert.ToUInt32(config.Get(propInfo.Name, ((uint)propInfo.GetValue(settingsClass, null)).ToString())), null); } } } return settingsClass; } #endregion public static float Clip(float x, float min, float max) { return Math.Min(Math.Max(x, min), max); } public static int Clip(int x, int min, int max) { return Math.Min(Math.Max(x, min), max); } public static Vector3 Clip(Vector3 vec, float min, float max) { return new Vector3(Clip(vec.X, min, max), Clip(vec.Y, min, max), Clip(vec.Z, min, max)); } /// /// Convert an UUID to a raw uuid string. Right now this is a string without hyphens. /// /// /// public static String ToRawUuidString(UUID UUID) { return UUID.Guid.ToString("n"); } public static string CleanString(string input) { if (input.Length == 0) return input; int clip = input.Length; // Test for ++ string terminator int pos = input.IndexOf("\0"); if (pos != -1 && pos < clip) clip = pos; // Test for CR pos = input.IndexOf("\r"); if (pos != -1 && pos < clip) clip = pos; // Test for LF pos = input.IndexOf("\n"); if (pos != -1 && pos < clip) clip = pos; // Truncate string before first end-of-line character found return input.Substring(0, clip); } /// /// returns the contents of /etc/issue on Unix Systems /// Use this for where it's absolutely necessary to implement platform specific stuff /// /// public static string ReadEtcIssue() { try { StreamReader sr = new StreamReader("/etc/issue.net"); string issue = sr.ReadToEnd(); sr.Close(); return issue; } catch (Exception) { return ""; } } public static void SerializeToFile(string filename, Object obj) { IFormatter formatter = new BinaryFormatter(); Stream stream = null; try { stream = new FileStream( filename, FileMode.Create, FileAccess.Write, FileShare.None); formatter.Serialize(stream, obj); } catch (Exception e) { m_log.Error(e.ToString()); } finally { if (stream != null) { stream.Close(); } } } public static Object DeserializeFromFile(string filename) { IFormatter formatter = new BinaryFormatter(); Stream stream = null; Object ret = null; try { stream = new FileStream( filename, FileMode.Open, FileAccess.Read, FileShare.None); ret = formatter.Deserialize(stream); } catch (Exception e) { m_log.Error(e.ToString()); } finally { if (stream != null) { stream.Close(); } } return ret; } public static string Compress(string text) { byte[] buffer = Util.UTF8.GetBytes(text); MemoryStream memory = new MemoryStream(); using (GZipStream compressor = new GZipStream(memory, CompressionMode.Compress, true)) { compressor.Write(buffer, 0, buffer.Length); } memory.Position = 0; byte[] compressed = new byte[memory.Length]; memory.Read(compressed, 0, compressed.Length); byte[] compressedBuffer = new byte[compressed.Length + 4]; Buffer.BlockCopy(compressed, 0, compressedBuffer, 4, compressed.Length); Buffer.BlockCopy(BitConverter.GetBytes(buffer.Length), 0, compressedBuffer, 0, 4); return Convert.ToBase64String(compressedBuffer); } public static string Decompress(string compressedText) { byte[] compressedBuffer = Convert.FromBase64String(compressedText); using (MemoryStream memory = new MemoryStream()) { int msgLength = BitConverter.ToInt32(compressedBuffer, 0); memory.Write(compressedBuffer, 4, compressedBuffer.Length - 4); byte[] buffer = new byte[msgLength]; memory.Position = 0; using (GZipStream decompressor = new GZipStream(memory, CompressionMode.Decompress)) { decompressor.Read(buffer, 0, buffer.Length); } return Util.UTF8.GetString(buffer); } } /// /// Copy data from one stream to another, leaving the read position of both streams at the beginning. /// /// /// Input stream. Must be seekable. /// /// /// Thrown if the input stream is not seekable. /// public static Stream Copy(Stream inputStream) { if (!inputStream.CanSeek) throw new ArgumentException("Util.Copy(Stream inputStream) must receive an inputStream that can seek"); const int readSize = 256; byte[] buffer = new byte[readSize]; MemoryStream ms = new MemoryStream(); int count = inputStream.Read(buffer, 0, readSize); while (count > 0) { ms.Write(buffer, 0, count); count = inputStream.Read(buffer, 0, readSize); } ms.Position = 0; inputStream.Position = 0; return ms; } public static XmlRpcResponse XmlRpcCommand(string url, string methodName, params object[] args) { return SendXmlRpcCommand(url, methodName, args); } public static XmlRpcResponse SendXmlRpcCommand(string url, string methodName, object[] args) { XmlRpcRequest client = new XmlRpcRequest(methodName, args); return client.Send(url, 6000); } /// /// Returns an error message that the user could not be found in the database /// /// XML string consisting of a error element containing individual error(s) public static XmlRpcResponse CreateUnknownUserErrorResponse() { XmlRpcResponse response = new XmlRpcResponse(); Hashtable responseData = new Hashtable(); responseData["error_type"] = "unknown_user"; responseData["error_desc"] = "The user requested is not in the database"; response.Value = responseData; return response; } /// /// Converts a byte array in big endian order into an ulong. /// /// /// The array of bytes /// /// /// The extracted ulong /// public static ulong BytesToUInt64Big(byte[] bytes) { if (bytes.Length < 8) return 0; return ((ulong)bytes[0] << 56) | ((ulong)bytes[1] << 48) | ((ulong)bytes[2] << 40) | ((ulong)bytes[3] << 32) | ((ulong)bytes[4] << 24) | ((ulong)bytes[5] << 16) | ((ulong)bytes[6] << 8) | (ulong)bytes[7]; } // used for RemoteParcelRequest (for "About Landmark") public static UUID BuildFakeParcelID(ulong regionHandle, uint x, uint y) { byte[] bytes = { (byte)regionHandle, (byte)(regionHandle >> 8), (byte)(regionHandle >> 16), (byte)(regionHandle >> 24), (byte)(regionHandle >> 32), (byte)(regionHandle >> 40), (byte)(regionHandle >> 48), (byte)(regionHandle >> 56), (byte)x, (byte)(x >> 8), 0, 0, (byte)y, (byte)(y >> 8), 0, 0 }; return new UUID(bytes, 0); } public static UUID BuildFakeParcelID(ulong regionHandle, uint x, uint y, uint z) { byte[] bytes = { (byte)regionHandle, (byte)(regionHandle >> 8), (byte)(regionHandle >> 16), (byte)(regionHandle >> 24), (byte)(regionHandle >> 32), (byte)(regionHandle >> 40), (byte)(regionHandle >> 48), (byte)(regionHandle >> 56), (byte)x, (byte)(x >> 8), (byte)z, (byte)(z >> 8), (byte)y, (byte)(y >> 8), 0, 0 }; return new UUID(bytes, 0); } public static void ParseFakeParcelID(UUID parcelID, out ulong regionHandle, out uint x, out uint y) { byte[] bytes = parcelID.GetBytes(); regionHandle = Utils.BytesToUInt64(bytes); x = Utils.BytesToUInt(bytes, 8) & 0xffff; y = Utils.BytesToUInt(bytes, 12) & 0xffff; } public static void ParseFakeParcelID(UUID parcelID, out ulong regionHandle, out uint x, out uint y, out uint z) { byte[] bytes = parcelID.GetBytes(); regionHandle = Utils.BytesToUInt64(bytes); x = Utils.BytesToUInt(bytes, 8) & 0xffff; z = (Utils.BytesToUInt(bytes, 8) & 0xffff0000) >> 16; y = Utils.BytesToUInt(bytes, 12) & 0xffff; } public static void FakeParcelIDToGlobalPosition(UUID parcelID, out uint x, out uint y) { ulong regionHandle; uint rx, ry; ParseFakeParcelID(parcelID, out regionHandle, out x, out y); Utils.LongToUInts(regionHandle, out rx, out ry); x += rx; y += ry; } /// /// Get operating system information if available. Returns only the first 45 characters of information /// /// /// Operating system information. Returns an empty string if none was available. /// public static string GetOperatingSystemInformation() { string os = String.Empty; if (Environment.OSVersion.Platform != PlatformID.Unix) { os = Environment.OSVersion.ToString(); } else { os = ReadEtcIssue(); } if (os.Length > 45) { os = os.Substring(0, 45); } return os; } public static string GetRuntimeInformation() { string ru = String.Empty; if (Environment.OSVersion.Platform == PlatformID.Unix) ru = "Unix/Mono"; else if (Environment.OSVersion.Platform == PlatformID.MacOSX) ru = "OSX/Mono"; else { if (IsPlatformMono) ru = "Win/Mono"; else ru = "Win/.NET"; } return ru; } /// /// Is the given string a UUID? /// /// /// public static bool isUUID(string s) { return UUIDPattern.IsMatch(s); } public static string GetDisplayConnectionString(string connectionString) { int passPosition = 0; int passEndPosition = 0; string displayConnectionString = null; // hide the password in the connection string passPosition = connectionString.IndexOf("password", StringComparison.OrdinalIgnoreCase); passPosition = connectionString.IndexOf("=", passPosition); if (passPosition < connectionString.Length) passPosition += 1; passEndPosition = connectionString.IndexOf(";", passPosition); displayConnectionString = connectionString.Substring(0, passPosition); displayConnectionString += "***"; displayConnectionString += connectionString.Substring(passEndPosition, connectionString.Length - passEndPosition); return displayConnectionString; } public static string Base64ToString(string str) { Decoder utf8Decode = Encoding.UTF8.GetDecoder(); byte[] todecode_byte = Convert.FromBase64String(str); int charCount = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length); char[] decoded_char = new char[charCount]; utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0); string result = new String(decoded_char); return result; } public static void BinaryToASCII(char[] chars) { for (int i = 0; i < chars.Length; i++) { char ch = chars[i]; if (ch < 32 || ch > 127) chars[i] = '.'; } } public static string BinaryToASCII(string src) { char[] chars = src.ToCharArray(); BinaryToASCII(chars); return new String(chars); } /// /// Reads a known number of bytes from a stream. /// Throws EndOfStreamException if the stream doesn't contain enough data. /// /// The stream to read data from /// The array to write bytes into. The array /// will be completely filled from the stream, so an appropriate /// size must be given. public static void ReadStream(Stream stream, byte[] data) { int offset = 0; int remaining = data.Length; while (remaining > 0) { int read = stream.Read(data, offset, remaining); if (read <= 0) throw new EndOfStreamException(String.Format("End of stream reached with {0} bytes left to read", remaining)); remaining -= read; offset += read; } } public static Guid GetHashGuid(string data, string salt) { byte[] hash = ComputeMD5Hash(data + salt); //string s = BitConverter.ToString(hash); Guid guid = new Guid(hash); return guid; } public static byte ConvertMaturityToAccessLevel(uint maturity) { byte retVal = 0; switch (maturity) { case 0: //PG retVal = 13; break; case 1: //Mature retVal = 21; break; case 2: // Adult retVal = 42; break; } return retVal; } public static uint ConvertAccessLevelToMaturity(byte maturity) { if (maturity <= 13) return 0; else if (maturity <= 21) return 1; else return 2; } /// /// Produces an OSDMap from its string representation on a stream /// /// The stream /// The size of the data on the stream /// The OSDMap or an exception public static OSDMap GetOSDMap(Stream stream, int length) { byte[] data = new byte[length]; stream.Read(data, 0, length); string strdata = Util.UTF8.GetString(data); OSDMap args = null; OSD buffer; buffer = OSDParser.DeserializeJson(strdata); if (buffer.Type == OSDType.Map) { args = (OSDMap)buffer; return args; } return null; } public static OSDMap GetOSDMap(string data) { OSDMap args = null; try { OSD buffer; // We should pay attention to the content-type, but let's assume we know it's Json buffer = OSDParser.DeserializeJson(data); if (buffer.Type == OSDType.Map) { args = (OSDMap)buffer; return args; } else { // uh? m_log.Debug(("[UTILS]: Got OSD of unexpected type " + buffer.Type.ToString())); return null; } } catch (Exception ex) { m_log.Debug("[UTILS]: exception on GetOSDMap " + ex.Message); return null; } } public static string[] Glob(string path) { string vol=String.Empty; if (Path.VolumeSeparatorChar != Path.DirectorySeparatorChar) { string[] vcomps = path.Split(new char[] {Path.VolumeSeparatorChar}, 2, StringSplitOptions.RemoveEmptyEntries); if (vcomps.Length > 1) { path = vcomps[1]; vol = vcomps[0]; } } string[] comps = path.Split(new char[] {Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar}, StringSplitOptions.RemoveEmptyEntries); // Glob path = vol; if (vol != String.Empty) path += new String(new char[] {Path.VolumeSeparatorChar, Path.DirectorySeparatorChar}); else path = new String(new char[] {Path.DirectorySeparatorChar}); List paths = new List(); List found = new List(); paths.Add(path); int compIndex = -1; foreach (string c in comps) { compIndex++; List addpaths = new List(); foreach (string p in paths) { string[] dirs = Directory.GetDirectories(p, c); if (dirs.Length != 0) { foreach (string dir in dirs) addpaths.Add(Path.Combine(path, dir)); } // Only add files if that is the last path component if (compIndex == comps.Length - 1) { string[] files = Directory.GetFiles(p, c); foreach (string f in files) found.Add(f); } } paths = addpaths; } return found.ToArray(); } public static string ServerURI(string uri) { if (uri == string.Empty) return string.Empty; // Get rid of eventual slashes at the end uri = uri.TrimEnd('/'); IPAddress ipaddr1 = null; string port1 = ""; try { ipaddr1 = Util.GetHostFromURL(uri); } catch { } try { port1 = uri.Split(new char[] { ':' })[2]; } catch { } // We tried our best to convert the domain names to IP addresses return (ipaddr1 != null) ? "http://" + ipaddr1.ToString() + ":" + port1 : uri; } /// /// Convert a string to a byte format suitable for transport in an LLUDP packet. The output is truncated to 256 bytes if necessary. /// /// /// If null or empty, then an bytes[0] is returned. /// Using "\0" will return a conversion of the null character to a byte. This is not the same as bytes[0] /// /// /// Arguments to substitute into the string via the {} mechanism. /// /// public static byte[] StringToBytes256(string str, params object[] args) { return StringToBytes256(string.Format(str, args)); } /// /// Convert a string to a byte format suitable for transport in an LLUDP packet. The output is truncated to 256 bytes if necessary. /// /// /// If null or empty, then an bytes[0] is returned. /// Using "\0" will return a conversion of the null character to a byte. This is not the same as bytes[0] /// /// public static byte[] StringToBytes256(string str) { if (String.IsNullOrEmpty(str)) { return Utils.EmptyBytes; } if (str.Length > 254) str = str.Remove(254); if (!str.EndsWith("\0")) { str += "\0"; } // Because this is UTF-8 encoding and not ASCII, it's possible we // might have gotten an oversized array even after the string trim byte[] data = UTF8.GetBytes(str); if (data.Length > 256) { Array.Resize(ref data, 256); data[255] = 0; } return data; } /// /// Convert a string to a byte format suitable for transport in an LLUDP packet. The output is truncated to 1024 bytes if necessary. /// /// /// If null or empty, then an bytes[0] is returned. /// Using "\0" will return a conversion of the null character to a byte. This is not the same as bytes[0] /// /// /// Arguments to substitute into the string via the {} mechanism. /// /// public static byte[] StringToBytes1024(string str, params object[] args) { return StringToBytes1024(string.Format(str, args)); } /// /// Convert a string to a byte format suitable for transport in an LLUDP packet. The output is truncated to 1024 bytes if necessary. /// /// /// If null or empty, then an bytes[0] is returned. /// Using "\0" will return a conversion of the null character to a byte. This is not the same as bytes[0] /// /// public static byte[] StringToBytes1024(string str) { if (String.IsNullOrEmpty(str)) { return Utils.EmptyBytes; } if (str.Length > 1023) str = str.Remove(1023); if (!str.EndsWith("\0")) { str += "\0"; } // Because this is UTF-8 encoding and not ASCII, it's possible we // might have gotten an oversized array even after the string trim byte[] data = UTF8.GetBytes(str); if (data.Length > 1024) { Array.Resize(ref data, 1024); data[1023] = 0; } return data; } /// /// Pretty format the hashtable contents to a single line. /// /// /// Used for debugging output. /// /// public static string PrettyFormatToSingleLine(Hashtable ht) { StringBuilder sb = new StringBuilder(); int i = 0; foreach (string key in ht.Keys) { sb.AppendFormat("{0}:{1}", key, ht[key]); if (++i < ht.Count) sb.AppendFormat(", "); } return sb.ToString(); } /// /// Used to trigger an early library load on Windows systems. /// /// /// Required to get 32-bit and 64-bit processes to automatically use the /// appropriate native library. /// /// /// [DllImport("kernel32.dll")] public static extern IntPtr LoadLibrary(string dllToLoad); /// /// Determine whether the current process is 64 bit /// /// true if so, false if not public static bool Is64BitProcess() { return IntPtr.Size == 8; } #region FireAndForget Threading Pattern /// /// Created to work around a limitation in Mono with nested delegates /// private sealed class FireAndForgetWrapper { private static volatile FireAndForgetWrapper instance; private static object syncRoot = new Object(); public static FireAndForgetWrapper Instance { get { if (instance == null) { lock (syncRoot) { if (instance == null) { instance = new FireAndForgetWrapper(); } } } return instance; } } public void FireAndForget(System.Threading.WaitCallback callback) { callback.BeginInvoke(null, EndFireAndForget, callback); } public void FireAndForget(System.Threading.WaitCallback callback, object obj) { callback.BeginInvoke(obj, EndFireAndForget, callback); } private static void EndFireAndForget(IAsyncResult ar) { System.Threading.WaitCallback callback = (System.Threading.WaitCallback)ar.AsyncState; try { callback.EndInvoke(ar); } catch (Exception ex) { m_log.Error("[UTIL]: Asynchronous method threw an exception: " + ex.Message, ex); } ar.AsyncWaitHandle.Close(); } } public static void FireAndForget(System.Threading.WaitCallback callback) { FireAndForget(callback, null, null); } public static void InitThreadPool(int minThreads, int maxThreads) { if (maxThreads < 2) throw new ArgumentOutOfRangeException("maxThreads", "maxThreads must be greater than 2"); if (minThreads > maxThreads || minThreads < 2) throw new ArgumentOutOfRangeException("minThreads", "minThreads must be greater than 2 and less than or equal to maxThreads"); if (m_ThreadPool != null) throw new InvalidOperationException("SmartThreadPool is already initialized"); STPStartInfo startInfo = new STPStartInfo(); startInfo.ThreadPoolName = "Util"; startInfo.IdleTimeout = 2000; startInfo.MaxWorkerThreads = maxThreads; startInfo.MinWorkerThreads = minThreads; m_ThreadPool = new SmartThreadPool(startInfo); m_threadPoolWatchdog = new Timer(ThreadPoolWatchdog, null, 0, 1000); } public static int FireAndForgetCount() { const int MAX_SYSTEM_THREADS = 200; switch (FireAndForgetMethod) { case FireAndForgetMethod.UnsafeQueueUserWorkItem: case FireAndForgetMethod.QueueUserWorkItem: case FireAndForgetMethod.BeginInvoke: int workerThreads, iocpThreads; ThreadPool.GetAvailableThreads(out workerThreads, out iocpThreads); return workerThreads; case FireAndForgetMethod.SmartThreadPool: return m_ThreadPool.MaxThreads - m_ThreadPool.InUseThreads; case FireAndForgetMethod.Thread: return MAX_SYSTEM_THREADS - System.Diagnostics.Process.GetCurrentProcess().Threads.Count; default: throw new NotImplementedException(); } } /// /// Additional information about threads in the main thread pool. Used to time how long the /// thread has been running, and abort it if it has timed-out. /// private class ThreadInfo { public long ThreadFuncNum { get; set; } public string StackTrace { get; set; } private string context; public bool LogThread { get; set; } public IWorkItemResult WorkItem { get; set; } public Thread Thread { get; set; } public bool Running { get; set; } public bool Aborted { get; set; } private int started; public ThreadInfo(long threadFuncNum, string context) { ThreadFuncNum = threadFuncNum; this.context = context; LogThread = true; Thread = null; Running = false; Aborted = false; } public void Started() { Thread = Thread.CurrentThread; started = EnvironmentTickCount(); Running = true; } public void Ended() { Running = false; } public int Elapsed() { return EnvironmentTickCountSubtract(started); } public void Abort() { Aborted = true; WorkItem.Cancel(true); } /// /// Returns the thread's stack trace. /// /// /// May return one of two stack traces. First, tries to get the thread's active stack /// trace. But this can fail, so as a fallback this method will return the stack /// trace that was active when the task was queued. /// public string GetStackTrace() { string ret = (context == null) ? "" : ("(" + context + ") "); StackTrace activeStackTrace = Util.GetStackTrace(Thread); if (activeStackTrace != null) ret += activeStackTrace.ToString(); else if (StackTrace != null) ret += "(Stack trace when queued) " + StackTrace; // else, no stack trace available return ret; } } private static long nextThreadFuncNum = 0; private static long numQueuedThreadFuncs = 0; private static long numRunningThreadFuncs = 0; private static Int32 threadFuncOverloadMode = 0; // Maps (ThreadFunc number -> Thread) private static ConcurrentDictionary activeThreads = new ConcurrentDictionary(); private static readonly int THREAD_TIMEOUT = 10 * 60 * 1000; // 10 minutes /// /// Finds threads in the main thread pool that have timed-out, and aborts them. /// private static void ThreadPoolWatchdog(object state) { foreach (KeyValuePair entry in activeThreads) { ThreadInfo t = entry.Value; if (t.Running && !t.Aborted && (t.Elapsed() >= THREAD_TIMEOUT)) { m_log.WarnFormat("Timeout in threadfunc {0} ({1}) {2}", t.ThreadFuncNum, t.Thread.Name, t.GetStackTrace()); t.Abort(); ThreadInfo dummy; activeThreads.TryRemove(entry.Key, out dummy); // It's possible that the thread won't abort. To make sure the thread pool isn't // depleted, increase the pool size. m_ThreadPool.MaxThreads++; } } } public static void FireAndForget(System.Threading.WaitCallback callback, object obj) { FireAndForget(callback, obj, null); } public static void FireAndForget(System.Threading.WaitCallback callback, object obj, string context) { WaitCallback realCallback; bool loggingEnabled = LogThreadPool > 0; long threadFuncNum = Interlocked.Increment(ref nextThreadFuncNum); ThreadInfo threadInfo = new ThreadInfo(threadFuncNum, context); if (FireAndForgetMethod == FireAndForgetMethod.RegressionTest) { // If we're running regression tests, then we want any exceptions to rise up to the test code. realCallback = o => { Culture.SetCurrentCulture(); callback(o); }; } else { // When OpenSim interacts with a database or sends data over the wire, it must send this in en_US culture // so that we don't encounter problems where, for instance, data is saved with a culture that uses commas // for decimals places but is read by a culture that treats commas as number seperators. realCallback = o => { long numQueued1 = Interlocked.Decrement(ref numQueuedThreadFuncs); long numRunning1 = Interlocked.Increment(ref numRunningThreadFuncs); threadInfo.Started(); activeThreads[threadFuncNum] = threadInfo; try { if ((loggingEnabled || (threadFuncOverloadMode == 1)) && threadInfo.LogThread) m_log.DebugFormat("Run threadfunc {0} (Queued {1}, Running {2})", threadFuncNum, numQueued1, numRunning1); Culture.SetCurrentCulture(); callback(o); } catch (ThreadAbortException e) { m_log.Error(string.Format("Aborted threadfunc {0} ", threadFuncNum), e); } catch (Exception e) { m_log.Error(string.Format("[UTIL]: Util STP threadfunc {0} terminated with error ", threadFuncNum), e); } finally { Interlocked.Decrement(ref numRunningThreadFuncs); threadInfo.Ended(); ThreadInfo dummy; activeThreads.TryRemove(threadFuncNum, out dummy); if ((loggingEnabled || (threadFuncOverloadMode == 1)) && threadInfo.LogThread) m_log.DebugFormat("Exit threadfunc {0} ({1})", threadFuncNum, FormatDuration(threadInfo.Elapsed())); } }; } long numQueued = Interlocked.Increment(ref numQueuedThreadFuncs); try { long numRunning = numRunningThreadFuncs; if (m_ThreadPool != null) { if ((threadFuncOverloadMode == 0) && (numRunning >= m_ThreadPool.MaxThreads)) { if (Interlocked.CompareExchange(ref threadFuncOverloadMode, 1, 0) == 0) m_log.DebugFormat("Threadfunc: enable overload mode (Queued {0}, Running {1})", numQueued, numRunning); } else if ((threadFuncOverloadMode == 1) && (numRunning <= (m_ThreadPool.MaxThreads * 2) / 3)) { if (Interlocked.CompareExchange(ref threadFuncOverloadMode, 0, 1) == 1) m_log.DebugFormat("Threadfunc: disable overload mode (Queued {0}, Running {1})", numQueued, numRunning); } } if (loggingEnabled || (threadFuncOverloadMode == 1)) { string full, partial; GetFireAndForgetStackTrace(out full, out partial); threadInfo.StackTrace = full; threadInfo.LogThread = ShouldLogThread(partial); if (threadInfo.LogThread) { m_log.DebugFormat("Queue threadfunc {0} (Queued {1}, Running {2}) {3}{4}", threadFuncNum, numQueued, numRunningThreadFuncs, (context == null) ? "" : ("(" + context + ") "), (LogThreadPool >= 2) ? full : partial); } } switch (FireAndForgetMethod) { case FireAndForgetMethod.RegressionTest: case FireAndForgetMethod.None: realCallback.Invoke(obj); break; case FireAndForgetMethod.UnsafeQueueUserWorkItem: ThreadPool.UnsafeQueueUserWorkItem(realCallback, obj); break; case FireAndForgetMethod.QueueUserWorkItem: ThreadPool.QueueUserWorkItem(realCallback, obj); break; case FireAndForgetMethod.BeginInvoke: FireAndForgetWrapper wrapper = FireAndForgetWrapper.Instance; wrapper.FireAndForget(realCallback, obj); break; case FireAndForgetMethod.SmartThreadPool: if (m_ThreadPool == null) InitThreadPool(2, 15); threadInfo.WorkItem = m_ThreadPool.QueueWorkItem((cb, o) => cb(o), realCallback, obj); break; case FireAndForgetMethod.Thread: Thread thread = new Thread(delegate(object o) { realCallback(o); }); thread.Start(obj); break; default: throw new NotImplementedException(); } } catch (Exception) { Interlocked.Decrement(ref numQueuedThreadFuncs); ThreadInfo dummy; activeThreads.TryRemove(threadFuncNum, out dummy); throw; } } /// /// Returns whether the thread should be logged. Some very common threads aren't logged, /// to avoid filling up the log. /// /// A partial stack trace of where the thread was queued /// Whether to log this thread private static bool ShouldLogThread(string stackTrace) { if (LogThreadPool < 3) { if (stackTrace.Contains("BeginFireQueueEmpty")) return false; } return true; } /// /// Returns a stack trace for a thread added using FireAndForget(). /// /// Will contain the full stack trace /// Will contain only the first frame of the stack trace private static void GetFireAndForgetStackTrace(out string full, out string partial) { string src = Environment.StackTrace; string[] lines = src.Split(new string[] { Environment.NewLine }, StringSplitOptions.None); StringBuilder dest = new StringBuilder(src.Length); bool started = false; bool first = true; partial = ""; for (int i = 0; i < lines.Length; i++) { string line = lines[i]; if (!started) { // Skip the initial stack frames, because they're of no interest for debugging if (line.Contains("StackTrace") || line.Contains("FireAndForget")) continue; started = true; } if (first) { line = line.TrimStart(); first = false; partial = line; } bool last = (i == lines.Length - 1); if (last) dest.Append(line); else dest.AppendLine(line); } full = dest.ToString(); } #pragma warning disable 0618 /// /// Return the stack trace of a different thread. /// /// /// This is complicated because the thread needs to be paused in order to get its stack /// trace. And pausing another thread can cause a deadlock. This method attempts to /// avoid deadlock by using a short timeout (200ms), after which it gives up and /// returns 'null' instead of the stack trace. /// /// Take from: http://stackoverflow.com/a/14935378 /// /// WARNING: this doesn't work in Mono. See https://bugzilla.novell.com/show_bug.cgi?id=571691 /// /// /// The stack trace, or null if failed to get it private static StackTrace GetStackTrace(Thread targetThread) { if (IsPlatformMono) { // This doesn't work in Mono return null; } ManualResetEventSlim fallbackThreadReady = new ManualResetEventSlim(); ManualResetEventSlim exitedSafely = new ManualResetEventSlim(); try { new Thread(delegate() { fallbackThreadReady.Set(); while (!exitedSafely.Wait(200)) { try { targetThread.Resume(); } catch (Exception) { // Whatever happens, do never stop to resume the main-thread regularly until the main-thread has exited safely. } } }).Start(); fallbackThreadReady.Wait(); // From here, you have about 200ms to get the stack-trace targetThread.Suspend(); StackTrace trace = null; try { trace = new StackTrace(targetThread, true); } catch (ThreadStateException) { //failed to get stack trace, since the fallback-thread resumed the thread //possible reasons: //1.) This thread was just too slow //2.) A deadlock ocurred //Automatic retry seems too risky here, so just return null. } try { targetThread.Resume(); } catch (ThreadStateException) { // Thread is running again already } return trace; } finally { // Signal the fallack-thread to stop exitedSafely.Set(); } } #pragma warning restore 0618 /// /// Get information about the current state of the smart thread pool. /// /// /// null if this isn't the pool being used for non-scriptengine threads. /// public static STPInfo GetSmartThreadPoolInfo() { if (m_ThreadPool == null) return null; STPInfo stpi = new STPInfo(); stpi.Name = m_ThreadPool.Name; stpi.STPStartInfo = m_ThreadPool.STPStartInfo; stpi.IsIdle = m_ThreadPool.IsIdle; stpi.IsShuttingDown = m_ThreadPool.IsShuttingdown; stpi.MaxThreads = m_ThreadPool.MaxThreads; stpi.MinThreads = m_ThreadPool.MinThreads; stpi.InUseThreads = m_ThreadPool.InUseThreads; stpi.ActiveThreads = m_ThreadPool.ActiveThreads; stpi.WaitingCallbacks = m_ThreadPool.WaitingCallbacks; stpi.MaxConcurrentWorkItems = m_ThreadPool.Concurrency; return stpi; } #endregion FireAndForget Threading Pattern /// /// Run the callback on a different thread, outside the thread pool. This is used for tasks /// that may take a long time. /// public static void RunThreadNoTimeout(WaitCallback callback, string name, object obj) { if (FireAndForgetMethod == FireAndForgetMethod.RegressionTest) { Culture.SetCurrentCulture(); callback(obj); return; } Thread t = new Thread(delegate() { try { Culture.SetCurrentCulture(); callback(obj); } catch (Exception e) { m_log.Error("Exception in thread " + name, e); } }); t.Name = name; t.Start(); } /// /// Environment.TickCount is an int but it counts all 32 bits so it goes positive /// and negative every 24.9 days. This trims down TickCount so it doesn't wrap /// for the callers. /// This trims it to a 12 day interval so don't let your frame time get too long. /// /// public static Int32 EnvironmentTickCount() { return Environment.TickCount & EnvironmentTickCountMask; } const Int32 EnvironmentTickCountMask = 0x3fffffff; /// /// Environment.TickCount is an int but it counts all 32 bits so it goes positive /// and negative every 24.9 days. Subtracts the passed value (previously fetched by /// 'EnvironmentTickCount()') and accounts for any wrapping. /// /// /// /// subtraction of passed prevValue from current Environment.TickCount public static Int32 EnvironmentTickCountSubtract(Int32 newValue, Int32 prevValue) { Int32 diff = newValue - prevValue; return (diff >= 0) ? diff : (diff + EnvironmentTickCountMask + 1); } /// /// Environment.TickCount is an int but it counts all 32 bits so it goes positive /// and negative every 24.9 days. Subtracts the passed value (previously fetched by /// 'EnvironmentTickCount()') and accounts for any wrapping. /// /// subtraction of passed prevValue from current Environment.TickCount public static Int32 EnvironmentTickCountSubtract(Int32 prevValue) { return EnvironmentTickCountSubtract(EnvironmentTickCount(), prevValue); } // Returns value of Tick Count A - TickCount B accounting for wrapping of TickCount // Assumes both tcA and tcB came from previous calls to Util.EnvironmentTickCount(). // A positive return value indicates A occured later than B public static Int32 EnvironmentTickCountCompare(Int32 tcA, Int32 tcB) { // A, B and TC are all between 0 and 0x3fffffff int tc = EnvironmentTickCount(); if (tc - tcA >= 0) tcA += EnvironmentTickCountMask + 1; if (tc - tcB >= 0) tcB += EnvironmentTickCountMask + 1; return tcA - tcB; } /// /// Formats a duration (given in milliseconds). /// public static string FormatDuration(int ms) { TimeSpan span = new TimeSpan(ms * TimeSpan.TicksPerMillisecond); string str = ""; string suffix = null; int hours = (int)span.TotalHours; if (hours > 0) { str += hours.ToString(str.Length == 0 ? "0" : "00"); suffix = "hours"; } if ((hours > 0) || (span.Minutes > 0)) { if (str.Length > 0) str += ":"; str += span.Minutes.ToString(str.Length == 0 ? "0" : "00"); if (suffix == null) suffix = "min"; } if ((hours > 0) || (span.Minutes > 0) || (span.Seconds > 0)) { if (str.Length > 0) str += ":"; str += span.Seconds.ToString(str.Length == 0 ? "0" : "00"); if (suffix == null) suffix = "sec"; } if (suffix == null) suffix = "ms"; if (span.TotalMinutes < 1) { int ms1 = span.Milliseconds; if (str.Length > 0) { ms1 /= 100; str += "."; } str += ms1.ToString("0"); } str += " " + suffix; return str; } /// /// Prints the call stack at any given point. Useful for debugging. /// public static void PrintCallStack() { PrintCallStack(m_log.DebugFormat); } public delegate void DebugPrinter(string msg, params Object[] parm); public static void PrintCallStack(DebugPrinter printer) { StackTrace stackTrace = new StackTrace(true); // get call stack StackFrame[] stackFrames = stackTrace.GetFrames(); // get method calls (frames) // write call stack method names foreach (StackFrame stackFrame in stackFrames) { MethodBase mb = stackFrame.GetMethod(); printer("{0}.{1}:{2}", mb.DeclaringType, mb.Name, stackFrame.GetFileLineNumber()); // write method name } } /// /// Gets the client IP address /// /// /// public static IPEndPoint GetClientIPFromXFF(string xff) { if (xff == string.Empty) return null; string[] parts = xff.Split(new char[] { ',' }); if (parts.Length > 0) { try { return new IPEndPoint(IPAddress.Parse(parts[0]), 0); } catch (Exception e) { m_log.WarnFormat("[UTIL]: Exception parsing XFF header {0}: {1}", xff, e.Message); } } return null; } public static string GetCallerIP(Hashtable req) { if (req.ContainsKey("headers")) { try { Hashtable headers = (Hashtable)req["headers"]; if (headers.ContainsKey("remote_addr") && headers["remote_addr"] != null) return headers["remote_addr"].ToString(); } catch (Exception e) { m_log.WarnFormat("[UTIL]: exception in GetCallerIP: {0}", e.Message); } } return string.Empty; } #region Xml Serialization Utilities public static bool ReadBoolean(XmlTextReader reader) { // AuroraSim uses "int" for some fields that are boolean in OpenSim, e.g. "PassCollisions". Don't fail because of this. reader.ReadStartElement(); string val = reader.ReadContentAsString().ToLower(); bool result = val.Equals("true") || val.Equals("1"); reader.ReadEndElement(); return result; } public static UUID ReadUUID(XmlTextReader reader, string name) { UUID id; string idStr; reader.ReadStartElement(name); if (reader.Name == "Guid") idStr = reader.ReadElementString("Guid"); else if (reader.Name == "UUID") idStr = reader.ReadElementString("UUID"); else // no leading tag idStr = reader.ReadContentAsString(); UUID.TryParse(idStr, out id); reader.ReadEndElement(); return id; } public static Vector3 ReadVector(XmlTextReader reader, string name) { Vector3 vec; reader.ReadStartElement(name); vec.X = reader.ReadElementContentAsFloat(reader.Name, String.Empty); // X or x vec.Y = reader.ReadElementContentAsFloat(reader.Name, String.Empty); // Y or y vec.Z = reader.ReadElementContentAsFloat(reader.Name, String.Empty); // Z or z reader.ReadEndElement(); return vec; } public static Quaternion ReadQuaternion(XmlTextReader reader, string name) { Quaternion quat = new Quaternion(); reader.ReadStartElement(name); while (reader.NodeType != XmlNodeType.EndElement) { switch (reader.Name.ToLower()) { case "x": quat.X = reader.ReadElementContentAsFloat(reader.Name, String.Empty); break; case "y": quat.Y = reader.ReadElementContentAsFloat(reader.Name, String.Empty); break; case "z": quat.Z = reader.ReadElementContentAsFloat(reader.Name, String.Empty); break; case "w": quat.W = reader.ReadElementContentAsFloat(reader.Name, String.Empty); break; } } reader.ReadEndElement(); return quat; } public static T ReadEnum(XmlTextReader reader, string name) { string value = reader.ReadElementContentAsString(name, String.Empty); // !!!!! to deal with flags without commas if (value.Contains(" ") && !value.Contains(",")) value = value.Replace(" ", ", "); return (T)Enum.Parse(typeof(T), value); ; } #endregion #region Universal User Identifiers /// /// /// uuid[;endpoint[;first last[;secret]]] /// the uuid part /// the endpoint part (e.g. http://foo.com) /// the first name part (e.g. Test) /// the last name part (e.g User) /// the secret part public static bool ParseUniversalUserIdentifier(string value, out UUID uuid, out string url, out string firstname, out string lastname, out string secret) { uuid = UUID.Zero; url = string.Empty; firstname = "Unknown"; lastname = "UserUPUUI"; secret = string.Empty; string[] parts = value.Split(';'); if (parts.Length >= 1) if (!UUID.TryParse(parts[0], out uuid)) return false; if (parts.Length >= 2) url = parts[1]; if (parts.Length >= 3) { string[] name = parts[2].Split(); if (name.Length == 2) { firstname = name[0]; lastname = name[1]; } } if (parts.Length >= 4) secret = parts[3]; return true; } /// /// Produces a universal (HG) system-facing identifier given the information /// /// /// uuid[;homeURI[;first last]] public static string ProduceUserUniversalIdentifier(AgentCircuitData acircuit) { if (acircuit.ServiceURLs.ContainsKey("HomeURI")) return UniversalIdentifier(acircuit.AgentID, acircuit.firstname, acircuit.lastname, acircuit.ServiceURLs["HomeURI"].ToString()); else return acircuit.AgentID.ToString(); } /// /// Produces a universal (HG) system-facing identifier given the information /// /// UUID of the user /// first name (e.g Test) /// last name (e.g. User) /// homeURI (e.g. http://foo.com) /// a string of the form uuid[;homeURI[;first last]] public static string UniversalIdentifier(UUID id, String firstName, String lastName, String homeURI) { string agentsURI = homeURI; if (!agentsURI.EndsWith("/")) agentsURI += "/"; // This is ugly, but there's no other way, given that the name is changed // in the agent circuit data for foreigners if (lastName.Contains("@")) { string[] parts = firstName.Split(new char[] { '.' }); if (parts.Length == 2) return CalcUniversalIdentifier(id, agentsURI, parts[0] + " " + parts[1]); } return CalcUniversalIdentifier(id, agentsURI, firstName + " " + lastName); } private static string CalcUniversalIdentifier(UUID id, string agentsURI, string name) { return id.ToString() + ";" + agentsURI + ";" + name; } /// /// Produces a universal (HG) user-facing name given the information /// /// /// /// /// string of the form first.last @foo.com or first last public static string UniversalName(String firstName, String lastName, String homeURI) { Uri uri = null; try { uri = new Uri(homeURI); } catch (UriFormatException) { return firstName + " " + lastName; } return firstName + "." + lastName + " " + "@" + uri.Authority; } #endregion /// /// Escapes the special characters used in "LIKE". /// /// /// For example: EscapeForLike("foo_bar%baz") = "foo\_bar\%baz" /// public static string EscapeForLike(string str) { return str.Replace("_", "\\_").Replace("%", "\\%"); } /// /// Returns the name of the user's viewer. /// /// /// This method handles two ways that viewers specify their name: /// 1. Viewer = "Firestorm-Release 4.4.2.34167", Channel = "(don't care)" -> "Firestorm-Release 4.4.2.34167" /// 2. Viewer = "4.5.1.38838", Channel = "Firestorm-Beta" -> "Firestorm-Beta 4.5.1.38838" /// public static string GetViewerName(AgentCircuitData agent) { string name = agent.Viewer; if (name == null) name = ""; else name = name.Trim(); // Check if 'Viewer' is just a version number. If it's *not*, then we // assume that it contains the real viewer name, and we return it. foreach (char c in name) { if (Char.IsLetter(c)) return name; } // The 'Viewer' string contains just a version number. If there's anything in // 'Channel' then assume that it's the viewer name. if ((agent.Channel != null) && (agent.Channel.Length > 0)) name = agent.Channel.Trim() + " " + name; return name; } } public class DoubleQueue where T:class { private Queue m_lowQueue = new Queue(); private Queue m_highQueue = new Queue(); private object m_syncRoot = new object(); private Semaphore m_s = new Semaphore(0, 1); public DoubleQueue() { } public virtual int Count { get { lock (m_syncRoot) return m_highQueue.Count + m_lowQueue.Count; } } public virtual void Enqueue(T data) { Enqueue(m_lowQueue, data); } public virtual void EnqueueLow(T data) { Enqueue(m_lowQueue, data); } public virtual void EnqueueHigh(T data) { Enqueue(m_highQueue, data); } private void Enqueue(Queue q, T data) { lock (m_syncRoot) { q.Enqueue(data); m_s.WaitOne(0); m_s.Release(); } } public virtual T Dequeue() { return Dequeue(Timeout.Infinite); } public virtual T Dequeue(int tmo) { return Dequeue(TimeSpan.FromMilliseconds(tmo)); } public virtual T Dequeue(TimeSpan wait) { T res = null; if (!Dequeue(wait, ref res)) return null; return res; } public bool Dequeue(int timeout, ref T res) { return Dequeue(TimeSpan.FromMilliseconds(timeout), ref res); } public bool Dequeue(TimeSpan wait, ref T res) { if (!m_s.WaitOne(wait)) return false; lock (m_syncRoot) { if (m_highQueue.Count > 0) res = m_highQueue.Dequeue(); else if (m_lowQueue.Count > 0) res = m_lowQueue.Dequeue(); if (m_highQueue.Count == 0 && m_lowQueue.Count == 0) return true; try { m_s.Release(); } catch { } return true; } } public virtual void Clear() { lock (m_syncRoot) { // Make sure sem count is 0 m_s.WaitOne(0); m_lowQueue.Clear(); m_highQueue.Clear(); } } } }