ppg.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;
    }

}