beagled/WebServices/ExternalAccessFilter.cs

   1 //
   2 // ExternalAccessFilter.cs
   3 //
   4 // Copyright (C) 2005 Novell, Inc.
   5 //
   6 // Authors:
   7 //   Vijay K. Nanjundaswamy (knvijay@novell.com)
   8 //
   9
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining a
  12 // copy of this software and associated documentation files (the "Software"),
  13 // to deal in the Software without restriction, including without limitation
  14 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
  15 // and/or sell copies of the Software, and to permit persons to whom the
  16 // Software is furnished to do so, subject to the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be included in
  19 // all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  22 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  23 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  24 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  25 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  26 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  27 // DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 using System;
  31 using System.IO;
  32 using System.Collections;
  33
  34 using Beagle;
  35 using Beagle.Util;
  36
  37 namespace Beagle.WebService {
  38
  39         public class ExternalAccessFilter
  40         {
  41                 ArrayList matchers;
  42                 static Logger log = Logger.Get ("ExternalAccessFilter");
  43                 string FileUriPrefix = "file://";
  44                 string HttpUriBase = "http://hostname:8888/beagle/";
  45                 string[] reserved_suffixes;
  46                 static readonly string ConfigFile = "publicfolders.cfg";
  47
  48 // Exported Folders: The leaf folder name should be unique.
  49 // This leaf name will be used for the BeagleXSP application list.
  50
  51                 public ExternalAccessFilter (string HttpUriBase, string[] reserved_suffixes)
  52                 {
  53                         this.HttpUriBase = HttpUriBase;
  54                         this.reserved_suffixes = reserved_suffixes;
  55
  56                         //Check for ~/.beagle/config/webservices.xml configuration:
  57                         ArrayList publicFolders = Conf.WebServices.PublicFolders;
  58
  59                         if ((publicFolders != null) && (publicFolders.Count > 0)) {
  60
  61                                 SetupFilters(publicFolders);
  62
  63                                 if (File.Exists (Path.Combine (PathFinder.StorageDir, ConfigFile)))
  64                                 {
  65                                         log.Warn("ExternalAccessFilter: Detected deprecated configuration file for PublicFolders !");
  66                                         log.Info("ExternalAccessFilter: Remove '~/.beagle/publicfolders.cfg' file.\n Use 'beagle-settings' or 'beagle-config' instead to setup public folders.");
  67                                 }
  68                                 return;
  69                         }
  70
  71                 publicFolders = new ArrayList();
  72 /*
  73                         //Fallback to ~/.beagle/publicfolders.cfg
  74                         if (File.Exists (Path.Combine (PathFinder.StorageDir, ConfigFile))) {
  75
  76                 StreamReader reader = new StreamReader(
  77                                         Path.Combine (PathFinder.StorageDir, ConfigFile));
  78
  79                 string entry;
  80                 while ( ((entry = reader.ReadLine ()) != null) && (entry.Trim().Length > 1)) {
  81                         if (entry[0] != '#')
  82                                                 publicFolders.Add(entry);
  83                 }
  84             }
  85 */
  86                 SetupFilters(publicFolders);
  87                 }
  88
  89 /*
  90                 public void ReplaceAccessFilter(ArrayList newlist)
  91                 {
  92                         bool fa = SetupFilters(newlist);
  93
  94                         if (usingPublicFoldersDotCfgFile && fa) {
  95                                 usingPublicFoldersDotCfgFile = false;
  96                                 log.Warn("ExternalAccessFilter: Duplicate configuration of PublicFolders in '~/.beagle/publicfolders.cfg' and '~/.beagle/config/webservices.xml' !");
  97                                 log.Info("ExternalAccessFilter: Remove '~/.beagle/publicfolders.cfg' file. Use 'beagle-config' instead to setup public folders.");
  98                                 log.Info("ExternalAccessFilter: Replacing PublicFoldersList with new list from \"webservices.xml\"");
  99                         }
 100
 101                         //Initialize();
 102                 }
 103 */
 104                 public ArrayList Matchers {
 105
 106                         get { return matchers; }
 107                 }
 108
 109                 public void Initialize() {
 110
 111                         foreach (SimpleMatcher sm in matchers)
 112                                 if (! sm.Match.StartsWith(FileUriPrefix)) {
 113                                         sm.Match = FileUriPrefix + sm.Match + "/";
 114                                         sm.Rewrite = HttpUriBase + sm.Rewrite + "/";
 115
 116                                         Logger.Log.Debug("ExternalAccessFilter: Adding Match: " + sm.Match + "," + sm.Rewrite);
 117                                 }
 118                 }
 119
 120                 private bool SetupFilters(ArrayList folders)
 121                 {
 122                         bool filterAdded = false;
 123                         matchers = new ArrayList();
 124                         ArrayList suffixes = new ArrayList();
 125
 126                         //Populate reserved suffixes
 127                         suffixes.AddRange(reserved_suffixes);
 128
 129                         //Check if 'public' folder exists and setup default mapping for it:
 130                         if (Directory.Exists(PathFinder.HomeDir + "/public"))
 131                         {
 132                                 SimpleMatcher defaultMatcher = new SimpleMatcher();
 133
 134                                 //file:///home/userid/public/
 135                                 defaultMatcher.Match = PathFinder.HomeDir + "/public";
 136                                 //http://hostname:8888/beagle/public/
 137                                 defaultMatcher.Rewrite = "public";
 138
 139                                 matchers.Add(defaultMatcher);
 140                                 suffixes.Add("public");
 141                         }
 142
 143             //string[] folders = entry.Split (',');
 144             foreach (string d in folders) {
 145
 146                 //Each entry must start with ~/
 147                 if ((d.Trim().Length > 1) &&
 148                                 (d.StartsWith("~/") || (d.StartsWith(PathFinder.HomeDir + "/"))) ) {
 149                         string d2;
 150                         if (d.StartsWith("~/"))
 151                                 d2 = d.Replace("~/", PathFinder.HomeDir + "/");
 152                         else
 153                                 d2 = d;
 154
 155                         if (!Directory.Exists(d2))
 156                                                 continue;
 157
 158                         string[] comp = d2.Split('/');
 159                         string leaf;
 160                         if (comp.Length > 1)
 161                                 for (int li = comp.Length; li > 0; --li) {
 162                                         if ((leaf = comp[li - 1].Trim()).Length > 0) {
 163                                                 //Check the leaf component is unique
 164                                                 if (suffixes.Contains(leaf))
 165                                                 {
 166                                                         Logger.Log.Warn("ExternalAccessFilter: Ignoring entry {0}. Reason: Entry suffix not unique", d);
 167                                                         break;
 168                                                 }
 169                                                 else
 170                                                         suffixes.Add(leaf);
 171
 172                                                                 filterAdded = true;
 173                                                                 SimpleMatcher matcher = new SimpleMatcher ();
 174
 175                                                                 matcher.Match = d2;
 176                                                                 matcher.Rewrite = leaf;
 177                                                                 matchers.Add (matcher);
 178                                                                 break;
 179                                         }
 180                                         }
 181                 } //end if
 182             } //end foreach
 183                         return filterAdded;
 184                 }
 185
 186                 //Returns: false, if Hit does not match any filter
 187                 //                 true,  if Hit URI is part of any specified filter
 188                 public bool FilterHit (Hit hit)
 189                 {
 190                         if ((hit == null) || (matchers.Count == 0))
 191                                 return false;
 192
 193                         string uri = hit.UriAsString;
 194                         foreach (SimpleMatcher matcher in matchers)
 195                         {
 196                                 if (uri.IndexOf (matcher.Match) == -1)
 197                                         continue;
 198
 199                                 return hit.IsFile;   //return true;
 200                         }
 201
 202                         return false;
 203                 }
 204
 205                 //Returns: null, if Hit does not match any filter
 206                 //                 Uri,  after Translation
 207                 public string TranslateHit (Hit hit)
 208                 {
 209                         if ((hit == null) || (matchers.Count == 0))
 210                                 return null;
 211
 212                         string uri = hit.UriAsString;
 213                         string newuri = null;
 214
 215                         foreach (SimpleMatcher matcher in matchers)
 216                         {
 217                                 if (uri.IndexOf (matcher.Match) == -1)
 218                                         continue;
 219
 220                                 newuri = uri.Replace (matcher.Match, matcher.Rewrite);
 221                                 //Console.WriteLine("TranslateHit: " + newuri);
 222
 223                                 return newuri;
 224                         }
 225
 226                         return null;    //Hit does not match any specified filter
 227                 }
 228         }
 229
 230         public class SimpleMatcher
 231         {
 232                 public string Match;
 233                 public string Rewrite;
 234         }
 235 }