Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
  /*
2
   * JBoss, Home of Professional Open Source
3
   * Copyright 2009, JBoss Inc., and individual contributors as indicated
4
   * by the @authors tag. See the copyright.txt in the distribution for a
5
   * full listing of individual contributors.
6
   *
7
   * This is free software; you can redistribute it and/or modify it
8
   * under the terms of the GNU Lesser General Public License as
9
   * published by the Free Software Foundation; either version 2.1 of
10
  * the License, or (at your option) any later version.
11
  *
12
  * This software is distributed in the hope that it will be useful,
13
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15
  * Lesser General Public License for more details.
16
  *
17
  * You should have received a copy of the GNU Lesser General Public
18
  * License along with this software; if not, write to the Free
19
  * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20
  * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
21
  * 
22
  * 
23
  * This file incorporates work covered by the following copyright and
24
  * permission notice:
25
  *
26
  * Copyright 1999-2009 The Apache Software Foundation
27
  *
28
  * Licensed to the Apache Software Foundation (ASF) under one
29
  * or more contributor license agreements.  See the NOTICE file
30
  * distributed with this work for additional information
31
  * regarding copyright ownership.  The ASF licenses this file
32
  * to you under the Apache License, Version 2.0 (the
33
  * "License"); you may not use this file except in compliance
34
  * with the License.  You may obtain a copy of the License at
35
  *
36
  *  http://www.apache.org/licenses/LICENSE-2.0
37
  *
38
  * Unless required by applicable law or agreed to in writing,
39
  * software distributed under the License is distributed on an
40
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
41
  * KIND, either express or implied.  See the License for the
42
  * specific language governing permissions and limitations
43
  * under the License.
44
  */
45
 
46
 
47
 package org.apache.catalina.startup;
48
 
49
 
50
 import java.io.File;
56
 import java.util.Map;
58
 import java.util.Set;
59
 
60
 import  javax.servlet.HttpMethodConstraintElement;
61
 import  javax.servlet.ServletSecurityElement;
62
 import  javax.servlet.annotation.ServletSecurity.EmptyRoleSemantic;
63
 import  javax.servlet.annotation.ServletSecurity.TransportGuarantee;
64
 
Startup event listener for a Context that configures the properties of that Context, and the associated defined servlets.

Author(s):
Craig R. McClanahan
Jean-Francois Arcand
Version:
$Revision: 1500 $ $Date: 2010-07-02 11:46:55 +0200 (Fri, 02 Jul 2010) $
94
 
95
 
96
 public class ContextConfig
