ppg.java

Java的wap push

package push;

import javax.servlet.*;
import javax.servlet.http.*;
import java.net.*;
import java.io.*;
import java.util.StringTokenizer;

/**
 * <code>PPG</code> class implements some push proxy gateway (PPG) functionality
 * for the purposes of this example only. This simple PPG is targeted to be used
 * in conjunction with WAP toolkit, and IPv4 type client addressing.
 * 
 */
public final class PPG extends HttpServlet {

	/* xml version */
	private final static String XML_VERSION = "<?xml version=\"1.0\"?>";
	/* Push Access Protocol (PAP) document type */
	private final static String PAP_DOCTYPE = "<!DOCTYPE pap PUBLIC \"-//WAPFORUM//DTD PAP 1.0//EN\" \"http://www.wapforum.org/DTD/pap_1.0.dtd\" >";
	/* content type of the push request multipart body */
	private final static String CONTENT_TYPE = "multipart/related; boundary=multipart-boundary; type=\"application/xml\"";

	/*
	 * WAP Push connection less service (client side). The registered port
	 * number.
	 */
	private static final int connectionlessPushPort = 2948;

	private static int transactionId = 0;

	/**
	 * <code>doPost</code>
	 * 
	 * @param request
	 *            a <code>HttpServletRequest</code> value
	 * @param response
	 *            a <code>HttpServletResponse</code> value
	 * @exception ServletException
	 *                if an error occurs
	 * @exception IOException
	 *                if an error occurs
	 */
	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		String clientAddress = null;
		String pushId = null;
		int resultCode = 1001; // accepted for processing

