- Moved the dtstart,dtend fixing to icalUtilities so it can be called from updateFrom...

[jgroupdav.git] / src / main / java / net / bionicmessage / groupdav / groupDAV.java

/* BionicMessage.net Java GroupDAV library V1.0
 * groupDAV.java
 *
 * Created on February 26, 2006, 1:11 PM
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"), 
 * to deal in the Software without restriction, including without limitation 
 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
 * and/or sell copies of the Software, and to permit persons to whom the 
 * Software is furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in 
 * all copies or substantial portions of the Software.
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 
 * IN THE SOFTWARE.
 *
 *
 */
package net.bionicmessage.groupdav;

import java.io.*;
import java.net.*;
import net.bionicmessage.extutils.*;
import java.util.*;
import java.util.logging.*;
import javax.xml.parsers.*;
import org.xml.sax.InputSource;
import javax.net.SocketFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

/**
 * A basic GroupDAV implementation
 * @author <a href="http://bionicmessage.net">Mathew McBride</a>.
 */
public class groupDAV implements IDAVHandler {

    public static final int MODE_GROUPDAV = 0;
    public static final int MODE_CALDAV = 1;
    public static final int MODE_CARDDAV = 2;
    private String host = "";
    private int po = 2000;
    private String base64cache = "";
    private String sdir = "";
    private static Logger logger =
            Logger.getLogger(("funambol"));
    private static ConsoleHandler ch = new ConsoleHandler();
    DocumentBuilderFactory fdb = DocumentBuilderFactory.newInstance();
    private SocketFactory ssf = null;
    private boolean ssl = false;
    private Socket sock = null;
    private int offset = 0;
    private StringBuffer sbuf = null;
    private Thread th = null;
    public static final String USER_AGENT = "BionicMessage.net GroupDAV {1.0a;Java}";
    private String tok = "http://";
    private String origurl = "";
    private URL serverURL = null;
    private CalDAVExtensions cdavex = null;
    private CardDAVExtensions cardex = null;
    private ConcurrentDownloader cd = null;    // SAXDAVHandler stuff
    private SAXDAVHandler sx;
    private boolean propReady = false;
    private Exception propRetException = null;
    private List<HTTPCookie> cookieJar = null;

    
    /** For use in situations where something (i.e in the case of
     * Funambol's authentication) has already given us a HTTP Basic Base64
     * representation of user:pass
     * @param url The host and port of the server to connect to, in the
     *            format of http://hostname:port/
     * @param b64cache A String pre-encoded in Base 64 representing
     *                 &quot;Autorization: Basic pass:user&quot;
     *                 (Google HTTP Basic authentication for more information)
     */
    public groupDAV(String url, String b64cache) {
        base64cache = "Authorization: Basic " + b64cache;
        init(url);
    }

    /** Constructor using a http://// url, and plain text passwords.
     * @param url The host and port of the server to connect to, in the
     *            format of http://hostname:port/
     * @param user The username of the user connecting to the server
     * @param pass The password of the user connecting to the server
     */
    public groupDAV(String url, String user, String pass) {
        base64cache = "Authorization: Basic " + Base64.encodeBytes(new String(user + ":" + pass).getBytes());
        init(url);
    }

    /** Set the logger to output to
     * @param log The logger instance to use
     */
    public void setLogger(Logger log) {
        logger = log;
        cdavex.setLog(log);
    }

    /** Initiate client */
    public void init(String url) {
        origurl = url;
        try {
            serverURL = new URL(url);
            if (serverURL.getProtocol().contains("https")) {
                ssl = true;
            }
            host = serverURL.getHost();
            po = serverURL.getPort();
            if (po == -1 && !ssl) {
                po = 80;
            } else if (po == -1 && ssl) {
                po = 443;
            }
        } catch (MalformedURLException ex) {
            Logger.getLogger(groupDAV.class.getName()).log(Level.SEVERE, null, ex);
            throw new IllegalArgumentException(ex);
        }
        if (!origurl.substring(origurl.length() - 1).equals("/")) {
            origurl = url + "/";
        }
        logger.setLevel(Level.ALL);
        logger.addHandler(ch);
        ch.setLevel(Level.ALL);
        logger.info("GroupDAV client init()");
        try {
            ssf = SSLSocketFactory.getDefault();
        } catch (Exception e) {
            e.printStackTrace();
        }
        cdavex = new CalDAVExtensions(serverURL, this, logger);
        cardex = new CardDAVExtensions(serverURL, this, logger);
        cookieJar = new ArrayList<HTTPCookie>(2); // don't expect 
    }

