wapclient.java

WAP Stack implementation jwap.sourceforge.net

/**
 * 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 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;

/**
 * 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();