		try {
			// first, check the content type which should be "multipart/related"
			String contentType = request.getHeader("content-type");
			StringTokenizer st = new StringTokenizer(contentType, ";");
			String token = st.nextToken();
			String boundary = null;
			if (!token.equalsIgnoreCase("multipart/related"))
				throw new Exception("wrong content type");
			// finds the boundary string
			while (st.hasMoreTokens()) {
				token = st.nextToken().trim();
				if (token.startsWith("boundary=")) {
					boundary = token.substring(9);
					break;
				}
			}
			if (boundary == null)
				throw new Exception("no multipart boundary");
			boundary = "--" + boundary;
			String endBoundary = boundary + "--";
			StringBuffer messageContent = new StringBuffer();
			BufferedReader in = request.getReader();
			String line;
			int i = 0;
			boolean startContent = false;
			System.out.println("boundary=" + boundary);
			// extract message content part
			while ((line = in.readLine()) != null) {
				if (line.equals(boundary))
					++i;
				else if (line.equals(endBoundary))
					break;
				if (i == 1) { // PAP control entity
					int j = line.indexOf("address-value=");
					if (j >= 0) {
						clientAddress = line.substring(j + 15, line.indexOf(
								'"', j + 17));
					}
					j = line.indexOf("push-id=");
					if (j >= 0) {
						pushId = line.substring(j + 9, line
								.indexOf('"', j + 11));
					}
				} else if (i == 2) { // PAP content entity
					if (startContent)
						messageContent.append(line);
					else if (line.trim().equals("")) // end of headers
						startContent = true;
					else if (line.toLowerCase().startsWith("content-type:"))
						contentType = line.substring(13).trim();
				}
			}
			if ((i = clientAddress.indexOf("/TYPE=IPv4")) == -1) {
				resultCode = 2002; // address error
				throw new Exception(
						"This PPG can handle only IPv4 type addresses");
			}
			clientAddress = clientAddress.substring(clientAddress
					.indexOf("WAPPUSH=") + 8, i);
			if (clientAddress == null) {
				resultCode = 2002; // address error
				throw new Exception("Client address is not known");
			}
			System.out.println("clientAddress: " + clientAddress);
			System.out.println("pushId: " + pushId);
			System.out.println("message content: " + messageContent);

			unitPushRequest(clientAddress, messageContent.toString().trim(),
					contentType);
		} catch (Exception e) {
			System.err.println(e);
			if (resultCode < 2000)
				resultCode = 2000; // bad message
		}
		// start writing the result
		response.setStatus(202); // accepted
		response.setContentType("application/xml");
		PrintWriter out = response.getWriter();
		out.println(XML_VERSION);
		out.println(PAP_DOCTYPE);
		out.println("<pap product-name=\"MobileZoo PPG\">");
		out.println("  <push-response push-id=\"" + pushId + "\">");
		out.println("    <response result");
		out.println("       code=\"" + resultCode + "\"");
		out.println("       desc=\"" + resultCodeDesc(resultCode) + "\">");
		out.println("    </response-result>");
		out.println("  </push-response>");
		out.println("</pap>");
	}

	/**
	 * Returns description of a PAP result response code
	 * 
	 * @param code
	 *            an <code>int</code> value
	 * @return a <code>String</code> value
	 */
	private static String resultCodeDesc(int code) {
		switch (code) {
		case 1001:
			return "Accepted for Processing";
		case 2000:
			return "Bad Request";
		case 2002:
			return "Address Error";
		}
		return "Unknown result code";
	}

	/**
	 * <code>unitPushRequest</code> generates a connectionless mode Push request
	 * 
	 * @param clientAddress
	 *            a <code>String</code> value
	 * @param messageContent
	 *            a <code>String</code> value
	 * @param contentType
	 *            a <code>String</code> value
	 * @exception Exception
	 *                if an error occurs
	 */
	private void unitPushRequest(String clientAddress, String messageContent,
			String contentType) throws Exception {
		ByteArrayOutputStream content = new ByteArrayOutputStream();
		contentType = encodeContent(messageContent, content, contentType);
		int wspContentType = encodeContentType(contentType);
		transactionId %= 127;
		byte[] wspPdu = wspPduPUSH(transactionId++, wspContentType, content
				.toByteArray());
		sendData(clientAddress, connectionlessPushPort, wspPdu, wspPdu.length);
	}

	/**
	 * A simplified "WBXML encoder". It handles only SI content type, and only
	 * href attribute within SI content (others ignored). No well-formedness nor
	 * validity checks are performed during the encoding.
	 * 
	 * @param messageContent
	 *            a <code>String</code> value
	 * @param content
	 *            a <code>ByteArrayOutputStream</code> value
	 * @param contentType
	 *            a <code>String</code> value
	 * @return a <code>String</code> value
	 */
	private static String encodeContent(String messageContent,
			ByteArrayOutputStream content, String contentType) throws Exception {
		if (contentType.startsWith("text/vnd.wap.si")) {
			int i = messageContent.indexOf("href=\"http://");
			if (i > 0) {
				try {
					final byte[] bytes1 = { 0x0, 0x5, 0x4, 0x0, 0x45,
							(byte) 0xc6, 0xc, 0x3 };
					final byte[] bytes2 = { 0x0, 0x7, 0x1, 0x3 };
					final byte[] bytes3 = { 0x0, 0x1, 0x1 };
					String href = messageContent.substring(i + 13,
							messageContent.indexOf("\"", i + 14));
					String message = messageContent.substring(messageContent
							.indexOf(">", i + 15) + 1, messageContent.indexOf(
							"</indication>", i + 16));
					content.write(bytes1);
					content.write(href.getBytes());
					content.write(bytes2);
					content.write(message.trim().getBytes());
					content.write(bytes3);
					return "application/vnd.wap.sic";
				} catch (Exception e) {
					content.reset();
				}
			}
		}
		content.write(messageContent.getBytes());
		return contentType;
	}

	/**
	 * <code>encodeContentType</code> encodes mime type (cf. WSP specification
	 * WAP-203-WSP 4-May-2000)
	 * 
	 * @param contentType
	 *            a <code>String</code> value
	 * @return an <code>int</code> value
	 */
	private static int encodeContentType(String contentType) throws Exception {
		contentType = contentType.toLowerCase();
		if (contentType.startsWith("text/vnd.wap.wml"))
			return 0x88;
		else if (contentType.startsWith("text/vnd.wap.si"))
			return 0xAD;
		else if (contentType.startsWith("text/vnd.wap.sl"))
			return 0xAF;
		else if (contentType.startsWith("application/vnd.wap.wmlc"))
			return 0x94;
		else if (contentType.startsWith("application/vnd.wap.sic"))
			return 0xAE;
		else if (contentType.startsWith("applicavtion/vnd.wap.slc"))
			return 0xB0;
		throw new Exception("unsupported content type:" + contentType);
	}

	// WSP PDU Type Assigments
	// Table 34 (page 94) in WSP specification WAP-203-WSP 4-May-2000
	private static final int WSP_PUSH = 0x06;

	/**
	 * Generate WSP PUSH PDU (note: only partial functionality provided)
	 * 
	 * @param tid
	 *            an <code>int</code> value
	 * @param contentType
	 *            an <code>int</code> value
	 * @param content
	 *            a <code>byte[]</code> value
	 * @return a <code>byte[]</code> value
	 * @exception Exception
	 *                if an error occurs
	 */
	private static byte[] wspPduPUSH(int tid, int contentType, byte[] content)
			throws Exception {
		ByteArrayOutputStream data = new ByteArrayOutputStream();
		data.write(tid);
		data.write(WSP_PUSH);
		data.write(1); // contenttype size + headers size
		data.write(contentType);
		data.write(content);
		return data.toByteArray();
	}

	/**
	 * <code>sendData</code> sends data to given address and port using UDP
	 * datagram socket
	 * 
	 * @param addressStr
	 *            a <code>String</code> value
	 * @param port
	 *            an <code>int</code> value
	 * @param data
	 *            a <code>byte[]</code> value
	 * @param dataSize
	 *            an <code>int</code> value
	 * @return an <code>int</code> value
	 * @exception Exception
	 *                if an error occurs
	 */
	private static int sendData(String addressStr, int port, final byte[] data,
			int dataSize) throws Exception {
		if (dataSize <= 0)
			return 0;
		InetAddress addr = InetAddress.getByName(addressStr);
		System.out.println("sendData addr = " + addr.getHostAddress()
				+ "; port = " + port + "; data_size = " + dataSize);
		DatagramSocket s = new DatagramSocket();
		// s.setSoTimeout(1000);
		DatagramPacket packet = new DatagramPacket(data, dataSize, addr, port);
		s.send(packet);
		int nBytes = packet.getLength();
		if (dataSize != nBytes)
			System.err
					.println("warning: not all bytes of a datagram are sent to socket!?");
		s.close();
		return nBytes;
	}

}