97
     implements LifecycleListener {
98
 
99
     protected static org.jboss.logging.Logger log=
100
        org.jboss.logging.Logger.getLogger( ContextConfig.class );
102
    // ----------------------------------------------------- Instance Variables
103


    
Custom mappings of login methods to authenticators 
108
    protected Map customAuthenticators;


    
The set of Authenticators that we know how to configure. The key is the name of the implemented authentication method, and the value is the fully qualified Java class name of the corresponding Valve. 
116
    protected static Properties authenticators = null;


    
The Context we are associated with. 
122
    protected Context context = null;


    
Track any fatal errors during startup configuration processing. 
128
    protected boolean ok = false;


    
The string resources for this package. 
134
    protected static final StringManager sm =
135
        StringManager.getManager(.);


    
Deployment count. 
141
    protected static long deploymentCount = 0L;
142
    
143
    
144
    protected static final LoginConfig DUMMY_LOGIN_CONFIG =
145
                                new LoginConfig("NONE", null, null, null);
148
    // ------------------------------------------------------------- Properties
149


    
Sets custom mappings of login methods to authenticators.

Parameters:
customAuthenticators Custom mappings of login methods to authenticators
157
    public void setCustomAuthenticators(Map customAuthenticators) {
158
        this. = customAuthenticators;
159
    }
162
    // --------------------------------------------------------- Public Methods
163


    
Process events for an associated Context.

Parameters:
event The lifecycle event that has occurred
170
    public void lifecycleEvent(LifecycleEvent event) {
172
        // Identify the context we are associated with
173
        try {
174
             = (Context) event.getLifecycle();
175
        } catch (ClassCastException e) {
176
            .error(.getString("contextConfig.cce", event.getLifecycle()), e);
177
            return;
178
        }
180
        // Process the event that has occurred
181
        if (event.getType().equals(.)) {
182
            start();
183
        } else if (event.getType().equals(.)) {
184
            beforeStart();
185
        } else if (event.getType().equals(.)) {
186
            
187
        } else if (event.getType().equals(.)) {
188
            completeConfig();
189
        } else if (event.getType().equals(.)) {
190
            stop();
191
        } else if (event.getType().equals(.)) {
192
            init();
193
        } else if (event.getType().equals(.)) {
194
            destroy();
195
        }
197
    }
200
    // -------------------------------------------------------- Protected Methods
201


    
Process the application configuration file, if it exists. 
206
    protected void applicationWebConfig() {
207
    }
    
    
Parse TLDs. This is separate, and is not subject to the order defined. Also, all TLDs from all JARs are parsed. 
213
    protected void applicationTldConfig() {
214
        
215
    }
    

    
Set up an Authenticator automatically if required, and one has not already been configured. 
222
    protected void authenticatorConfig() {
224
        // Does this Context require an Authenticator?
225
        SecurityConstraint constraints[] = .findConstraints();
226
        if ((constraints == null) || (constraints.length == 0))
227
            return;
228
        LoginConfig loginConfig = .getLoginConfig();
229
        if (loginConfig == null) {
230
            loginConfig = ;
231
            .setLoginConfig(loginConfig);
232
        }
234
        // Has an authenticator been configured already?
235
        if ( instanceof Authenticator)
236
            return;
237
        if ( instanceof ContainerBase) {
238
            Pipeline pipeline = ((ContainerBase) ).getPipeline();
239
            if (pipeline != null) {
240
                Valve basic = pipeline.getBasic();
241
                if ((basic != null) && (basic instanceof Authenticator)) {
242
                    if (.getAuthenticator() == null) {
243
                        .setAuthenticator((Authenticator) basic);
244
                    }
245
                    return;
246
                }
247
                Valve valves[] = pipeline.getValves();
248
                for (int i = 0; i < valves.length; i++) {
249
                    if (valves[i] instanceof Authenticator) {
250
                        if (.getAuthenticator() == null) {
251
                            .setAuthenticator((Authenticator) valves[i]);
252
                        }
253
                        return;
254
                    }
255
                }
256
            }
257
        } else {
258
            return;     // Cannot install a Valve even if it would be needed
259
        }
261
        // Has a Realm been configured for us to authenticate against?
262
        if (.getRealm() == null) {
263
            .error(.getString("contextConfig.missingRealm"));
264
             = false;
265
            return;
266
        }
268
        /*
269
         * First check to see if there is a custom mapping for the login
270
         * method. If so, use it. Otherwise, check if there is a mapping in
271
         * org/apache/catalina/startup/Authenticators.properties.
272
         */
273
        Valve authenticator = null;
274
        if ( != null) {
275
            authenticator = (Valve)
276
                .get(loginConfig.getAuthMethod());
277
        }
278
        if (authenticator == null) {
279
            // Load our mapping properties if necessary
280
            if ( == null) {
281
                try {
282
                    InputStream is=this.getClass().getClassLoader().getResourceAsStream("org/apache/catalina/startup/Authenticators.properties");
283
                    if( is!=null ) {
284
                         = new Properties();
285
                        .load(is);
286
                    } else {
287
                        .error(.getString(
288
                                "contextConfig.authenticatorResources"));
289
                        =false;
290
                        return;
291
                    }
292
                } catch (IOException e) {
293
                    .error(.getString(
294
                                "contextConfig.authenticatorResources"), e);
295
                     = false;
296
                    return;
297
                }
298
            }
300
            // Identify the class name of the Valve we should configure
301
            String authenticatorName = null;
302
            authenticatorName =
303
                    .getProperty(loginConfig.getAuthMethod());
304
            if (authenticatorName == null) {
305
                .error(.getString("contextConfig.authenticatorMissing",
306
                                 loginConfig.getAuthMethod()));
307
                 = false;
308
                return;
309
            }
311
            // Instantiate and install an Authenticator of the requested class
312
            try {
313
                Class authenticatorClass = Class.forName(authenticatorName);
314
                authenticator = (Valve) authenticatorClass.newInstance();
315
            } catch (Throwable t) {
316
                .error(.getString(
317
                                    "contextConfig.authenticatorInstantiate",
318
                                    authenticatorName),
319
                          t);
320
                 = false;
321
            }
322
        }
324
        if (authenticator instanceof Authenticator) {
325
            .setAuthenticator((Authenticator) authenticator);
326
        }
327
        if (authenticator != null &&  instanceof ContainerBase) {
328
            Pipeline pipeline = ((ContainerBase) ).getPipeline();
329
            if (pipeline != null) {
330
                ((ContainerBase) ).addValve(authenticator);
331
                if (.isDebugEnabled()) {
332
                    .debug(.getString(
333
                                    "contextConfig.authenticatorConfigured",
334
                                    loginConfig.getAuthMethod()));
335
                }
336
            }
337
        }
339
    }
342
    protected String getBaseDir() {
343
        Container engineC=.getParent().getParent();
344
        if( engineC instanceof StandardEngine ) {
345
            return ((StandardEngine)engineC).getBaseDir();
346
        }
347
        return System.getProperty("catalina.base");
348
    }

    
Process the default configuration file, if it exists. The default config must be read with the container loader - so container servlets can be loaded 
355
    protected void defaultWebConfig() {
356
        
357
    }


    
Parse fragments order. 
363
    protected void createFragmentsOrder() {
364
        
365
    }
    
    
    
Process additional descriptors: TLDs, web fragments, and map overlays. 
371
    protected void applicationExtraDescriptorsConfig() {
372
        
373
    }
    
    
    
Find and parse ServletContainerInitializer service in specified JAR. 
380
        
381
    }
    
    
    
