11
|
1 /*
|
|
2 * 510ConnectBot
|
|
3 * Copyright 2014 Carl Byington
|
|
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
|
|
18 package com.five_ten_sg.connectbot.transport;
|
|
19
|
|
20 import java.io.IOException;
|
|
21 import java.io.InputStream;
|
|
22 import java.io.OutputStream;
|
|
23 import java.net.Socket;
|
|
24 import java.net.SocketException;
|
13
|
25 import java.net.UnknownHostException;
|
11
|
26 import java.util.List;
|
|
27 import java.util.Map;
|
13
|
28 import java.util.regex.Matcher;
|
|
29 import java.util.regex.Pattern;
|
11
|
30
|
12
|
31 import org.tn5250j.framework.tn5250.Screen5250;
|
|
32 import org.tn5250j.framework.tn5250.tnvt;
|
|
33
|
13
|
34 import com.five_ten_sg.connectbot.R;
|
11
|
35 import com.five_ten_sg.connectbot.bean.HostBean;
|
|
36 import com.five_ten_sg.connectbot.bean.PortForwardBean;
|
|
37 import com.five_ten_sg.connectbot.service.TerminalBridge;
|
29
|
38 import com.five_ten_sg.connectbot.service.TerminalKeyListener;
|
11
|
39 import com.five_ten_sg.connectbot.service.TerminalManager;
|
|
40 import com.five_ten_sg.connectbot.util.HostDatabase;
|
|
41 import android.content.Context;
|
|
42 import android.net.Uri;
|
13
|
43 import android.util.Log;
|
29
|
44 import de.mud.terminal.vt320;
|
11
|
45
|
|
46
|
|
47 /**
|
|
48 * @author Carl Byington
|
|
49 *
|
|
50 */
|
|
51 public class TN5250 extends AbsTransport {
|
|
52 private static final String PROTOCOL = "tn5250";
|
|
53 private static final String TAG = "ConnectBot.tn5250";
|
|
54 private static final int DEFAULT_PORT = 23;
|
31
|
55
|
11
|
56 private Screen5250 screen52;
|
31
|
57 private tnvt handler = null;
|
|
58 private Socket socket;
|
|
59 private boolean connected = false;
|
11
|
60
|
12
|
61 static final Pattern hostmask;
|
|
62 static {
|
|
63 hostmask = Pattern.compile("^([0-9a-z.-]+)(:(\\d+))?$", Pattern.CASE_INSENSITIVE);
|
|
64 }
|
|
65
|
|
66
|
11
|
67 public TN5250() {
|
|
68 super();
|
|
69 }
|
|
70
|
|
71
|
31
|
72 /**
|
|
73 * @return protocol part of the URI
|
|
74 */
|
11
|
75 public static String getProtocolName() {
|
|
76 return PROTOCOL;
|
|
77 }
|
|
78
|
31
|
79
|
|
80 /**
|
|
81 * Encode the current transport into a URI that can be passed via intent calls.
|
|
82 * @return URI to host
|
|
83 */
|
12
|
84 public Uri getUri(String input) {
|
|
85 Matcher matcher = hostmask.matcher(input);
|
|
86
|
|
87 if (!matcher.matches())
|
|
88 return null;
|
|
89
|
|
90 StringBuilder sb = new StringBuilder();
|
|
91 sb.append(PROTOCOL)
|
|
92 .append("://")
|
|
93 .append(matcher.group(1));
|
|
94 String portString = matcher.group(3);
|
|
95 int port = DEFAULT_PORT;
|
|
96
|
|
97 if (portString != null) {
|
|
98 try {
|
|
99 port = Integer.parseInt(portString);
|
|
100
|
|
101 if (port < 1 || port > 65535) {
|
|
102 port = DEFAULT_PORT;
|
|
103 }
|
|
104 }
|
|
105 catch (NumberFormatException nfe) {
|
|
106 // Keep the default port
|
|
107 }
|
|
108 }
|
|
109
|
|
110 if (port != DEFAULT_PORT) {
|
|
111 sb.append(':');
|
|
112 sb.append(port);
|
|
113 }
|
|
114
|
|
115 sb.append("/#")
|
|
116 .append(Uri.encode(input));
|
|
117 Uri uri = Uri.parse(sb.toString());
|
|
118 return uri;
|
11
|
119 }
|
|
120
|
31
|
121
|
11
|
122 /**
|
|
123 * Causes transport to connect to the target host. After connecting but before a
|
|
124 * session is started, must call back to {@link TerminalBridge#onConnected()}.
|
|
125 * After that call a session may be opened.
|
|
126 */
|
|
127 @Override
|
|
128 public void connect() {
|
30
|
129 screen52 = new Screen5250();
|
29
|
130 handler = new tnvt(screen52, true, false, bridge, manager);
|
32
|
131 screen52.setVT(handler);
|
|
132 screen52.setBuffer(buffer);
|
23
|
133 connected = handler.connect(host.getHostname(), host.getPort());
|
29
|
134 if (connected) bridge.onConnected();
|
11
|
135 }
|
|
136
|
|
137
|
|
138 /**
|
|
139 * Checks if read() will block. If there are no bytes remaining in
|
|
140 * the underlying transport, return true.
|
|
141 */
|
|
142 @Override
|
|
143 public boolean willBlock() {
|
29
|
144 // we don't use a relay thread between the transport and the vt320 buffer
|
|
145 return true;
|
11
|
146 }
|
|
147
|
31
|
148
|
11
|
149 /**
|
|
150 * Reads from the transport. Transport must support reading into a byte array
|
|
151 * <code>buffer</code> at the start of <code>offset</code> and a maximum of
|
|
152 * <code>length</code> bytes. If the remote host disconnects, throw an
|
|
153 * {@link IOException}.
|
|
154 * @param buffer byte buffer to store read bytes into
|
|
155 * @param offset where to start writing in the buffer
|
|
156 * @param length maximum number of bytes to read
|
|
157 * @return number of bytes read
|
|
158 * @throws IOException when remote host disconnects
|
|
159 */
|
|
160 public int read(byte[] buffer, int offset, int length) throws IOException {
|
29
|
161 // we don't use a relay thread between the transport and the vt320 buffer
|
11
|
162 return 0;
|
|
163 }
|
|
164
|
|
165
|
|
166 /**
|
|
167 * Writes to the transport. If the host is not yet connected, simply return without
|
|
168 * doing anything. An {@link IOException} should be thrown if there is an error after
|
|
169 * connection.
|
|
170 * @param buffer bytes to write to transport
|
|
171 * @throws IOException when there is a problem writing after connection
|
|
172 */
|
|
173 public void write(byte[] buffer) throws IOException {
|
|
174 }
|
|
175
|
31
|
176
|
11
|
177 /**
|
|
178 * Writes to the transport. See {@link #write(byte[])} for behavior details.
|
|
179 * @param c character to write to the transport
|
|
180 * @throws IOException when there is a problem writing after connection
|
|
181 */
|
|
182 public void write(int c) throws IOException {
|
|
183 }
|
|
184
|
31
|
185
|
11
|
186 /**
|
|
187 * Flushes the write commands to the transport.
|
|
188 * @throws IOException when there is a problem writing after connection
|
|
189 */
|
|
190 public void flush() throws IOException {
|
|
191 }
|
|
192
|
31
|
193
|
11
|
194 /**
|
32
|
195 * Closes the connection to the terminal.
|
11
|
196 */
|
|
197 public void close() {
|
13
|
198 handler.disconnect();
|
11
|
199 connected = false;
|
32
|
200 bridge.dispatchDisconnect(false);
|
11
|
201 }
|
|
202
|
31
|
203
|
11
|
204 /**
|
|
205 * Tells the transport what dimensions the display is currently
|
|
206 * @param columns columns of text
|
|
207 * @param rows rows of text
|
|
208 * @param width width in pixels
|
|
209 * @param height height in pixels
|
|
210 */
|
|
211 @Override
|
|
212 public void setDimensions(int columns, int rows, int width, int height) {
|
|
213 // do nothing
|
|
214 }
|
|
215
|
|
216
|
|
217 @Override
|
|
218 public int getDefaultPort() {
|
|
219 return DEFAULT_PORT;
|
|
220 }
|
|
221
|
31
|
222
|
11
|
223 @Override
|
|
224 public boolean isConnected() {
|
|
225 return connected;
|
|
226 }
|
|
227
|
31
|
228
|
11
|
229 @Override
|
|
230 public boolean isSessionOpen() {
|
|
231 return connected;
|
|
232 }
|
|
233
|
31
|
234
|
11
|
235 @Override
|
|
236 public boolean isAuthenticated() {
|
|
237 return connected;
|
|
238 }
|
|
239
|
|
240
|
|
241 @Override
|
|
242 public String getDefaultNickname(String username, String hostname, int port) {
|
|
243 if (port == DEFAULT_PORT) {
|
|
244 return String.format("%s", hostname);
|
|
245 }
|
|
246 else {
|
|
247 return String.format("%s:%d", hostname, port);
|
|
248 }
|
|
249 }
|
|
250
|
31
|
251
|
11
|
252 @Override
|
|
253 public void getSelectionArgs(Uri uri, Map<String, String> selection) {
|
|
254 selection.put(HostDatabase.FIELD_HOST_PROTOCOL, PROTOCOL);
|
|
255 selection.put(HostDatabase.FIELD_HOST_NICKNAME, uri.getFragment());
|
|
256 selection.put(HostDatabase.FIELD_HOST_HOSTNAME, uri.getHost());
|
|
257 int port = uri.getPort();
|
|
258
|
|
259 if (port < 0)
|
|
260 port = DEFAULT_PORT;
|
|
261
|
|
262 selection.put(HostDatabase.FIELD_HOST_PORT, Integer.toString(port));
|
|
263 }
|
|
264
|
|
265
|
|
266 @Override
|
|
267 public HostBean createHost(Uri uri) {
|
|
268 HostBean host = new HostBean();
|
|
269 host.setProtocol(PROTOCOL);
|
|
270 host.setHostname(uri.getHost());
|
|
271 int port = uri.getPort();
|
|
272
|
|
273 if (port < 0)
|
|
274 port = DEFAULT_PORT;
|
|
275
|
|
276 host.setPort(port);
|
|
277 String nickname = uri.getFragment();
|
|
278
|
|
279 if (nickname == null || nickname.length() == 0) {
|
|
280 host.setNickname(getDefaultNickname(host.getUsername(),
|
|
281 host.getHostname(), host.getPort()));
|
|
282 }
|
|
283 else {
|
|
284 host.setNickname(uri.getFragment());
|
|
285 }
|
|
286
|
|
287 return host;
|
|
288 }
|
|
289
|
|
290
|
12
|
291 public String getFormatHint(Context context) {
|
11
|
292 return String.format("%s:%s",
|
|
293 context.getString(R.string.format_hostname),
|
|
294 context.getString(R.string.format_port));
|
|
295 }
|
|
296
|
|
297
|
|
298 @Override
|
|
299 public boolean usesNetwork() {
|
|
300 return true;
|
|
301 }
|
29
|
302
|
|
303
|
|
304 @Override
|
|
305 public boolean needsRelay() {
|
|
306 // we don't use a relay thread between the transport and the vt320 buffer
|
|
307 return false;
|
|
308 }
|
|
309
|
11
|
310 }
|