Mercurial > 510Connectbot

comparison app/src/main/java/com/five_ten_sg/connectbot/transport/TN5250.java @ 438:d29cce60f393

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
migrate from Eclipse to Android Studio
author Carl Byington <carl@five-ten-sg.com>
date Thu, 03 Dec 2015 11:23:55 -0800
parents src/com/five_ten_sg/connectbot/transport/TN5250.java@071eccdff8ea
children f698820bffdf
comparison
equal deleted inserted replaced
437:208b31032318 438:d29cce60f393
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;
25 import java.net.UnknownHostException;
26 import java.util.HashMap;
27 import java.util.List;
28 import java.util.Map;
29 import java.util.regex.Matcher;
30 import java.util.regex.Pattern;
31
32 import org.tn5250j.framework.tn5250.Screen5250;
33 import org.tn5250j.framework.tn5250.tnvt;
34
35 import com.five_ten_sg.connectbot.R;
36 import com.five_ten_sg.connectbot.bean.HostBean;
37 import com.five_ten_sg.connectbot.bean.PortForwardBean;
38 import com.five_ten_sg.connectbot.service.TerminalBridge;
39 import com.five_ten_sg.connectbot.service.TerminalKeyListener;
40 import com.five_ten_sg.connectbot.service.TerminalManager;
41 import com.five_ten_sg.connectbot.util.HostDatabase;
42 import com.five_ten_sg.connectbot.util.PreferenceConstants;
43 import android.content.Context;
44 import android.net.Uri;
45 import android.util.Log;
46 import android.view.KeyCharacterMap;
47 import android.view.KeyEvent;
48 import android.view.View;
49 import de.mud.terminal.vt320;
50
51
52 /**
53 * @author Carl Byington
54 *
55 */
56 public class TN5250 extends AbsTransport {
57 private static final String PROTOCOL = "tn5250";
58 private static final String TAG = "ConnectBot.tn5250";
59 private static final int DEFAULT_PORT = 23;
60
61 private Screen5250 screen52;
62 private tnvt handler = null;
63 private Socket socket;
64 private boolean connected = false;
65
66 static final Pattern hostmask;
67 static {
68 hostmask = Pattern.compile("^([0-9a-z.-]+)(:(\\d+))?$", Pattern.CASE_INSENSITIVE);
69 }
70
71
72 class vt320x5250 extends vt320 {
73 private HashMap<Integer, Integer> controls;
74 private HashMap<Integer, String> mnemonics;
75
76 public vt320x5250() {
77 this(80, 24);
78 }
79
80 public vt320x5250(int width, int height) {
81 super(width, height);
82 controls = new HashMap<Integer, Integer>();
83 controls.put(0x01, KEY_PAUSE); // ctrl-a -> [attn]
84 controls.put(0x08, KEY_BACK_SPACE);
85 controls.put(0x09, KEY_TAB);
86 controls.put(0x0d, KEY_ENTER);
87 controls.put(0x12, KEY_ESCAPE); // ctrl-r -> [reset]
88 controls.put(0x13, KEY_SYSREQ); // ctrl-s -> [sysreq]
89 controls.put(0x1b, KEY_ESCAPE); // esc -> [reset]
90 mnemonics = new HashMap<Integer, String>();
91 mnemonics.put(KEY_PAUSE , "[attn]");
92 mnemonics.put(KEY_F1 , "[pf1]");
93 mnemonics.put(KEY_F2 , "[pf2]");
94 mnemonics.put(KEY_F3 , "[pf3]");
95 mnemonics.put(KEY_F4 , "[pf4]");
96 mnemonics.put(KEY_F5 , "[pf5]");
97 mnemonics.put(KEY_F6 , "[pf6]");
98 mnemonics.put(KEY_F7 , "[pf7]");
99 mnemonics.put(KEY_F8 , "[pf8]");
100 mnemonics.put(KEY_F9 , "[pf9]");
101 mnemonics.put(KEY_F10 , "[pf10]");
102 mnemonics.put(KEY_F11 , "[pf11]");
103 mnemonics.put(KEY_F12 , "[pf12]");
104 mnemonics.put(KEY_F13 , "[pf13]");
105 mnemonics.put(KEY_F14 , "[pf14]");
106 mnemonics.put(KEY_F15 , "[pf15]");
107 mnemonics.put(KEY_F16 , "[pf16]");
108 mnemonics.put(KEY_F17 , "[pf17]");
109 mnemonics.put(KEY_F18 , "[pf18]");
110 mnemonics.put(KEY_F19 , "[pf19]");
111 mnemonics.put(KEY_F20 , "[pf20]");
112 mnemonics.put(KEY_F21 , "[pf21]");
113 mnemonics.put(KEY_F22 , "[pf22]");
114 mnemonics.put(KEY_F23 , "[pf23]");
115 mnemonics.put(KEY_F24 , "[pf24]");
116 mnemonics.put(KEY_UP , "[up]");
117 mnemonics.put(KEY_DOWN , "[down]");
118 mnemonics.put(KEY_LEFT , "[left]");
119 mnemonics.put(KEY_RIGHT , "[right]");
120 mnemonics.put(KEY_PAGE_DOWN , "[pgdown]");
121 mnemonics.put(KEY_PAGE_UP , "[pgup]");
122 mnemonics.put(KEY_INSERT , "[insert]");
123 mnemonics.put(KEY_DELETE , "[delete]");
124 mnemonics.put(KEY_BACK_SPACE , "[backspace]");
125 mnemonics.put(KEY_HOME , "[home]");
126 mnemonics.put(KEY_END , "[end]");
127 mnemonics.put(KEY_NUM_LOCK , "");
128 mnemonics.put(KEY_CAPS_LOCK , "");
129 mnemonics.put(KEY_SHIFT , "");
130 mnemonics.put(KEY_CONTROL , "");
131 mnemonics.put(KEY_ALT , "");
132 mnemonics.put(KEY_ENTER , "[enter]");
133 mnemonics.put(KEY_NUMPAD0 , "0");
134 mnemonics.put(KEY_NUMPAD1 , "1");
135 mnemonics.put(KEY_NUMPAD2 , "2");
136 mnemonics.put(KEY_NUMPAD3 , "3");
137 mnemonics.put(KEY_NUMPAD4 , "4");
138 mnemonics.put(KEY_NUMPAD5 , "5");
139 mnemonics.put(KEY_NUMPAD6 , "6");
140 mnemonics.put(KEY_NUMPAD7 , "7");
141 mnemonics.put(KEY_NUMPAD8 , "8");
142 mnemonics.put(KEY_NUMPAD9 , "9");
143 mnemonics.put(KEY_DECIMAL , ".");
144 mnemonics.put(KEY_ADD , "+");
145 mnemonics.put(KEY_ESCAPE , "[reset]");
146 mnemonics.put(KEY_TAB , "[tab]");
147 mnemonics.put(KEY_SYSREQ , "[sysreq]");
148 }
149
150 @Override
151 public void debug(String s) {
152 Log.d(TAG, s);
153 }
154
155 // monitor injecting a field
156 @Override
157 public void setField(int l, int c, char [] data) {
158 screen52.setField(l, c, data);
159 }
160
161 // monitor simulating key depress
162 @Override
163 public void keyDepressed(int keyCode, char keyChar, int modifiers) {
164 if (mnemonics.containsKey(keyCode)) {
165 String s = mnemonics.get(keyCode);
166
167 if (s != "") screen52.sendKeys(s);
168 }
169 }
170
171 // terminal key listener found special key, send notification to monitor
172 @Override
173 public void monitorKey(boolean down) {
174 if (bridge.monitor != null) bridge.monitor.keyState(down);
175 }
176
177 // terminal key listener sending to local screen
178 @Override
179 public void write(byte[] b) {
180 screen52.sendKeys(new String(b));
181
182 if (bridge.monitor != null) bridge.monitor.testMoved();
183 }
184 @Override
185 public void write(int b) {
186 if (controls.containsKey(b)) keyPressed(controls.get(b), ' ', 0);
187 else screen52.sendKeys(new String(new byte[] {(byte)b}));
188
189 if (bridge.monitor != null) bridge.monitor.testMoved();
190 }
191 @Override
192 public void keyPressed(int keyCode, char keyChar, int modifiers) {
193 keyDepressed(keyCode, keyChar, modifiers);
194
195 if (bridge.monitor != null) bridge.monitor.testMoved();
196 }
197
198 // 5250 writing to the screen
199 // test for changed screen contents
200 @Override
201 public void testChanged() {
202 if (bridge.monitor != null) bridge.monitor.testChanged();
203 }
204 @Override
205 public void putChar(int c, int l, char ch, int attributes) {
206 if (bridge.monitor != null) bridge.monitor.screenChanged(l, c);
207
208 super.putChar(c, l, ch, attributes);
209 }
210 @Override
211 public void setCursorPosition(int c, int l) {
212 if (bridge.monitor != null) bridge.monitor.cursorMove(l, c);
213
214 super.setCursorPosition(c, l);
215 redraw();
216 }
217 };
218
219
220 public TN5250() {
221 super();
222 }
223
224
225 /**
226 * @return protocol part of the URI
227 */
228 public static String getProtocolName() {
229 return PROTOCOL;
230 }
231
232
233 /**
234 * Encode the current transport into a URI that can be passed via intent calls.
235 * @return URI to host
236 */
237 public Uri getUri(String input) {
238 Matcher matcher = hostmask.matcher(input);
239
240 if (!matcher.matches())
241 return null;
242
243 StringBuilder sb = new StringBuilder();
244 sb.append(PROTOCOL)
245 .append("://")
246 .append(matcher.group(1));
247 String portString = matcher.group(3);
248 int port = DEFAULT_PORT;
249
250 if (portString != null) {
251 try {
252 port = Integer.parseInt(portString);
253
254 if (port < 1 || port > 65535) {
255 port = DEFAULT_PORT;
256 }
257 }
258 catch (NumberFormatException nfe) {
259 // Keep the default port
260 }
261 }
262
263 if (port != DEFAULT_PORT) {
264 sb.append(':');
265 sb.append(port);
266 }
267
268 sb.append("/#")
269 .append(Uri.encode(input));
270 Uri uri = Uri.parse(sb.toString());
271 return uri;
272 }
273
274
275 /**
276 * Causes transport to connect to the target host. After connecting but before a
277 * session is started, must call back to {@link TerminalBridge#onConnected()}.
278 * After that call a session may be opened.
279 */
280 @Override
281 public void connect() {
282 screen52 = new Screen5250();
283 handler = new tnvt(screen52, true, true, bridge, manager);
284 screen52.setVT(handler);
285 screen52.setBuffer(buffer);
286 bridge.addFontSizeChangedListener(screen52);
287 connected = handler.connect(host, homeDirectory, buffer);
288
289 if (connected) bridge.onConnected();
290 }
291
292
293 /**
294 * Checks if read() will block. If there are no bytes remaining in
295 * the underlying transport, return true.
296 */
297 @Override
298 public boolean willBlock() {
299 // we don't use a relay thread between the transport and the vt320 buffer
300 return true;
301 }
302
303
304 /**
305 * Reads from the transport. Transport must support reading into a byte array
306 * <code>buffer</code> at the start of <code>offset</code> and a maximum of
307 * <code>length</code> bytes. If the remote host disconnects, throw an
308 * {@link IOException}.
309 * @param buffer byte buffer to store read bytes into
310 * @param offset where to start writing in the buffer
311 * @param length maximum number of bytes to read
312 * @return number of bytes read
313 * @throws IOException when remote host disconnects
314 */
315 public int read(byte[] buffer, int offset, int length) throws IOException {
316 // we don't use a relay thread between the transport and the vt320 buffer
317 return 0;
318 }
319
320
321 /**
322 * Writes to the transport. If the host is not yet connected, simply return without
323 * doing anything. An {@link IOException} should be thrown if there is an error after
324 * connection.
325 * @param buffer bytes to write to transport
326 * @throws IOException when there is a problem writing after connection
327 */
328 public void write(byte[] buffer) throws IOException {
329 }
330
331
332 /**
333 * Writes to the transport. See {@link #write(byte[])} for behavior details.
334 * @param c character to write to the transport
335 * @throws IOException when there is a problem writing after connection
336 */
337 public void write(int c) throws IOException {
338 }
339
340
341 /**
342 * Flushes the write commands to the transport.
343 * @throws IOException when there is a problem writing after connection
344 */
345 public void flush() throws IOException {
346 }
347
348
349 /**
350 * Closes the connection to the terminal.
351 */
352 public void close() {
353 handler.disconnect();
354 connected = false;
355 bridge.removeFontSizeChangedListener(screen52);
356 bridge.dispatchDisconnect(false);
357 }
358
359
360 /**
361 * Tells the transport what dimensions the display is currently
362 * @param columns columns of text
363 * @param rows rows of text
364 * @param width width in pixels
365 * @param height height in pixels
366 */
367 @Override
368 public void setDimensions(int columns, int rows, int width, int height) {
369 // do nothing
370 }
371
372
373 @Override
374 public vt320 getTransportBuffer() {
375 buffer = new vt320x5250();
376 return setupTransportBuffer();
377 }
378
379
380 @Override
381 public int getDefaultPort() {
382 return DEFAULT_PORT;
383 }
384
385
386 @Override
387 public boolean isConnected() {
388 return connected;
389 }
390
391
392 @Override
393 public boolean isSessionOpen() {
394 return connected;
395 }
396
397
398 @Override
399 public boolean isAuthenticated() {
400 return connected;
401 }
402
403
404 @Override
405 public String getDefaultNickname(String username, String hostname, int port) {
406 if (port == DEFAULT_PORT) {
407 return String.format("%s", hostname);
408 }
409 else {
410 return String.format("%s:%d", hostname, port);
411 }
412 }
413
414
415 @Override
416 public void getSelectionArgs(Uri uri, Map<String, String> selection) {
417 selection.put(HostDatabase.FIELD_HOST_PROTOCOL, PROTOCOL);
418 selection.put(HostDatabase.FIELD_HOST_NICKNAME, uri.getFragment());
419 selection.put(HostDatabase.FIELD_HOST_HOSTNAME, uri.getHost());
420 int port = uri.getPort();
421
422 if (port < 0) port = DEFAULT_PORT;
423
424 selection.put(HostDatabase.FIELD_HOST_PORT, Integer.toString(port));
425 }
426
427
428 @Override
429 public HostBean createHost(Uri uri) {
430 HostBean host = new HostBean();
431 host.setProtocol(PROTOCOL);
432 host.setHostname(uri.getHost());
433 int port = uri.getPort();
434
435 if (port < 0) port = DEFAULT_PORT;
436
437 host.setPort(port);
438 String nickname = uri.getFragment();
439
440 if (nickname == null || nickname.length() == 0) {
441 nickname = getDefaultNickname(host.getUsername(), host.getHostname(), host.getPort());
442 }
443
444 host.setNickname(nickname);
445 return host;
446 }
447
448
449 public String getFormatHint(Context context) {
450 return String.format("%s:%s",
451 context.getString(R.string.format_hostname),
452 context.getString(R.string.format_port));
453 }
454
455
456 @Override
457 public boolean usesNetwork() {
458 return true;
459 }
460
461
462 @Override
463 public boolean needsRelay() {
464 // we don't use a relay thread between the transport and the vt320 buffer
465 return false;
466 }
467
468 public TerminalKeyListener getTerminalKeyListener() {
469 return new TerminalKeyListener(manager, bridge, buffer, host.getEncoding());
470 }
471
472 }