Process a "init" event for this Context. 
387
    protected void init() {
388
            if (.isDebugEnabled())
389
            .debug(.getString("contextConfig.init"));
390
        .setConfigured(false);
391
         = true;
392
    }
    
    
    
Process a "before start" event for this Context. 
398
    protected void beforeStart() {
399
    }
    
    
    
Process a "start" event for this Context. 
405
    protected void start() {
406
        // Called from StandardContext.start()
408
        if (.isDebugEnabled())
409
            .debug(.getString("contextConfig.start"));
411
        // Process the default and application web.xml files
412
        if () {
413
            defaultWebConfig();
414
        }
415
        // Scan the main descriptors
416
        if () {
417
            applicationWebConfig();
418
        }
419
        // Parse any Servlet context initializer defined in a Jar
420
        if () {
422
        }
423
        // Parse fragment order
424
        if () {
425
            createFragmentsOrder();
426
        }
427
        // Scan fragments, TLDs and annotations
428
        if () {
429
            applicationExtraDescriptorsConfig();
430
        }
431
        // Parse any TLDs found for listeners
432
        if () {
433
            applicationTldConfig();
434
        }
436
        // Dump the contents of this pipeline if requested
437
        if ((.isDebugEnabled()) && ( instanceof ContainerBase)) {
438
            .debug("Pipeline Configuration:");
439
            Pipeline pipeline = ((ContainerBase) ).getPipeline();
440
            Valve valves[] = null;
441
            if (pipeline != null)
442
                valves = pipeline.getValves();
443
            if (valves != null) {
444
                for (int i = 0; i < valves.length; i++) {
445
                    .debug("  " + valves[i].getInfo());
446
                }
447
            }
448
            .debug("======================");
449
        }
451
        // Make our application available if no problems were encountered
452
        if () {
453
            .setConfigured(true);
454
        } else {
455
            .error(.getString("contextConfig.unavailable"));
456
            .setConfigured(false);
457
        }
459
    }

    
Process a "start" event for this Context. 
464
    protected void completeConfig() {
465
        
466
    }

    
