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

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
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
  
19
  package org.apache.catalina.servlets;
20
  
21
  
22
  import static org.jboss.web.CatalinaMessages.MESSAGES;
23
  
28
  import java.io.Writer;
32
  import java.util.Date;
35
  import java.util.Locale;
36
  import java.util.Stack;
38
  import java.util.Vector;
39
  
53
  
64
  import org.w3c.dom.Node;
Servlet which adds support for WebDAV level 2. All the basic HTTP requests are handled by the DefaultServlet. The WebDAVServlet must not be used as the default servlet (ie mapped to '/') as it will not work in this configuration. To enable WebDAV for a context add the following to web.xml:
<servlet>
<servlet-name>webdav</servlet-name>
<servlet-class>org.apache.catalina.servlets.WebdavServlet</servlet-class>
<init-param>
<param-name>debug</param-name>
<param-value>0</param-value>
</init-param>
<init-param>
<param-name>listings</param-name>
<param-value>true</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>webdav</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>

This will enable read only access. To enable read-write access add:
<init-param>
<param-name>readonly</param-name>
<param-value>false</param-value>
</init-param>

To make the content editable via a different URL, using the following mapping:
<servlet-mapping>
<servlet-name>webdav</servlet-name>
<url-pattern>/webdavedit/*</url-pattern>
</servlet-mapping>

Don't forget to secure access appropriately to the editing URLs. With this configuration the context will be accessible to normal users as before. Those users with the necessary access will be able to edit content available via http://host:port/context/content using http://host:port/context/webdavedit/content

Author(s):
Remy Maucherat
Version:
$Revision: 1739 $ $Date: 2011-06-14 16:56:59 +0200 (Tue, 14 Jun 2011) $
120
 
121
 
122
 public class WebdavServlet
123
     extends DefaultServlet {
124
 
125
 
126
     // -------------------------------------------------------------- Constants
127
 
128
 
129
     private static final String METHOD_PROPFIND = "PROPFIND";
130
     private static final String METHOD_PROPPATCH = "PROPPATCH";
131
     private static final String METHOD_MKCOL = "MKCOL";
132
     private static final String METHOD_COPY = "COPY";
133
     private static final String METHOD_MOVE = "MOVE";
134
     private static final String METHOD_LOCK = "LOCK";
135
     private static final String METHOD_UNLOCK = "UNLOCK";


    
PROPFIND - Specify a property mask. 
140
 
141
     private static final int FIND_BY_PROPERTY = 0;


    
PROPFIND - Display all properties. 
146
 
147
     private static final int FIND_ALL_PROP = 1;


    
PROPFIND - Return property names. 
152
 
153
     private static final int FIND_PROPERTY_NAMES = 2;


    
Create a new lock. 
158
 
159
     private static final int LOCK_CREATION = 0;


    
Refresh lock. 
164
 
165
     private static final int LOCK_REFRESH = 1;


    
Default lock timeout value. 
170
 
171
     private static final int DEFAULT_TIMEOUT = 3600;


    
Maximum lock timeout. 
176
 
177
     private static final int MAX_TIMEOUT = 604800;


    
Default namespace. 
182
 
183
     protected static final String DEFAULT_NAMESPACE = "DAV:";


    
Simple date format for the creation date ISO representation (partial). 
188
 
189
     protected static final SimpleDateFormat creationDateFormat =
190
         new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");


     
MD5 message digest provider. 
195
 
196
     protected static MessageDigest md5Helper;


    
The MD5 helper object for this class. 
201
 
202
     protected static final MD5Encoder md5Encoder = new MD5Encoder();
203
 
204
 
205
 
206
     static {
207
         .setTimeZone(TimeZone.getTimeZone("GMT"));
208
     }
209
 
210
 
211
     // ----------------------------------------------------- Instance Variables
212
 

    
Repository of the locks put on single resources.

Key : path
Value : LockInfo 

219
 
220
     private Hashtable<String,LockInfo> resourceLocks =
221
         new Hashtable<String,LockInfo>();


    
Repository of the lock-null resources.

Key : path of the collection containing the lock-null resource
Value : Vector of lock-null resource which are members of the collection. Each element of the Vector is the path associated with the lock-null resource. 

231
 
233
         new Hashtable<String,Vector<String>>();


    
Vector of the heritable locks.

Key : path
Value : LockInfo 

241
 
242
     private Vector<LockInfo> collectionLocks = new Vector<LockInfo>();


    
Secret information used to generate reasonably secure lock ids. 
247
 
248
     private String secret = "catalina";


    
Default depth in spec is infinite. Limit depth to 3 by default as infinite depth makes operations very expensive. 
254
 
255
     private int maxDepth = 3;
256
 
257
 
258
     // --------------------------------------------------------- Public Methods
259
 

    
Initialize this servlet. 
263
 
264
     public void init()
265
         throws ServletException {
266
 
267
         super.init();
268
 
269
         if (getServletConfig().getInitParameter("secret") != null)
270
              = getServletConfig().getInitParameter("secret");
271
 
272
         if (getServletConfig().getInitParameter("maxDepth") != null)
273
              = Integer.parseInt(
274
                     getServletConfig().getInitParameter("maxDepth"));
275
 
276
         // Load the MD5 helper used to calculate signatures.
277
         try {
278
              = MessageDigest.getInstance("MD5");
279
         } catch (NoSuchAlgorithmException e) {
280
             throw new UnavailableException("No MD5");
281
         }
282
 
283
     }
284
 
285
 
286
     // ------------------------------------------------------ Protected Methods
287
 

    
Return JAXP document builder instance. 
291
 
292
     protected DocumentBuilder getDocumentBuilder()
293
         throws ServletException {
294
         DocumentBuilder documentBuilder = null;
295
         DocumentBuilderFactory documentBuilderFactory = null;
296
         try {
297
             documentBuilderFactory = DocumentBuilderFactory.newInstance();
298
             documentBuilderFactory.setNamespaceAware(true);
299
             documentBuilderFactory.setExpandEntityReferences(false);
300
             documentBuilder = documentBuilderFactory.newDocumentBuilder();
301
             documentBuilder.setEntityResolver(
302
                     new WebdavResolver(this.getServletContext()));
303
         } catch(ParserConfigurationException e) {
304
             throw new ServletException(.jaxpInitializationFailed());
305
         }
306
         return documentBuilder;
307
     }


    
Handles the special WebDAV methods. 
312
 
313
     protected void service(HttpServletRequest req, HttpServletResponse resp)
314
         throws ServletException, IOException {
315
 
316
         String method = req.getMethod();
317
 
318
         if ( > 0) {
319
             String path = getRelativePath(req);
320
             log("[" + method + "] " + path);
321
         }
322
 
323
         if (method.equals()) {
324
             doPropfind(req, resp);
325
         } else if (method.equals()) {
326
             doProppatch(req, resp);
327
         } else if (method.equals()) {
328
             doMkcol(req, resp);
329
         } else if (method.equals()) {
330
             doCopy(req, resp);
331
         } else if (method.equals()) {
332
             doMove(req, resp);
333
         } else if (method.equals()) {
334
             doLock(req, resp);
335
         } else if (method.equals()) {
336
             doUnlock(req, resp);
337
         } else {
338
             // DefaultServlet processing
339
             super.service(req, resp);
340
         }
341
 
342
     }


    
Check if the conditions specified in the optional If headers are satisfied.

Parameters:
request The servlet request we are processing
response The servlet response we are creating
resourceAttributes The resource information
Returns:
boolean true if the resource meets all the specified conditions, and false if any of the conditions is not satisfied, in which case request processing is stopped
355
 
356
     protected boolean checkIfHeaders(HttpServletRequest request,
357
                                      HttpServletResponse response,
358
                                      ResourceAttributes resourceAttributes)
359
         throws IOException {
360
 
361
         if (!super.checkIfHeaders(request, response, resourceAttributes))
362
             return false;
363
 
364
         // TODO : Checking the WebDAV If header
365
         return true;
366
 
367
     }


    
Override the DefaultServlet implementation and only use the PathInfo. If the ServletPath is non-null, it will be because the WebDAV servlet has been mapped to a url other than /* to configure editing at different url than normal viewing.

Parameters:
request The servlet request we are processing
377
 
378
     protected String getRelativePath(HttpServletRequest request) {
379
         // Are we being processed by a RequestDispatcher.include()?
380
         if (request.getAttribute(.) != null) {
381
             String result = (String) request.getAttribute(
382
                     .);
383
             if ((result == null) || (result.equals("")))
384
                 result = "/";
385
             return (result);
386
         }
387
 
388
         // No, extract the desired path directly from the request
389
         String result = request.getPathInfo();
390
         if ((result == null) || (result.equals(""))) {
391
             result = "/";
392
         }
393
         return (result);
394
 
395
     }


    
OPTIONS Method.

Parameters:
req The request
resp The response
Throws:
javax.servlet.ServletException If an error occurs
java.io.IOException If an IO error occurs
405
 
406
     protected void doOptions(HttpServletRequest req, HttpServletResponse resp)
407
         throws ServletException, IOException {
408
 
409
         resp.addHeader("DAV", "1,2");
410
 
411
         StringBuilder methodsAllowed = determineMethodsAllowed(,
412
                                                               req);
413
 
414
         resp.addHeader("Allow", methodsAllowed.toString());
415
         resp.addHeader("MS-Author-Via", "DAV");
416
 
417
     }


    
PROPFIND Method. 
422
 
423
     protected void doPropfind(HttpServletRequest req, HttpServletResponse resp)
424
         throws ServletException, IOException {
425
 
426
         if (!) {
427
             // Get allowed methods
428
             StringBuilder methodsAllowed = determineMethodsAllowed(,
429
                                                                   req);
430
 
431
             resp.addHeader("Allow", methodsAllowed.toString());
432
             resp.sendError(.);
433
             return;
434
         }
435
 
436
         String path = getRelativePath(req);
437
         if (path.endsWith("/"))
438
             path = path.substring(0, path.length() - 1);
439
 
440
         if ((path.toUpperCase(.).startsWith("/WEB-INF")) ||
441
             (path.toUpperCase(.).startsWith("/META-INF"))) {
442
             resp.sendError(.);
443
             return;
444
         }
445
 
446
         // Properties which are to be displayed.
447
         Vector<String> properties = null;
448
         // Propfind depth
449
         int depth = ;
450
         // Propfind type
451
         int type = ;
452
 
453
         String depthStr = req.getHeader("Depth");
454
 
455
         if (depthStr == null) {
456
             depth = ;
457
         } else {
458
             if (depthStr.equals("0")) {
459
                 depth = 0;
460
             } else if (depthStr.equals("1")) {
461
                 depth = 1;
462
             } else if (depthStr.equals("infinity")) {
463
                 depth = ;
464
             }
465
         }
466
 
467
         Node propNode = null;
468
         
469
         if (req.getContentLength() > 0) {
470
             DocumentBuilder documentBuilder = getDocumentBuilder();
471
     
472
             try {
473
                 Document document = documentBuilder.parse
474
                     (new InputSource(req.getInputStream()));
475
     
476
                 // Get the root element of the document
477
                 Element rootElement = document.getDocumentElement();
478
                 NodeList childList = rootElement.getChildNodes();
479
     
480
                 for (int i=0; i < childList.getLength(); i++) {
481
                     Node currentNode = childList.item(i);
482
                     switch (currentNode.getNodeType()) {
483
                     case .:
484
                         break;
485
                     case .:
486
                         if (currentNode.getNodeName().endsWith("prop")) {
487
                             type = ;
488
                             propNode = currentNode;
489
                         }
490
                         if (currentNode.getNodeName().endsWith("propname")) {
491
                             type = ;
492
                         }
493
                         if (currentNode.getNodeName().endsWith("allprop")) {
494
                             type = ;
495
                         }
496
                         break;
497
                     }
498
                 }
499
             } catch (SAXException e) {
500
                 // Something went wrong - bad request
501
                 resp.sendError(.);
502
             } catch (IOException e) {
503
                 // Something went wrong - bad request
504
                 resp.sendError(.);
505
             }
506
         }
507
 
508
         if (type == ) {
509
             properties = new Vector<String>();
510
             NodeList childList = propNode.getChildNodes();
511
 
512
             for (int i=0; i < childList.getLength(); i++) {
513
                 Node currentNode = childList.item(i);
514
                 switch (currentNode.getNodeType()) {
515
                 case .:
516
                     break;
517
                 case .:
518
                     String nodeName = currentNode.getNodeName();
519
                     String propertyName = null;
520
                     if (nodeName.indexOf(':') != -1) {
521
                         propertyName = nodeName.substring
522
                             (nodeName.indexOf(':') + 1);
523
                     } else {
524
                         propertyName = nodeName;
525
                     }
526
                     // href is a live property which is handled differently
527
                     properties.addElement(propertyName);
528
                     break;
529
                 }
530
             }
531
 
532
         }
533
 
534
         boolean exists = true;
535
         Object object = null;
536
         try {
537
             object = .lookup(path);
538
         } catch (NamingException e) {
539
             exists = false;
540
             int slash = path.lastIndexOf('/');
541
             if (slash != -1) {
542
                 String parentPath = path.substring(0, slash);
543
                 Vector<String> currentLockNullResources =
544
                     .get(parentPath);
545
                 if (currentLockNullResources != null) {
546
                     Enumeration<String> lockNullResourcesList =
547
                         currentLockNullResources.elements();
548
                     while (lockNullResourcesList.hasMoreElements()) {
549
                         String lockNullPath =
550
                             lockNullResourcesList.nextElement();
551
                         if (lockNullPath.equals(path)) {
552
                             resp.setStatus(.);
553
                             resp.setContentType("text/xml; charset=UTF-8");
554
                             // Create multistatus object
555
                             XMLWriter generatedXML =
556
                                 new XMLWriter(resp.getWriter());
557
                             generatedXML.writeXMLHeader();
558
                             generatedXML.writeElement
559
                                 (null, "multistatus"
560
                                  + generateNamespaceDeclarations(),
561
                                  .);
562
                             parseLockNullProperties
563
                                 (req, generatedXML, lockNullPath, type,
564
                                  properties);
565
                             generatedXML.writeElement(null, "multistatus",
566
                                                       .);
567
                             generatedXML.sendData();
568
                             return;
569
                         }
570
                     }
571
                 }
572
             }
573
         }
574
 
575
         if (!exists) {
576
             resp.sendError(., path);
577
             return;
578
         }
579
 
580
         resp.setStatus(.);
581
 
582
         resp.setContentType("text/xml; charset=UTF-8");
583
 
584
         // Create multistatus object
585
         XMLWriter generatedXML = new XMLWriter(resp.getWriter());
586
         generatedXML.writeXMLHeader();
587
 
588
         generatedXML.writeElement(null, "multistatus"
589
                                   + generateNamespaceDeclarations(),
590
                                   .);
591
 
592
         if (depth == 0) {
593
             parseProperties(req, generatedXML, path, type,
594
                             properties);
595
         } else {
596
             // The stack always contains the object of the current level
597
             Stack<String> stack = new Stack<String>();
598
             stack.push(path);
599
 
600
             // Stack of the objects one level below
601
             Stack<String> stackBelow = new Stack<String>();
602
 
603
             while ((!stack.isEmpty()) && (depth >= 0)) {
604
 
605
                 String currentPath = stack.pop();
606
                 parseProperties(req, generatedXML, currentPath,
607
                                 type, properties);
608
 
609
                 try {
610
                     object = .lookup(currentPath);
611
                 } catch (NamingException e) {
612
                     continue;
613
                 }
614
 
615
                 if ((object instanceof DirContext) && (depth > 0)) {
616
 
617
                     try {
618
                         NamingEnumeration<NameClassPair> enumeration =
619
                             .list(currentPath);
620
                         while (enumeration.hasMoreElements()) {
621
                             NameClassPair ncPair = enumeration.nextElement();
622
                             String newPath = currentPath;
623
                             if (!(newPath.endsWith("/")))
624
                                 newPath += "/";
625
                             newPath += ncPair.getName();
626
                             stackBelow.push(newPath);
627
                         }
628
                     } catch (NamingException e) {
629
                         resp.sendError
630
                             (.,
631
                              path);
632
                         return;
633
                     }
634
 
635
                     // Displaying the lock-null resources present in that
636
                     // collection
637
                     String lockPath = currentPath;
638
                     if (lockPath.endsWith("/"))
639
                         lockPath =
640
                             lockPath.substring(0, lockPath.length() - 1);
641
                     Vector<String> currentLockNullResources =
642
                         .get(lockPath);
643
                     if (currentLockNullResources != null) {
644
                         Enumeration<String> lockNullResourcesList =
645
                             currentLockNullResources.elements();
646
                         while (lockNullResourcesList.hasMoreElements()) {
647
                             String lockNullPath =
648
                                 lockNullResourcesList.nextElement();
649
                             parseLockNullProperties
650
                                 (req, generatedXML, lockNullPath, type,
651
                                  properties);
652
                         }
653
                     }
654
 
655
                 }
656
 
657
                 if (stack.isEmpty()) {
658
                     depth--;
659
                     stack = stackBelow;
660
                     stackBelow = new Stack<String>();
661
                 }
662
 
663
                 generatedXML.sendData();
664
 
665
             }
666
         }
667
 
668
         generatedXML.writeElement(null, "multistatus",
669
                                   .);
670
 
671
         generatedXML.sendData();
672
 
673
     }


    
PROPPATCH Method. 
678
 
679
     protected void doProppatch(HttpServletRequest req,
680
                                HttpServletResponse resp)
681
         throws ServletException, IOException {
682
 
683
         if () {
684
             resp.sendError(.);
685
             return;
686
         }
687
 
688
         if (isLocked(req)) {
689
             resp.sendError(.);
690
             return;
691
         }
692
 
694
 
695
     }


    
MKCOL Method. 
700
 
701
     protected void doMkcol(HttpServletRequest req, HttpServletResponse resp)
702
         throws ServletException, IOException {
703
 
704
         if () {
705
             resp.sendError(.);
706
             return;
707
         }
708
 
709
         if (isLocked(req)) {
710
             resp.sendError(.);
711
             return;
712
         }
713
 
714
         String path = getRelativePath(req);
715
 
716
         if ((path.toUpperCase(.).startsWith("/WEB-INF")) ||
717
             (path.toUpperCase(.).startsWith("/META-INF"))) {
718
             resp.sendError(.);
719
             return;
720
         }
721
 
722
         boolean exists = true;
723
         try {
724
             .lookup(path);
725
         } catch (NamingException e) {
726
             exists = false;
727
         }
728
 
729
         // Can't create a collection if a resource already exists at the given
730
         // path
731
         if (exists) {
732
             // Get allowed methods
733
             StringBuilder methodsAllowed = determineMethodsAllowed(,
734
                                                                   req);
735
 
736
             resp.addHeader("Allow", methodsAllowed.toString());
737
 
738
             resp.sendError(.);
739
             return;
740
         }
741
 
742
         if (req.getContentLength() > 0) {
743
             DocumentBuilder documentBuilder = getDocumentBuilder();
744
             try {
745
                 // Document document =
746
                 documentBuilder.parse(new InputSource(req.getInputStream()));
747
                 // TODO : Process this request body
748
                 resp.sendError(.);
749
                 return;
750
 
751
             } catch(SAXException saxe) {
752
                 // Parse error - assume invalid content
753
                 resp.sendError(.);
754
                 return;
755
             }
756
         }
757
 
758
         boolean result = true;
759
         try {
760
             .createSubcontext(path);
761
         } catch (NamingException e) {
762
             result = false;
763
         }
764
 
765
         if (!result) {
766
             resp.sendError(.,
767
                            WebdavStatus.getStatusText
768
                            (.));
769
         } else {
770
             resp.setStatus(.);
771
             // Removing any lock-null resource which would be present
772
             .remove(path);
773
         }
774
 
775
     }


    
DELETE Method. 
780
 
781
     protected void doDelete(HttpServletRequest req, HttpServletResponse resp)
782
         throws ServletException, IOException {
783
 
784
         if () {
785
             resp.sendError(.);
786
             return;
787
         }
788
 
789
         if (isLocked(req)) {
790
             resp.sendError(.);
791
             return;
792
         }
793
 
794
         deleteResource(req, resp);
795
 
796
     }


    
Process a POST request for the specified resource.

Parameters:
req The servlet request we are processing
resp The servlet response we are creating
Throws:
java.io.IOException if an input/output error occurs
javax.servlet.ServletException if a servlet-specified error occurs
807
 
808
     protected void doPut(HttpServletRequest req, HttpServletResponse resp)
809
         throws ServletException, IOException {
810
 
811
         if (isLocked(req)) {
812
             resp.sendError(.);
813
             return;
814
         }
815
 
816
         super.doPut(req, resp);
817
 
818
         String path = getRelativePath(req);
819
 
820
         // Removing any lock-null resource which would be present
821
         .remove(path);
822
 
823
     }

    
COPY Method. 
827
 
828
     protected void doCopy(HttpServletRequest req, HttpServletResponse resp)
829
         throws ServletException, IOException {
830
 
831
         if () {
832
             resp.sendError(.);
833
             return;
834
         }
835
 
836
         copyResource(req, resp);
837
 
838
     }


    
MOVE Method. 
843
 
844
     protected void doMove(HttpServletRequest req, HttpServletResponse resp)
845
         throws ServletException, IOException {
846
 
847
         if () {
848
             resp.sendError(.);
849
             return;
850
         }
851
 
852
         if (isLocked(req)) {
853
             resp.sendError(.);
854
             return;
855
         }
856
 
857
         String path = getRelativePath(req);
858
 
859
         if (copyResource(req, resp)) {
860
             deleteResource(path, req, resp, false);
861
         }
862
 
863
     }


    
LOCK Method. 
868
 
869
     protected void doLock(HttpServletRequest req, HttpServletResponse resp)
870
         throws ServletException, IOException {
871
 
872
         if () {
873
             resp.sendError(.);
874
             return;
875
         }
876
 
877
         if (isLocked(req)) {
878
             resp.sendError(.);
879
             return;
880
         }
881
 
882
         LockInfo lock = new LockInfo();
883
 
884
         // Parsing lock request
885
 
886
         // Parsing depth header
887
 
888
         String depthStr = req.getHeader("Depth");
889
 
890
         if (depthStr == null) {
891
             lock.depth = ;
892
         } else {
893
             if (depthStr.equals("0")) {
894
                 lock.depth = 0;
895
             } else {
896
                 lock.depth = ;
897
             }
898
         }
899
 
900
         // Parsing timeout header
901
 
902
         int lockDuration = ;
903
         String lockDurationStr = req.getHeader("Timeout");
904
         if (lockDurationStr == null) {
905
             lockDuration = ;
906
         } else {
907
             int commaPos = lockDurationStr.indexOf(",");
908
             // If multiple timeouts, just use the first
909
             if (commaPos != -1) {
910
                 lockDurationStr = lockDurationStr.substring(0,commaPos);
911
             }
912
             if (lockDurationStr.startsWith("Second-")) {
913
                 lockDuration =
914
                     (new Integer(lockDurationStr.substring(7))).intValue();
915
             } else {
916
                 if (lockDurationStr.equalsIgnoreCase("infinity")) {
917
                     lockDuration = ;
918
                 } else {
919
                     try {
920
                         lockDuration =
921
                             (new Integer(lockDurationStr)).intValue();
922
                     } catch (NumberFormatException e) {
923
                         lockDuration = ;
924
                     }
925
                 }
926
             }
927
             if (lockDuration == 0) {
928
                 lockDuration = ;
929
             }
930
             if (lockDuration > ) {
931
                 lockDuration = ;
932
             }
933
         }
934
         lock.expiresAt = System.currentTimeMillis() + (lockDuration * 1000);
935
 
936
         int lockRequestType = ;
937
 
938
         Node lockInfoNode = null;
939
 
940
         DocumentBuilder documentBuilder = getDocumentBuilder();
941
 
942
         try {
943
             Document document = documentBuilder.parse(new InputSource
944
                 (req.getInputStream()));
945
 
946
             // Get the root element of the document
947
             Element rootElement = document.getDocumentElement();
948
             lockInfoNode = rootElement;
949
         } catch (IOException e) {
950
             lockRequestType = ;
951
         } catch (SAXException e) {
952
             lockRequestType = ;
953
         }
954
 
955
         if (lockInfoNode != null) {
956
 
957
             // Reading lock information
958
 
959
             NodeList childList = lockInfoNode.getChildNodes();
960
             StringWriter strWriter = null;
961
             DOMWriter domWriter = null;
962
 
963
             Node lockScopeNode = null;
964
             Node lockTypeNode = null;
965
             Node lockOwnerNode = null;
966
 
967
             for (int i=0; i < childList.getLength(); i++) {
968
                 Node currentNode = childList.item(i);
969
                 switch (currentNode.getNodeType()) {
970
                 case .:
971
                     break;
972
                 case .:
973
                     String nodeName = currentNode.getNodeName();
974
                     if (nodeName.endsWith("lockscope")) {
975
                         lockScopeNode = currentNode;
976
                     }
977
                     if (nodeName.endsWith("locktype")) {
978
                         lockTypeNode = currentNode;
979
                     }
980
                     if (nodeName.endsWith("owner")) {
981
                         lockOwnerNode = currentNode;
982
                     }
983
                     break;
984
                 }
985
             }
986
 
987
             if (lockScopeNode != null) {
988
 
989
                 childList = lockScopeNode.getChildNodes();
990
                 for (int i=0; i < childList.getLength(); i++) {
991
                     Node currentNode = childList.item(i);
992
                     switch (currentNode.getNodeType()) {
993
                     case .:
994
                         break;
995
                     case .:
996
                         String tempScope = currentNode.getNodeName();
997
                         if (tempScope.indexOf(':') != -1) {
998
                             lock.scope = tempScope.substring
999
                                 (tempScope.indexOf(':') + 1);
1000
                        } else {
1001
                            lock.scope = tempScope;
1002
                        }
1003
                        break;
1004
                    }
1005
                }
1007
                if (lock.scope == null) {
1008
                    // Bad request
1009
                    resp.setStatus(.);
1010
                }
1012
            } else {
1013
                // Bad request
1014
                resp.setStatus(.);
1015
            }
1017
            if (lockTypeNode != null) {
1019
                childList = lockTypeNode.getChildNodes();
1020
                for (int i=0; i < childList.getLength(); i++) {
1021
                    Node currentNode = childList.item(i);
1022
                    switch (currentNode.getNodeType()) {
1023
                    case .:
1024
                        break;
1025
                    case .:
1026
                        String tempType = currentNode.getNodeName();
1027
                        if (tempType.indexOf(':') != -1) {
1028
                            lock.type =
1029
                                tempType.substring(tempType.indexOf(':') + 1);
1030
                        } else {
1031
                            lock.type = tempType;
1032
                        }
1033
                        break;
1034
                    }
1035
                }
1037
                if (lock.type == null) {
1038
                    // Bad request
1039
                    resp.setStatus(.);
1040
                }
1042
            } else {
1043
                // Bad request
1044
                resp.setStatus(.);
1045
            }
1047
            if (lockOwnerNode != null) {
1049
                childList = lockOwnerNode.getChildNodes();
1050
                for (int i=0; i < childList.getLength(); i++) {
1051
                    Node currentNode = childList.item(i);
1052
                    switch (currentNode.getNodeType()) {
1053
                    case .:
1054
                        lock.owner += currentNode.getNodeValue();
1055
                        break;
1056
                    case .:
1057
                        strWriter = new StringWriter();
1058
                        domWriter = new DOMWriter(strWriter, true);
1059
                        domWriter.setQualifiedNames(false);
1060
                        domWriter.print(currentNode);
1061
                        lock.owner += strWriter.toString();
1062
                        break;
1063
                    }
1064
                }
1066
                if (lock.owner == null) {
1067
                    // Bad request
1068
                    resp.setStatus(.);
1069
                }
1071
            } else {
1072
                lock.owner = new String();
1073
            }
1075
        }
1077
        String path = getRelativePath(req);
1079
        lock.path = path;
1081
        boolean exists = true;
1082
        Object object = null;
1083
        try {
1084
            object = .lookup(path);
1085
        } catch (NamingException e) {
1086
            exists = false;
1087
        }
1089
        Enumeration<LockInfo> locksList = null;
1091
        if (lockRequestType == ) {
1093
            // Generating lock id
1094
            String lockTokenStr = req.getServletPath() + "-" + lock.type + "-"
1095
                + lock.scope + "-" + req.getUserPrincipal() + "-"
1096
                + lock.depth + "-" + lock.owner + "-" + lock.tokens + "-"
1097
                + lock.expiresAt + "-" + System.currentTimeMillis() + "-"
1098
                + ;
1099
            String lockToken =
1100
                .encode(.digest(lockTokenStr.getBytes()));
1102
            if ( (exists) && (object instanceof DirContext) &&
1103
                 (lock.depth == ) ) {
1105
                // Locking a collection (and all its member resources)
1107
                // Checking if a child resource of this collection is
1108
                // already locked
1109
                Vector<String> lockPaths = new Vector<String>();
1110
                locksList = .elements();
1111
                while (locksList.hasMoreElements()) {
1112
                    LockInfo currentLock = locksList.nextElement();
1113
                    if (currentLock.hasExpired()) {
1114
                        .remove(currentLock.path);
1115
                        continue;
1116
                    }
1117
                    if ( (currentLock.path.startsWith(lock.path)) &&
1118
                         ((currentLock.isExclusive()) ||
1119
                          (lock.isExclusive())) ) {
1120
                        // A child collection of this collection is locked
1121
                        lockPaths.addElement(currentLock.path);
1122
                    }
1123
                }
1124
                locksList = .elements();
1125
                while (locksList.hasMoreElements()) {
1126
                    LockInfo currentLock = locksList.nextElement();
1127
                    if (currentLock.hasExpired()) {
1128
                        .remove(currentLock.path);
1129
                        continue;
1130
                    }
1131
                    if ( (currentLock.path.startsWith(lock.path)) &&
1132
                         ((currentLock.isExclusive()) ||
1133
                          (lock.isExclusive())) ) {
1134
                        // A child resource of this collection is locked
1135
                        lockPaths.addElement(currentLock.path);
1136
                    }
1137
                }
1139
                if (!lockPaths.isEmpty()) {
1141
                    // One of the child paths was locked
1142
                    // We generate a multistatus error report
1144
                    Enumeration<String> lockPathsList = lockPaths.elements();
1146
                    resp.setStatus(.);
1148
                    XMLWriter generatedXML = new XMLWriter();
1149
                    generatedXML.writeXMLHeader();
1151
                    generatedXML.writeElement
1152
                        (null, "multistatus" + generateNamespaceDeclarations(),
1153
                         .);
1155
                    while (lockPathsList.hasMoreElements()) {
1156
                        generatedXML.writeElement(null, "response",
1157
                                                  .);
1158
                        generatedXML.writeElement(null, "href",
1159
                                                  .);
1160
                        generatedXML
1161
                            .writeText(lockPathsList.nextElement());
1162
                        generatedXML.writeElement(null, "href",
1163
                                                  .);
1164
                        generatedXML.writeElement(null, "status",
1165
                                                  .);
1166
                        generatedXML
1167
                            .writeText("HTTP/1.1 " + .
1168
                                       + " " + WebdavStatus
1169
                                       .getStatusText(.));
1170
                        generatedXML.writeElement(null, "status",
1171
                                                  .);
1173
                        generatedXML.writeElement(null, "response",
1174
                                                  .);
1175
                    }
1177
                    generatedXML.writeElement(null, "multistatus",
1178
                                          .);
1180
                    Writer writer = resp.getWriter();
1181
                    writer.write(generatedXML.toString());
1182
                    writer.close();
1184
                    return;
1186
                }
1188
                boolean addLock = true;
1190
                // Checking if there is already a shared lock on this path
1191
                locksList = .elements();
1192
                while (locksList.hasMoreElements()) {
1194
                    LockInfo currentLock = locksList.nextElement();
1195
                    if (currentLock.path.equals(lock.path)) {
1197
                        if (currentLock.isExclusive()) {
1198
                            resp.sendError(.);
1199
                            return;
1200
                        } else {
1201
                            if (lock.isExclusive()) {
1202
                                resp.sendError(.);
1203
                                return;
1204
                            }
1205
                        }
1207
                        currentLock.tokens.addElement(lockToken);
1208
                        lock = currentLock;
1209
                        addLock = false;
1211
                    }
1213
                }
1215
                if (addLock) {
1216
                    lock.tokens.addElement(lockToken);
1217
                    .addElement(lock);
1218
                }
1220
            } else {
1222
                // Locking a single resource
1224
                // Retrieving an already existing lock on that resource
1225
                LockInfo presentLock = .get(lock.path);
1226
                if (presentLock != null) {
1228
                    if ((presentLock.isExclusive()) || (lock.isExclusive())) {
1229
                        // If either lock is exclusive, the lock can't be
1230
                        // granted
1231
                        resp.sendError(.);
1232
                        return;
1233
                    } else {
1234
                        presentLock.tokens.addElement(lockToken);
1235
                        lock = presentLock;
1236
                    }
1238
                } else {