wapclient.java

WAP协议栈的JAVA实现

     */
    public synchronized boolean isConnected() {
        return session!=null; 
    }
    
    /**
     * Execute a WSP GET request.
     * 
     * <pre>
     * Usage: WAPClient &lt;WAP-Gateway-address[:port]&gt; [GET/POST] [options] &lt;URL&gt;
     *   if method (GET/POST) is unspecified, GET is assumed
     * 
     *   Common options:
     *   -u <user-agent>   The User-Agent (defaults to jWAP/1.x)
     *   -o <file>         write response to file
     *   -v                show response-headers
     * 
     * POST options:
     *   -c <content-type> The content-type  of the response body
     *   -p <file>         A file containing the post data, use '-' to read the post data from standard input
     * </pre>
     */
    public static void main(String[] args) throws IOException {
        if(args.length < 2 ) {
            System.err.println(USAGE);
            System.exit(1);
        }
        String wapGW = args[0];
        int wapPort = 9201;
        
        int c =wapGW.indexOf(':');
        if( c > 0 ) {
            wapPort = Integer.parseInt(wapGW.substring(c+1));
            wapGW = wapGW.substring(0, c);
        }
        
        int argp=1;
        String method = args[argp];
        String userAgent = null;
        String output = null;
        boolean showHeaders = false;
        String contentType = null;
        String input = null;
        String url = null;
        
        if( "GET".equals(method) || "POST".equals(method) ) {
            argp++;
        } 
        
        try {
            while( url == null && argp < args.length ) 
            {
                String arg = args[argp++];
                if( "-u".equals(arg) ) {
                    userAgent=args[argp++];
                } else if( "-o".equals(arg) ) {
                    output = args[argp++];
                } else if( "-v".equals(arg) ) {
                    showHeaders=true;   
                } else if( "-c".equals(arg) ) {
                    contentType = args[argp++];
                } else if( "-p".equals(arg) ) {
                    input = args[argp++];   
                } else if( arg.startsWith("-") ){
                    System.err.println(arg+": Unknown option");
                    System.err.println(USAGE);
                    System.exit(1);
                } else {
                    url = arg;                     
                }
            }
        } catch( Exception unknown ) {
            System.err.println(USAGE);
            System.exit(1);   
        }
        
        if( url == null ) {
            System.err.println("Error: <URL> is mandatory");
            System.err.println(USAGE);
            System.exit(1);   
        }
        
        WAPClient client = new WAPClient(wapGW, wapPort);
        Request request = null;
        OutputStream out = null;
        
        if( output == null || "-".equals(output) ) {
            out = System.out;    
        } else {
            out = new FileOutputStream(output);   
        }
        
        if( "POST".equals(method) ) {
            if( contentType == null ) {
                System.err.println("Warning: no content-type specified, assuming "+DEFAULT_CONTENT_TYPE);
                contentType = DEFAULT_CONTENT_TYPE;
            }
            byte[] postData = readPostData(input);
            
            PostRequest preq = new PostRequest(url);
            request = preq;
            preq.setContentType(contentType);
            preq.setRequestBody(postData);
        } else {
            request = new GetRequest(url);
        }
        try {
            client.connect();
            Response response = client.execute(request);
            if( out == System.out ) {
                System.out.println("");   
            }
            if( showHeaders || !response.isSuccess()) {
                out.write(("Status: "+response.getStatus()+" "+response.getStatusText()+"\n").getBytes());
                for(Enumeration e = response.getHeaderNames(); e.hasMoreElements(); ) {
                    String key = (String) e.nextElement();
                    for(Enumeration e2 = response.getHeaders(key); e2.hasMoreElements(); ) {
                        String val = e2.nextElement().toString();
                        out.write((key+": "+val+"\n").getBytes());
                    }
                }
                out.write("\n".getBytes());
            }
            out.write(response.getResponseBody());
        } finally {
            client.disconnect();   
            if( out != null && out == System.out ) {
                out.close();   
            } 
        }
        System.exit(0);
    }
    
    private static byte[] readPostData(String input) throws IOException {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        InputStream in = null;
        if( input == null ) {
            System.out.println("Reading post-data from input stream, hit EOF when done");
            in = System.in;
        } else if( "-".equals(input)) {
            in = System.in;
        } else {
            in = new FileInputStream(input);
        }
        byte[] buf = new byte[1024];
        int read = 0;
        while( (read=in.read(buf)) > 0 ) {
            out.write(buf,0,read);
        }
        in.close();
        return out.toByteArray();
    }

    private Object waitForCompletion(Object key, long timeout)
    {
        Object object = null;
        long startAt = 0;
        
        if( timeout > 0 ) {
            startAt = System.currentTimeMillis();
        }
        while(object == null) {
            if( timeout > 0 && (startAt + timeout) < System.currentTimeMillis()) {
                log.debug("Timeout occurred");
                break;   
            }
            synchronized(pendingRequests) {
                object = pendingRequests.remove(key);
                if( object == null ) {
                    try {
                        pendingRequests.wait(timeout);
                    } catch (InterruptedException e) {
                        log.warn("Interrupted");
                    }
                }
            }
        }
        return object;
    }
    
    private void complete(Object key, Object value)
    {
        synchronized(pendingRequests) {
            pendingRequests.put(key, value);
            pendingRequests.notifyAll();   
        }   
    }
        
    // -----------------------------------------------------------
    private class UpperLayerImpl implements IWSPUpperLayer2
    {
        // Connection established
        public void s_connect_cnf() {
            complete(sessionLock, CONNECTED);
        }

        public void s_disconnect_ind(short reason) {
            if(log.isDebugEnabled()) {
                log.debug("s_disconnect_ind("+reason+")");
            }
            complete(sessionLock, "DISCONNECTED: "+reason);
            session = null;
        }

        public void s_disconnect_ind(CWSPSocketAddress[] redirectInfo) {
            complete(sessionLock, redirectInfo);
        }

        public void s_methodResult_ind(CWSPResult result) {
            Response response = new Response(result);
            CWSPMethodManager mgr = result.getMethodManager();
            // Acknowledge reception (TODO: arg should not be null)
            mgr.s_methodResult(null);
            complete(mgr, response);
        }

        public void s_suspend_ind(short reason) {
            if(log.isDebugEnabled()) {
                log.debug("s_suspend_ind("+reason+")");
            }
        }

        public void s_resume_cnf() {
            log.debug("s_resume_cnf()");
        }

        public void s_disconnect_ind(InetAddress[] redirectInfo) {
        }

        public void s_methodResult_ind(byte[] payload, String contentType, boolean moreData) {
        }
    }
}