Process a "stop" event for this Context. 
471
    protected void stop() {
473
        if (.isDebugEnabled())
474
            .debug(.getString("contextConfig.stop"));
476
        int i;
478
        // Removing children
479
        Container[] children = .findChildren();
480
        for (i = 0; i < children.length; i++) {
481
            .removeChild(children[i]);
482
        }
484
        // Removing application parameters
485
        /*
486
        ApplicationParameter[] applicationParameters =
487
            context.findApplicationParameters();
488
        for (i = 0; i < applicationParameters.length; i++) {
489
            context.removeApplicationParameter
490
                (applicationParameters[i].getName());
491
        }
492
        */
494
        // Removing security constraints
495
        SecurityConstraint[] securityConstraints = .findConstraints();
496
        for (i = 0; i < securityConstraints.length; i++) {
497
            .removeConstraint(securityConstraints[i]);
498
        }
500
        // Removing errors pages
501
        ErrorPage[] errorPages = .findErrorPages();
502
        for (i = 0; i < errorPages.length; i++) {
503
            .removeErrorPage(errorPages[i]);
504
        }
506
        // Removing filter defs
507
        FilterDef[] filterDefs = .findFilterDefs();
508
        for (i = 0; i < filterDefs.length; i++) {
509
            .removeFilterDef(filterDefs[i]);
510
        }
512
        // Removing filter maps
513
        FilterMap[] filterMaps = .findFilterMaps();
514
        for (i = 0; i < filterMaps.length; i++) {
515
            .removeFilterMap(filterMaps[i]);
516
        }
518
        // Removing Mime mappings
519
        String[] mimeMappings = .findMimeMappings();
520
        for (i = 0; i < mimeMappings.length; i++) {
521
            .removeMimeMapping(mimeMappings[i]);
522
        }
524
        // Removing parameters
525
        String[] parameters = .findParameters();
526
        for (i = 0; i < parameters.length; i++) {
527
            .removeParameter(parameters[i]);
528
        }
530
        // Removing sercurity role
531
        String[] securityRoles = .findSecurityRoles();
532
        for (i = 0; i < securityRoles.length; i++) {
533
            .removeSecurityRole(securityRoles[i]);
534
        }
536
        // Removing servlet mappings
537
        String[] servletMappings = .findServletMappings();
538
        for (i = 0; i < servletMappings.length; i++) {
539
            .removeServletMapping(servletMappings[i]);
540
        }
542
        // FIXME : Removing status pages
544
        // Removing taglibs
545
        String[] taglibs = .findTaglibs();
546
        for (i = 0; i < taglibs.length; i++) {
547
            .removeTaglib(taglibs[i]);
548
        }
550
        // FIXME: remove JSP property groups
551
        
552
        // FIXME: remove JSP tag libraries
553
        
554
        // Removing welcome files
555
        String[] welcomeFiles = .findWelcomeFiles();
556
        for (i = 0; i < welcomeFiles.length; i++) {
557
            .removeWelcomeFile(welcomeFiles[i]);
558
        }
560
        // Removing wrapper lifecycles
561
        String[] wrapperLifecycles = .findWrapperLifecycles();
562
        for (i = 0; i < wrapperLifecycles.length; i++) {
563
            .removeWrapperLifecycle(wrapperLifecycles[i]);
564
        }
566
        // Removing wrapper listeners
567
        String[] wrapperListeners = .findWrapperListeners();
568
        for (i = 0; i < wrapperListeners.length; i++) {
569
            .removeWrapperListener(wrapperListeners[i]);
570
        }
572
         = true;
574
    }
    
    
    
Process a "destroy" event for this Context. 
580
    protected void destroy() {
581
        // Called from StandardContext.destroy()
582
        if (.isDebugEnabled())
583
            .debug(.getString("contextConfig.destroy"));
585
        // Changed to getWorkPath per Bugzilla 35819.
586
        String workDir = ((StandardContext) ).getWorkPath();
587
        if (workDir != null)
588
            ExpandWar.delete(new File(workDir));
589
    }
    
    
    
