wapclient.java~3~

jwap 协议 udp 可以用于手机通讯

/**
 * JWAP - A Java Implementation of the WAP Protocols
 * Copyright (C) 2001-2004 Niko Bender
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
package net.sourceforge.jwap;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.*;
import java.util.Calendar;
import java.lang.String;

import net.sourceforge.jwap.util.Logger;
import net.sourceforge.jwap.wsp.CWSPMethodManager;
import net.sourceforge.jwap.wsp.CWSPResult;
import net.sourceforge.jwap.wsp.CWSPSession;
import net.sourceforge.jwap.wsp.CWSPSocketAddress;
import net.sourceforge.jwap.wsp.IWSPUpperLayer2;
import net.sourceforge.jwap.wsp.pdu.CWSPHeaders;
import net.sourceforge.jwap.wtp.CWTPSocket;
import net.sourceforge.jwap.util.wbxml.WBXMLDecoder;
import org.w3c.dom.Document;
import org.apache.xml.serialize.XMLSerializer;
import org.apache.xml.serialize.OutputFormat;

/**
 * This class represents a WSP "User-Agent" which can be used for executing
 * WSP <code>GET</code> and <code>POST</code> methods.
 * <p>
 * <h3>Example</h3>
 * <pre>
 * WAPClient client = new WAPClient("localhost", 9201);
 * Request request = new GetRequest("http://localhost/");
 * client.connect();
 * Response response = client.execute(request);
 * client.disconnect();
 * </pre>
 * @author Michel Marti
 *
 */
public class WAPClient {
  /** Default connect/disconnect timeout in milliseconds: 30000 */
  public static final long DEFAULT_CONNECT_TIMEOUT = 30000;
  /** Default execute timeout in milliseconds: 180000 */
  public static final long DEFAULT_EXEC_TIMEOUT = 180000;

  private static final Logger log = Logger.getLogger(WAPClient.class);

  static {
    Logger.initLogSystem(true);
  }

  private static final String USAGE =
      "Usage: WAPClient <WAP-Gateway-address[:port]> [GET/POST] [options] <URL>\n" +
      "   if method (GET/POST) is unspecified, GET is assumed\n\n" +
      "   Common options:\n" +
      "      -u <user-agent>   The User-Agent (defaults to jWAP/1.x)\n" +
      "      -o <file>         write response to file\n" +
      "      -l [addr]:port    local port (and address) to bind to\n" +
      "      -tc <timeout>     connection timeout (seconds, default=30)\n" +
      "      -tx <timeout>     request timeout (seconds, default=180)\n" +
      "      -v                show response-headers\n\n" +
      "   POST options:\n" +
      "      -c <content-type> The content-type  of the response body\n" +
      "      -p <file>         A file containing the post data, use '-' to read" +
      " the post data from standard input";

  private static final String DEFAULT_CONTENT_TYPE = "application/unknown";
  private static final String CONNECTED = "CONNECTED";

  private InetAddress gwAddr;
  private InetAddress localAddr;
  private int gwPort;
  private int localPort;
  private CWSPSession session;
  private long disconnectTimeout;

  private byte[] sessionLock = new byte[0];

  private IWSPUpperLayer2 upperLayerImpl;
  private Hashtable pendingRequests;

  private WAPClient() {}

  /**
   * Construct a new WAP Client
   * @param wapGateway hostname of the WAP gateway to use
   * @param port port-number
   * @throws UnknownHostException if the hostname cannot be resolved
   */
  public WAPClient(String wapGateway, int port) throws UnknownHostException {
    this(InetAddress.getByName(wapGateway), port);
  }

  /**
   * Construct a new WAP Client
   * @param wapGateway the address of the WAP gateway to use
   * @param port the WAP gateway port number
   */
  public WAPClient(InetAddress wapGateway, int port) {
    this(wapGateway, port, null, CWTPSocket.DEFAULT_PORT);
  }

  /**
   * Construct a new WAP Client
   * @param wapGateway the addresss of the WAP gateway to use
   * @param wapPort the WAP gateway port number
   * @param localAddress the local address to bind to
   * @param localPort the local port to bind to (0 to let the OS pick a free port)
   */
  public WAPClient(InetAddress wapGateway, int wapPort,
                   InetAddress localAddress,
                   int localPort) {
    gwAddr = wapGateway;
    gwPort = wapPort;
    this.localAddr = localAddress;
    this.localPort = localPort;
    upperLayerImpl = new UpperLayerImpl();
    pendingRequests = new Hashtable();
  }

  /**
   * Execute a request. The client must be connected to the gateway.
   * @param request the request to execute
   * @return the response
   * @throws SocketException if a timeout occurred
   * @throws IllegalStateException if the client is not connected
   */
  public Response execute(Request request) throws SocketException,
      IllegalStateException {
    return execute(request, DEFAULT_EXEC_TIMEOUT);
  }

