Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * #%L
   * =====================================================
   *   _____                _     ____  _   _       _   _
   *  |_   _|_ __ _   _ ___| |_  / __ \| | | | ___ | | | |
   *    | | | '__| | | / __| __|/ / _` | |_| |/ __|| |_| |
   *    | | | |  | |_| \__ \ |_| | (_| |  _  |\__ \|  _  |
   *    |_| |_|   \__,_|___/\__|\ \__,_|_| |_||___/|_| |_|
   *                             \____/
  * 
  * =====================================================
  * 
  * Hochschule Hannover
  * (University of Applied Sciences and Arts, Hannover)
  * Faculty IV, Dept. of Computer Science
  * Ricklinger Stadtweg 118, 30459 Hannover, Germany
  * 
  * Email: trust@f4-i.fh-hannover.de
  * Website: http://trust.f4.hs-hannover.de/
  * 
  * This file is part of ifmapj, version 2.0.0, implemented by the Trust@HsH
  * research group at the Hochschule Hannover.
  * %%
  * Copyright (C) 2010 - 2014 Trust@HsH
  * %%
  * Licensed 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.
  * #L%
  */
 package de.hshannover.f4.trust.ifmapj.channel;
 
 import java.util.Map;
 
 
Attempt to create a CommunicationHandler implementation to be independent of any extra library... Meaning making usage only of standard JAVA classes.

Author(s):
aw
 
 
 
 	private byte[] mBuffer;
 
 	private class StatusLine {
 		public int mStatusCode;
 		public String mReason;
 	}
 
 			SSLSocketFactory sslSocketFactoryHostnameVerifier verifierint initialConnectionTimeout)
 		super(urluserpasssslSocketFactoryverifierinitialConnectionTimeout);
 
 		// some random initial buffer
 		 = new byte[1024];
 	}
 
 		StatusLine statusLine = null;
 		int retLength = -1;
 
 		statusLine = readStatusLine();
 		checkStatusLine(statusLine);
			retLength = readChunkedBody();
			retLength = readContinuousBody();
