Ignore:
Timestamp:
Jul 21, 2015, 9:51:32 PM (9 years ago)
Author:
alloc
Message:

Fixes intermediate state

Location:
binary-improvements/MapRendering
Files:
11 added
7 edited
5 moved

Legend:

Unmodified
Added
Removed

  • binary-improvements/MapRendering/Web/API/GetLandClaims.cs

    r238 r244  
    99        public class GetLandClaims : WebAPI
    1010        {
    11                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, HttpListenerBasicIdentity user)
     11                public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user, int permissionLevel)
    1212                {
    1313                        string steamid = string.Empty;
    … …  
    1717                                steamid = req.QueryString ["steamid"];
    1818                                if (steamid.Length != 17 || !long.TryParse (steamid, out tempLong)) {
    19                                         resp.StatusCode = (int)HttpStatusCode.InternalServerError;
     19                                        resp.StatusCode = (int)HttpStatusCode.BadRequest;
    2020                                        Web.SetResponseTextContent (resp, "Invalid SteamID given");
    2121                                        return;

  • binary-improvements/MapRendering/Web/API/GetPlayerInventory.cs

    r233 r244  
    99        public class GetPlayerInventory : WebAPI
    1010        {
    11                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, HttpListenerBasicIdentity user)
     11                public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user, int permissionLevel)
    1212                {
    1313                        if (req.QueryString ["steamid"] == null) {

  • binary-improvements/MapRendering/Web/API/GetPlayersLocation.cs

    r233 r244  
    99        public class GetPlayersLocation : WebAPI
    1010        {
    11                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, HttpListenerBasicIdentity user)
     11                public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user, int permissionLevel)
    1212                {
    1313                        JSONArray playersJsResult = new JSONArray ();

  • binary-improvements/MapRendering/Web/API/GetPlayersOnline.cs

    r233 r244  
    99        public class GetPlayersOnline : WebAPI
    1010        {
    11                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, HttpListenerBasicIdentity user)
     11                public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user, int permissionLevel)
    1212                {
    1313                        JSONArray players = new JSONArray();

  • binary-improvements/MapRendering/Web/API/WebAPI.cs

    r230 r244  
    1616                }
    1717
    18                 public abstract void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, HttpListenerBasicIdentity user);
     18                public abstract void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user, int permissionLevel);
    1919        }
    2020}

  • binary-improvements/MapRendering/Web/Handlers/ApiHandler.cs

    r230 r244  
    66using System.Threading;
    77
    8 namespace AllocsFixes.NetConnections.Servers.Web
     8namespace AllocsFixes.NetConnections.Servers.Web.Handlers
    99{
    10         public class ApiHandler : PathHandler
    11         {
     10        public class ApiHandler : PathHandler {
    1211                private string staticPart;
    1312                private Dictionary<String, WebAPI> apis = new Dictionary<string, WebAPI> ();
    1413
    15                 public ApiHandler (string staticPart)
    16                 {
     14                public ApiHandler (string staticPart, string moduleName = null) : base(moduleName) {
    1715                        this.staticPart = staticPart;
    18                         apis.Add ("getlandclaims", new GetLandClaims ());
    19                         apis.Add ("getplayersonline", new GetPlayersOnline ());
    20                         apis.Add ("getplayerslocation", new GetPlayersLocation ());
    21                         apis.Add ("getplayerinventory", new GetPlayerInventory ());
     16                        addApi ("getlandclaims", new GetLandClaims ());
     17                        addApi ("getplayersonline", new GetPlayersOnline ());
     18                        addApi ("getplayerslocation", new GetPlayersLocation ());
     19                        addApi ("getplayerinventory", new GetPlayerInventory ());
     20                        addApi ("getstats", new GetStats ());
    2221                }
    2322
    24                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, HttpListenerBasicIdentity user)
    25                 {
     23                private void addApi (string _apiName, WebAPI _api) {
     24                        apis.Add (_apiName, _api);
     25                        WebPermissions.Instance.AddKnownModule ("webapi." + _apiName);
     26                }
     27
     28                public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user, int permissionLevel) {
    2629                        string apiName = req.Url.AbsolutePath.Remove (0, staticPart.Length);
    27                         if (!AuthorizeForCommand (apiName, user)) {
     30                        if (!AuthorizeForCommand (apiName, user, permissionLevel)) {
    2831                                resp.StatusCode = (int)HttpStatusCode.Forbidden;
     32                                if (user != null) {
     33                                        Log.Out ("ApiHandler: user '{0}' not allowed to execute '{1}'", user.SteamID, apiName);
     34                                } else {
     35                                        Log.Out ("ApiHandler: unidentified user from '{0}' not allowed to execute '{1}'", req.RemoteEndPoint.Address, apiName);
     36                                }
     37                                return;
    2938                        } else {
    3039                                foreach (KeyValuePair<string, WebAPI> kvp in apis) {
    3140                                        try {
    3241                                                if (apiName.StartsWith (kvp.Key)) {
    33                                                         kvp.Value.HandleRequest (req, resp, user);
     42                                                        kvp.Value.HandleRequest (req, resp, user, permissionLevel);
    3443                                                        return;
    3544                                                }
    … …  
    4655                }
    4756
    48                 private bool AuthorizeForCommand (string apiName, HttpListenerBasicIdentity user)
    49                 {
    50                         return true;
     57                private bool AuthorizeForCommand (string apiName, WebConnection user, int permissionLevel) {
     58                        return WebPermissions.Instance.ModuleAllowedWithLevel ("webapi." + apiName, permissionLevel);
    5159                }
    5260

  • binary-improvements/MapRendering/Web/Handlers/ItemIconHandler.cs

    r242 r244  
    77using UnityEngine;
    88
    9 namespace AllocsFixes.NetConnections.Servers.Web
     9namespace AllocsFixes.NetConnections.Servers.Web.Handlers
    1010{
    1111        public class ItemIconHandler : PathHandler
    … …  
    1616                private bool loaded = false;
    1717
    18                 public ItemIconHandler (string staticPart, bool logMissingFiles) {
     18                public ItemIconHandler (string staticPart, bool logMissingFiles, string moduleName = null) : base(moduleName) {
    1919                        this.staticPart = staticPart;
    2020                        this.logMissingFiles = logMissingFiles;
    2121                }
    2222
    23                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, HttpListenerBasicIdentity user) {
     23                public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user, int permissionLevel) {
    2424                        if (!loaded) {
    2525                                if (!LoadIcons ()) {

  • binary-improvements/MapRendering/Web/Handlers/PathHandler.cs

    r230 r244  
    22using System.Net;
    33
    4 namespace AllocsFixes.NetConnections.Servers.Web
     4namespace AllocsFixes.NetConnections.Servers.Web.Handlers
    55{
    66        public abstract class PathHandler
    77        {
    8                 public abstract void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, HttpListenerBasicIdentity user);
     8                private string moduleName = null;
     9                public string ModuleName {
     10                        get { return moduleName; }
     11                }
     12
     13                protected PathHandler (string _moduleName) {
     14                        this.moduleName = _moduleName;
     15                        WebPermissions.Instance.AddKnownModule (_moduleName);
     16                }
     17
     18                public abstract void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user, int permissionLevel);
     19
     20                public bool IsAuthorizedForHandler (WebConnection user, int permissionLevel) {
     21                        if (moduleName != null) {
     22                                return WebPermissions.Instance.ModuleAllowedWithLevel (moduleName, permissionLevel);
     23                        } else {
     24                                return true;
     25                        }
     26                }
    927        }
    1028}

  • binary-improvements/MapRendering/Web/Handlers/SimpleRedirectHandler.cs

    r230 r244  
    22using System.Net;
    33
    4 namespace AllocsFixes.NetConnections.Servers.Web
     4namespace AllocsFixes.NetConnections.Servers.Web.Handlers
    55{
    66        public class SimpleRedirectHandler : PathHandler
    … …  
    88                string target;
    99
    10                 public SimpleRedirectHandler (string target)
     10                public SimpleRedirectHandler (string target, string moduleName = null) : base(moduleName)
    1111                {
    1212                        this.target = target;
    1313                }
    1414
    15                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, HttpListenerBasicIdentity user)
     15                public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user, int permissionLevel)
    1616                {
    1717                        resp.Redirect (target);

  • binary-improvements/MapRendering/Web/Handlers/StaticHandler.cs

    r230 r244  
    55using System.Threading;
    66
    7 namespace AllocsFixes.NetConnections.Servers.Web
     7namespace AllocsFixes.NetConnections.Servers.Web.Handlers
    88{
    99        public class StaticHandler : PathHandler
    … …  
    1414                private bool logMissingFiles;
    1515
    16                 public StaticHandler (string staticPart, string filePath, AllocsFixes.FileCache.AbstractCache cache, bool logMissingFiles)
     16                public StaticHandler (string staticPart, string filePath, AllocsFixes.FileCache.AbstractCache cache, bool logMissingFiles, string moduleName = null) : base(moduleName)
    1717                {
    1818                        this.staticPart = staticPart;
    … …  
    2222                }
    2323
    24                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, HttpListenerBasicIdentity user)
     24                public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user, int permissionLevel)
    2525                {
    2626                        string fn = req.Url.AbsolutePath.Remove (0, staticPart.Length);

  • binary-improvements/MapRendering/Web/Web.cs

    r238 r244  
    11using System;
    22using System.Collections.Generic;
     3using System.Collections.Specialized;
    34using System.IO;
    45using System.Net;
    … …  
    910using UnityEngine;
    1011
     12using AllocsFixes.NetConnections.Servers.Web.Handlers;
     13
    1114namespace AllocsFixes.NetConnections.Servers.Web
    1215{
    1316        public class Web : IConsoleServer {
     17                private const int GUEST_PERMISSION_LEVEL = 2000;
    1418                private readonly HttpListener _listener = new HttpListener ();
    1519                private Dictionary<string, PathHandler> handlers = new Dictionary<string, PathHandler> ();
    16                 private bool authEnabled = false;
    17                 private string realm = "7dtd Admin Panel";
    1820                public static int handlingCount = 0;
    1921                public static int currentHandlers = 0;
    2022                private string dataFolder;
    21                 private bool mapEnabled = false;
     23                private bool useStaticCache = false;
     24
     25                public bool isSslRedirected {
     26                        private set;
     27                        get;
     28                }
     29
     30                public ConnectionHandler connectionHandler;
    2231
    2332                public Web () {
    … …  
    2534                                int webPort = GamePrefs.GetInt (EnumGamePrefs.ControlPanelPort);
    2635                                if (webPort < 1 || webPort > 65533) {
    27                                         Log.Out ("Webserver not started (ControlPanelPort not within 1-65534)");
     36                                        Log.Out ("Webserver not started (ControlPanelPort not within 1-65533)");
    2837                                        return;
    2938                                }
    … …  
    3342                                }
    3443
     44                                // TODO: Read from config
     45                                isSslRedirected = false;
     46                                useStaticCache = false;
     47
    3548                                dataFolder = Path.GetDirectoryName (Assembly.GetExecutingAssembly ().Location) + "/webserver";
    3649
    … …  
    4760                                                new SimpleRedirectHandler ("/static/favicon.ico"));
    4861                                handlers.Add (
    49                                                 "/static/",
    50                                                 new StaticHandler (
    51                                                                 "/static/",
    52                                                                 dataFolder,
    53                                                                 new AllocsFixes.FileCache.DirectAccess (),
    54                                                                 true)
    55                                 ); // TODO: Enable cache
     62                                                "/session/",
     63                                                new SessionHandler (
     64                                                                        "/session/",
     65                                                                        dataFolder,
     66                                                                        this)
     67                                );
     68                                handlers.Add (
     69                                                "/userstatus",
     70                                                new UserStatusHandler ()
     71                                );
     72                                if (useStaticCache) {
     73                                        handlers.Add (
     74                                                        "/static/",
     75                                                        new StaticHandler (
     76                                                                        "/static/",
     77                                                                        dataFolder,
     78                                                                        new AllocsFixes.FileCache.SimpleCache (),
     79                                                                        true)
     80                                        );
     81                                } else {
     82                                        handlers.Add (
     83                                                        "/static/",
     84                                                        new StaticHandler (
     85                                                                        "/static/",
     86                                                                        dataFolder,
     87                                                                        new AllocsFixes.FileCache.DirectAccess (),
     88                                                                        true)
     89                                        );
     90                                }
    5691
    5792                                handlers.Add (
    … …  
    68103                                                GameUtils.GetSaveGameDir () + "/map",
    69104                                                MapRendering.MapRendering.GetTileCache (),
    70                                                 false)
    71                                 );
    72 
    73                                 handlers.Add ("/api/", new ApiHandler ("/api/"));
     105                                                false,
     106                                                "web.map")
     107                                );
     108
     109                                handlers.Add (
     110                                        "/api/",
     111                                        new ApiHandler ("/api/")
     112                                );
     113
     114                                connectionHandler = new ConnectionHandler (this);
    74115
    75116                                _listener.Prefixes.Add (String.Format ("http://*:{0}/", webPort + 2));
    76                                 authEnabled = File.Exists (dataFolder + "/protect");
    77                                 if (authEnabled) {
    78                                         _listener.AuthenticationSchemes = AuthenticationSchemes.Basic;
    79                                 }
    80117                                _listener.Start ();
    81                                 _listener.Realm = realm;
    82118
    83119                                SdtdConsole.Instance.RegisterServer (this);
    … …  
    85121                                _listener.BeginGetContext (new AsyncCallback (HandleRequest), _listener);
    86122
    87                                 Log.Out ("Started Webserver on " + (webPort + 2) + " (authentication " + (authEnabled ? "enabled" : "disabled") + ")");
     123                                Log.Out ("Started Webserver on " + (webPort + 2));
    88124                        } catch (Exception e) {
    89125                                Log.Out ("Error in Web.ctor: " + e);
    … …  
    98134                                _listener.BeginGetContext (new AsyncCallback (HandleRequest), _listener);
    99135                                try {
    100                                         ctx.Response.ProtocolVersion = new Version ("1.0");
    101 
    102                                         HttpListenerBasicIdentity user = Authorize (ctx);
    103 
    104                                         if (!authEnabled || (user.Name.ToLower ().Equals ("admin") && user.Password.Equals (GamePrefs.GetString (EnumGamePrefs.ControlPanelPassword)))) {
    105                                                 if (ctx.Request.Url.AbsolutePath.Length < 2) {
    106                                                         handlers ["/index.htm"].HandleRequest (ctx.Request, ctx.Response, user);
    107                                                         return;
    108                                                 } else {
    109                                                         foreach (KeyValuePair<string, PathHandler> kvp in handlers) {
    110                                                                 if (ctx.Request.Url.AbsolutePath.StartsWith (kvp.Key)) {
    111                                                                         kvp.Value.HandleRequest (ctx.Request, ctx.Response, user);
    112                                                                         return;
     136                                        HttpListenerRequest request = ctx.Request;
     137                                        HttpListenerResponse response = ctx.Response;
     138
     139                                        response.ProtocolVersion = new Version ("1.1");
     140
     141                                        WebConnection conn;
     142                                        int permissionLevel = DoAuthentication (request, out conn);
     143
     144
     145                                        //Log.Out ("Login status: conn!=null: {0}, permissionlevel: {1}", conn != null, permissionLevel);
     146
     147
     148                                        if (conn != null) {
     149                                                Cookie cookie = new Cookie ("sid", conn.SessionID, "/");
     150                                                cookie.Expired = false;
     151                                                cookie.Expires = new DateTime (2020, 1, 1);
     152                                                cookie.HttpOnly = true;
     153                                                cookie.Secure = false;
     154                                                response.AppendCookie (cookie);
     155                                        }
     156
     157                                        if (request.Url.AbsolutePath.Length < 2) {
     158                                                handlers ["/index.htm"].HandleRequest (request, response, conn, permissionLevel);
     159                                                return;
     160                                        } else {
     161                                                foreach (KeyValuePair<string, PathHandler> kvp in handlers) {
     162                                                        if (request.Url.AbsolutePath.StartsWith (kvp.Key)) {
     163                                                                if (!kvp.Value.IsAuthorizedForHandler (conn, permissionLevel)) {
     164                                                                        response.StatusCode = (int)HttpStatusCode.Forbidden;
     165                                                                        if (conn != null) {
     166                                                                                Log.Out ("Web.HandleRequest: user '{0}' not allowed to access '{1}'", conn.SteamID, kvp.Value.ModuleName);
     167                                                                        } else {
     168                                                                                Log.Out ("Web.HandleRequest: unidentified user from '{0}' not allowed to access '{1}'", request.RemoteEndPoint.Address, kvp.Value.ModuleName);
     169                                                                        }
     170                                                                } else {
     171                                                                        kvp.Value.HandleRequest (request, response, conn, permissionLevel);
    113172                                                                }
     173                                                                return;
    114174                                                        }
    115175                                                }
    116 
    117                                                 Log.Out ("Error in Web.HandleRequest(): No handler found for path \"" + ctx.Request.Url.AbsolutePath + "\"");
    118                                                 ctx.Response.StatusCode = (int)HttpStatusCode.NotFound;
    119                                         } else {
    120                                                 ctx.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
    121                                                 ctx.Response.Headers ["WWW-Authenticate"] = "Basic realm=\"" + realm + "\"";
    122                                         }
     176                                        }
     177
     178                                        Log.Out ("Error in Web.HandleRequest(): No handler found for path \"" + request.Url.AbsolutePath + "\"");
     179                                        response.StatusCode = (int)HttpStatusCode.NotFound;
    123180                                } catch (IOException e) {
    124181                                        if (e.InnerException is SocketException) {
    … …  
    131188                                } finally {
    132189                                        if (ctx != null) {
    133                                                 ctx.Response.OutputStream.Close ();
     190                                                ctx.Response.Close ();
    134191                                        }
    135192                                        Interlocked.Decrement (ref currentHandlers);
    … …  
    138195                }
    139196
    140                 private HttpListenerBasicIdentity Authorize (HttpListenerContext ctx) {
    141                         try {
    142                                 return (HttpListenerBasicIdentity)ctx.User.Identity;
    143                         } catch (NullReferenceException) {
    144                                 return null;
    145                         }
     197                private int DoAuthentication (HttpListenerRequest _req, out WebConnection _con) {
     198                        _con = null;
     199
     200                        string sessionId = null;
     201                        if (_req.Cookies ["sid"] != null) {
     202                                sessionId = _req.Cookies ["sid"].Value;
     203                        }
     204
     205                        if (!string.IsNullOrEmpty (sessionId)) {
     206                                WebConnection con = connectionHandler.IsLoggedIn (sessionId, _req.RemoteEndPoint.Address.ToString ());
     207                                if (con != null) {
     208                                        _con = con;
     209                                        return GameManager.Instance.adminTools.GetAdminToolsClientInfo (_con.SteamID.ToString ()).PermissionLevel;
     210                                }
     211                        }
     212
     213                        if (_req.QueryString ["adminuser"] != null && _req.QueryString ["admintoken"] != null) {
     214                                WebPermissions.AdminToken admin = WebPermissions.Instance.GetWebAdmin (_req.QueryString ["adminuser"], _req.QueryString ["admintoken"]);
     215                                if (admin != null) {
     216                                        return admin.permissionLevel;
     217                                } else {
     218                                        Log.Warning ("Invalid Admintoken used from " + _req.RemoteEndPoint.ToString ());
     219                                }
     220                        }
     221
     222                        if (_req.Url.AbsolutePath.StartsWith ("/session/verify")) {
     223                                ulong id = OpenID.Validate (_req);
     224                                if (id > 0) {
     225                                        WebConnection con = connectionHandler.LogIn (id, _req.RemoteEndPoint.Address.ToString ());
     226                                        _con = con;
     227                                        //Log.Out ("Logged in with session id: {0}", con.SessionID);
     228                                        return GameManager.Instance.adminTools.GetAdminToolsClientInfo (id.ToString ()).PermissionLevel;
     229                                } else {
     230                                        Log.Out ("Steam OpenID login failed from {0}", _req.RemoteEndPoint.ToString ());
     231                                }
     232                        }
     233
     234                        return GUEST_PERMISSION_LEVEL;
    146235                }
    147236
    … …  
    156245
    157246                public void SendLine (string line) {
    158                         try {
    159                                 //Log.Out ("NOT IMPLEMENTED: Web.WriteToClient");
    160                         } catch (Exception e) {
    161                                 Log.Out ("Error in Web.WriteToClient: " + e);
    162                         }
     247                        connectionHandler.SendLine (line);
    163248                }
    164249
    165250                public void SendLog (string text, string trace, UnityEngine.LogType type) {
    166                         //throw new System.NotImplementedException ();
     251                        connectionHandler.SendLog (text, trace, type);
    167252                }
    168253

  • binary-improvements/MapRendering/WebAndMapRendering.csproj

    r238 r244  
    3838      <Private>False</Private>
    3939    </Reference>
     40    <Reference Include="System.Xml">
     41      <HintPath>..\7dtd-binaries\System.Xml.dll</HintPath>
     42      <Private>False</Private>
     43    </Reference>
    4044  </ItemGroup>
    4145  <ItemGroup>
    … …  
    4852    <Compile Include="API.cs" />
    4953    <Compile Include="Web\Web.cs" />
    50     <Compile Include="Web\PathHandler.cs" />
    51     <Compile Include="Web\StaticHandler.cs" />
    52     <Compile Include="Web\SimpleRedirectHandler.cs" />
    5354    <Compile Include="Web\MimeType.cs" />
    54     <Compile Include="Web\ApiHandler.cs" />
    5555    <Compile Include="Web\API\GetPlayersOnline.cs" />
    5656    <Compile Include="Web\API\WebAPI.cs" />
    … …  
    5959    <Compile Include="Web\API\GetLandClaims.cs" />
    6060    <Compile Include="Commands\webstat.cs" />
    61     <Compile Include="Web\ItemIconHandler.cs" />
     61    <Compile Include="Web\API\GetStats.cs" />
     62    <Compile Include="Web\WebConnection.cs" />
     63    <Compile Include="Web\OpenID.cs" />
     64    <Compile Include="Web\ConnectionHandler.cs" />
     65    <Compile Include="Web\WebPermissions.cs" />
     66    <Compile Include="Web\Handlers\ApiHandler.cs" />
     67    <Compile Include="Web\Handlers\ItemIconHandler.cs" />
     68    <Compile Include="Web\Handlers\PathHandler.cs" />
     69    <Compile Include="Web\Handlers\SimpleRedirectHandler.cs" />
     70    <Compile Include="Web\Handlers\StaticHandler.cs" />
     71    <Compile Include="Web\Handlers\SessionHandler.cs" />
     72    <Compile Include="Web\API\ExecuteConsoleCommand.cs" />
     73    <Compile Include="Commands\ReloadWebPermissions.cs" />
     74    <Compile Include="Web\Handlers\UserStatusHandler.cs" />
     75    <Compile Include="Commands\WebTokens.cs" />
     76    <Compile Include="Commands\WebPermissionsCmd.cs" />
    6277  </ItemGroup>
    6378  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
    … …  
    7186  <ItemGroup>
    7287    <Folder Include="Commands\" />
     88    <Folder Include="Web\Handlers\" />
    7389  </ItemGroup>
    7490  <ItemGroup>
Note: See TracChangeset for help on using the changeset viewer.