5 files changed, 603 insertions, 0 deletions
diff --git a/OpenSim/Region/Communications/OGS1/CommunicationsOGS1.cs b/OpenSim/Region/Communications/OGS1/CommunicationsOGS1.cs
new file mode 100644
index 0000000..cc05845
--- /dev/null
+++ b/OpenSim/Region/Communications/OGS1/CommunicationsOGS1.cs
@@ -0,0 +1,18 @@
+using OpenSim.Framework.Communications;
+using OpenSim.Framework.Types;
+using OpenSim.Framework.Servers;
+namespace OpenSim.Region.Communications.OGS1
+{
+    public class CommunicationsOGS1 : CommunicationsManager
+    {
+        
+        public CommunicationsOGS1(NetworkServersInfo serversInfo, BaseHttpServer httpServer ) :base(serversInfo, httpServer)
+        {
+            OGS1GridServices gridInterComms = new OGS1GridServices(serversInfo, httpServer);
+            GridServer = gridInterComms;
+            InterRegion = gridInterComms;
+            UserServer = new OGS1UserServices(this);
+        }
+    }
+}
diff --git a/OpenSim/Region/Communications/OGS1/OGS1GridServices.cs b/OpenSim/Region/Communications/OGS1/OGS1GridServices.cs
new file mode 100644
index 0000000..66c1739
--- /dev/null
+++ b/OpenSim/Region/Communications/OGS1/OGS1GridServices.cs
@@ -0,0 +1,378 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Net;
+using System.Runtime.Remoting;
+using System.Runtime.Remoting.Channels;
+using System.Runtime.Remoting.Channels.Tcp;
+using libsecondlife;
+using Nwc.XmlRpc;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Framework.Console;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Types;
+namespace OpenSim.Region.Communications.OGS1
+{
+    public class OGS1GridServices : IGridServices, IInterRegionCommunications
+    {
+        public Dictionary<ulong, RegionCommsListener> listeners = new Dictionary<ulong, RegionCommsListener>();
+        protected Dictionary<ulong, RegionInfo> regions = new Dictionary<ulong, RegionInfo>();
+        public BaseHttpServer httpListener;
+        public NetworkServersInfo serversInfo;
+        public BaseHttpServer httpServer;
+        public OGS1GridServices(NetworkServersInfo servers_info, BaseHttpServer httpServe)
+        {
+            serversInfo = servers_info;
+            httpServer = httpServe;
+            httpServer.AddXmlRPCHandler("expect_user", this.ExpectUser);
+            this.StartRemoting();
+        }
+        public RegionCommsListener RegisterRegion(RegionInfo regionInfo)
+        {
+            if (!this.regions.ContainsKey((uint)regionInfo.RegionHandle))
+            {
+                this.regions.Add(regionInfo.RegionHandle, regionInfo);
+            }
+            Hashtable GridParams = new Hashtable();
+            // Login / Authentication
+            GridParams["authkey"] = serversInfo.GridSendKey;
+            GridParams["UUID"] = regionInfo.SimUUID.ToStringHyphenated();
+            GridParams["sim_ip"] = regionInfo.ExternalHostName;
+            GridParams["sim_port"] = regionInfo.InternalEndPoint.Port.ToString();
+            GridParams["region_locx"] = regionInfo.RegionLocX.ToString();
+            GridParams["region_locy"] = regionInfo.RegionLocY.ToString();
+            GridParams["sim_name"] = regionInfo.RegionName;
+            GridParams["http_port"] = serversInfo.HttpListenerPort.ToString();
+            GridParams["remoting_port"] = serversInfo.RemotingListenerPort.ToString();
+            GridParams["map-image-id"] = regionInfo.estateSettings.terrainImageID.ToStringHyphenated();
+            // Package into an XMLRPC Request
+            ArrayList SendParams = new ArrayList();
+            SendParams.Add(GridParams);
+            // Send Request
+            XmlRpcRequest GridReq = new XmlRpcRequest("simulator_login", SendParams);
+            XmlRpcResponse GridResp = GridReq.Send(serversInfo.GridURL, 3000);
+            Hashtable GridRespData = (Hashtable)GridResp.Value;
+            Hashtable griddatahash = GridRespData;
+            // Process Response
+            if (GridRespData.ContainsKey("error"))
+            {
+                string errorstring = (string)GridRespData["error"];
+                MainLog.Instance.Error("Unable to connect to grid: " + errorstring);
+                return null;
+            }
+            /* if (!this.listeners.ContainsKey(regionInfo.RegionHandle))
+             {
+                 MainLog.Instance.Verbose("OGS1 - Registering new HTTP listener on port " + regionInfo.InternalEndPoint.Port.ToString());
+                // initialised = true;
+                 httpListener = new BaseHttpServer( regionInfo.InternalEndPoint.Port );
+                 httpListener.AddXmlRPCHandler("expect_user", this.ExpectUser);
+                 httpListener.Start();
+             }*/
+            // Initialise the background listeners
+            RegionCommsListener regListener = new RegionCommsListener();
+            if (this.listeners.ContainsKey(regionInfo.RegionHandle))
+            {
+                this.listeners.Add(regionInfo.RegionHandle, regListener);
+            }
+            else
+            {
+                listeners[regionInfo.RegionHandle] = regListener;
+            }
+            return regListener;
+        }
+        public List<RegionInfo> RequestNeighbours(RegionInfo regionInfo)
+        {
+            Hashtable respData = MapBlockQuery((int)regionInfo.RegionLocX - 1, (int)regionInfo.RegionLocY - 1, (int)regionInfo.RegionLocX + 1, (int)regionInfo.RegionLocY + 1);
+            List<RegionInfo> neighbours = new List<RegionInfo>();
+            foreach (ArrayList a in respData.Values)
+            {
+                foreach (Hashtable n in a)
+                {
+                    uint regX = Convert.ToUInt32(n["x"]);
+                    uint regY = Convert.ToUInt32(n["y"]);
+                    if ((regionInfo.RegionLocX != regX) || (regionInfo.RegionLocY != regY))
+                    {
+                        string internalIpStr = (string)n["sim_ip"];
+                        uint port = Convert.ToUInt32(n["sim_port"]);
+                        string externalUri = (string)n["sim_uri"];
+                        IPEndPoint neighbourInternalEndPoint = new IPEndPoint(IPAddress.Parse(internalIpStr), (int)port);
+                        string neighbourExternalUri = externalUri;
+                        RegionInfo neighbour = new RegionInfo(regX, regY, neighbourInternalEndPoint, internalIpStr);
+                        //OGS1
+                        //neighbour.RegionHandle = (ulong)n["regionhandle"]; is now calculated locally
+                        neighbour.RegionName = (string)n["name"];
+                        //OGS1+
+                        neighbour.SimUUID = (string)n["uuid"];
+                        neighbours.Add(neighbour);
+                    }
+                }
+            }
+            return neighbours;
+        }
+        public RegionInfo RequestNeighbourInfo(ulong regionHandle)
+        {
+            if (this.regions.ContainsKey(regionHandle))
+            {
+                return this.regions[regionHandle];
+            }
+            //TODO not a region in this instance so ask remote grid server
+            Hashtable requestData = new Hashtable();
+            requestData["region_handle"] = regionHandle.ToString();
+            requestData["authkey"] = this.serversInfo.GridSendKey;
+            ArrayList SendParams = new ArrayList();
+            SendParams.Add(requestData);
+            XmlRpcRequest GridReq = new XmlRpcRequest("simulator_data_request", SendParams);
+            XmlRpcResponse GridResp = GridReq.Send(this.serversInfo.GridURL, 3000);
+            Hashtable responseData = (Hashtable)GridResp.Value;
+            if (responseData.ContainsKey("error"))
+            {
+                Console.WriteLine("error received from grid server" + responseData["error"]);
+                return null;
+            }
+            uint regX = Convert.ToUInt32((string)responseData["region_locx"]);
+            uint regY = Convert.ToUInt32((string)responseData["region_locy"]);
+            string internalIpStr = (string)responseData["sim_ip"];
+            uint port = Convert.ToUInt32(responseData["sim_port"]);
+            string externalUri = (string)responseData["sim_uri"];
+            IPEndPoint neighbourInternalEndPoint = new IPEndPoint(IPAddress.Parse(internalIpStr), (int)port);
+            string neighbourExternalUri = externalUri;
+            RegionInfo regionInfo = new RegionInfo(regX, regY, neighbourInternalEndPoint, internalIpStr);
+            regionInfo.RemotingPort = Convert.ToUInt32((string)responseData["remoting_port"]);
+            regionInfo.RemotingAddress = internalIpStr;
+            regionInfo.SimUUID = new LLUUID((string)responseData["region_UUID"]);
+            regionInfo.RegionName = (string)responseData["region_name"];
+            return regionInfo;
+        }
+        public List<MapBlockData> RequestNeighbourMapBlocks(int minX, int minY, int maxX, int maxY)
+        {
+            Hashtable respData = MapBlockQuery(minX, minY, maxX, maxY);
+            List<MapBlockData> neighbours = new List<MapBlockData>();
+            foreach (ArrayList a in respData.Values)
+            {
+                foreach (Hashtable n in a)
+                {
+                    MapBlockData neighbour = new MapBlockData();
+                    neighbour.X = Convert.ToUInt16(n["x"]);
+                    neighbour.Y = Convert.ToUInt16(n["y"]);
+                    neighbour.Name = (string)n["name"];
+                    neighbour.Access = Convert.ToByte(n["access"]);
+                    neighbour.RegionFlags = Convert.ToUInt32(n["region-flags"]);
+                    neighbour.WaterHeight = Convert.ToByte(n["water-height"]);
+                    neighbour.MapImageId = new LLUUID((string)n["map-image-id"]);
+                    neighbours.Add(neighbour);
+                }
+            }
+            return neighbours;
+        }
+        /// <summary>
+        /// Performs a XML-RPC query against the grid server returning mapblock information in the specified coordinates
+        /// </summary>
+        /// <remarks>REDUNDANT - OGS1 is to be phased out in favour of OGS2</remarks>
+        /// <param name="minX">Minimum X value</param>
+        /// <param name="minY">Minimum Y value</param>
+        /// <param name="maxX">Maximum X value</param>
+        /// <param name="maxY">Maximum Y value</param>
+        /// <returns>Hashtable of hashtables containing map data elements</returns>
+        private Hashtable MapBlockQuery(int minX, int minY, int maxX, int maxY)
+        {
+            Hashtable param = new Hashtable();
+            param["xmin"] = minX;
+            param["ymin"] = minY;
+            param["xmax"] = maxX;
+            param["ymax"] = maxY;
+            IList parameters = new ArrayList();
+            parameters.Add(param);
+            XmlRpcRequest req = new XmlRpcRequest("map_block", parameters);
+            XmlRpcResponse resp = req.Send(serversInfo.GridURL, 3000);
+            Hashtable respData = (Hashtable)resp.Value;
+            return respData;
+        }
+        // Grid Request Processing
+        public XmlRpcResponse ExpectUser(XmlRpcRequest request)
+        {
+            Console.WriteLine("Expecting User...");
+            Hashtable requestData = (Hashtable)request.Params[0];
+            AgentCircuitData agentData = new AgentCircuitData();
+            agentData.SessionID = new LLUUID((string)requestData["session_id"]);
+            agentData.SecureSessionID = new LLUUID((string)requestData["secure_session_id"]);
+            agentData.firstname = (string)requestData["firstname"];
+            agentData.lastname = (string)requestData["lastname"];
+            agentData.AgentID = new LLUUID((string)requestData["agent_id"]);
+            agentData.circuitcode = Convert.ToUInt32(requestData["circuit_code"]);
+            if (requestData.ContainsKey("child_agent") && requestData["child_agent"].Equals("1"))
+            {
+                agentData.child = true;
+            }
+            else
+            {
+                agentData.startpos = new LLVector3(Convert.ToUInt32(requestData["startpos_x"]), Convert.ToUInt32(requestData["startpos_y"]), Convert.ToUInt32(requestData["startpos_z"]));
+                agentData.child = false;
+            }
+            if (listeners.ContainsKey(Convert.ToUInt64((string)requestData["regionhandle"])))
+            {
+                this.listeners[Convert.ToUInt64((string)requestData["regionhandle"])].TriggerExpectUser(Convert.ToUInt64((string)requestData["regionhandle"]), agentData);
+            }
+            else
+            {
+                MainLog.Instance.Error("ExpectUser() - Unknown region " + ((ulong)requestData["regionhandle"]).ToString());
+            }
+            MainLog.Instance.Verbose("ExpectUser() - Welcoming new user...");
+            return new XmlRpcResponse();
+        }
+        #region InterRegion Comms
+        private void StartRemoting()
+        {
+            TcpChannel ch = new TcpChannel(this.serversInfo.RemotingListenerPort);
+            ChannelServices.RegisterChannel(ch, true);
+            WellKnownServiceTypeEntry wellType = new WellKnownServiceTypeEntry(typeof(OGS1InterRegionRemoting), "InterRegions", WellKnownObjectMode.Singleton);
+            RemotingConfiguration.RegisterWellKnownServiceType(wellType);
+            InterRegionSingleton.Instance.OnArrival += this.IncomingArrival;
+            InterRegionSingleton.Instance.OnChildAgent += this.IncomingChildAgent;
+        }
+        #region Methods called by regions in this instance
+        public bool InformRegionOfChildAgent(ulong regionHandle, AgentCircuitData agentData)
+        {
+            if (this.listeners.ContainsKey(regionHandle))
+            {
+                this.listeners[regionHandle].TriggerExpectUser(regionHandle, agentData);
+                return true;
+            }
+            RegionInfo regInfo = this.RequestNeighbourInfo(regionHandle);
+            if (regInfo != null)
+            {
+                //don't want to be creating a new link to the remote instance every time like we are here
+                bool retValue = false;
+               
+                OGS1InterRegionRemoting remObject = (OGS1InterRegionRemoting)Activator.GetObject(
+                    typeof(OGS1InterRegionRemoting),
+                    "tcp://"+ regInfo.RemotingAddress+":"+regInfo.RemotingPort+"/InterRegions");
+                if (remObject != null)
+                {
+                    
+                    retValue = remObject.InformRegionOfChildAgent(regionHandle, agentData);
+                }
+                else
+                {
+                    Console.WriteLine("remoting object not found");
+                }
+                remObject = null;
+                return retValue;
+            }
+ 
+            return false;
+        }
+        public bool ExpectAvatarCrossing(ulong regionHandle, LLUUID agentID, LLVector3 position)
+        {
+            if (this.listeners.ContainsKey(regionHandle))
+            {
+                this.listeners[regionHandle].TriggerExpectAvatarCrossing(regionHandle, agentID, position);
+                return true;
+            }
+            RegionInfo regInfo = this.RequestNeighbourInfo(regionHandle);
+            if (regInfo != null)
+            {
+                bool retValue = false;
+                OGS1InterRegionRemoting remObject = (OGS1InterRegionRemoting)Activator.GetObject(
+                    typeof(OGS1InterRegionRemoting),
+                    "tcp://" + regInfo.RemotingAddress + ":" + regInfo.RemotingPort + "/InterRegions");
+                if (remObject != null)
+                {
+                    retValue = remObject.ExpectAvatarCrossing(regionHandle, agentID, position);
+                }
+                else
+                {
+                    Console.WriteLine("remoting object not found");
+                }
+                remObject = null;
+                return retValue;
+            }
+            //TODO need to see if we know about where this region is and use .net remoting 
+            // to inform it. 
+            return false;
+        }
+        #endregion
+        #region Methods triggered by calls from external instances
+        public bool IncomingChildAgent(ulong regionHandle, AgentCircuitData agentData)
+        {
+            if (this.listeners.ContainsKey(regionHandle))
+            {
+                this.listeners[regionHandle].TriggerExpectUser(regionHandle, agentData);
+                return true;
+            }
+            return false;
+        }
+        public bool IncomingArrival(ulong regionHandle, LLUUID agentID, LLVector3 position)
+        {
+            if (this.listeners.ContainsKey(regionHandle))
+            {
+                this.listeners[regionHandle].TriggerExpectAvatarCrossing(regionHandle, agentID, position);
+                return true;
+            }
+            return false;
+        }
+        #endregion
+        #endregion
+    }
+}
diff --git a/OpenSim/Region/Communications/OGS1/OGS1InterSimComms.cs b/OpenSim/Region/Communications/OGS1/OGS1InterSimComms.cs
new file mode 100644
index 0000000..f514a29
--- /dev/null
+++ b/OpenSim/Region/Communications/OGS1/OGS1InterSimComms.cs
@@ -0,0 +1,69 @@
+using System;
+using libsecondlife;
+using OpenSim.Framework.Types;
+namespace OpenSim.Region.Communications.OGS1
+{
+    public delegate bool InformRegionChild(ulong regionHandle, AgentCircuitData agentData);
+    public delegate bool ExpectArrival(ulong regionHandle, LLUUID agentID, LLVector3 position);
+    public sealed class InterRegionSingleton
+    {
+        static readonly InterRegionSingleton instance = new InterRegionSingleton();
+        public event InformRegionChild OnChildAgent;
+        public event ExpectArrival OnArrival;
+        static InterRegionSingleton()
+        {
+        }
+        InterRegionSingleton()
+        {
+        }
+        public static InterRegionSingleton Instance
+        {
+            get
+            {
+                return instance;
+            }
+        }
+        public bool InformRegionOfChildAgent(ulong regionHandle, AgentCircuitData agentData)
+        {
+            if (OnChildAgent != null)
+            {
+                return OnChildAgent(regionHandle, agentData);
+            }
+            return false;
+        }
+        public bool ExpectAvatarCrossing(ulong regionHandle, LLUUID agentID, LLVector3 position)
+        {
+            if (OnArrival != null)
+            {
+                return OnArrival(regionHandle, agentID, position);
+            }
+            return false;
+        }
+    }
+    public class OGS1InterRegionRemoting : MarshalByRefObject
+    {
+        public OGS1InterRegionRemoting()
+        {
+        }
+        public bool InformRegionOfChildAgent(ulong regionHandle, AgentCircuitData agentData)
+        {
+            return InterRegionSingleton.Instance.InformRegionOfChildAgent(regionHandle, agentData);
+        }
+        public bool ExpectAvatarCrossing(ulong regionHandle, LLUUID agentID, LLVector3 position)
+        {
+            return InterRegionSingleton.Instance.ExpectAvatarCrossing(regionHandle, agentID, position);
+        }
+    }
+}
diff --git a/OpenSim/Region/Communications/OGS1/OGS1UserServices.cs b/OpenSim/Region/Communications/OGS1/OGS1UserServices.cs
new file mode 100644
index 0000000..2bbaf9d
--- /dev/null
+++ b/OpenSim/Region/Communications/OGS1/OGS1UserServices.cs
@@ -0,0 +1,105 @@
+using System;
+using System.Collections;
+using libsecondlife;
+using Nwc.XmlRpc;
+using OpenSim.Framework.Communications;
+using OpenSim.Framework.Data;
+namespace OpenSim.Region.Communications.OGS1
+{
+    public class OGS1UserServices :IUserServices
+    {
+        CommunicationsOGS1 m_parent;
+        public OGS1UserServices(CommunicationsOGS1 parent)
+        {
+            m_parent = parent;
+        }
+        public UserProfileData ConvertXMLRPCDataToUserProfile(Hashtable data)
+        {
+            if (data.Contains("error_type"))
+            {
+                Console.WriteLine("Error sent by user server when trying to get user profile: (" + data["error_type"] + "): " + data["error_desc"]);
+                return null;
+            }
+            UserProfileData userData = new UserProfileData();
+            userData.username = (string)data["firstname"];
+            userData.surname = (string)data["lastname"];
+            userData.UUID = new LLUUID((string)data["uuid"]);
+            userData.userInventoryURI = (string)data["server_inventory"];
+            userData.userAssetURI = (string)data["server_asset"];
+            userData.profileFirstText = (string)data["profile_firstlife_about"];
+            userData.profileFirstImage = new LLUUID((string)data["profile_firstlife_image"]);
+            userData.profileCanDoMask = Convert.ToUInt32((string)data["profile_can_do"]);
+            userData.profileWantDoMask = Convert.ToUInt32(data["profile_want_do"]);
+            userData.profileImage = new LLUUID((string)data["profile_image"]);
+            userData.lastLogin = Convert.ToInt32((string)data["profile_lastlogin"]);
+            userData.homeRegion = Convert.ToUInt64((string)data["home_region"]);
+            userData.homeLocation = new LLVector3((float)Convert.ToDecimal((string)data["home_coordinates_x"]), (float)Convert.ToDecimal((string)data["home_coordinates_y"]), (float)Convert.ToDecimal((string)data["home_coordinates_z"]));
+            userData.homeLookAt = new LLVector3((float)Convert.ToDecimal((string)data["home_look_x"]), (float)Convert.ToDecimal((string)data["home_look_y"]), (float)Convert.ToDecimal((string)data["home_look_z"]));
+            return userData;
+        }
+        public UserProfileData GetUserProfile(string firstName, string lastName)
+        {
+            return GetUserProfile(firstName + " " + lastName);
+        }
+        public UserProfileData GetUserProfile(string name)
+        {
+            //try
+            //{
+                Hashtable param = new Hashtable();
+                param["avatar_name"] = name;
+                IList parameters = new ArrayList();
+                parameters.Add(param);
+                XmlRpcRequest req = new XmlRpcRequest("get_user_by_name", parameters);
+                XmlRpcResponse resp = req.Send(m_parent.ServersInfo.UserURL, 3000);
+                Hashtable respData = (Hashtable)resp.Value;
+                return ConvertXMLRPCDataToUserProfile(respData);
+            //}
+            //catch (Exception e)
+            //{
+            //    Console.WriteLine("Error when trying to fetch profile data by name from remote user server: " + e.Message);
+            //}
+            //return null;
+        }
+        public UserProfileData GetUserProfile(LLUUID avatarID)
+        {
+            try
+            {
+                Hashtable param = new Hashtable();
+                param["avatar_uuid"] = avatarID.ToString();
+                IList parameters = new ArrayList();
+                parameters.Add(param);
+                XmlRpcRequest req = new XmlRpcRequest("get_user_by_uuid", parameters);
+                XmlRpcResponse resp = req.Send(m_parent.ServersInfo.UserURL, 3000);
+                Hashtable respData = (Hashtable)resp.Value;
+                return ConvertXMLRPCDataToUserProfile(respData);
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine("Error when trying to fetch profile data by uuid from remote user server: " + e.Message);
+            }
+            return null;
+        }
+        public UserProfileData SetupMasterUser(string firstName, string lastName)
+        {
+            return SetupMasterUser(firstName, lastName, "");
+        }
+        public UserProfileData SetupMasterUser(string firstName, string lastName, string password)
+        {
+            UserProfileData profile = GetUserProfile(firstName, lastName);
+            if (profile == null)
+            {
+                Console.WriteLine("Unknown Master User. Grid Mode: No clue what I should do. Probably would choose the grid owner UUID when that is implemented");
+            }
+            return null;
+        }
+    }
+}
diff --git a/OpenSim/Region/Communications/OGS1/Properties/AssemblyInfo.cs b/OpenSim/Region/Communications/OGS1/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..41f811a
--- /dev/null
+++ b/OpenSim/Region/Communications/OGS1/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.InteropServices;
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenGrid.Framework.Communications.OGS1")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("OpenGrid.Framework.Communications.OGS1")]
+[assembly: AssemblyCopyright("Copyright ©  2007")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("a8b2b39b-c83b-41e2-b0b5-7ccfc1fddae7")]
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]