    public int getUseMode(String path) throws Exception {
        if (cdavex.doesSupportCalDAV(Common.createURL(path, serverURL))) {
            return MODE_CALDAV;
        } else if (cardex.doesSupportCardDAV(Common.createURL(path, serverURL))) {
            return MODE_CARDDAV;
        }
        return MODE_GROUPDAV;
    }

    /** Send after client initation to discover object stores on the server
     * @throws Exception When the server fails to supply discovery data */
    /* public boolean findStores() throws Exception {
    byte[] pfind = buildPROPFIND("");
    String output = sendNonKeepAliveRequest(pfind);
    int clength = findContentLength(output);
    if (clength == -1) {
    logger.warning("No Content-Length in findStores");
    }
    String xmldata = output.substring(output.length() - clength - 1, output.length());
    xmldata = xmldata.trim();
    if (!xmldata.contains("<?xml")) {
    throw new Exception("No <?xml field in xmldata, dying");
    }
    logger.finer("Split=" + xmldata);
    generateEntityList(xmldata, storeFinderHandler);
    return false;
    } */
    /** Get a list of store URL's from the server */
    /* public Hashtable getURLLocs() {
    Hashtable locations = new Hashtable();
    ArrayList list = storeFinderHandler.getObjectList();
    Hashtable dtypes = storeFinderHandler.getObjectDtypes();
    Hashtable gtypes = storeFinderHandler.getObjectGtypes();
    for (int i = 0; i < list.size(); i++) {
    String url = (String) list.get(0);
    String davtype = (String) dtypes.get(url);
    if (davtype.equals("collection")) {
    String gtype = (String) gtypes.get(url);
    if (gtype != null) {
    locations.put(url, gtype);
    }
    }
    }
    return locations;
    } */
    /** List objects in a store
     */
    public List listObjects(String url) throws Exception {
        logger.fine("Listing objects for: " + url);
        byte[] pfind = buildPROPFIND(url);
        HTTPInputStream istream = Common.sendNonKeepAliveRequest(serverURL, pfind);
        InputSource is = new InputSource(istream);
        propReady = false;
        propRetException = null;
        sx = new SAXDAVHandler(this, is);
        do {
        } while (!propReady);
        if (propRetException != null) {
            throw propRetException;
        }
        addToCookieJar(istream.getCookies());
        Map<String, String> etags = sx.getEtagMap();
        List<String> urls = sx.getHrefs();
        List<String> cleaned = new ArrayList(urls.size());
        List<String> types = sx.getTypes();
        for (int i = 0; i < urls.size(); i++) {
            String lurl = (String) urls.get(i);
            String type = (String) types.get(i);
            String etag = (String) etags.get(lurl);
            if (type != null && type.contains("collection") || etag.length() < 1) {
                /* Don't add this location to the list; it is a collection */
                logger.finer("Collection: "+lurl);
            } else {
                // Make sure all URLs coming out of here are FULL!
                URL fullURL = Common.createURL(lurl, serverURL);
                cleaned.add(fullURL.toString());
                logger.finer("Object: "+fullURL.toExternalForm());
            }
        }
        return cleaned;
    }

