jdbcsystemdatabase.java

这是linux下ssl vpn的实现程序

    }

    public WebForward createWebForward(WebForward webForward) throws Exception {
        JDBCPreparedStatement ps = db.getStatement("createWebForward.insert");

        /*
         * For this method, we could get errors when inserting proxy paths (if
         * path already exists). To deal with this the whole operation is run as
         * a transaction.
         */
        ps.startTransaction();

        try {
            int id = -1;
            ps.setString(1, webForward.getDestinationURL());
            ps.setInt(2, webForward.getType());
            ps.setString(3, webForward.getResourceName());
            ps.setString(4, webForward.getResourceDescription());
            ps.setString(5, webForward.getCategory());
            ps.setInt(6, webForward.getParentResourcePermission());
            Calendar now = Calendar.getInstance();
            ps.setString(7, db.formatTimestamp(now));
            ps.setString(8, db.formatTimestamp(now));
            ps.execute();
            webForward.setResourceId(id = db.getLastInsertId(ps, "createWebForward.lastInsertId"));

            if (webForward instanceof ReverseProxyWebForward) {
                ps = db.getStatement(ps, "createWebForward.reverseProxy.insert");
                StringTokenizer t = new StringTokenizer(((ReverseProxyWebForward) webForward).getPaths(), "\n\r");
                while (t.hasMoreTokens()) {
                    String path = t.nextToken();
                    ps.setString(1, path);
                    ps.setInt(2, id);
                    ps.execute();
                    ps.reset();
                }
                ps = db.getStatement(ps, "createWebForward.reverseProxyOptions.insert");
                ps.setInt(1, webForward.getResourceId());
                ps.setString(2, ((ReverseProxyWebForward) webForward).getAuthenticationUsername());
                ps.setString(3, Util.emptyWhenNull(((ReverseProxyWebForward) webForward).getAuthenticationPassword()));
                ps.setString(4, ((ReverseProxyWebForward) webForward).getPreferredAuthenticationScheme());
                ps.setInt(5, ((ReverseProxyWebForward) webForward).getActiveDNS() ? 1 : 0);
                ps.setString(6, ((ReverseProxyWebForward) webForward).getHostHeader());
                ps.setString(7, ((ReverseProxyWebForward) webForward).getFormType());
                ps.setString(8, ((ReverseProxyWebForward) webForward).getFormParameters());
                ps.setString(9, ((ReverseProxyWebForward) webForward).getCharset());
                ps.execute();
            }

            if (webForward instanceof ReplacementProxyWebForward) {
                ps = db.getStatement(ps, "createWebForward.replacementProxyOptions.insert");
                ps.setInt(1, webForward.getResourceId());
                ps.setString(2, ((ReplacementProxyWebForward) webForward).getAuthenticationUsername());
                ps.setString(3, Util.emptyWhenNull(((ReplacementProxyWebForward) webForward).getAuthenticationPassword()));
                ps.setString(4, ((ReplacementProxyWebForward) webForward).getPreferredAuthenticationScheme());
                ps.setString(5, ((ReplacementProxyWebForward) webForward).getEncoding());
                ps.setString(6, ((ReplacementProxyWebForward) webForward).getRestrictToHosts().getAsPropertyText());
                ps.setString(7, ((ReplacementProxyWebForward) webForward).getFormType());
                ps.setString(8, ((ReplacementProxyWebForward) webForward).getFormParameters());
                ps.execute();
            }

            ps.commit();
        } catch (Exception e) {
            ps.rollback();
            throw e;
        } finally {
            ps.releasePreparedStatement();
            ps.endTransaction();
        }
        return webForward;
    }

    public void updateWebForward(WebForward webForward) throws Exception {
        JDBCPreparedStatement ps = db.getStatement("updateWebForward.update");

        /*
         * For this method, we could get errors when inserting proxy paths (if
         * path already exists). To deal with this the whole operation is run as
         * a transaction.
         */
        ps.startTransaction();

        try {

            ps.setInt(1, webForward.getType());
            ps.setString(2, webForward.getResourceName());
            ps.setString(3, webForward.getDestinationURL());
            ps.setString(4, webForward.getResourceDescription());
            ps.setString(5, webForward.getCategory());
            ps.setInt(6, webForward.getParentResourcePermission());
            Calendar c = Calendar.getInstance();
            ps.setString(7, db.formatTimestamp(c));
            ps.setInt(8, webForward.getResourceId());
            ps.execute();

            if (webForward instanceof ReverseProxyWebForward) {
                ps = db.getStatement(ps, "updateWebForward.reverseProxy.delete");
                ps.setInt(1, webForward.getResourceId());
                ps.execute();
                ps = db.getStatement(ps, "updateWebForward.reverseProxy.insert");
                StringTokenizer t = new StringTokenizer(((ReverseProxyWebForward) webForward).getPaths(), "\n\r");
                while (t.hasMoreTokens()) {
                    String path = t.nextToken();
                    ps.setString(1, path);
                    ps.setInt(2, webForward.getResourceId());
                    ps.execute();
                    ps.reset();
                }
                ps = db.getStatement(ps, "updateWebForward.reverseProxyOptions.update");
                ps.setString(1, ((ReverseProxyWebForward) webForward).getAuthenticationUsername());
                ps.setString(2, ((ReverseProxyWebForward) webForward).getAuthenticationPassword());
                ps.setString(3, ((ReverseProxyWebForward) webForward).getPreferredAuthenticationScheme());
                ps.setInt(4, ((ReverseProxyWebForward) webForward).getActiveDNS() ? 1 : 0);
                ps.setString(5, ((ReverseProxyWebForward) webForward).getHostHeader());
                ps.setString(6, ((ReverseProxyWebForward) webForward).getFormType());
                ps.setString(7, ((ReverseProxyWebForward) webForward).getFormParameters());
                ps.setString(8, ((ReverseProxyWebForward) webForward).getCharset());
                ps.setInt(9, webForward.getResourceId());

                ps.execute();
            }

            if (webForward instanceof ReplacementProxyWebForward) {
                ps = db.getStatement(ps, "updateWebForward.replacementProxyOptions.update");
                ps.setString(1, ((ReplacementProxyWebForward) webForward).getEncoding());
                ps.setString(2, ((ReplacementProxyWebForward) webForward).getRestrictToHosts().getAsPropertyText());
                ps.setString(3, ((ReplacementProxyWebForward) webForward).getAuthenticationUsername());
                ps.setString(4, ((ReplacementProxyWebForward) webForward).getAuthenticationPassword());
                ps.setString(5, ((ReplacementProxyWebForward) webForward).getPreferredAuthenticationScheme());
                ps.setString(6, ((ReplacementProxyWebForward) webForward).getFormType());
                ps.setString(7, ((ReplacementProxyWebForward) webForward).getFormParameters());
                ps.setInt(8, webForward.getResourceId());
                ps.execute(); 
            }

            ps.commit();
        } catch (Exception e) {
            ps.rollback();
            throw e;
        } finally {
            ps.releasePreparedStatement();
            ps.endTransaction();
        }
    }

    /*
     * (non-Javadoc)
     * 
     * @see com.sslexplorer.security.SystemDatabase#deleteWebForward(int)
     */
    public WebForward deleteWebForward(int webForwardId) throws Exception {
        WebForward wf = getWebForward(webForwardId);
        if (wf == null) {
            throw new Exception("No web forward with id of " + webForwardId);
        }
        JDBCPreparedStatement ps = db.getStatement("deleteWebForward.delete.favorites");
        try {
            ps.setInt(1, PolicyConstants.WEBFORWARD_RESOURCE_TYPE_ID);
            ps.setString(2, String.valueOf(webForwardId));
            ps.execute();
        } finally {
            ps.releasePreparedStatement();
        }
        ps = db.getStatement("deleteWebForward.delete.webForward");
        try {
            ps.setInt(1, webForwardId);
            ps.execute();
        } finally {
            ps.releasePreparedStatement();
        }
        if (wf.getType() == WebForward.TYPE_REPLACEMENT_PROXY) {
            ps = db.getStatement("deleteWebForward.delete.replacementProxy.options");
            try {
                ps.setInt(1, wf.getResourceId());
                ps.execute();
            } finally {
                ps.releasePreparedStatement();
            }
        }
        if (wf.getType() == WebForward.TYPE_REVERSE_PROXY) {
            ps = db.getStatement("deleteWebForward.delete.reverseProxy");
            try {
                ps.setInt(1, wf.getResourceId());
                ps.execute();
            } finally {
                ps.releasePreparedStatement();
            }
            ps = db.getStatement("deleteWebForward.delete.reverseProxy.options");
            try {
                ps.setInt(1, wf.getResourceId());
                ps.execute();
            } finally {
                ps.releasePreparedStatement();
            }
        }
        return wf;
    }

    public NetworkPlace createNetworkPlace(String scheme, String shortName, String description, String uri,

    boolean readOnly, boolean allowResursive, boolean noDelete, boolean showHidden, int parentResourcePermission) throws Exception {
        JDBCPreparedStatement ps = db.getStatement("createNetworkPlace.insert");
        try {
            ps.setString(1, scheme);
            ps.setString(2, uri);
            ps.setString(3, shortName);
            ps.setString(4, description);
            ps.setInt(5, readOnly ? 1 : 0);
            ps.setInt(6, allowResursive ? 1 : 0);
            ps.setInt(7, noDelete ? 1 : 0);
            ps.setInt(8, showHidden ? 1 : 0);
            ps.setInt(9, parentResourcePermission);
            Calendar now = Calendar.getInstance();
            ps.setString(10, db.formatTimestamp(now));
            ps.setString(11, db.formatTimestamp(now));
            ps.execute();
            int id = db.getLastInsertId(ps, "createNetworkPlace.lastInsertId");
            return this.getNetworkPlace(id);
        } finally {
            ps.releasePreparedStatement();
        }
    }

    /*
     * (non-Javadoc)
     * 
     * @see com.sslexplorer.security.SystemDatabase#getNetworkPlace(java.lang.String)
     */
    public NetworkPlace getNetworkPlace(String name) throws Exception {
        JDBCPreparedStatement ps = null;
        ps = db.getStatement("getNetworkPlace.select.name");
        ps.setString(1, name);
        try {
            ResultSet rs = ps.executeQuery();
            try {
                if (rs.next()) {
                    return buildNetworkPlace(rs);
                }
                return null;
            } finally {
                rs.close();
            }
        } finally {
            ps.releasePreparedStatement();
        }
    }

    /*
     * (non-Javadoc)
     * 
     * @see com.sslexplorer.security.SystemDatabase#getNetworkPlace(int)
     */
    public NetworkPlace getNetworkPlace(int resourceId) throws Exception {
        JDBCPreparedStatement ps = null;
        ps = db.getStatement("getNetworkPlace.select");
        ps.setInt(1, resourceId);
        try {
            ResultSet rs = ps.executeQuery();
            try {
                if (rs.next()) {
                    return buildNetworkPlace(rs);
                }
                return null;
            } finally {
                rs.close();
            }
        } finally {
            ps.releasePreparedStatement();
        }
    }

    /*
     * (non-Javadoc)
     * 
     * @see com.sslexplorer.security.SystemDatabase#updateNetworkPlace(int,
     *      java.lang.String, java.lang.String, java.lang.String, boolean,
     *      boolean, boolean, boolean, int)
     */
    public void updateNetworkPlace(int resourceId, String scheme, String resourceName, String resourceDescription, String uri, boolean readOnly,
                                   boolean allowResursive, boolean noDelete, boolean showHidden, int parentResourcePermission)
                    throws Exception {
        JDBCPreparedStatement ps = db.getStatement("updateNetworkPlace.update");
        try {
            ps.setString(1, resourceName);
            ps.setString(2, scheme);
            ps.setString(3, uri);
            ps.setString(4, resourceDescription);
            ps.setInt(5, readOnly ? 1 : 0);
            ps.setInt(6, allowResursive ? 1 : 0);
            ps.setInt(7, noDelete ? 1 : 0);
            ps.setInt(8, showHidden ? 1 : 0);
            ps.setInt(9, parentResourcePermission);
            Calendar now = Calendar.getInstance();
            ps.setString(10, db.formatTimestamp(now));
            ps.setInt(11, resourceId);
            ps.execute();
        } finally {
            ps.releasePreparedStatement();
        }
    }

    /*
     * (non-Javadoc)
     * 
     * @see com.sslexplorer.security.SystemDatabase#getNetworkPlaces()
     */
    public List getNetworkPlaces() throws Exception {
        List v = new ArrayList();
        JDBCPreparedStatement ps = db.getStatement("getNetworkPlaces.select");
        try {
            ResultSet rs = ps.executeQuery();
            try {
                while (rs.next()) {
                    v.add(buildNetworkPlace(rs));
                }
            } finally {
                rs.close();
            }
        } finally {
            ps.releasePreparedStatement();
        }
        return v;
    }

    /*
     * (non-Javadoc)
     * 
     * @see com.sslexplorer.security.SystemDatabase#deleteNetworkPlace(int)
     */
    public NetworkPlace deleteNetworkPlace(int id) throws Exception {
        NetworkPlace np = getNetworkPlace(id);
        if (np == null) {
            throw new Exception("Tunnel " + id + " doesn't exist.");
        }
        JDBCPreparedStatement ps = null;
        ps = db.getStatement("deleteNetworkPlace.delete");
        try {
            ps.setInt(1, id);
            ps.execute();
        } finally {
            ps.releasePreparedStatement();
        }
        return np;
    }

    //
    // Replacements
    //

    /*
     * (non-Javadoc)
     * 
     * @see com.sslexplorer.security.SystemDatabase#getReplacementsForContent(java.lang.String,
     *      int, java.lang.String, java.lang.String)
     */