Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. The ASF licenses this file to You * under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. For additional information regarding * copyright in this work, please see the NOTICE file in the top level * directory of this distribution. */ package org.apache.abdera.protocol.server.multipart; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.PushbackInputStream; import java.util.Collection; import java.util.Enumeration; import java.util.HashMap; import java.util.Map; import javax.mail.Header; import javax.mail.MessagingException; import javax.mail.internet.InternetHeaders; import org.apache.abdera.model.Document; import org.apache.abdera.model.Element; import org.apache.abdera.model.Entry; import org.apache.abdera.parser.ParseException; import org.apache.abdera.parser.Parser; import org.apache.abdera.protocol.server.RequestContext; import org.apache.abdera.protocol.server.impl.AbstractCollectionAdapter; import org.apache.abdera.util.Constants; import org.apache.abdera.util.MimeTypeHelper; import org.apache.commons.codec.binary.Base64; @SuppressWarnings("unchecked") public abstract class AbstractMultipartCollectionAdapter extends AbstractCollectionAdapter implements MultipartRelatedCollectionInfo { private static final String CONTENT_TYPE_HEADER = "content-type"; private static final String CONTENT_ID_HEADER = "content-id"; private static final String START_PARAM = "start"; private static final String TYPE_PARAM = "type"; private static final String BOUNDARY_PARAM = "boundary"; protected Map<String, String> accepts; public String[] getAccepts(RequestContext request) { Collection<String> acceptKeys = getAlternateAccepts(request).keySet(); return acceptKeys.toArray(new String[acceptKeys.size()]); } protected MultipartRelatedPost getMultipartRelatedData(RequestContext request) throws IOException, ParseException, MessagingException { MultipartInputStream multipart = getMultipartStream(request); multipart.skipBoundary(); String start = request.getContentType().getParameter(START_PARAM); Document<Entry> entry = null; Map<String, String> entryHeaders = new HashMap<String, String>(); InputStream data = null; Map<String, String> dataHeaders = new HashMap<String, String>(); Map<String, String> headers = getHeaders(multipart); // check if the first boundary is the media link entry if (start == null || start.length() == 0 || (headers.containsKey(CONTENT_ID_HEADER) && start.equals(headers.get(CONTENT_ID_HEADER))) || (headers.containsKey(CONTENT_TYPE_HEADER) && MimeTypeHelper.isAtom(headers.get(CONTENT_TYPE_HEADER)))) { entry = getEntry(multipart, request); entryHeaders.putAll(headers); } else { data = getDataInputStream(multipart); dataHeaders.putAll(headers); } multipart.skipBoundary(); headers = getHeaders(multipart); if (start != null && (headers.containsKey(CONTENT_ID_HEADER) && start.equals(headers.get(CONTENT_ID_HEADER))) && (headers.containsKey(CONTENT_TYPE_HEADER) && MimeTypeHelper.isAtom(headers.get(CONTENT_TYPE_HEADER)))) { entry = getEntry(multipart, request); entryHeaders.putAll(headers); } else { data = getDataInputStream(multipart); dataHeaders.putAll(headers); } checkMultipartContent(entry, dataHeaders, request); return new MultipartRelatedPost(entry, data, entryHeaders, dataHeaders); } private MultipartInputStream getMultipartStream(RequestContext request) throws IOException, ParseException, IllegalArgumentException { String boundary = request.getContentType().getParameter(BOUNDARY_PARAM); if (boundary == null) { throw new IllegalArgumentException("multipart/related stream invalid, boundary parameter is missing."); } boundary = "--" + boundary; String type = request.getContentType().getParameter(TYPE_PARAM); if (!(type != null && MimeTypeHelper.isAtom(type))) { throw new ParseException( "multipart/related stream invalid, type parameter should be " + Constants.ATOM_MEDIA_TYPE); } PushbackInputStream pushBackInput = new PushbackInputStream(request.getInputStream(), 2); pushBackInput.unread("\r\n".getBytes()); return new MultipartInputStream(pushBackInput, boundary.getBytes()); } private void checkMultipartContent(Document<Entry> entry, Map<String, String> dataHeaders, RequestContext request) throws ParseException { if (entry == null) { throw new ParseException("multipart/related stream invalid, media link entry is missing"); } if (!dataHeaders.containsKey(CONTENT_TYPE_HEADER)) { throw new ParseException("multipart/related stream invalid, data content-type is missing"); } if (!isContentTypeAccepted(dataHeaders.get(CONTENT_TYPE_HEADER), request)) { throw new ParseException("multipart/related stream invalid, content-type " + dataHeaders.get(CONTENT_TYPE_HEADER) + " not accepted into this multipart file"); } } private Map<String, String> getHeaders(MultipartInputStream multipart) throws IOException, MessagingException { Map<String, String> mapHeaders = new HashMap<String, String>(); moveToHeaders(multipart); InternetHeaders headers = new InternetHeaders(multipart); Enumeration<Header> allHeaders = headers.getAllHeaders(); if (allHeaders != null) { while (allHeaders.hasMoreElements()) { Header header = allHeaders.nextElement(); mapHeaders.put(header.getName().toLowerCase(), header.getValue()); } } return mapHeaders; } private boolean moveToHeaders(InputStream stream) throws IOException { boolean dash = false; boolean cr = false; int byteReaded; while ((byteReaded = stream.read()) != -1) { switch (byteReaded) { case '\r': cr = true; dash = false; break; case '\n': if (cr == true) return true; dash = false; break; case '-': if (dash == true) { // two dashes stream.close(); return false; } dash = true; cr = false; break; default: dash = false; cr = false; } } return false; } private InputStream getDataInputStream(InputStream stream) throws IOException { Base64 base64 = new Base64(); ByteArrayOutputStream bo = new ByteArrayOutputStream(); byte[] buffer = new byte[1024]; while (stream.read(buffer) != -1) { bo.write(buffer); } return new ByteArrayInputStream(base64.decode(bo.toByteArray())); } private <T extends Element> Document<T> getEntry(InputStream stream, RequestContext request) throws ParseException, IOException { Parser parser = request.getAbdera().getParser(); if (parser == null) throw new IllegalArgumentException("No Parser implementation was provided"); Document<?> document = parser.parse(stream, request.getResolvedUri().toString(), parser.getDefaultParserOptions()); return (Document<T>) document; } private boolean isContentTypeAccepted(String contentType, RequestContext request) { if (getAlternateAccepts(request) == null) { return false; } for (Map.Entry<String, String> accept : getAlternateAccepts(request).entrySet()) { if (accept.getKey().equalsIgnoreCase(contentType) && accept.getValue() != null && accept.getValue().equalsIgnoreCase(Constants.LN_ALTERNATE_MULTIPART_RELATED)) { return true; } } return false; } protected class MultipartRelatedPost { private final Document<Entry> entry; private final InputStream data; private final Map<String, String> entryHeaders; private final Map<String, String> dataHeaders; public MultipartRelatedPost(Document<Entry> entry, InputStream data, Map<String, String> entryHeaders, Map<String, String> dataHeaders) { this.entry = entry; this.data = data; this.entryHeaders = entryHeaders; this.dataHeaders = dataHeaders; } public Document<Entry> getEntry() { return entry; } public InputStream getData() { return data; } public Map<String, String> getEntryHeaders() { return entryHeaders; } public Map<String, String> getDataHeaders() { return dataHeaders; } } }