    /** Posts an object */
    public GroupDAVObject postObject(String subdir, String uid, String contents) throws Exception {
        // Todo - convert to full URL
        if (!subdir.endsWith("/")) {
            subdir = subdir.concat("/");
        }
        uid = uid.trim();
        String type = "text/calendar;charset=utf-8";
        if (contents.indexOf("begin:vcard") != -1 ||
                contents.indexOf("BEGIN:VCARD") != -1) {
            type = "text/x-vcard;charset=utf-8";
        }
        HashMap headers = new HashMap();
        headers.put("Content-Type", type);
        headers.put("If-None-Match", "*");
        URL fullURL = Common.createURL(subdir + "new.ics", serverURL);
        //byte[] query = buildGroupDAVQuery("PUT", subdir + "new.ics", contents, headers);
        byte[] query = Common.buildQuery("PUT", fullURL, contents.getBytes(), headers,
                this);
        String q = new String(query);
        String t = Common.sendNonKeepAliveRequest(serverURL, query, this, logger);
        logger.fine("We got" + t);
        String firstLine = t.split("\r\n")[0];
        if (firstLine.indexOf("405") != -1) {
            throw new Exception("Post error: " + t);
        }
        GroupDAVObject gobjP = new GroupDAVObject(t, GroupDAVObject.OBJECT_PUT);
        addToCookieJar(gobjP.getCookies());
        /* Did the server give us a location? If not, assume the location is exactly
         * what we gave it (this rarely happens anyway) */
        if (gobjP.getLocation() == null) {
            gobjP.setLocation(origurl + subdir + uid);
        } else if (gobjP.getLocation() != null) {
            URL url = Common.createURL(gobjP.getLocation(), serverURL);
            gobjP.setLocation(url.toString());
        }
        // Did the server give us an eTag with the PUT request or will we have
        // to fetch the object?
        if (gobjP.getEtag() == null) {
            GroupDAVObject gobjG = getObject(gobjP.getLocation());
            return gobjG;
        } else {
            return gobjP;
        }
    }

    /** Modifies an object on the server. 
     * @param addr Path to object on server (i.e /groupdav/Calendar/event.ics)
     * @param contents New object contents
     * @param etag Previous etag of object
     * @return A GroupDAVObject with returned server contents
     * @throws java.lang.Exception Due to network errors
     */
    public GroupDAVObject modifyObject(String addr,
            String contents,
            String etag) throws Exception {
        String type = "text/calendar";
        if (contents.indexOf("begin:vcard") != -1 ||
                contents.indexOf("BEGIN:VCARD") != -1) {
            type = "text/x-vcard";
        }
        // Drop the hostname since we specify it in Host:
        //addr = addr.replace(origurl, "/");
        URL objAddr = new URL(serverURL, addr);

        HashMap headers = new HashMap();
        headers.put("Content-Type", type);
        headers.put("If-Match", etag);
        byte[] query = Common.buildQuery("PUT", objAddr, contents.getBytes("UTF-8"), headers, this);
        String q = new String(query);
        String resp = Common.sendNonKeepAliveRequest(serverURL, query, this, logger);
        logger.finest("We got: " + resp);
        String firstLine = resp.split("\r\n")[0];
        GroupDAVObject gobjP = new GroupDAVObject(resp, GroupDAVObject.OBJECT_PUT);
        if (gobjP.getStatus() > 400 && gobjP.getStatus() != 403) { // let 403 errors slide
            throw new Exception("Error modifying object: " + firstLine);
        } else if (gobjP.getStatus() == 403) {
            return null; // Forbidden errors should be dealt with by the user.
        }
        /* Did the server give us a location? If not, assume the location is exactly
         * what we gave it */
        if (gobjP.getLocation() == null) {
            gobjP.setLocation(addr);
        } else if (gobjP.getLocation() != null) {
            URL url = Common.createURL(gobjP.getLocation(), serverURL);
            gobjP.setLocation(url.toString());
        }
        // Did the server give us an eTag with the PUT request or will we have
        // to fetch the object?
        if (gobjP.getEtag() == null) {
            GroupDAVObject gobjG = getObject(gobjP.getLocation());
            return gobjG;
        } else {
            return gobjP;
        }
    }