Translate servlet security associated with Servlets to security constraints. 
595
    protected void resolveServletSecurity() {
596
        // Skip all patterns for which a static security constraint has been defined
597
        HashSet<String> excludedPatterns = new HashSet<String>();
598
        SecurityConstraint[] staticConstraints = .findConstraints();
599
        for (SecurityConstraint staticConstraint : staticConstraints) {
600
            for (SecurityCollection collection : staticConstraint.findCollections()) {
601
                for (String urlPattern : collection.findPatterns()) {
602
                    excludedPatterns.add(urlPattern);
603
                }
604
            }
605
        }
606
        // Iterate over servlet security objects
607
        Container wrappers[] = .findChildren();
608
        for (int i = 0; i < wrappers.length; i++) {
609
            Wrapper wrapper = (Wrapper) wrappers[i];
610
            ServletSecurityElement servletSecurity = wrapper.getServletSecurity();
611
            if (servletSecurity != null) {
612
                
613
                ArrayList<String> methodOmissions = new ArrayList<String>();
614
                boolean classPA = servletSecurity.getEmptyRoleSemantic().equals(EmptyRoleSemantic.PERMIT);
615
                boolean classDA = servletSecurity.getEmptyRoleSemantic().equals(EmptyRoleSemantic.DENY);
616
                boolean classTP = servletSecurity.getTransportGuarantee().equals(TransportGuarantee.CONFIDENTIAL);
617
                String[] classRA = servletSecurity.getRolesAllowed();
618
                Collection<HttpMethodConstraintElement> httpMethodConstraints = 
619
                    servletSecurity.getHttpMethodConstraints();
621
                // Process method constraints
622
                if (httpMethodConstraints != null && httpMethodConstraints.size() > 0)
623
                {
624
                   for (HttpMethodConstraintElement httpMethodConstraint : httpMethodConstraints)
625
                   {
626
                       String method = toHttpMethod(httpMethodConstraint.getMethodName());
627
                      methodOmissions.add(method);
628
                      boolean methodPA = httpMethodConstraint.getEmptyRoleSemantic().equals(EmptyRoleSemantic.PERMIT);
629
                      boolean methodDA = httpMethodConstraint.getEmptyRoleSemantic().equals(EmptyRoleSemantic.DENY);
630
                      boolean methodTP = httpMethodConstraint.getTransportGuarantee().equals(TransportGuarantee.CONFIDENTIAL);
631
                      String[] methodRA = httpMethodConstraint.getRolesAllowed();
632
                      if (methodDA || methodTP || (methodRA != null && methodRA.length > 0))
633
                      {
634
                         // Define a constraint specific for the method
635
                         SecurityConstraint constraint = new SecurityConstraint();
636
                         if (methodDA) {
637
                             constraint.setAuthConstraint(true);
638
                         }
639
                         if (methodPA && (methodRA == null || methodRA.length == 0)) {
640
                             constraint.addAuthRole("*");
641
                         }
642
                         if (methodRA != null) {
643
                             for (String role : methodRA) {
644
                                 constraint.addAuthRole(role);
645
                             }
646
                         }
647
                         if (methodTP) {
648
                             constraint.setUserConstraint(.....);
649
                         }
650
                         SecurityCollection collection = new SecurityCollection();
651
                         collection.addMethod(method);
652
                         // Determine pattern set
653
                         String[] urlPatterns = wrapper.findMappings();
654
                         Set<String> servletSecurityPatterns = new HashSet<String>();
655
                         for (String urlPattern : urlPatterns) {
656
                             if (!excludedPatterns.contains(urlPattern)) {
657
                                 servletSecurityPatterns.add(urlPattern);
658
                             }
659
                         }
660
                         for (String urlPattern : servletSecurityPatterns) {
661
                             collection.addPattern(urlPattern);
662
                         }
663
                         constraint.addCollection(collection);
664
                         .addConstraint(constraint);
665
                      }
667
                   }
669
                }
671
                if (classDA || classTP || (classRA != null && classRA.length > 0))
672
                {
673
                    // Define a constraint for the class
674
                    SecurityConstraint constraint = new SecurityConstraint();
675
                    if (classPA && (classRA == null || classRA.length == 0)) {
676
                        constraint.addAuthRole("*");
677
                    }
678
                    if (classDA) {
679
                        constraint.setAuthConstraint(true);
680
                    }
681
                    if (classRA != null) {
682
                        for (String role : classRA) {
683
                            constraint.addAuthRole(role);
684
                        }
685
                    }
686
                    if (classTP) {
687
                        constraint.setUserConstraint(.....);
688
                    }
689
                    SecurityCollection collection = new SecurityCollection();
690
                    // Determine pattern set
691
                    String[] urlPatterns = wrapper.findMappings();
692
                    Set<String> servletSecurityPatterns = new HashSet<String>();
693
                    for (String urlPattern : urlPatterns) {
694
                        if (!excludedPatterns.contains(urlPattern)) {
695
                            servletSecurityPatterns.add(urlPattern);
696
                        }
697
                    }
698
                    for (String urlPattern : servletSecurityPatterns) {
699
                        collection.addPattern(urlPattern);
700
                    }
701
                    for (String methodOmission : methodOmissions) {
702
                        collection.addMethodOmission(methodOmission);
703
                    }
704
                    constraint.addCollection(collection);
705
                    .addConstraint(constraint);
706
                }
707
                
708
            }
709
        }
710
    }
    
    
    
