1 //======================================================================== 2 //$Id: RewriteHandler.java 1918 2010-10-06 18:48:08Z jesse $ 3 //Copyright 2004-2005 Mort Bay Consulting Pty. Ltd. 4 //------------------------------------------------------------------------ 5 //Licensed under the Apache License, Version 2.0 (the "License"); 6 //you may not use this file except in compliance with the License. 7 //You may obtain a copy of the License at 8 //http://www.apache.org/licenses/LICENSE-2.0 9 //Unless required by applicable law or agreed to in writing, software 10 //distributed under the License is distributed on an "AS IS" BASIS, 11 //WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 //See the License for the specific language governing permissions and 13 //limitations under the License. 14 //======================================================================== 15 package org.mortbay.jetty.handler.rewrite; 16 17 import java.io.IOException; 18 19 import javax.servlet.ServletException; 20 import javax.servlet.http.HttpServletRequest; 21 import javax.servlet.http.HttpServletResponse; 22 23 import org.mortbay.jetty.HttpConnection; 24 import org.mortbay.jetty.Request; 25 import org.mortbay.jetty.handler.HandlerWrapper; 26 import org.mortbay.jetty.servlet.PathMap; 27 import org.mortbay.log.Log; 28 import org.mortbay.util.LazyList; 29 30 /* ------------------------------------------------------------ */ 31 /** 32 *<p> The RewriteHandler is responsible for managing a list of rules to be applied to requests. 33 * Its capabilities are not only limited to url rewrites such as RewritePatternRule or RewriteRegexRule; 34 * there is also handling for cookies, headers, redirection, setting status or error codes 35 * whenever the rule finds a match. 36 * 37 * <p> The rules can be matched by the ff. options: pattern matching of PathMap 38 * (class PatternRule), regular expressions (class RegexRule) or certain conditions set 39 * (e.g. MsieSslRule - the requests must be in SSL mode). 40 * 41 * Here are the list of rules: 42 * <ul> 43 * <li> CookiePatternRule - adds a new cookie in response. </li> 44 * <li> HeaderPatternRule - adds/modifies the HTTP headers in response. </li> 45 * <li> RedirectPatternRule - sets the redirect location. </li> 46 * <li> ResponsePatternRule - sets the status/error codes. </li> 47 * <li> RewritePatternRule - rewrites the requested URI. </li> 48 * <li> RewriteRegexRule - rewrites the requested URI using regular expression for pattern matching. </li> 49 * <li> MsieSslRule - disables the keep alive on SSL for IE5 and IE6. </li> 50 * <li> LegacyRule - the old version of rewrite. </li> 51 * <li> ForwardedSchemeHeaderRule - set the scheme according to the headers present. </li> 52 * </ul> 53 * 54 * <p> The rules can be grouped into rule containers (class RuleContainerRule), and will only 55 * be applied if the request matches the conditions for their container 56 * (e.g., by virtual host name) 57 * 58 * Here are a list of rule containers: 59 * <ul> 60 * <li> VirtualHostRuleContainer - checks whether the request matches one of a set of virtual host names.</li> 61 * <li> LowThreadsRuleContainer - checks whether the threadpool is low on threads</li> 62 * </ul> 63 * 64 */ 65 public class RewriteHandler extends HandlerWrapper 66 { 67 68 private RuleContainer _rules; 69 70 /* ------------------------------------------------------------ */ 71 public RewriteHandler() 72 { 73 _rules = new RuleContainer(); 74 } 75 76 /* ------------------------------------------------------------ */ 77 /** 78 * To enable configuration from jetty.xml on rewriteRequestURI, rewritePathInfo and 79 * originalPathAttribute 80 * 81 * @param legacyRule old style rewrite rule 82 */ 83 public void setLegacyRule(LegacyRule legacyRule) 84 { 85 _rules.setLegacyRule(legacyRule); 86 } 87 88 /* ------------------------------------------------------------ */ 89 /** 90 * Returns the list of rules. 91 * @return an array of {@link Rule}. 92 */ 93 public Rule[] getRules() 94 { 95 return _rules.getRules(); 96 } 97 98 /* ------------------------------------------------------------ */ 99 /** 100 * Assigns the rules to process. 101 * @param rules an array of {@link Rule}. 102 */ 103 public void setRules(Rule[] rules) 104 { 105 _rules.setRules(rules); 106 } 107 108 /*------------------------------------------------------------ */ 109 /** 110 * Assigns the rules to process. 111 * @param rules a {@link RuleContainer} containing other rules to process 112 */ 113 public void setRules(RuleContainer rules) 114 { 115 _rules = rules; 116 } 117 118 /* ------------------------------------------------------------ */ 119 /** 120 * Add a Rule 121 * @param rule The rule to add to the end of the rules array 122 */ 123 public void addRule(Rule rule) 124 { 125 _rules.addRule(rule); 126 } 127 128 129 /* ------------------------------------------------------------ */ 130 /** 131 * @return the rewriteRequestURI If true, this handler will rewrite the value 132 * returned by {@link HttpServletRequest#getRequestURI()}. 133 */ 134 public boolean isRewriteRequestURI() 135 { 136 return _rules.isRewriteRequestURI(); 137 } 138 139 /* ------------------------------------------------------------ */ 140 /** 141 * @param rewriteRequestURI true if this handler will rewrite the value 142 * returned by {@link HttpServletRequest#getRequestURI()}. 143 */ 144 public void setRewriteRequestURI(boolean rewriteRequestURI) 145 { 146 _rules.setRewriteRequestURI(rewriteRequestURI); 147 } 148 149 /* ------------------------------------------------------------ */ 150 /** 151 * @return true if this handler will rewrite the value 152 * returned by {@link HttpServletRequest#getPathInfo()}. 153 */ 154 public boolean isRewritePathInfo() 155 { 156 return _rules.isRewritePathInfo(); 157 } 158 159 /* ------------------------------------------------------------ */ 160 /** 161 * @param rewritePathInfo true if this handler will rewrite the value 162 * returned by {@link HttpServletRequest#getPathInfo()}. 163 */ 164 public void setRewritePathInfo(boolean rewritePathInfo) 165 { 166 _rules.setRewritePathInfo(rewritePathInfo); 167 } 168 169 /* ------------------------------------------------------------ */ 170 /** 171 * @return the originalPathAttribute. If non null, this string will be used 172 * as the attribute name to store the original request path. 173 */ 174 public String getOriginalPathAttribute() 175 { 176 return _rules.getOriginalPathAttribute(); 177 } 178 179 /* ------------------------------------------------------------ */ 180 /** 181 * @param originalPathAttribute If non null, this string will be used 182 * as the attribute name to store the original request path. 183 */ 184 public void setOriginalPathAttribute(String originalPathAttribute) 185 { 186 _rules.setOriginalPathAttribute(originalPathAttribute); 187 } 188 189 190 /* ------------------------------------------------------------ */ 191 /** 192 * @deprecated 193 */ 194 public PathMap getRewrite() 195 { 196 return _rules.getRewrite(); 197 } 198 199 /* ------------------------------------------------------------ */ 200 /** 201 * @deprecated 202 */ 203 public void setRewrite(PathMap rewrite) 204 { 205 _rules.setRewrite(rewrite); 206 } 207 208 /* ------------------------------------------------------------ */ 209 /** 210 * @deprecated 211 */ 212 public void addRewriteRule(String pattern, String prefix) 213 { 214 _rules.addRewriteRule(pattern,prefix); 215 } 216 217 /* ------------------------------------------------------------ */ 218 /* (non-Javadoc) 219 * @see org.mortbay.jetty.handler.HandlerWrapper#handle(java.lang.String, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, int) 220 */ 221 public void handle(String target, HttpServletRequest request, HttpServletResponse response, int dispatch) throws IOException, ServletException 222 { 223 if (isStarted()) 224 { 225 String returned = _rules.matchAndApply(target, request, response); 226 target = (returned == null) ? target : returned; 227 228 Request baseRequest = (request instanceof Request?(Request)request:HttpConnection.getCurrentConnection().getRequest()); 229 230 if (!baseRequest.isHandled()) 231 { 232 super.handle(target, request, response, dispatch); 233 } 234 } 235 } 236 237 }