    public GroupDAVObject deleteObject(String addr, String etag) throws Exception {
        URL netURL = new URL(serverURL, addr);
        HashMap header = new HashMap();
        header.put("If-Match", etag);
        byte[] query = Common.buildQuery("DELETE", netURL, new byte[0], header, this);
        String resp = Common.sendNonKeepAliveRequest(serverURL, query, this, logger);
        logger.finest("We got: " + resp);
        GroupDAVObject gbo = new GroupDAVObject(resp, GroupDAVObject.OBJECT_KILLED);
        return gbo;
    }

    /** Execute a GET command and return a GroupDAVObject */
    public GroupDAVObject getObject(String url) throws Exception {
        //url = url.replace(tok + host + ":" + po, "");
        URL pathURL = Common.createURL(url, serverURL);
        String header[] = {base64cache};
        byte[] send = Common.buildQuery("GET", pathURL, new byte[0], null, this);
        String st = new String(send);
        String t = Common.sendNonKeepAliveRequest(serverURL, send, this, logger);
        String firstLine = t.split("\r\n")[0];
        GroupDAVObject obj = new GroupDAVObject(t, GroupDAVObject.OBJECT_GET);
        if (obj.getStatus() > 400) {
            throw new Exception("HTTP error encountered: "+firstLine);
        }
        obj.setLocation(pathURL.toExternalForm());
        return obj;
    }

    public Map<String, String> getURLsByEventEnding(String path, String startRange, String endRange) throws Exception {
        //return cdavex.getByTimeRange(Common.createURL(path, serverURL), "VEVENT", "DTSTART", startRange, endRange);
        return getURLsByTimeRange(path, "VEVENT", "DTEND", startRange, endRange);
    }

    public Map<String, String> getURLsByTimeRange(String path, String type, String property, String startRange,
            String endRange) throws Exception {
        return cdavex.getByTimeRange(Common.createURL(path, serverURL), type, property, startRange, endRange);
    }

    /** Obtain all objects from a server store */
    public List<GroupDAVObject> getAllObjectsInPath(String path, int typeOfQuery, int downloadParameter)
            throws Exception {
        List toDL = this.listObjects(path);
        return getObjectsInBulk(path, toDL,typeOfQuery,downloadParameter);
    }

    /** Download objects in bulk.
     * @param root The root dir to get all objects from (i.e /groupdav/Calendar/)
     * @param paths A list of objects to download
     * @param typeOfQuery Server type
     * @param downloadParamater Paramater for download driver
     */
    public List<GroupDAVObject> getObjectsInBulk(String root, 
            List<String> paths, 
            int typeOfQuery,
            int downloadParameter) throws Exception {
        URL path = Common.createURL(root, serverURL);
        List<GroupDAVObject> downloaded = null;
        downloaded = new ArrayList<GroupDAVObject>(paths.size());
        if (paths.size() > downloadParameter && typeOfQuery != MODE_GROUPDAV) {
            int downloadedCounter = 0;
            while (downloadedCounter != paths.size()) {
                int start = downloadedCounter;
                int finish = 0;
                if ((paths.size() - downloadedCounter) > downloadParameter) {
                    finish = (downloadedCounter + downloadParameter);
                } else {
                    finish = start + (paths.size() - downloadedCounter);
                }
                List<String> toDL = paths.subList((downloadedCounter), finish);
                downloaded = performBulkFetch(path, toDL, typeOfQuery, downloadParameter, downloaded);
                downloadedCounter = (downloadedCounter + toDL.size());
            }
        } else {
            downloaded = performBulkFetch(path, paths, typeOfQuery, downloadParameter, downloaded);
        }
        return downloaded;
    }

