// $Id: DAVFrame.java,v 1.39 2007/02/09 22:45:42 ylafon Exp $

// (c) COPYRIGHT MIT, INRIA and Keio, 2000.

// Please first read the full copyright statement in file COPYRIGHT.html

* @version $Revision: 1.39 $

* @author  Beno�t Mah� (bmahe@w3.org)

*/

    public static final boolean debug    = false;

    public static final boolean debugxml = false;

    /**

     * Condition check return code - Condition existed and succeeded.

     * And lock has been checked

     */

    public static final int COND_OK_LOCK = 3;

    /**

     * Cached mime type

     */

    protected static HttpMimeType xmlcontenttype        = null;

    protected static HttpMimeType collectioncontenttype = null;

    protected static boolean isReadOnly(String propname) {

  return (propname.equals(DAVNode.CREATIONDATE_NODE) ||

    propname.equals(DAVNode.GETCONTENTLENGTH_NODE) ||

    propname.equals(DAVNode.GETETAG_NODE) ||

    propname.equals(DAVNode.GETLASTMODIFIED_NODE));

    }

    protected static boolean acceptRedirect(DAVRequest request) {

  String method = request.getMethod();

  return ! (method.equals("PROPPATCH") ||

      method.equals("PROPFIND") ||

      method.equals("COPY") ||

      method.equals("MOVE") ||

      method.equals("DELETE") ||

      method.equals("LOCK") ||

      method.equals("UNLOCK"));

    }

    /**

     * The DAVManager we use.

     */

    protected  org.w3c.www.protocol.webdav.DAVManager manager = null;

    /**

     * Name ot the state to hold the remaining path (used with MKCOL)

     */

    public final static String REMAINING_PATH = "org.w3c.jigsaw.webdav.rpath";

    public final static String LOCK_USERNAME = "org.w3c.jigsaw.webdav.user";

    public final static String LOCK_TOKEN    = "org.w3c.jigsaw.webdav.token";

    public final static String LOCK_OWNER    = "org.w3c.jigsaw.webdav.owner";

    public final static String LOCK_EXPIRE   = "org.w3c.jigsaw.webdav.expire";

    public final static String LOCK_TIMEOUT  = "org.w3c.jigsaw.webdav.timeout";

    public final static String LOCKED_REREFENCE 

  = "org.w3c.jigsaw.webdav.reference";

    public final static Long DEFAULT_LOCK_TIMEOUT =

  new Long(24 * 60 * 60 * 1000); // 1 day

    public final static Long MAX_LOCK_TIMEOUT =

  new Long(7 * 24 * 60 * 60 * 1000); // 1 week

    /**

     * Attribute index - The index for the creation date attribute.

     */

    protected static int ATTR_CREATION_DATE = -1 ;

    /**

     * Attribute index - The index for the dead properties

     */

    protected static int ATTR_DEAD_PROPERTIES = -1 ;

    /**

     * Attribute index - The index for the lock token

     */

    protected static int ATTR_LOCK_TOKEN = -1 ;

    /**

     * Attribute index - The index for the lock token

     */

    protected static int ATTR_LOCK_TIMEOUT = -1 ;

    /**

     * Attribute index - The index for the lock date

     */

    protected static int ATTR_LOCK_DATE = -1 ;

    /**

     * Attribute index - The index for the lock depth

     */

    protected static int ATTR_LOCK_DEPTH = -1 ;

    /**

     * Attribute index - The index for the lock owner

     */

    protected static int ATTR_LOCK_OWNER = -1 ;

    /**

     * Attribute index - The index for the lock username

     */

    protected static int ATTR_LOCK_USERNAME = -1 ;

    static {

  Class     cls = null ;

  // Get a pointer to our own class:

  try {

      cls  = Class.forName("org.w3c.jigsaw.webdav.DAVFrame") ;

  } catch (Exception ex) {

      ex.printStackTrace() ;

      System.exit(1) ;

  }

  // Our creation date

  Attribute a = new DateAttribute("creation-date",

          null,

          Attribute.COMPUTED) ;

  ATTR_CREATION_DATE = AttributeRegistry.registerAttribute(cls,a);

  // Our creation date

  a = new PropertiesAttribute("dead-properties",

            null,

            Attribute.COMPUTED) ;

  ATTR_DEAD_PROPERTIES = AttributeRegistry.registerAttribute(cls,a);

  // Our lock token (if any)

  a = new StringAttribute("lock-token",

        null,

        Attribute.COMPUTED) ;

  ATTR_LOCK_TOKEN = AttributeRegistry.registerAttribute(cls,a);

  // Our timeout token (if any)

  a = new DateAttribute("lock-timeout",

            null,

            Attribute.COMPUTED) ;

  ATTR_LOCK_TIMEOUT = AttributeRegistry.registerAttribute(cls,a);

  // Our lock token date

  a = new DateAttribute("lock-date",

            null,

            Attribute.COMPUTED) ;

  ATTR_LOCK_DATE = AttributeRegistry.registerAttribute(cls,a);

  // Our expire token (if any)

  a = new IntegerAttribute("lock-depth",

         null,

         Attribute.COMPUTED) ;

  ATTR_LOCK_DEPTH = AttributeRegistry.registerAttribute(cls,a);

  // Our lock owner

  a = new StringAttribute("lock-owner",

        null,

        Attribute.COMPUTED) ;

  ATTR_LOCK_OWNER = AttributeRegistry.registerAttribute(cls,a);

  // Our lock owner

  a = new StringAttribute("lock-username",

        null,

        Attribute.COMPUTED) ;

  ATTR_LOCK_USERNAME = AttributeRegistry.registerAttribute(cls,a);

  // xml content type

  try {

      MimeType type = new MimeType("text/xml");

      type.addParameter("charset", WEBDAV.ENCODING);

      xmlcontenttype = HttpFactory.makeMimeType(type);

      type = new MimeType("httpd/unix-directory");

      type.addParameter("charset", WEBDAV.ENCODING);

      collectioncontenttype = HttpFactory.makeMimeType(type);

  } catch (MimeTypeFormatException ex) {

      ex.printStackTrace() ;

      System.exit(1) ;

  }

    }

    public boolean isCollection() {

  return (dresource != null);

    }

   

    /**

     * Get this resource creation date

     * @return A long giving the creation date or -1 if undefined.

     */

    public long getCreationDate() {

  return getLong(ATTR_CREATION_DATE, (long) -1) ;

    }

    protected void updateLockDate(DAVRequest request) {

  if (checkLockOwner(request)) {

      if (debug) {

    System.out.println(">>> update lock date");

      }

      setValue(ATTR_LOCK_DATE, new Long(System.currentTimeMillis()));

  }

    }

    /**

     * Get the lock token expiration date

     * @return A long giving the expiration date or -1 if undefined.

     */

    protected long getTokenExpirationDate(DAVRequest request) {

  long timeout  = getLong(ATTR_LOCK_TIMEOUT, (long) -1) ;

  long lockdate = getLong(ATTR_LOCK_DATE, (long) -1);

  if ((lockdate != -1) && (timeout != -1)) {

      return lockdate + timeout;

  } else if (request != null) {

      Long expire = (Long)request.getState(LOCK_EXPIRE);

      if (expire != null) {

    return expire.longValue();

      }

  }

  return -1;

    }

    /**

     * Get the lock token

     * @return A String instance or null

     */

    protected String getCurrentLockToken(DAVRequest request) {

  String token = getString(ATTR_LOCK_TOKEN, null);

  if ((token == null) && (request != null)) {

      token = (String)request.getState(LOCK_TOKEN);

  }

  return token;

    }

    protected long getCurrentLockTimeout(DAVRequest request) {

  long timeout = getLong(ATTR_LOCK_TIMEOUT, (long)-1);

  if (timeout == -1) {

      Long l = (Long)request.getState(LOCK_TIMEOUT);

      if (l != null) {

    return l.longValue();

      } else {

    return DEFAULT_LOCK_TIMEOUT.longValue();

      }

  } else {

      return timeout;

  }

    }

    protected Node ownerNode = null;

    /**

     * Get the lock owner

     * @return A String instance or null

     */

    protected Node getCurrentLockOwner(DAVRequest request) {

  if (ownerNode == null) {

      String owner = getString(ATTR_LOCK_OWNER, null);

      if (owner != null) {

    Base64Decoder decoder = new Base64Decoder(owner);

    try {

        String decoded = decoder.processString();

        ByteArrayInputStream in =

      new ByteArrayInputStream(decoded.getBytes());

        Document doc = DAVBody.getDocument(in, null);

        ownerNode = doc.getDocumentElement();

    } catch (Exception ex) {

        ex.printStackTrace();

    }

      } else if ((owner == null) && (request != null)) {

    return (Node)request.getState(LOCK_OWNER);

      }

  }

  return ownerNode;

    }

    /**

     * Set the lock Owner

     */

    protected void setLockOwner(Node owner) {

  ownerNode = owner;

  saveLockOwner();

    }

    private synchronized void saveLockOwner() {

  if (ownerNode != null) {

      Document doc = DAVBody.createDocument(DAVNode.OWNER_NODE);

      DAVNode.exportChildren(doc,

           doc.getDocumentElement(),

           ownerNode,

           true);

      ByteArrayOutputStream out    = new ByteArrayOutputStream();

      OutputFormat          format =

    new OutputFormat(doc, WEBDAV.ENCODING, true);

      format.setOmitXMLDeclaration(false);

      format.setPreserveSpace(true);

      XMLSerializer serializer = new XMLSerializer(out, format);

      try {

    serializer.serialize(doc);

    if (debug)

        System.out.println("["+out.toString(WEBDAV.ENCODING)+"]");

    Base64Encoder encoder =

        new Base64Encoder(out.toString(WEBDAV.ENCODING));

    setValue(ATTR_LOCK_OWNER, encoder.processString());

      } catch (IOException ex) {

    ex.printStackTrace();

      }

  }

    }

    /**

     * Get the lock depth 

     * @return An int (WEBDAV.DEPTH_0 or WEBDAV.DEPTH_INFINITY)

     */

    protected int getCurrentLockDepth() {

  return getInt(ATTR_LOCK_DEPTH, WEBDAV.DEPTH_INFINITY) ;

    }

    /**

     * Get the username of the client that lock the resource

     */

    protected String getCurrentLockUsername(DAVRequest request) {

  String username = (String)getValue(ATTR_LOCK_USERNAME, null);

  if ((username == null) && (request != null)) {

      username = (String)request.getState(LOCK_USERNAME);

  }

  return username;

    }

    private boolean hasLock() {

  return definesAttribute(ATTR_LOCK_TOKEN);

    }

    /**

     * Check if this resource or one of their parent (with depth equals

     * to infinity) has been locked

     * @param request the incomming request (it null isLocked will returns

     * true if and only if the resource has been personally locked, not one

     * of its parents)

     * @return a boolean

     */

    protected boolean isLocked(DAVRequest request) {

  if (hasLock()) {

      if (debug) {

    System.out.println(">>> Checking timeout...");

    System.out.println(System.currentTimeMillis()+" > ");

    System.out.println(getTokenExpirationDate(null));

      }