1 /***
2 *
3 * Copyright 2004 Hiram Chirino
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17 package org.activeio.adapter;
18
19 import java.io.IOException;
20 import java.io.InputStream;
21 import java.io.OutputStream;
22 import java.net.InetAddress;
23 import java.net.Socket;
24 import java.net.SocketAddress;
25 import java.net.SocketException;
26 import java.nio.channels.SocketChannel;
27
28 import org.activeio.Packet;
29 import org.activeio.SynchChannel;
30 import org.activeio.net.SocketMetadata;
31 import org.activeio.packet.ByteArrayPacket;
32
33 /***
34 * Provides a {@see java.net.Socket} interface to a {@see org.activeio.SynchChannel}.
35 *
36 * If the {@see org.activeio.SynchChannel} being adapted can not be
37 * {@see org.activeio.Channel#narrow(Class)}ed to a {@see org.activeio.net.SocketMetadata}
38 * then all methods accessing socket metadata will throw a {@see java.net.SocketException}.
39 *
40 */
41 public class SynchChannelToSocketAdapter extends Socket {
42
43 private final SynchChannel channel;
44 private final SynchChannelInputStream inputStream;
45 private final SynchChannelOutputStream outputStream;
46 private final SocketMetadata socketMetadata;
47 private final Packet urgentPackget = new ByteArrayPacket(new byte[1]);
48 boolean closed;
49
50 public SynchChannelToSocketAdapter(SynchChannel channel) {
51 this(channel, (SocketMetadata)channel.narrow(SocketMetadata.class));
52 }
53
54 public SynchChannelToSocketAdapter(SynchChannel channel, SocketMetadata socketMetadata) {
55 this.channel = channel;
56 this.socketMetadata = socketMetadata;
57 this.inputStream = new SynchChannelInputStream(channel);
58 this.outputStream = new SynchChannelOutputStream(channel);
59 }
60
61 public boolean isConnected() {
62 return true;
63 }
64
65 public boolean isBound() {
66 return true;
67 }
68
69 public boolean isClosed() {
70 return closed;
71 }
72
73 public void bind(SocketAddress bindpoint) throws IOException {
74 throw new IOException("Not supported");
75 }
76
77 public synchronized void close() throws IOException {
78 if( closed )
79 return;
80 closed = true;
81 inputStream.close();
82 outputStream.close();
83 channel.dispose();
84 }
85
86 public void connect(SocketAddress endpoint) throws IOException {
87 throw new IOException("Not supported");
88 }
89
90 public void connect(SocketAddress endpoint, int timeout) throws IOException {
91 throw new IOException("Not supported");
92 }
93
94 public SocketChannel getChannel() {
95 return null;
96 }
97
98 public InputStream getInputStream() throws IOException {
99 return inputStream;
100 }
101
102 public OutputStream getOutputStream() throws IOException {
103 return outputStream;
104 }
105
106 public boolean isInputShutdown() {
107 return inputStream.isClosed();
108 }
109
110 public boolean isOutputShutdown() {
111 return outputStream.isClosed();
112 }
113
114 public void sendUrgentData(int data) throws IOException {
115 urgentPackget.clear();
116 urgentPackget.write(data);
117 urgentPackget.flip();
118 channel.write(urgentPackget);
119 }
120
121 public int getSoTimeout() throws SocketException {
122 return (int) inputStream.getTimeout();
123 }
124
125 public synchronized void setSoTimeout(int timeout) throws SocketException {
126 inputStream.setTimeout(timeout);
127 }
128
129 public void shutdownOutput() throws IOException {
130 outputStream.close();
131 }
132
133 public void shutdownInput() throws IOException {
134 inputStream.close();
135 }
136
137 protected SocketMetadata getSocketMetadata() throws SocketException {
138 if( socketMetadata == null )
139 throw new SocketException("No socket metadata available.");
140 return socketMetadata;
141 }
142
143 public InetAddress getInetAddress() {
144 if( socketMetadata ==null )
145 return null;
146 return socketMetadata.getInetAddress();
147 }
148 public boolean getKeepAlive() throws SocketException {
149 return getSocketMetadata().getKeepAlive();
150 }
151 public InetAddress getLocalAddress() {
152 if( socketMetadata ==null )
153 return null;
154 return socketMetadata.getLocalAddress();
155 }
156 public int getLocalPort() {
157 if( socketMetadata ==null )
158 return -1;
159 return socketMetadata.getLocalPort();
160 }
161 public SocketAddress getLocalSocketAddress() {
162 if( socketMetadata ==null )
163 return null;
164 return socketMetadata.getLocalSocketAddress();
165 }
166 public boolean getOOBInline() throws SocketException {
167 return getSocketMetadata().getOOBInline();
168 }
169 public int getPort() {
170 if( socketMetadata ==null )
171 return -1;
172 return socketMetadata.getPort();
173 }
174 public int getReceiveBufferSize() throws SocketException {
175 return getSocketMetadata().getReceiveBufferSize();
176 }
177 public SocketAddress getRemoteSocketAddress() {
178 if( socketMetadata ==null )
179 return null;
180 return socketMetadata.getRemoteSocketAddress();
181 }
182 public boolean getReuseAddress() throws SocketException {
183 return getSocketMetadata().getReuseAddress();
184 }
185 public int getSendBufferSize() throws SocketException {
186 return getSocketMetadata().getSendBufferSize();
187 }
188 public int getSoLinger() throws SocketException {
189 return getSocketMetadata().getSoLinger();
190 }
191 public boolean getTcpNoDelay() throws SocketException {
192 return getSocketMetadata().getTcpNoDelay();
193 }
194 public int getTrafficClass() throws SocketException {
195 return getSocketMetadata().getTrafficClass();
196 }
197 public void setKeepAlive(boolean on) throws SocketException {
198 getSocketMetadata().setKeepAlive(on);
199 }
200 public void setOOBInline(boolean on) throws SocketException {
201 getSocketMetadata().setOOBInline(on);
202 }
203 public void setReceiveBufferSize(int size) throws SocketException {
204 getSocketMetadata().setReceiveBufferSize(size);
205 }
206 public void setReuseAddress(boolean on) throws SocketException {
207 getSocketMetadata().setReuseAddress(on);
208 }
209 public void setSendBufferSize(int size) throws SocketException {
210 getSocketMetadata().setSendBufferSize(size);
211 }
212 public void setSoLinger(boolean on, int linger) throws SocketException {
213 getSocketMetadata().setSoLinger(on, linger);
214 }
215 public void setTcpNoDelay(boolean on) throws SocketException {
216 getSocketMetadata().setTcpNoDelay(on);
217 }
218 public void setTrafficClass(int tc) throws SocketException {
219 getSocketMetadata().setTrafficClass(tc);
220 }
221 }