Although this does not comply with the spec, it is likely Java method names will be used in the annotations. Since it is not possible to validate, this would be an error that is invisible for the user.

Parameters:
method
Returns:
720
    protected String toHttpMethod(String method) {
721
        if (method == null || method.length() < 3 || (!method.startsWith("do")))
722
            return method;
723
        return method.substring(2).toUpperCase();
724
    }
    
    
    
Validate the usage of security role names in the web application deployment descriptor. If any problems are found, issue warning messages (for backwards compatibility) and add the missing roles. (To make these problems fatal instead, simply set the ok instance variable to false as well). 
734
    protected void validateSecurityRoles() {
736
        // Check role names used in <security-constraint> elements
737
        SecurityConstraint constraints[] = .findConstraints();
738
        for (int i = 0; i < constraints.length; i++) {
739
            String roles[] = constraints[i].findAuthRoles();
740
            for (int j = 0; j < roles.length; j++) {
741
                if (!"*".equals(roles[j]) &&
742
                    !.findSecurityRole(roles[j])) {
743
                    .info(.getString("contextConfig.role.auth", roles[j]));
744
                    .addSecurityRole(roles[j]);
745
                }
746
            }
747
        }
749
        // Check role names used in <servlet> elements
750
        Container wrappers[] = .findChildren();
751
        for (int i = 0; i < wrappers.length; i++) {
752
            Wrapper wrapper = (Wrapper) wrappers[i];
753
            String runAs = wrapper.getRunAs();
754
            if ((runAs != null) && !.findSecurityRole(runAs)) {
755
                .info(.getString("contextConfig.role.runas", runAs));
756
                .addSecurityRole(runAs);
757
            }
758
            String names[] = wrapper.findSecurityReferences();
759
            for (int j = 0; j < names.length; j++) {
760
                String link = wrapper.findSecurityReference(names[j]);
761
                if ((link != null) && !.findSecurityRole(link)) {
762
                    .info(.getString("contextConfig.role.link", link));
763
                    .addSecurityRole(link);
764
                }
765
            }
766
        }
768
    }
771
    protected String getHostConfigPath(String resourceName) {
772
        StringBuilder result = new StringBuilder();
773
        Container container = ;
774
        Container host = null;
775
        Container engine = null;
776
        while (container != null) {
777
            if (container instanceof Host)
778
                host = container;
779
            if (container instanceof Engine)
780
                engine = container;
781
            container = container.getParent();
782
        }
783
        if (engine != null) {
784
            result.append(engine.getName()).append('/');
785
        }
786
        if (host != null) {
787
            result.append(host.getName()).append('/');
788
        }
789
        result.append(resourceName);
790
        return result.toString();
791
    }
New to GrepCode? Check out our FAQ X