  /**
   * Execute a request. The client must be connected to the gateway.
   * @param request the request to execute
   * @param timeout timeout in milliseconds
   * @return the response
   * @throws SocketException if a timeout occurred
   * @throws IllegalStateException if the client is not connected
   */
  public Response execute(Request request, long timeout) throws SocketException,
      IllegalStateException {
    CWSPMethodManager mgr = null;

    synchronized (this) {
      if (session == null) {
        throw new IllegalStateException("Not yet connected");
      }

      CWSPHeaders headers = request.getWSPHeaders();
      if (headers.getHeader("accept") == null) {
        headers.setHeader("accept", "*/*");
      }
      String uh = headers.getHeader("user-agent");
      if (uh == null) {
        headers.setHeader("user-agent", "jWAP/1.2");
      }
      else if ("".equals(uh)) {
        headers.setHeader("user-agent", null);
      }

      if (request instanceof GetRequest) {
        if (log.isDebugEnabled()) {
          log.debug("Executing GET Request for URL " + request.getURL());
        }
        mgr = session.s_get(headers, request.getURL());
      }
      else if (request instanceof PostRequest) {
        if (log.isDebugEnabled()) {
          log.debug("Executing POST Request for URL " + request.getURL());
        }
        PostRequest post = (PostRequest) request;
        mgr = session.s_post(post.getWSPHeaders(), post.getRequestBody(),
                             post.getContentType(), post.getURL());
      }
    }
    // Wait until the method shows up in our hashtable
    if (log.isDebugEnabled()) {
      log.debug("Waiting " + timeout + "ms for execute completion...");
    }
    Response response = (Response) waitForCompletion(mgr, timeout);

    if (response == null) {
      throw new SocketException("Timeout executing request");
    }
    return response;
  }

  /**
   * Connect to the WAP gateway. Before requests can be executed, this method
   * must be called.
   * @throws SocketException if the connection could not be established
   * @throws IllegalStateException if the client is already connected
   */
  public synchronized void connect() throws SocketException,
      IllegalStateException {
    connect(DEFAULT_CONNECT_TIMEOUT);
  }

  /**
   * Connect to the WAP gateway. Before requests can be executed, this method
   * must be called.
   * @param timeout timeout in milliseconds
   * @throws SocketException if the connection could not be established
   * @throws IllegalStateException if the client is already connected
   */
  public synchronized void connect(long timeout) throws SocketException,
      IllegalStateException {
    connect(null, timeout);
  }

  /**
   * Connect to the WAP gateway. Before requests can be executed, this method
   * must be called.
   * @param timeout timeout in milliseconds
   * @param headers WSP headers used for connect or null
   *   objects. The headers will be encoded using the default WAP codepage.
   * @throws SocketException if the connection could not be established
   * @throws IllegalStateException if the client is already connected
   */
  public synchronized void connect(CWSPHeaders headers, long timeout) throws
      SocketException, IllegalStateException {
    if (session != null) {
      throw new IllegalStateException("Already connected");
    }

    disconnectTimeout = timeout;
    pendingRequests.clear();
    if (log.isDebugEnabled()) {
      log.debug("Establishing WSP session with " + gwAddr.getHostAddress() +
                ":" + gwPort);
    }

    session = new CWSPSession(gwAddr, gwPort, localAddr, localPort,
                              upperLayerImpl, false);

    session.s_connect(headers);

    Object result = waitForCompletion(sessionLock, timeout);

    if (result == null) {
      CWSPSession ts = session;
      session = null;
      try {
        ts.s_disconnect();
      }
      catch (Exception unknown) {}
      throw new SocketException("connect: Timeout occurred");
    }

    if (result != null) {
      if (result instanceof CWSPSocketAddress[]) {
        // redirect received ...
        CWSPSocketAddress[] addr = (CWSPSocketAddress[]) result;
        if (addr.length > 0) {
          // Take the first address and try to reconnect...
          gwAddr = addr[0].getAddress();
          int p = addr[0].getPort();
          if (p > 0) {
            gwPort = p;
          }
          session = null;
          if (log.isDebugEnabled()) {
            log.debug("Redirect to " + gwAddr.getHostAddress() + ":" + gwPort);
          }
          connect(headers, timeout);
          return;
        }

      }
      else if (!CONNECTED.equals(result)) {
        CWSPSession ts = session;
        session = null;
        ts.s_disconnect();
        if (result == null) {
          throw new SocketException("Timeout while establishing connection");
        }
        else if (!CONNECTED.equals(result)) {
          throw new SocketException("Connection failed.");
        }
      }
    }
    log.debug("Connection established");
  }

  /**
   * Disconnect from the WAP gateway. This releases used resources as well.
   */
  public synchronized void disconnect() {
    if (session == null) {
      return;
    }
    log.debug("Disconnecting client...");
    CWSPSession ts = session;
    session = null;
    ts.s_disconnect();
    // Wait for confirmation
    Object result = waitForCompletion(sessionLock, disconnectTimeout);
    session = null;
    log.debug("Client disconnected...");
  }