    protected List<GroupDAVObject> performBulkFetch(
            URL root, 
            List<String> paths, 
            int typeOfQuery, 
            int itemsAtOnce,
            List<GroupDAVObject> addTo) throws Exception {

        /* for (String u : paths) {
        cd.addURLToDownload(u);
        }
        return cd.downloadObjects(); */
        if (typeOfQuery == MODE_GROUPDAV) {
            cd = new ConcurrentDownloader(this);
            for (String u: paths) {
                cd.addURLToDownload(u);
            }
            return cd.downloadObjects(addTo,itemsAtOnce);
        } else if (typeOfQuery == MODE_CALDAV && paths.size() > 0) {
            return cdavex.doMultiget(root, paths, addTo);
        } else if (typeOfQuery == MODE_CARDDAV && paths.size() > 0) {
            return cardex.doMultiget(root, paths, addTo);
        }
        return new ArrayList<GroupDAVObject>();
    }

    /** Build a PROPFIND query to list the contents of a collection
     * 
     * @param subdir The server path to query
     * @return A Byte array containing the HTTP headers and DAV query. 
     */
    public byte[] buildPROPFIND(String subdir) throws Exception {
        URL fullDir = new URL(serverURL, subdir);
        String XMLSTRING = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
                "<propfind xmlns=\"DAV:\"><allprop/><prop><getetag/></prop></propfind>";
        HashMap headers = new HashMap();
        headers.put("Cache-control", "no-cache");
        headers.put("Depth", "1");
        headers.put("Content-Type", "text/xml;charset=utf-8");
        byte[] query = Common.buildQuery("PROPFIND", fullDir, XMLSTRING.getBytes(), headers, this);
        return query;

    }

    private int findContentLength(String data) {
        String[] headers = data.split("\n");
        for (int i = 0; i < headers.length; i++) {
            String curHeader = headers[i];
            String[] line = curHeader.split(":");
            if (line[0].equalsIgnoreCase("Content-Length")) {
                Integer it = new Integer(line[1].trim());
                return it.intValue();
            }
        }
        return -1;
    }

    /** Returns a list of HTTP/DAV etags. Object URL's are the key in the Map.
     * If the DAV PROPFIND did not return etag properties in its result
     * an attempt to get() a etag will return null as per Map implemementation rules
     */
    public Map<String, String> getEtags() {
        // return dirFinderHandler.getObjectEtags(); 
        /* We have to convert all URLs here to full */
        Map etags = sx.getEtagMap();
        Hashtable<String, String> newEtags = new Hashtable(etags.size());
        Set urls = etags.keySet();
        Iterator urlIt = urls.iterator();
        while (urlIt.hasNext()) {
            try {
                String url = (String) urlIt.next();
                String etag = (String) etags.get(url);
                URL fullURL = Common.createURL(url, serverURL);
                newEtags.put(fullURL.toString(), etag);
            } catch (MalformedURLException ex) {
                Logger.getLogger(groupDAV.class.getName()).log(Level.SEVERE, null, ex);
            }

        }
        return newEtags;
    }

    /** Runs a HTTP OPTIONS operating to authenticate the user and return 
     * certain user parameters
     * @param path
     * @return
     * @throws java.lang.Exception
     */
    public Map<String, String> returnParamsForUser(URL path) throws Exception {
        byte[] query = Common.buildQuery("OPTIONS", path, new byte[0], null, this);
        String response = Common.sendNonKeepAliveRequest(path, query, this, logger);
        HashMap returnedParameters = new HashMap();
        GroupDAVObject opt_response = new GroupDAVObject(response, GroupDAVObject.OBJECT_GET);
        if (opt_response.getStatus() == 200) {
            return returnedParameters;
        } else {
            System.err.println("Returned response: " + opt_response.getStatus());
        }
        return null;
    }

    public boolean getReady() {
        return propReady;
    }

    public void setReady(boolean ready) {
        propReady = ready;
    }

    public void setRetException(Exception e) {
        propRetException = e;
    }
    public List<HTTPCookie> getCookieJar() {
        return cookieJar;
    }
    public void addToCookieJar(List<HTTPCookie> newCookies) {
        /* For some reason Collection.addAll doesn't always seem to work
         * Do the work ourselves */
        for(HTTPCookie c: newCookies) {
            cookieJar.add(c);
        }
    }
    public String getBase64cache() {
        return base64cache;
    }
    
}