← Back to branch summary

~ubuntu-branches/ubuntu/lucid/libstruts1.2-java/lucid

« back to all changes in this revision

Viewing changes to contrib/struts-faces/src/example2/org/apache/struts/webapp/example2/memory/MemoryDatabasePlugIn.java

  • Committer: Bazaar Package Importer
  • Author(s): Arnaud Vandyck
  • Date: 2006-04-24 12:14:23 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20060424121423-naev53qigqgks0sa
Tags: 1.2.9-1
http://bugs.debian.org/360551
New upstream  release Fixes  three security  problems: CVE-2006-1546,
CVE-2006-1547,  CVE-2006-1548  (closes:  #360551),  thanks  to  Moritz
Muehlenhoff.

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/struts-faces/src/example2/org/apache/struts/webapp/example2/memory/MemoryDatabasePlugIn.java
1
 
/*
2
 
 * Copyright 1999-2002,2004 The Apache Software Foundation.
3
 
 * 
4
 
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 
 * you may not use this file except in compliance with the License.
6
 
 * You may obtain a copy of the License at
7
 
 * 
8
 
 *      http://www.apache.org/licenses/LICENSE-2.0
9
 
 * 
10
 
 * Unless required by applicable law or agreed to in writing, software
11
 
 * distributed under the License is distributed on an "AS IS" BASIS,
12
 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 
 * See the License for the specific language governing permissions and
14
 
 * limitations under the License.
15
 
 */
16
 
 
17
 
 
18
 
package org.apache.struts.webapp.example2.memory;
19
 
 
20
 
 
21
 
import java.io.BufferedInputStream;
22
 
import java.io.BufferedOutputStream;
23
 
import java.io.File;
24
 
import java.io.FileOutputStream;
25
 
import java.io.InputStream;
26
 
import java.util.ArrayList;
27
 
import javax.servlet.ServletException;
28
 
import org.apache.commons.logging.Log;
29
 
import org.apache.commons.logging.LogFactory;
30
 
import org.apache.struts.action.ActionServlet;
31
 
import org.apache.struts.action.PlugIn;
32
 
import org.apache.struts.config.ModuleConfig;
33
 
import org.apache.struts.util.LabelValueBean;
34
 
import org.apache.struts.webapp.example2.Constants;
35
 
 
36
 
/**
37
 
 * <p><strong>MemoryDatabasePlugIn</strong> initializes and finalizes the
38
 
 * persistent storage of User and Subscription information for the Struts
39
 
 * Demonstration Application, using an in-memory database backed by an
40
 
 * XML file.</p>
41
 
 *
42
 
 * <p><strong>IMPLEMENTATION WARNING</strong> - If this web application is run
43
 
 * from a WAR file, or in another environment where reading and writing of the
44
 
 * web application resource is impossible, the initial contents will be copied
45
 
 * to a file in the web application temporary directory provided by the
46
 
 * container.  This is for demonstration purposes only - you should
47
 
 * <strong>NOT</strong> assume that files written here will survive a restart
48
 
 * of your servlet container.</p>
49
 
 *
50
 
 * @author Craig R. McClanahan
51
 
 * @version $Revision: 1.2 $ $Date: 2004/03/08 02:49:53 $
52
 
 */
53
 
 
54
 
public final class MemoryDatabasePlugIn implements PlugIn {
55
 
 
56
 
 
57
 
    // ----------------------------------------------------- Instance Variables
58
 
 
59
 
 
60
 
    /**
61
 
     * The application configuration for our owning module.
62
 
     */
63
 
    private ModuleConfig config = null;
64
 
 
65
 
 
66
 
    /**
67
 
     * The {@link MemoryUserDatabase} object we construct and make available.
68
 
     */
69
 
    private MemoryUserDatabase database = null;
70
 
 
71
 
 
72
 
    /**
73
 
     * Logging output for this plug in instance.
74
 
     */
75
 
    private Log log = LogFactory.getLog(this.getClass());
76
 
 
77
 
 
78
 
    /**
79
 
     * The {@link ActionServlet} owning this application.
80
 
     */
81
 
    private ActionServlet servlet = null;
82
 
 
83
 
 
84
 
    // ------------------------------------------------------------- Properties
85
 
 
86
 
 
87
 
    /**
88
 
     * The web application resource path of our persistent database
89
 
     * storage file.
90
 
     */
91
 
    private String pathname = "/WEB-INF/database.xml";
92
 
 
93
 
    public String getPathname() {
94
 
        return (this.pathname);
95
 
    }
96
 
 
97
 
    public void setPathname(String pathname) {
98
 
        this.pathname = pathname;
99
 
    }
100
 
 
101
 
 
102
 
    // --------------------------------------------------------- PlugIn Methods
103
 
 
104
 
 
105
 
    /**
106
 
     * Gracefully shut down this database, releasing any resources
107
 
     * that were allocated at initialization.
108
 
     */
109
 
    public void destroy() {
110
 
 
111
 
        log.info("Finalizing memory database plug in");
112
 
 
113
 
        if (database != null) {
114
 
            try {
115
 
                database.close();
116
 
            } catch (Exception e) {
117
 
                log.error("Closing memory database", e);
118
 
            }
119
 
        }
120
 
 
121
 
        servlet.getServletContext().removeAttribute(Constants.DATABASE_KEY);
122
 
        database = null;
123
 
        servlet = null;
124
 
        database = null;
125
 
        config = null;
126
 
 
127
 
    }
128
 
 
129
 
 
130
 
    /**
131
 
     * Initialize and load our initial database from persistent storage.
132
 
     *
133
 
     * @param servlet The ActionServlet for this web application
134
 
     * @param config The ApplicationConfig for our owning module
135
 
     *
136
 
     * @exception ServletException if we cannot configure ourselves correctly
137
 
     */
138
 
    public void init(ActionServlet servlet, ModuleConfig config)
139
 
        throws ServletException {
140
 
 
141
 
        log.info("Initializing memory database plug in from '" +
142
 
                 pathname + "'");
143
 
 
144
 
        // Remember our associated configuration and servlet
145
 
        this.config = config;
146
 
        this.servlet = servlet;
147
 
 
148
 
        // Construct a new database and make it available
149
 
        database = new MemoryUserDatabase();
150
 
        try {
151
 
            String path = calculatePath();
152
 
            if (log.isDebugEnabled()) {
153
 
                log.debug(" Loading database from '" + path + "'");
154
 
            }
155
 
            database.setPathname(path);
156
 
            database.open();
157
 
        } catch (Exception e) {
158
 
            log.error("Opening memory database", e);
159
 
            throw new ServletException("Cannot load database from '" +
160
 
                                       pathname + "'", e);
161
 
        }
162
 
 
163
 
        // Make the initialized database available
164
 
        servlet.getServletContext().setAttribute(Constants.DATABASE_KEY,
165
 
                                                 database);
166
 
 
167
 
        // Setup and cache other required data
168
 
        setupCache(servlet, config);
169
 
 
170
 
    }
171
 
 
172
 
 
173
 
    // --------------------------------------------------------- Public Methods
174
 
 
175
 
 
176
 
    // ------------------------------------------------------ Protected Methods
177
 
 
178
 
 
179
 
    /**
180
 
     * <p>Cache commonly required data as servlet context attributes.</p>
181
 
     *
182
 
     * @param servlet The <code>ActionServlet</code> instance running
183
 
     *  this webapp
184
 
     * @param config The <code>ModuleConfig</code> for this application module
185
 
     */
186
 
    protected void setupCache(ActionServlet servlet, ModuleConfig config) {
187
 
 
188
 
        // Set up list of server types under "serverTypes"
189
 
        ArrayList serverTypes = new ArrayList();
190
 
        serverTypes.add(new LabelValueBean("IMAP Protocol", "imap"));
191
 
        serverTypes.add(new LabelValueBean("POP3 Protocol", "pop3"));
192
 
        servlet.getServletContext().setAttribute("serverTypes", serverTypes);
193
 
 
194
 
    }
195
 
 
196
 
 
197
 
 
198
 
 
199
 
    // -------------------------------------------------------- Private Methods
200
 
 
201
 
 
202
 
    /**
203
 
     * Calculate and return an absolute pathname to the XML file to contain
204
 
     * our persistent storage information.
205
 
     *
206
 
     * @exception Exception if an input/output error occurs
207
 
     */
208
 
    private String calculatePath() throws Exception {
209
 
 
210
 
        // Can we access the database via file I/O?
211
 
        String path = servlet.getServletContext().getRealPath(pathname);
212
 
        if (path != null) {
213
 
            return (path);
214
 
        }
215
 
 
216
 
        // Does a copy of this file already exist in our temporary directory
217
 
        File dir = (File)
218
 
            servlet.getServletContext().getAttribute
219
 
            ("javax.servlet.context.tempdir");
220
 
        File file = new File(dir, "struts-example-database.xml");
221
 
        if (file.exists()) {
222
 
            return (file.getAbsolutePath());
223
 
        }
224
 
 
225
 
        // Copy the static resource to a temporary file and return its path
226
 
        InputStream is =
227
 
            servlet.getServletContext().getResourceAsStream(pathname);
228
 
        BufferedInputStream bis = new BufferedInputStream(is, 1024);
229
 
        FileOutputStream os =
230
 
            new FileOutputStream(file);
231
 
        BufferedOutputStream bos = new BufferedOutputStream(os, 1024);
232
 
        byte buffer[] = new byte[1024];
233
 
        while (true) {
234
 
            int n = bis.read(buffer);
235
 
            if (n <= 0) {
236
 
                break;
237
 
            }
238
 
            bos.write(buffer, 0, n);
239
 
        }
240
 
        bos.close();
241
 
        bis.close();
242
 
        return (file.getAbsolutePath());
243
 
 
244
 
    }
245
 
 
246
 
 
247
 
}