else {
			throw new CommunicationException("Could not determine length of body");
		}
		return new ByteArrayInputStream(, 0, retLength);
	}
		String chunkLengthLine = null;
		String tmpLine = null;
		int curOffset = 0;
		int curChunkLength = -1;
		while ((chunkLengthLine = .readLine()) != null) {
			if (chunkLengthLine.length() == 0) {
				throw new CommunicationException("Unexpected empty chunk length");
			}
			curChunkLength = parseChunkLength(chunkLengthLine);
			// Was the last chunk reached?
			if (curChunkLength == 0) {
				break;
			}
			reallocateBuffer(. + 2 * curChunkLength);
			readStreamIntoBuffer(curOffsetcurChunkLength);
			curOffset += curChunkLength;
			// Read the CR LF sequence at the end of the chunk body
			if (tmpLine == null || tmpLine.length() > 0) {
				throw new CommunicationException("Unexpected chunk ending: " + tmpLine);
			}
		}
		// After the last chunk, there might be some trailers, we ignore them
		// for now, but we need to read them anyway.
		while ((tmpLine = .readLine()) != null) {
			if (tmpLine.length() == 0) {
				break;
			}
		}
		return curOffset;
	}
	private int parseChunkLength(String chunkLengthLinethrows CommunicationException {
		String []lengthStrElements = chunkLengthLine.split(" ");
		if (lengthStrElements.length < 1) {
			throw new CommunicationException("No chunk length included: " + chunkLengthLine);
		}
		try {
			return Integer.parseInt(lengthStrElements[0], 16);
catch (NumberFormatException e) {
			throw new CommunicationException("Could not parse chunk length");
		}
	}
	private boolean responseContainsContentLength() {
		return findHeaderValue("Content-Length") != null;
	}
	private boolean responseIsChunked() {
		String teHeader = findHeaderValue("Transfer-Encoding");
		// FIXME: We only look out for chunked, but
		// there could be something else as well
		return teHeader != null && teHeader.contains("chunked");
	}
	protected void prepareCommunication() throws IOException {
		if ( != null &&  != null) {
			return;
		}
	}
	protected void createPostRequest(String paththrows IOException {
		writeLine("POST " + path + " HTTP/1.1");
	}
	protected void addHeader(String keyString valuethrows IOException {
		writeHeaderLine(keyvalue);
	}
	protected void finishHeaders() throws IOException {
	}
	protected boolean replyIsGzipped() throws IOException {
		String encodingHdr = findHeaderValue("Content-Encoding");
		return encodingHdr != null && encodingHdr.contains("gzip");
	}
	private void sendHttpBody(InputStream isthrows IOException {
		int length = is.available();
	}
	private void writeHeaderLine(String keyString valuethrows IOException {
		writeLine(key + ": " + value);
	}
	private void writeHeaderEnding() throws IOException {
	}
	private void writeLine(String linethrows IOException {
		.write((line + "\r\n").getBytes());
	}
	protected void closeTcpConnectionImpl() throws IOException {
		IOException tmp = null;
		try {
			if ( != null) {
			}
catch (IOException e) {
			if (tmp == null) {
				tmp = e;
			}
finally {
			 = null;
		}
		try {
			if ( != null) {
			}
catch (IOException e) {
			if (tmp != null) {
				tmp = e;
			}
finally {
			 = null;
		}
		if (tmp != null) {
			throw tmp;
		}
	}
	private int getContentLength() throws CommunicationException {
		String lengthHdr = findHeaderValue("Content-Length");
		if (lengthHdr == null) {
			throw new CommunicationException("No Content-Length header found");
		}
		return parseContentLengthHeader(lengthHdr);
	}
	private int parseContentLengthHeader(String lengthHdrthrows CommunicationException {
		try {
			return Integer.parseInt(lengthHdr);
catch (NumberFormatException e) {
			throw new CommunicationException("Content-Length invalid: "
"\"" + lengthHdr + "\"");
		}
	}
	private String findHeaderValue(String hdrField) {
		for (String hdr : .keySet()) {
			if (hdr.equalsIgnoreCase(hdrField)) {
				return .get(hdr);
			}
		}
		return null;
	}
	private void receiveHeaders() throws CommunicationExceptionIOException  {
		String line = null;
		while ((.readLine()) != null && line.length() > 0) {
			String[] fields = line.split(":", 2);
			if (fields.length < 2) {
				throw new CommunicationException("Invalid Header Received: "  + line);
			}
			// trim a bit
			fields[0] = fields[0].replaceAll("^\\s+""");
			fields[0] = fields[0].replaceAll("\\s+$""");
			fields[1] = fields[1].replaceAll("^\\s+""");
			fields[1] = fields[1].replaceAll("\\s+$""");
			.put(fields[0], fields[1]);
		}
		if (line == null) {
			throw new CommunicationException("Unexpected EOF reached");
		}
	}
		StatusLine ret = new StatusLine();
		if (line == null) {
			throw new CommunicationException("No status line received");
		}
		String[] fields = line.split(" ", 3);
		if (fields.length < 2) {
			throw new CommunicationException("Bad status line received");
		}
		String proto = fields[0];
		if (!proto.equals("HTTP/1.1")) {
			throw new  CommunicationException("Communication not HTTP/1.1");
		}
		try {
			ret.mStatusCode = Integer.parseInt(fields[1]);
catch (NumberFormatException e) {
			throw new CommunicationException("Bad status code received");
		}
		if (fields.length == 3) {
			ret.mReason = fields[2];
		}
		return ret;
	}
		int length = getContentLength();
		return length;
	}
	private void checkStatusLine(StatusLine statusthrows CommunicationException {
		if (status.mStatusCode != 200) {
			IfmapJLog.warn("HTTP Status Code: "
status.mStatusCode + " "
status.mReason);
			throw new CommunicationException("HTTP Status Code: "
status.mStatusCode + " "
status.mReason);
		}
	}
	private void sendBufferContents(int lengththrows IOException {
	}

Helper to read length bytes into mBuffer.

Parameters:
is
length
Throws:
java.io.IOException
	private void readStreamIntoBuffer(InputStream isint lengththrows IOException {
		readStreamIntoBuffer(is, 0, length);
	}
	private void readStreamIntoBuffer(InputStream isint offint length)
			throws IOException {
		int read = 0;
		int ret;
		while (read < length) {
			ret = is.read(read + offlength - read);
			if (ret == -1) {
				throw new IOException("Stream exception");
			}
			read += ret;
		}
	}

Check if our current buffer is too small, and if yes, allocate some more

Parameters:
length
	private void allocateBuffer(int newLength) {
		allocateBuffer(newLengthfalse);
	}
	private void reallocateBuffer(int newLength) {
		allocateBuffer(newLengthtrue);
	}
	private void allocateBuffer(int newLengthboolean copy) {
		byte[] tmp;
		if (newLength > .) {
			tmp = ;
			 = new byte[newLength];
			if (copy) {
				System.arraycopy(tmp, 0, , 0, tmp.length);
			}
		}
	}
New to GrepCode? Check out our FAQ X