Java > Open Source Codes > org > apache > tomcat > util > http > mapper > Mapper


1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements. See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License. You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 package org.apache.tomcat.util.http.mapper;
19
20 import javax.naming.NamingException ;
21 import javax.naming.directory.DirContext ;
22
23 import org.apache.tomcat.util.buf.CharChunk;
24 import org.apache.tomcat.util.buf.MessageBytes;
25 import org.apache.tomcat.util.buf.Ascii;
26 import java.util.List ;
27 import java.util.ArrayList ;
28
29 /**
30  * Mapper, which implements the servlet API mapping rules (which are derived
31  * from the HTTP rules).
32  *
33  * @author Remy Maucherat
34  */
35 public final class Mapper {
36
37
38     private static org.apache.commons.logging.Log logger =
39         org.apache.commons.logging.LogFactory.getLog(Mapper.class);
40     // ----------------------------------------------------- Instance Variables
41
42
43     /**
44      * Array containing the virtual hosts definitions.
45      */
46     protected Host[] hosts = new Host[0];
47
48
49     /**
50      * Default host name.
51      */
52     protected String defaultHostName = null;
53
54     /**
55      * Context associated with this wrapper, used for wrapper mapping.
56      */
57     protected Context context = new Context ();
58
59
60     // --------------------------------------------------------- Public Methods
61
62
63     /**
64      * Get default host.
65      *
66      * @return Default host name
67      */
68     public String getDefaultHostName() {
69         return defaultHostName;
70     }
71
72
73     /**
74      * Set default host.
75      *
76      * @param defaultHostName Default host name
77      */
78     public void setDefaultHostName(String defaultHostName) {
79         this.defaultHostName = defaultHostName;
80     }
81
82     /**
83      * Add a new host to the mapper.
84      *
85      * @param name Virtual host name
86      * @param host Host object
87      */
88     public synchronized void addHost(String name, String [] aliases,
89                                      Object host) {
90         Host[] newHosts = new Host[hosts.length + 1];
91         Host newHost = new Host();
92         ContextList contextList = new ContextList();
93         newHost.name = name;
94         newHost.contextList = contextList;
95         newHost.object = host;
96         if (insertMap(hosts, newHosts, newHost)) {
97             hosts = newHosts;
98         }
99         for (int i = 0; i < aliases.length; i++) {
100             newHosts = new Host[hosts.length + 1];
101             newHost = new Host();
102             newHost.name = aliases[i];
103             newHost.contextList = contextList;
104             newHost.object = host;
105             if (insertMap(hosts, newHosts, newHost)) {
106                 hosts = newHosts;
107             }
108         }
109     }
110
111
112     /**
113      * Remove a host from the mapper.
114      *
115      * @param name Virtual host name
116      */
117     public synchronized void removeHost(String name) {
118         // Find and remove the old host
119 int pos = find(hosts, name);
120         if (pos < 0) {
121             return;
122         }
123         Object host = hosts[pos].object;
124         Host[] newHosts = new Host[hosts.length - 1];
125         if (removeMap(hosts, newHosts, name)) {
126             hosts = newHosts;
127         }
128         // Remove all aliases (they will map to the same host object)
129 for (int i = 0; i < newHosts.length; i++) {
130             if (newHosts[i].object == host) {
131                 Host[] newHosts2 = new Host[hosts.length - 1];
132                 if (removeMap(hosts, newHosts2, newHosts[i].name)) {
133                     hosts = newHosts2;
134                 }
135             }
136         }
137     }
138
139     public String [] getHosts() {
140         String hostN[] = new String [hosts.length];
141         for( int i = 0; i < hosts.length; i++ ) {
142             hostN[i] = hosts[i].name;
143         }
144         return hostN;
145     }
146
147
148     /**
149      * Set context, used for wrapper mapping (request dispatcher).
150      *
151      * @param welcomeResources Welcome files defined for this context
152      * @param resources Static resources of the context
153      */
154     public void setContext(String path, String [] welcomeResources,
155                            javax.naming.Context resources) {
156         context.name = path;
157         context.welcomeResources = welcomeResources;
158         context.resources = resources;
159     }
160
161
162     /**
163      * Add a new Context to an existing Host.
164      *
165      * @param hostName Virtual host name this context belongs to
166      * @param path Context path
167      * @param context Context object
168      * @param welcomeResources Welcome files defined for this context
169      * @param resources Static resources of the context
170      */
171     public void addContext
172         (String hostName, String path, Object context,
173          String [] welcomeResources, javax.naming.Context resources) {
174
175         Host[] hosts = this.hosts;
176         int pos = find(hosts, hostName);
177         if( pos <0 ) {
178             addHost(hostName, new String [0], "");
179             hosts = this.hosts;
180             pos = find(hosts, hostName);
181         }
182         if (pos < 0) {
183             logger.error("No host found: " + hostName);
184         }
185         Host host = hosts[pos];
186         if (host.name.equals(hostName)) {
187             int slashCount = slashCount(path);
188             synchronized (host) {
189                 Context [] contexts = host.contextList.contexts;
190                 // Update nesting
191 if (slashCount > host.contextList.nesting) {
192                     host.contextList.nesting = slashCount;
193                 }
194                 Context [] newContexts = new Context [contexts.length + 1];
195                 Context newContext = new Context ();
196                 newContext.name = path;
197                 newContext.object = context;
198                 newContext.welcomeResources = welcomeResources;
199                 newContext.resources = resources;
200                 if (insertMap(contexts, newContexts, newContext)) {
201                     host.contextList.contexts = newContexts;
202                 }
203             }
204         }
205
206     }
207
208
209     /**
210      * Remove a context from an existing host.
211      *
212      * @param hostName Virtual host name this context belongs to
213      * @param path Context path
214      */
215     public void removeContext(String hostName, String path) {
216         Host[] hosts = this.hosts;
217         int pos = find(hosts, hostName);
218         if (pos < 0) {
219             return;
220         }
221         Host host = hosts[pos];
222         if (host.name.equals(hostName)) {
223             synchronized (host) {
224                 Context [] contexts = host.contextList.contexts;
225                 if( contexts.length == 0 ){
226                     return;
227                 }
228                 Context [] newContexts = new Context [contexts.length - 1];
229                 if (removeMap(contexts, newContexts, path)) {
230                     host.contextList.contexts = newContexts;
231                     // Recalculate nesting
232 host.contextList.nesting = 0;
233                     for (int i = 0; i < newContexts.length; i++) {
234                         int slashCount = slashCount(newContexts[i].name);
235                         if (slashCount > host.contextList.nesting) {
236                             host.contextList.nesting = slashCount;
237                         }
238                     }
239                 }
240             }
241         }
242     }
243
244
245     /**
246      * Return all contexts, in //HOST/PATH form
247      *
248      * @return The context names
249      */
250     public String [] getContextNames() {
251         List list=new ArrayList ();
252         for( int i=0; i<hosts.length; i++ ) {
253             for( int j=0; j<hosts[i].contextList.contexts.length; j++ ) {
254                 String cname=hosts[i].contextList.contexts[j].name;
255                 list.add("//" + hosts[i].name +
256                         (cname.startsWith("/") ? cname : "/"));
257             }
258         }
259         String res[] = new String [list.size()];
260         return (String [])list.toArray(res);
261     }
262
263
264     /**
265      * Add a new Wrapper to an existing Context.
266      *
267      * @param hostName Virtual host name this wrapper belongs to
268      * @param contextPath Context path this wrapper belongs to
269      * @param path Wrapper mapping
270      * @param wrapper Wrapper object
271      */
272     public void addWrapper(String hostName, String contextPath, String path,
273                            Object wrapper) {
274         addWrapper(hostName, contextPath, path, wrapper, false);
275     }
276
277
278     public void addWrapper(String hostName, String contextPath, String path,
279                            Object wrapper, boolean jspWildCard) {
280         Host[] hosts = this.hosts;
281         int pos = find(hosts, hostName);
282         if (pos < 0) {
283             return;
284         }
285         Host host = hosts[pos];
286         if (host.name.equals(hostName)) {
287             Context [] contexts = host.contextList.contexts;
288             int pos2 = find(contexts, contextPath);
289             if( pos2<0 ) {
290                 logger.error("No context found: " + contextPath );
291                 return;
292             }
293             Context context = contexts[pos2];
294             if (context.name.equals(contextPath)) {
295                 addWrapper(context, path, wrapper, jspWildCard);
296             }
297         }
298     }
299
300
301     /**
302      * Add a wrapper to the context associated with this wrapper.
303      *
304      * @param path Wrapper mapping
305      * @param wrapper The Wrapper object
306      */
307     public void addWrapper(String path, Object wrapper) {
308         addWrapper(context, path, wrapper);
309     }
310
311
312     public void addWrapper(String path, Object wrapper, boolean jspWildCard) {
313         addWrapper(context, path, wrapper, jspWildCard);
314     }
315
316
317     protected void addWrapper(Context context, String path, Object wrapper) {
318         addWrapper(context, path, wrapper, false);
319     }
320
321
322     /**
323      * Adds a wrapper to the given context.
324      *
325      * @param context The context to which to add the wrapper
326      * @param path Wrapper mapping
327      * @param wrapper The Wrapper object
328      * @param jspWildCard true if the wrapper corresponds to the JspServlet
329      * and the mapping path contains a wildcard; false otherwise
330      */
331     protected void addWrapper(Context context, String path, Object wrapper,
332                               boolean jspWildCard) {
333
334         synchronized (context) {
335             Wrapper newWrapper = new Wrapper();
336             newWrapper.object = wrapper;
337             newWrapper.jspWildCard = jspWildCard;
338             if (path.endsWith("/*")) {
339                 // Wildcard wrapper
340 newWrapper.name = path.substring(0, path.length() - 2);
341                 Wrapper[] oldWrappers = context.wildcardWrappers;
342                 Wrapper[] newWrappers =
343                     new Wrapper[oldWrappers.length + 1];
344                 if (insertMap(oldWrappers, newWrappers, newWrapper)) {
345                     context.wildcardWrappers = newWrappers;
346                     int slashCount = slashCount(newWrapper.name);
347                     if (slashCount > context.nesting) {
348                         context.nesting = slashCount;
349                     }
350                 }
351             } else if (path.startsWith("*.")) {
352                 // Extension wrapper
353 newWrapper.name = path.substring(2);
354                 Wrapper[] oldWrappers = context.extensionWrappers;
355                 Wrapper[] newWrappers =
356                     new Wrapper[oldWrappers.length + 1];
357                 if (insertMap(oldWrappers, newWrappers, newWrapper)) {
358                     context.extensionWrappers = newWrappers;
359                 }
360             } else if (path.equals("/")) {
361                 // Default wrapper
362 newWrapper.name = "";
363                 context.defaultWrapper = newWrapper;
364             } else {
365                 // Exact wrapper
366 newWrapper.name = path;
367                 Wrapper[] oldWrappers = context.exactWrappers;
368                 Wrapper[] newWrappers =
369                     new Wrapper[oldWrappers.length + 1];
370                 if (insertMap(oldWrappers, newWrappers, newWrapper)) {
371                     context.exactWrappers = newWrappers;
372                 }
373             }
374         }
375     }
376
377
378     /**
379      * Remove a wrapper from the context associated with this wrapper.
380      *
381      * @param path Wrapper mapping
382      */
383     public void removeWrapper(String path) {
384         removeWrapper(context, path);
385     }
386
387
388     /**
389      * Remove a wrapper from an existing context.
390      *
391      * @param hostName Virtual host name this wrapper belongs to
392      * @param contextPath Context path this wrapper belongs to
393      * @param path Wrapper mapping
394      */
395     public void removeWrapper
396         (String hostName, String contextPath, String path) {
397         Host[] hosts = this.hosts;
398         int pos = find(hosts, hostName);
399         if (pos < 0) {
400             return;
401         }
402         Host host = hosts[pos];
403         if (host.name.equals(hostName)) {
404             Context [] contexts = host.contextList.contexts;
405             int pos2 = find(contexts, contextPath);
406             if (pos2 < 0) {
407                 return;
408             }
409             Context context = contexts[pos2];
410             if (context.name.equals(contextPath)) {
411                 removeWrapper(context, path);
412             }
413         }
414     }
415
416     protected void removeWrapper(Context context, String path) {
417         synchronized (context) {
418             if (path.endsWith("/*")) {
419                 // Wildcard wrapper
420 String name = path.substring(0, path.length() - 2);
421                 Wrapper[] oldWrappers = context.wildcardWrappers;
422                 Wrapper[] newWrappers =
423                     new Wrapper[oldWrappers.length - 1];
424                 if (removeMap(oldWrappers, newWrappers, name)) {
425                     // Recalculate nesting
426 context.nesting = 0;
427                     for (int i = 0; i < newWrappers.length; i++) {
428                         int slashCount = slashCount(newWrappers[i].name);
429                         if (slashCount > context.nesting) {
430                             context.nesting = slashCount;
431                         }
432                     }
433                     context.wildcardWrappers = newWrappers;
434                 }
435             } else if (path.startsWith("*.")) {
436                 // Extension wrapper
437 String name = path.substring(2);
438                 Wrapper[] oldWrappers = context.extensionWrappers;
439                 Wrapper[] newWrappers =
440                     new Wrapper[oldWrappers.length - 1];
441                 if (removeMap(oldWrappers, newWrappers, name)) {
442                     context.extensionWrappers = newWrappers;
443                 }
444             } else if (path.equals("/")) {
445                 // Default wrapper
446 context.defaultWrapper = null;
447             } else {
448                 // Exact wrapper
449 String name = path;
450                 Wrapper[] oldWrappers = context.exactWrappers;
451                 Wrapper[] newWrappers =
452                     new Wrapper[oldWrappers.length - 1];
453                 if (removeMap(oldWrappers, newWrappers, name)) {
454                     context.exactWrappers = newWrappers;
455                 }
456             }
457         }
458     }
459
460     public String getWrappersString( String host, String context ) {
461         String names[]=getWrapperNames(host, context);
462         StringBuffer sb=new StringBuffer ();
463         for( int i=0; i<names.length; i++ ) {
464             sb.append(names[i]).append(":");
465         }
466         return sb.toString();
467     }
468
469     public String [] getWrapperNames( String host, String context ) {
470         List list=new ArrayList ();
471         if( host==null ) host="";
472         if( context==null ) context="";
473         for( int i=0; i<hosts.length; i++ ) {
474             if( ! host.equals( hosts[i].name ))
475                 continue;
476             for( int j=0; j<hosts[i].contextList.contexts.length; j++ ) {
477                 if( ! context.equals( hosts[i].contextList.contexts[j].name))
478                     continue;
479                 // found the context
480 Context ctx=hosts[i].contextList.contexts[j];
481                 list.add( ctx.defaultWrapper.path);
482                 for( int k=0; k<ctx.exactWrappers.length; k++ ) {
483                     list.add( ctx.exactWrappers[k].path);
484                 }
485                 for( int k=0; k<ctx.wildcardWrappers.length; k++ ) {
486                     list.add( ctx.wildcardWrappers[k].path + "*");
487                 }
488                 for( int k=0; k<ctx.extensionWrappers.length; k++ ) {
489                     list.add( "*." + ctx.extensionWrappers[k].path);
490                 }
491             }
492         }
493         String res[]=new String [list.size()];
494         return (String [])list.toArray(res);
495     }
496
497
498
499     /**
500      * Map the specified host name and URI, mutating the given mapping data.
501      *
502      * @param host Virtual host name
503      * @param uri URI
504      * @param mappingData This structure will contain the result of the mapping
505      * operation
506      */
507     public void map(MessageBytes host, MessageBytes uri,
508                     MappingData mappingData)
509         throws Exception {
510
511         if (host.isNull()) {
512             host.getCharChunk().append(defaultHostName);
513         }
514         host.toChars();
515         uri.toChars();
516         internalMap(host.getCharChunk(), uri.getCharChunk(), mappingData);
517
518     }
519
520
521     /**
522      * Map the specified URI relative to the context,
523      * mutating the given mapping data.
524      *
525      * @param uri URI
526      * @param mappingData This structure will contain the result of the mapping
527      * operation
528      */
529     public void map(MessageBytes uri, MappingData mappingData)
530         throws Exception {
531
532         uri.toChars();
533         CharChunk uricc = uri.getCharChunk();
534         uricc.setLimit(-1);
535         internalMapWrapper(context, uricc, mappingData);
536
537     }
538
539
540     // -------------------------------------------------------- Private Methods
541
542
543     /**
544      * Map the specified URI.
545      */
546     private final void internalMap(CharChunk host, CharChunk uri,
547                                    MappingData mappingData)
548         throws Exception {
549
550         uri.setLimit(-1);
551
552         Context [] contexts = null;
553         Context context = null;
554         int nesting = 0;
555
556         // Virtual host mapping
557 if (mappingData.host == null) {
558             Host[] hosts = this.hosts;
559             int pos = findIgnoreCase(hosts, host);
560             if ((pos != -1) && (host.equalsIgnoreCase(hosts[pos].name))) {
561                 mappingData.host = hosts[pos].object;
562                 contexts = hosts[pos].contextList.contexts;
563                 nesting = hosts[pos].contextList.nesting;
564             } else {
565                 if (defaultHostName == null) {
566                     return;
567                 }
568                 pos = find(hosts, defaultHostName);
569                 if ((pos != -1) && (defaultHostName.equals(hosts[pos].name))) {
570                     mappingData.host = hosts[pos].object;
571                     contexts = hosts[pos].contextList.contexts;
572                     nesting = hosts[pos].contextList.nesting;
573                 } else {
574                     return;
575                 }
576             }
577         }
578
579         // Context mapping
580 if (mappingData.context == null) {
581             int pos = find(contexts, uri);
582             if (pos == -1) {
583                 return;
584             }
585
586             int lastSlash = -1;
587             int uriEnd = uri.getEnd();
588             int length = -1;
589             boolean found = false;
590             while (pos >= 0) {
591                 if (uri.startsWith(contexts[pos].name)) {
592                     length = contexts[pos].name.length();
593                     if (uri.getLength() == length) {
594                         found = true;
595                         break;
596                     } else if (uri.startsWithIgnoreCase("/", length)) {
597                         found = true;
598                         break;
599                     }
600                 }
601                 if (lastSlash == -1) {
602                     lastSlash = nthSlash(uri, nesting + 1);
603                 } else {
604                     lastSlash = lastSlash(uri);
605                 }
606                 uri.setEnd(lastSlash);
607                 pos = find(contexts, uri);
608             }
609             uri.setEnd(uriEnd);
610
611             if (!found) {
612                 if (contexts[0].name.equals("")) {
613                     context = contexts[0];
614                 }
615             } else {
616                 context = contexts[pos];
617             }
618             if (context != null) {
619                 mappingData.context = context.object;
620                 mappingData.contextPath.setString(context.name);
621             }
622         }
623
624         // Wrapper mapping
625 if ((context != null) && (mappingData.wrapper == null)) {
626             internalMapWrapper(context, uri, mappingData);
627         }
628
629     }
630
631
632     /**
633      * Wrapper mapping.
634      */
635     private final void internalMapWrapper(Context context, CharChunk path,
636                                           MappingData mappingData)
637         throws Exception {
638
639         int pathOffset = path.getOffset();
640         int pathEnd = path.getEnd();
641         int servletPath = pathOffset;
642         boolean noServletPath = false;
643
644         int length = context.name.length();
645         if (length != (pathEnd - pathOffset)) {
646             servletPath = pathOffset + length;
647         } else {
648             noServletPath = true;
649             path.append('/');
650             pathOffset = path.getOffset();
651             pathEnd = path.getEnd();
652             servletPath = pathOffset+length;
653         }
654
655         path.setOffset(servletPath);
656
657         // Rule 1 -- Exact Match
658 Wrapper[] exactWrappers = context.exactWrappers;
659         internalMapExactWrapper(exactWrappers, path, mappingData);
660
661         // Rule 2 -- Prefix Match
662 boolean checkJspWelcomeFiles = false;
663         Wrapper[] wildcardWrappers = context.wildcardWrappers;
664         if (mappingData.wrapper == null) {
665             internalMapWildcardWrapper(wildcardWrappers, context.nesting,
666                                        path, mappingData);
667             if (mappingData.wrapper != null && mappingData.jspWildCard) {
668                 char[] buf = path.getBuffer();
669                 if (buf[pathEnd - 1] == '/') {
670                     /*
671                      * Path ending in '/' was mapped to JSP servlet based on
672                      * wildcard match (e.g., as specified in url-pattern of a
673                      * jsp-property-group.
674                      * Force the context's welcome files, which are interpreted
675                      * as JSP files (since they match the url-pattern), to be
676                      * considered. See Bugzilla 27664.
677                      */
678                     mappingData.wrapper = null;
679                     checkJspWelcomeFiles = true;
680                 } else {
681                     // See Bugzilla 27704
682 mappingData.wrapperPath.setChars(buf, path.getStart(),
683                                                      path.getLength());
684                     mappingData.pathInfo.recycle();
685                 }
686             }
687         }
688
689         if(mappingData.wrapper == null && noServletPath) {
690             // The path is empty, redirect to "/"
691 mappingData.redirectPath.setChars
692                 (path.getBuffer(), pathOffset, pathEnd);
693             path.setEnd(pathEnd - 1);
694             return;
695         }
696
697         // Rule 3 -- Extension Match
698 Wrapper[] extensionWrappers = context.extensionWrappers;
699         if (mappingData.wrapper == null && !checkJspWelcomeFiles) {
700             internalMapExtensionWrapper(extensionWrappers, path, mappingData);
701         }
702
703         // Rule 4 -- Welcome resources processing for servlets
704 if (mappingData.wrapper == null) {
705             boolean checkWelcomeFiles = checkJspWelcomeFiles;
706             if (!checkWelcomeFiles) {
707                 char[] buf = path.getBuffer();
708                 checkWelcomeFiles = (buf[pathEnd - 1] == '/');
709             }
710             if (checkWelcomeFiles) {
711                 for (int i = 0; (i < context.welcomeResources.length)
712                          && (mappingData.wrapper == null); i++) {
713                     path.setOffset(pathOffset);
714                     path.setEnd(pathEnd);
715                     path.append(context.welcomeResources[i], 0,
716                                 context.welcomeResources[i].length());
717                     path.setOffset(servletPath);
718
719                     // Rule 4a -- Welcome resources processing for exact macth
720 internalMapExactWrapper(exactWrappers, path, mappingData);
721
722                     // Rule 4b -- Welcome resources processing for prefix match
723 if (mappingData.wrapper == null) {
724                         internalMapWildcardWrapper
725                             (wildcardWrappers, context.nesting,
726                              path, mappingData);
727                     }
728
729                     // Rule 4c -- Welcome resources processing
730 // for physical folder
731 if (mappingData.wrapper == null
732                         && context.resources != null) {
733                         Object file = null;
734                         String pathStr = path.toString();
735                         try {
736                             file = context.resources.lookup(pathStr);
737                         } catch(NamingException nex) {
738                             // Swallow not found, since this is normal
739 }
740                         if (file != null && !(file instanceof DirContext ) ) {
741                             internalMapExtensionWrapper(extensionWrappers,
742                                                         path, mappingData);
743                             if (mappingData.wrapper == null
744                                 && context.defaultWrapper != null) {
745                                 mappingData.wrapper =
746                                     context.defaultWrapper.object;
747                                 mappingData.requestPath.setChars
748                                     (path.getBuffer(), path.getStart(),
749                                      path.getLength());
750                                 mappingData.wrapperPath.setChars
751                                     (path.getBuffer(), path.getStart(),
752                                      path.getLength());
753                                 mappingData.requestPath.setString(pathStr);
754                                 mappingData.wrapperPath.setString(pathStr);
755                             }
756                         }
757                     }
758                 }
759
760                 path.setOffset(servletPath);
761                 path.setEnd(pathEnd);
762             }
763                                         
764         }
765
766
767         // Rule 7 -- Default servlet
768 if (mappingData.wrapper == null && !checkJspWelcomeFiles) {
769             if (context.defaultWrapper != null) {
770                 mappingData.wrapper = context.defaultWrapper.object;
771                 mappingData.requestPath.setChars
772                     (path.getBuffer(), path.getStart(), path.getLength());
773                 mappingData.wrapperPath.setChars
774                     (path.getBuffer(), path.getStart(), path.getLength());
775             }
776             // Redirection to a folder
777 char[] buf = path.getBuffer();
778             if (context.resources != null && buf[pathEnd -1 ] != '/') {
779                 Object file = null;
780                 String pathStr = path.toString();
781                 try {
782                     file = context.resources.lookup(pathStr);
783                 } catch(NamingException nex) {
784                     // Swallow, since someone else handles the 404
785 }
786                 if (file != null && file instanceof DirContext ) {
787                     // Note: this mutates the path: do not do any processing
788 // after this (since we set the redirectPath, there
789 // shouldn't be any)
790 path.setOffset(pathOffset);
791                     path.append('/');
792                     mappingData.redirectPath.setChars
793                         (path.getBuffer(), path.getStart(), path.getLength());
794                 } else {
795                     mappingData.requestPath.setString(pathStr);
796                     mappingData.wrapperPath.setString(pathStr);
797                 }
798             }
799         }
800
801         path.setOffset(pathOffset);
802         path.setEnd(pathEnd);
803
804     }
805
806
807     /**
808      * Exact mapping.
809      */
810     private final void internalMapExactWrapper
811         (Wrapper[] wrappers, CharChunk path, MappingData mappingData) {
812         int pos = find(wrappers, path);
813         if ((pos != -1) && (path.equals(wrappers[pos].name))) {
814             mappingData.requestPath.setString(wrappers[pos].name);
815             mappingData.wrapperPath.setString(wrappers[pos].name);
816             mappingData.wrapper = wrappers[pos].object;
817         }
818     }
819
820
821     /**
822      * Wildcard mapping.
823      */
824     private final void internalMapWildcardWrapper
825         (Wrapper[] wrappers, int nesting, CharChunk path,
826          MappingData mappingData) {
827
828         int pathEnd = path.getEnd();
829         int pathOffset = path.getOffset();
830
831         int lastSlash = -1;
832         int length = -1;
833         int pos = find(wrappers, path);
834         if (pos != -1) {
835             boolean found = false;
836             while (pos >= 0) {
837                 if (path.startsWith(wrappers[pos].name)) {
838                     length = wrappers[pos].name.length();
839                     if (path.getLength() == length) {
840                         found = true;
841                         break;
842                     } else if (path.startsWithIgnoreCase("/", length)) {
843                         found = true;
844                         break;
845                     }
846                 }
847                 if (lastSlash == -1) {
848                     lastSlash = nthSlash(path, nesting + 1);
849                 } else {
850                     lastSlash = lastSlash(path);
851                 }
852                 path.setEnd(lastSlash);
853                 pos = find(wrappers, path);
854             }
855             path.setEnd(pathEnd);
856             if (found) {
857                 mappingData.wrapperPath.setString(wrappers[pos].name);
858                 if (path.getLength() > length) {
859                     mappingData.pathInfo.setChars
860                         (path.getBuffer(),
861                          path.getOffset() + length,
862                          path.getLength() - length);
863                 }
864                 mappingData.requestPath.setChars
865                     (path.getBuffer(), path.getOffset(), path.getLength());
866                 mappingData.wrapper = wrappers[pos].object;
867                 mappingData.jspWildCard = wrappers[pos].jspWildCard;
868             }
869         }
870     }
871
872
873     /**
874      * Extension mappings.
875      */
876     private final void internalMapExtensionWrapper
877         (Wrapper[] wrappers, CharChunk path, MappingData mappingData) {
878         char[] buf = path.getBuffer();
879         int pathEnd = path.getEnd();
880         int servletPath = path.getOffset();
881         int slash = -1;
882         for (int i = pathEnd - 1; i >= servletPath; i--) {
883             if (buf[i] == '/') {
884                 slash = i;
885                 break;
886             }
887         }
888         if (slash >= 0) {
889             int period = -1;
890             for (int i = pathEnd - 1; i > slash; i--) {
891                 if (buf[i] == '.') {
892                     period = i;
893                     break;
894                 }
895             }
896             if (period >= 0) {
897                 path.setOffset(period + 1);
898                 path.setEnd(pathEnd);
899                 int pos = find(wrappers, path);
900                 if ((pos != -1)
901                     && (path.equals(wrappers[pos].name))) {
902                     mappingData.wrapperPath.setChars
903                         (buf, servletPath, pathEnd - servletPath);
904                     mappingData.requestPath.setChars
905                         (buf, servletPath, pathEnd - servletPath);
906                     mappingData.wrapper = wrappers[pos].object;
907                 }
908                 path.setOffset(servletPath);
909                 path.setEnd(pathEnd);
910             }
911         }
912     }
913
914
915     /**
916      * Find a map elemnt given its name in a sorted array of map elements.
917      * This will return the index for the closest inferior or equal item in the
918      * given array.
919      */
920     private static final int find(MapElement[] map, CharChunk name) {
921         return find(map, name, name.getStart(), name.getEnd());
922     }
923
924
925     /**
926      * Find a map elemnt given its name in a sorted array of map elements.
927      * This will return the index for the closest inferior or equal item in the
928      * given array.
929      */
930     private static final int find(MapElement[] map, CharChunk name,
931                                   int start, int end) {
932
933         int a = 0;
934         int b = map.length - 1;
935
936         // Special cases: -1 and 0
937 if (b == -1) {
938             return -1;
939         }
940         
941         if (compare(name, start, end, map[0].name) < 0 ) {
942             return -1;
943         }
944         if (b == 0) {
945             return 0;
946         }
947
948         int i = 0;
949         while (true) {
950             i = (b + a) / 2;
951             int result = compare(name, start, end, map[i].name);
952             if (result == 1) {
953                 a = i;
954             } else if (result == 0) {
955                 return i;
956             } else {
957                 b = i;
958             }
959             if ((b - a) == 1) {
960                 int result2 = compare(name, start, end, map[b].name);
961                 if (result2 < 0) {
962                     return a;
963                 } else {
964                     return b;
965                 }
966             }
967         }
968
969     }
970
971     /**
972      * Find a map elemnt given its name in a sorted array of map elements.
973      * This will return the index for the closest inferior or equal item in the
974      * given array.
975      */
976     private static final int findIgnoreCase(MapElement[] map, CharChunk name) {
977         return findIgnoreCase(map, name, name.getStart(), name.getEnd());
978     }
979
980
981     /**
982      * Find a map elemnt given its name in a sorted array of map elements.
983      * This will return the index for the closest inferior or equal item in the
984      * given array.
985      */
986     private static final int findIgnoreCase(MapElement[] map, CharChunk name,
987                                   int start, int end) {
988
989         int a = 0;
990         int b = map.length - 1;
991
992         // Special cases: -1 and 0
993 if (b == -1) {
994             return -1;
995         }
996         if (compareIgnoreCase(name, start, end, map[0].name) < 0 ) {
997             return -1;
998         }
999         if (b == 0) {
1000            return 0;
1001        }
1002
1003        int i = 0;
1004        while (true) {
1005            i = (b + a) / 2;
1006            int result = compareIgnoreCase(name, start, end, map[i].name);
1007            if (result == 1) {
1008                a = i;
1009            } else if (result == 0) {
1010                return i;
1011            } else {
1012                b = i;
1013            }
1014            if ((b - a) == 1) {
1015                int result2 = compareIgnoreCase(name, start, end, map[b].name);
1016                if (result2 < 0) {
1017                    return a;
1018                } else {
1019                    return b;
1020                }
1021            }
1022        }
1023
1024    }
1025
1026
1027    /**
1028     * Find a map elemnt given its name in a sorted array of map elements.
1029     * This will return the index for the closest inferior or equal item in the
1030     * given array.
1031     */
1032    private static final int find(MapElement[] map, String name) {
1033
1034        int a = 0;
1035        int b = map.length - 1;
1036
1037        // Special cases: -1 and 0
1038 if (b == -1) {
1039            return -1;
1040        }
1041        
1042        if (name.compareTo(map[0].name) < 0) {
1043            return -1;
1044        }
1045        if (b == 0) {
1046            return 0;
1047        }
1048
1049        int i = 0;
1050        while (true) {
1051            i = (b + a) / 2;
1052            int result = name.compareTo(map[i].name);
1053            if (result > 0) {
1054                a = i;
1055            } else if (result == 0) {
1056                return i;
1057            } else {
1058                b = i;
1059            }
1060            if ((b - a) == 1) {
1061                int result2 = name.compareTo(map[b].name);
1062                if (result2 < 0) {
1063                    return a;
1064                } else {
1065                    return b;
1066                }
1067            }
1068        }
1069
1070    }
1071
1072
1073    /**
1074     * Compare given char chunk with String.
1075     * Return -1, 0 or +1 if inferior, equal, or superior to the String.
1076     */
1077    private static final int compare(CharChunk name, int start, int end,
1078                                     String compareTo) {
1079        int result = 0;
1080        char[] c = name.getBuffer();
1081        int len = compareTo.length();
1082        if ((end - start) < len) {
1083            len = end - start;
1084        }
1085        for (int i = 0; (i < len) && (result == 0); i++) {
1086            if (c[i + start] > compareTo.charAt(i)) {
1087                result = 1;
1088            } else if (c[i + start] < compareTo.charAt(i)) {
1089                result = -1;
1090            }
1091        }
1092        if (result == 0) {
1093            if (compareTo.length() > (end - start)) {
1094                result = -1;
1095            } else if (compareTo.length() < (end - start)) {
1096                result = 1;
1097            }
1098        }
1099        return result;
1100    }
1101
1102
1103    /**
1104     * Compare given char chunk with String ignoring case.
1105     * Return -1, 0 or +1 if inferior, equal, or superior to the String.
1106     */
1107    private static final int compareIgnoreCase(CharChunk name, int start, int end,
1108                                     String compareTo) {
1109        int result = 0;
1110        char[] c = name.getBuffer();
1111        int len = compareTo.length();
1112        if ((end - start) < len) {
1113            len = end - start;
1114        }
1115        for (int i = 0; (i < len) && (result == 0); i++) {
1116            if (Ascii.toLower(c[i + start]) > Ascii.toLower(compareTo.charAt(i))) {
1117                result = 1;
1118            } else if (Ascii.toLower(c[i + start]) < Ascii.toLower(compareTo.charAt(i))) {
1119                result = -1;
1120            }
1121        }
1122        if (result == 0) {
1123            if (compareTo.length() > (end - start)) {
1124                result = -1;
1125            } else if (compareTo.length() < (end - start)) {
1126                result = 1;
1127            }
1128        }
1129        return result;
1130    }
1131
1132
1133    /**
1134     * Find the position of the last slash in the given char chunk.
1135     */
1136    private static final int lastSlash(CharChunk name) {
1137
1138        char[] c = name.getBuffer();
1139        int end = name.getEnd();
1140        int start = name.getStart();
1141        int pos = end;
1142
1143        while (pos > start) {
1144            if (c[--pos] == '/') {
1145                break;
1146            }
1147        }
1148
1149        return (pos);
1150
1151    }
1152
1153
1154    /**
1155     * Find the position of the nth slash, in the given char chunk.
1156     */
1157    private static final int nthSlash(CharChunk name, int n) {
1158
1159        char[] c = name.getBuffer();
1160        int end = name.getEnd();
1161        int start = name.getStart();
1162        int pos = start;
1163        int count = 0;
1164
1165        while (pos < end) {
1166            if ((c[pos++] == '/') && ((++count) == n)) {
1167                pos--;
1168                break;
1169            }
1170        }
1171
1172        return (pos);
1173
1174    }
1175
1176
1177    /**
1178     * Return the slash count in a given string.
1179     */
1180    private static final int slashCount(String name) {
1181        int pos = -1;
1182        int count = 0;
1183        while ((pos = name.indexOf('/', pos + 1)) != -1) {
1184            count++;
1185        }
1186        return count;
1187    }
1188
1189
1190    /**
1191     * Insert into the right place in a sorted MapElement array, and prevent
1192     * duplicates.
1193     */
1194    private static final boolean insertMap
1195        (MapElement[] oldMap, MapElement[] newMap, MapElement newElement) {
1196        int pos = find(oldMap, newElement.name);
1197        if ((pos != -1) && (newElement.name.equals(oldMap[pos].name))) {
1198            return false;
1199        }
1200        System.arraycopy(oldMap, 0, newMap, 0, pos + 1);
1201        newMap[pos + 1] = newElement;
1202        System.arraycopy
1203            (oldMap, pos + 1, newMap, pos + 2, oldMap.length - pos - 1);
1204        return true;
1205    }
1206
1207
1208    /**
1209     * Insert into the right place in a sorted MapElement array.
1210     */
1211    private static final boolean removeMap
1212        (MapElement[] oldMap, MapElement[] newMap, String name) {
1213        int pos = find(oldMap, name);
1214        if ((pos != -1) && (name.equals(oldMap[pos].name))) {
1215            System.arraycopy(oldMap, 0, newMap, 0, pos);
1216            System.arraycopy(oldMap, pos + 1, newMap, pos,
1217                             oldMap.length - pos - 1);
1218            return true;
1219        }
1220        return false;
1221    }
1222
1223
1224    // ------------------------------------------------- MapElement Inner Class
1225
1226
1227    protected static abstract class MapElement {
1228
1229        public String name = null;
1230        public Object object = null;
1231
1232    }
1233
1234
1235    // ------------------------------------------------------- Host Inner Class
1236
1237
1238    protected static final class Host
1239        extends MapElement {
1240
1241        public ContextList contextList = null;
1242
1243    }
1244
1245
1246    // ------------------------------------------------ ContextList Inner Class
1247
1248
1249    protected static final class ContextList {
1250
1251        public Context [] contexts = new Context [0];
1252        public int nesting = 0;
1253
1254    }
1255
1256
1257    // ---------------------------------------------------- Context Inner Class
1258
1259
1260    protected static final class Context
1261        extends MapElement {
1262
1263        public String path = null;
1264        public String [] welcomeResources = new String [0];
1265        public javax.naming.Context resources = null;
1266        public Wrapper defaultWrapper = null;
1267        public Wrapper[] exactWrappers = new Wrapper[0];
1268        public Wrapper[] wildcardWrappers = new Wrapper[0];
1269        public Wrapper[] extensionWrappers = new Wrapper[0];
1270        public int nesting = 0;
1271
1272    }
1273
1274
1275    // ---------------------------------------------------- Wrapper Inner Class
1276
1277
1278    protected static class Wrapper
1279        extends MapElement {
1280
1281        public String path = null;
1282        public boolean jspWildCard = false;
1283    }
1284
1285
1286    // -------------------------------------------------------- Testing Methods
1287
1288    // FIXME: Externalize this
1289 /*
1290    public static void main(String args[]) {
1291
1292        try {
1293
1294        Mapper mapper = new Mapper();
1295        System.out.println("Start");
1296
1297        mapper.addHost("sjbjdvwsbvhrb", new String[0], "blah1");
1298        mapper.addHost("sjbjdvwsbvhr/", new String[0], "blah1");
1299        mapper.addHost("wekhfewuifweuibf", new String[0], "blah2");
1300        mapper.addHost("ylwrehirkuewh", new String[0], "blah3");
1301        mapper.addHost("iohgeoihro", new String[0], "blah4");
1302        mapper.addHost("fwehoihoihwfeo", new String[0], "blah5");
1303        mapper.addHost("owefojiwefoi", new String[0], "blah6");
1304        mapper.addHost("iowejoiejfoiew", new String[0], "blah7");
1305        mapper.addHost("iowejoiejfoiew", new String[0], "blah17");
1306        mapper.addHost("ohewoihfewoih", new String[0], "blah8");
1307        mapper.addHost("fewohfoweoih", new String[0], "blah9");
1308        mapper.addHost("ttthtiuhwoih", new String[0], "blah10");
1309        mapper.addHost("lkwefjwojweffewoih", new String[0], "blah11");
1310        mapper.addHost("zzzuyopjvewpovewjhfewoih", new String[0], "blah12");
1311        mapper.addHost("xxxxgqwiwoih", new String[0], "blah13");
1312        mapper.addHost("qwigqwiwoih", new String[0], "blah14");
1313
1314        System.out.println("Map:");
1315        for (int i = 0; i < mapper.hosts.length; i++) {
1316            System.out.println(mapper.hosts[i].name);
1317        }
1318
1319        mapper.setDefaultHostName("ylwrehirkuewh");
1320
1321        String[] welcomes = new String[2];
1322        welcomes[0] = "boo/baba";
1323        welcomes[1] = "bobou";
1324
1325        mapper.addContext("iowejoiejfoiew", "", "context0", new String[0], null);
1326        mapper.addContext("iowejoiejfoiew", "/foo", "context1", new String[0], null);
1327        mapper.addContext("iowejoiejfoiew", "/foo/bar", "context2", welcomes, null);
1328        mapper.addContext("iowejoiejfoiew", "/foo/bar/bla", "context3", new String[0], null);
1329
1330        mapper.addWrapper("iowejoiejfoiew", "/foo/bar", "/fo/*", "wrapper0");
1331        mapper.addWrapper("iowejoiejfoiew", "/foo/bar", "/", "wrapper1");
1332        mapper.addWrapper("iowejoiejfoiew", "/foo/bar", "/blh", "wrapper2");
1333        mapper.addWrapper("iowejoiejfoiew", "/foo/bar", "*.jsp", "wrapper3");
1334        mapper.addWrapper("iowejoiejfoiew", "/foo/bar", "/blah/bou/*", "wrapper4");
1335        mapper.addWrapper("iowejoiejfoiew", "/foo/bar", "/blah/bobou/*", "wrapper5");
1336        mapper.addWrapper("iowejoiejfoiew", "/foo/bar", "*.htm", "wrapper6");
1337
1338        MappingData mappingData = new MappingData();
1339        MessageBytes host = MessageBytes.newInstance();
1340        host.setString("iowejoiejfoiew");
1341        MessageBytes uri = MessageBytes.newInstance();
1342        uri.setString("/foo/bar/blah/bobou/foo");
1343        uri.toChars();
1344        uri.getCharChunk().setLimit(-1);
1345
1346        mapper.map(host, uri, mappingData);
1347        System.out.println("MD Host:" + mappingData.host);
1348        System.out.println("MD Context:" + mappingData.context);
1349        System.out.println("MD Wrapper:" + mappingData.wrapper);
1350
1351        System.out.println("contextPath:" + mappingData.contextPath);
1352        System.out.println("wrapperPath:" + mappingData.wrapperPath);
1353        System.out.println("pathInfo:" + mappingData.pathInfo);
1354        System.out.println("redirectPath:" + mappingData.redirectPath);
1355
1356        mappingData.recycle();
1357        mapper.map(host, uri, mappingData);
1358        System.out.println("MD Host:" + mappingData.host);
1359        System.out.println("MD Context:" + mappingData.context);
1360        System.out.println("MD Wrapper:" + mappingData.wrapper);
1361
1362        System.out.println("contextPath:" + mappingData.contextPath);
1363        System.out.println("wrapperPath:" + mappingData.wrapperPath);
1364        System.out.println("pathInfo:" + mappingData.pathInfo);
1365        System.out.println("redirectPath:" + mappingData.redirectPath);
1366
1367        for (int i = 0; i < 1000000; i++) {
1368            mappingData.recycle();
1369            mapper.map(host, uri, mappingData);
1370        }
1371
1372        long time = System.currentTimeMillis();
1373        for (int i = 0; i < 1000000; i++) {
1374            mappingData.recycle();
1375            mapper.map(host, uri, mappingData);
1376        }
1377        System.out.println("Elapsed:" + (System.currentTimeMillis() - time));
1378
1379        System.out.println("MD Host:" + mappingData.host);
1380        System.out.println("MD Context:" + mappingData.context);
1381        System.out.println("MD Wrapper:" + mappingData.wrapper);
1382
1383        System.out.println("contextPath:" + mappingData.contextPath);
1384        System.out.println("wrapperPath:" + mappingData.wrapperPath);
1385        System.out.println("requestPath:" + mappingData.requestPath);
1386        System.out.println("pathInfo:" + mappingData.pathInfo);
1387        System.out.println("redirectPath:" + mappingData.redirectPath);
1388
1389        } catch (Exception e) {
1390            e.printStackTrace();
1391        }
1392
1393    }
1394    */
1395
1396
1397}
1398

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags