/* * %W% %E% * * Copyright 1990-2008 Sun Microsystems, Inc. All Rights Reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License version * 2 only, as published by the Free Software Foundation. * * This program 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 * General Public License version 2 for more details (a copy is * included at /legal/license.txt). * * You should have received a copy of the GNU General Public License * version 2 along with this work; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA * 02110-1301 USA * * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa * Clara, CA 95054 or visit www.sun.com if you need additional * information or have any questions. * */ package com.sun.cdc.io.j2me.socket; import java.io.*; import java.net.*; import javax.microedition.io.*; import com.sun.cdc.io.j2me.*; import com.sun.cdc.io.*; /** * GenericStreamConnection to the J2SE socket API. * * @author Nik Shaylor * @version 1.0 10/08/99 */ public class Protocol extends ConnectionBase implements StreamConnection, SocketConnection { /** Socket object */ Socket socket; /** Open count */ int opens = 0; /** IPv6 address */ boolean ipv6 = false; /** * Open the connection */ public void open(String name, int mode, boolean timeouts) throws IOException { throw new RuntimeException("Should not be called"); } /* * Check permission to connect to the indicated host. * This should be overriden by the MIDP protocol handler * to check the proper MIDP permission. */ protected void checkPermission(String host, int port) { // Check for SecurityManager.checkConnect() java.lang.SecurityManager sm = System.getSecurityManager(); if (sm != null){ if (host != null) { sm.checkConnect(host, port); } else { sm.checkConnect("localhost", port); } } return; } /* * Check permission when opening an OutputStream. MIDP * versions of the protocol handler should override this * with an empty method. Throw a SecurityException if * the connection is not allowed. Currently the socket * protocol handler does not make a permission check at * this point so this method is empty. */ protected void outputStreamPermissionCheck() { return; } /* * Check permission when opening an InputStream. MIDP * versions of the protocol handler should override this * with an empty method. A SecurityException will be * raised if the connection is not allowed. Currently the * socket protocol handler does not make a permission * check at this point so this method is empty. */ protected void inputStreamPermissionCheck() { return; } /** * Open the connection * @param name the target for the connection * @param writeable a flag that is true if the caller expects to write to the * connection. * @param timeouts A flag to indicate that the called wants timeout exceptions * * The name string for this protocol should be: * ": */ public Connection openPrim(String name, int mode, boolean timeouts) throws IOException { if(name.charAt(0) != '/' || name.charAt(1) != '/') { throw new IllegalArgumentException("Protocol must start with \"//\" "+name); } name = name.substring(2); try { /* Host name or IP number */ String nameOrIP = ""; /* Port number */ final int port; /* Look for the : */ int colon = name.indexOf(':'); if(colon != -1) { /* Strip off the protocol name */ nameOrIP = parseHostName(name, colon); /* Host name should not contain reserved characters specified in RFC 2396 */ if ((nameOrIP.indexOf('/') != -1) || (nameOrIP.indexOf('@') != -1) || (nameOrIP.indexOf('?') != -1) || (nameOrIP.indexOf(';') != -1)) { throw new IllegalArgumentException("hostname " + nameOrIP + " cannot contain \"?\" , \"@\" , \";\", \":\", or \"/\" character."); } } if(nameOrIP.length() == 0) { /* * If the open string is "socket://:nnnn" then we regard this as * "serversocket://:nnnn" */ /* socket:// and socket://: are also valid serversocket urls */ com.sun.cdc.io.j2me.serversocket.Protocol con = new com.sun.cdc.io.j2me.serversocket.Protocol(); con.open("//"+name, mode, timeouts); return con; } /* Get the port number */ if (ipv6) { int lastColon = name.lastIndexOf(":"); port = Integer.parseInt(name.substring(lastColon+1)); } else { port = Integer.parseInt(name.substring(colon+1)); } /* If the proper security check has not been made, make * it now. */ checkPermission(nameOrIP, port); /* Open the socket. Use a doPrivileged block * to avoid excessive prompting. */ final String hostName = nameOrIP; socket = (Socket)java.security.AccessController.doPrivileged( new java.security.PrivilegedExceptionAction() { public Object run() throws java.security.PrivilegedActionException, IOException { return new Socket(hostName, port); } }); opens++; return this; } catch(NumberFormatException x) { throw new IllegalArgumentException("Invalid port number in "+name); } catch(java.security.PrivilegedActionException pae) { IOException ioe = (IOException)pae.getException(); throw ioe; } } /** * Open the connection * @param socket an already formed socket * * This function is only used by com.sun.kjava.system.palm.protocol.socketserver; */ public void open(Socket socket) throws IOException { this.socket = socket; } private String parseHostName(String connection, int colon) { /* IPv6 addresses are enclosed within [] */ int beginIndex = connection.indexOf("["); int endIndex = connection.indexOf("]"); if (beginIndex > endIndex) { throw new IllegalArgumentException("invalid host name " + connection); } if ((beginIndex ==0) && (endIndex >0)) { return parseIPv6Address(connection, endIndex); } else { return parseIPv4Address(connection, colon); } } private String parseIPv4Address(String name, int colon) { return name.substring(0, colon); } private String parseIPv6Address(String address, int closing) { ipv6 = true; /* beginning '[' and closing ']' should be included in the hostname*/ return address.substring(0, closing+1); } /** * Returns an input stream for this socket. * * @return an input stream for reading bytes from this socket. * @exception IOException if an I/O error occurs when creating the * input stream. */ public InputStream openInputStream() throws IOException { inputStreamPermissionCheck(); InputStream is = new UniversalFilterInputStream(this, socket.getInputStream()); opens++; return is; } /** * Returns an output stream for this socket. * * @return an output stream for writing bytes to this socket. * @exception IOException if an I/O error occurs when creating the * output stream. */ public OutputStream openOutputStream() throws IOException { outputStreamPermissionCheck(); OutputStream os = new UniversalFilterOutputStream(this, socket.getOutputStream()); opens++; return os; } /** * Close the connection. * * @exception IOException if an I/O error occurs when closing the * connection. */ public void close() throws IOException { if(--opens == 0) { socket.close(); } } /** * Set a socket option for the connection. * * Options inform the low level networking code about intended * usage patterns that the application will use in dealing with * the socket connection. * * * Calling setSocketOption to assign buffer sizes * is a hint to the platform of the sizes to set the underlying * network I/O buffers. * Calling getSocketOption can be used to see what * sizes the system is using. * The system MAY adjust the buffer sizes to account for * better throughput available from Maximum Transmission Unit * (MTU) and Maximum Segment Size (MSS) data available * from current network information. * * * @param option socket option identifier (KEEPALIVE, LINGER, * SNDBUF, RCVBUF, or DELAY) * @param value numeric value for specified option * @exception IllegalArgumentException if the value is not * valid (e.g. negative value) or if the option * identifier is not valid * @exception IOException if the connection was closed * * @see #getSocketOption */ public void setSocketOption(byte option, int value) throws IllegalArgumentException, IOException { if (socket.isClosed()) { throw new IOException("Socket is closed"); } /* value can never be negative */ if (value < 0) { throw new IllegalArgumentException("Value cannot be negative"); } switch (option) { case SocketConnection.DELAY: socket.setTcpNoDelay(value != 0); break; case SocketConnection.KEEPALIVE: socket.setKeepAlive(value != 0); break; case SocketConnection.LINGER: socket.setSoLinger(value != 0, value); break; case SocketConnection.RCVBUF: socket.setReceiveBufferSize(value); break; case SocketConnection.SNDBUF: socket.setSendBufferSize(value); break; default: throw new IllegalArgumentException("Option identifier is out of range"); } } /** * Get a socket option for the connection. * * @param option socket option identifier (KEEPALIVE, LINGER, * SNDBUF, RCVBUF, or DELAY) * @return numeric value for specified option or -1 if the * value is not available. * @exception IllegalArgumentException if the option identifier is * not valid * @exception IOException if the connection was closed * @see #setSocketOption */ public int getSocketOption(byte option) throws IllegalArgumentException, IOException { if (socket.isClosed()) { throw new IOException("Socket is closed"); } switch (option) { case SocketConnection.DELAY: return (socket.getTcpNoDelay()) ? 1 : 0 ; case SocketConnection.KEEPALIVE: return (socket.getKeepAlive()) ? 1 : 0 ; case SocketConnection.LINGER: return socket.getSoLinger(); case SocketConnection.RCVBUF: return socket.getReceiveBufferSize(); case SocketConnection.SNDBUF: return socket.getSendBufferSize(); default: throw new IllegalArgumentException("Option identifier is out of range"); } } /** * Gets the local address to which the socket is bound. * * The host address(IP number) that can be used to connect to this * end of the socket connection from an external system. * Since IP addresses may be dynamically assigned, a remote application * will need to be robust in the face of IP number reassignment. * The local hostname (if available) can be accessed from * System.getProperty("microedition.hostname") * * * @return the local address to which the socket is bound. * @exception IOException if the connection was closed. * @see ServerSocketConnection */ public String getLocalAddress() throws IOException { if (socket.isClosed()) { throw new IOException("Socket is closed"); } return socket.getLocalAddress().getHostName(); } /** * Returns the local port to which this socket is bound. * * @return the local port number to which this socket is connected. * @exception IOException if the connection was closed. * @see ServerSocketConnection */ public int getLocalPort() throws IOException { if (socket.isClosed()) { throw new IOException("Socket is closed"); } return socket.getLocalPort(); } /** * Gets the remote address to which the socket is bound. * The address can be either the remote host name or the IP * address(if available). * * @return the remote address to which the socket is bound. * @exception IOException if the connection was closed. */ public String getAddress() throws IOException { if (socket.isClosed()) { throw new IOException("Socket is closed"); } return socket.getInetAddress().getHostName(); } /** * Returns the remote port to which this socket is bound. * * @return the remote port number to which this socket is connected. * @exception IOException if the connection was closed. */ public int getPort() throws IOException { if (socket.isClosed()) { throw new IOException("Socket is closed"); } return socket.getPort(); } }
