最近在做一个远程控制的模块，其中用到了telnet协议，开始用的是apache-net包的telnetclient，但发现问题不少，比较慢，还有就是判断是否read完毕的问题。后来经过讨论打算实现自己的telnet，于是网址打罗了一番，找了一个，但是bug也不少，就开始封装。具体的telnet我已经发过2篇文章了，这里再发布一个深化封装的telnet实现。

仅供参考，可以在windows和linux上运行。

  1. package baby.net.base;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import java.io.OutputStream;
  5. import java.net.InetSocketAddress;
  6. import java.net.Socket;
  7. import java.util.ArrayList;
  8. import org.apache.log4j.Logger;
  9. /**
  10. * telnet 基本连接类
  11. *
  12. * @description
  13. * @author weichaofan
  14. * @date 2013年10月25日
  15. */
  16. public class TelnetBase {
  17. private static final byte SB = (byte) 250;// 子选项开始
  18. private static final byte SE = (byte) 240;// 子选项结束
  19. private static final byte WILL = (byte) 251;// 选项协商
  20. private static final byte WONT = (byte) 252;// 选项协商
  21. private static final byte DO = (byte) 253;// 选项协商
  22. private static final byte DONT = (byte) 254;// 选项协商
  23. private static final byte IAC = (byte) 255;// 数据字节255
  24. private static final byte ECHO = (byte) 1;// 回显
  25. private static final byte IS = (byte) 0;// 是
  26. private static final byte SUPPRESS = (byte) 3;// 抑制继续进行
  27. private static final byte TT = (byte) 24;// 终端类型
  28. private InputStream is;
  29. private OutputStream os;
  30. private Socket client;
  31. private byte[] readBuffer = new byte[20 * 1024];
  32. private int miniReadIntervalMillSec = 3000;// 最短read阻塞间隔时间-毫秒
  33. private int connectTimeout = 1000;// 连接超时时间
  34. private int maxReadTimeout = 5000;
  35. public static String[] failTags = { "Failed", "fail", "incorrect" };
  36. public static String[] loginTags = { "$", "#", ">", "ogin", "@" };
  37. public static String[] commondEndTags= { "$", "#", ">"};
  38. public static String[] allTags = { "Failed", "fail", "incorrect", "$", "#",
  39. ">", "ogin", "@" };
  40. private String ip;
  41. private int port = 23;
  42. Logger logger = Logger.getLogger(getClass());
  43. /**
  44. *
  45. * 打开telnet连接
  46. *
  47. * @param ip
  48. * @param port
  49. *            23
  50. *
  51. * @return
  52. *
  53. * @throws CmdException
  54. */
  55. public TelnetBase(String ip) {
  56. this(ip, 23);
  57. }
  58. /**
  59. *
  60. * 打开telnet连接
  61. *
  62. * @param ip
  63. * @param port
  64. * @return
  65. * @throws CmdException
  66. */
  67. public TelnetBase(String ip, int port) {
  68. this.ip = ip;
  69. this.port = port;
  70. }
  71. /**
  72. * 连接
  73. *
  74. * @return
  75. * @throws Exception
  76. */
  77. public String connect() throws Exception {
  78. try {
  79. client = new Socket();
  80. client.connect(new InetSocketAddress(ip, port), connectTimeout);
  81. client.setSoTimeout(miniReadIntervalMillSec);// 设置is的read方法阻塞时间
  82. is = client.getInputStream();
  83. os = client.getOutputStream();
  84. } catch (Exception e) {
  85. this.close();
  86. throw new Exception(e);
  87. }
  88. return readKeyWords("ogin:");
  89. }
  90. /**
  91. *
  92. * 读取回显，并进行telnet协商
  93. *
  94. * @return
  95. *
  96. * @throws IOException
  97. */
  98. public String recieveEcho() throws IOException {
  99. int len = is.read(this.readBuffer);
  100. ArrayList<Byte> bsList = new ArrayList<Byte>();
  101. ArrayList<Byte> cmdList = new ArrayList<Byte>();
  102. for (int i = 0; i < len; i++) {
  103. int b = this.readBuffer[i] & 0xff;// &0xff是为了防止byte的255溢出,java中byte的取值是-128~127
  104. if (b != 255) {
  105. if (b == '\n' || b == '\0') {// NVT中行结束符以'\r\n'表示，回车以'\r\0表示'
  106. continue;
  107. }
  108. bsList.add((byte) b);
  109. continue;
  110. }
  111. cmdList.add(IAC);
  112. switch (this.readBuffer[++i] & 0xff) {
  113. case 251:// 服务器想激活某选项
  114. if ((readBuffer[++i] & 0xff) == 1) {// 同意回显
  115. cmdList.add(DO);
  116. cmdList.add(ECHO);
  117. } else if ((readBuffer[i] & 0xff) == 3) {// 同意抑制继续执行
  118. cmdList.add(DO);
  119. cmdList.add(SUPPRESS);
  120. // cmdList.add(GA);
  121. } else {// 不同意其他类型协商
  122. cmdList.add(DONT);
  123. cmdList.add(readBuffer[i]);
  124. }
  125. break;
  126. case 253:// 服务器想让客户端发起激活某选项
  127. if ((readBuffer[++i] & 0xff) == 24) {// 终端类型
  128. cmdList.add(WONT);// 同意激活终端类型协商
  129. cmdList.add(TT);
  130. } else if ((readBuffer[i] & 0xff) == 1) {
  131. cmdList.add(WILL);
  132. cmdList.add(ECHO);
  133. } else {
  134. cmdList.add(WONT);// 不同意其他类型协商
  135. cmdList.add(readBuffer[i]);
  136. }
  137. break;
  138. case 250:// 子选项开始
  139. cmdList.add(SB);
  140. if ((readBuffer[++i] & 0xff) == 24
  141. && (readBuffer[++i] & 0xff) == 1) {// 发送你的终端类型
  142. cmdList.add(TT);
  143. cmdList.add(IS);// 我的终端类型是
  144. cmdList.add((byte) 'V');
  145. cmdList.add((byte) 'T');
  146. cmdList.add((byte) '1');
  147. cmdList.add((byte) '0');
  148. cmdList.add((byte) '0');
  149. }
  150. break;
  151. case 240:// 子选项结束
  152. cmdList.add(SE);
  153. break;
  154. case 252:// 必须同意
  155. cmdList.add(DONT);
  156. cmdList.add(readBuffer[++i]);
  157. break;
  158. case 254:// 必须同意
  159. cmdList.add(WONT);
  160. cmdList.add(readBuffer[++i]);
  161. break;
  162. }
  163. }
  164. // 如果有协商则向服务端发送协商选项
  165. if (cmdList.size() > 0) {
  166. byte[] writeBuffer = new byte[cmdList.size()];
  167. for (int i = 0; i < cmdList.size(); i++) {
  168. writeBuffer[i] = cmdList.get(i);
  169. }
  170. os.write(writeBuffer);
  171. }
  172. // 组织回显字符
  173. int size = bsList.size();
  174. String str = "";
  175. if (size > 0) {
  176. byte[] bs = new byte[size];
  177. for (int i = 0; i < size; i++) {
  178. bs[i] = bsList.get(i).byteValue();
  179. }
  180. str = new String(bs, "gbk");
  181. } else {
  182. // 如果是协商，则回传协商信息
  183. if (cmdList.size() > 0) {
  184. str = recieveEcho();
  185. }
  186. }
  187. //  log(len, cmdList);
  188. return str;
  189. }
  190. private void log(int len, ArrayList<Byte> cmdList) {
  191. logger.debug("read===== ");
  192. for (int i = 0; i < len; i++) {
  193. logger.debug(readBuffer[i] & 0xff);
  194. logger.debug(" ");
  195. }
  196. if (cmdList.size() > 0) {
  197. logger.debug("write==== ");
  198. for (int i = 0; i < cmdList.size(); i++) {
  199. logger.debug(cmdList.get(i) & 0xff);
  200. logger.debug(" ");
  201. }
  202. }
  203. }
  204. /**
  205. * 用户名 命令中不要包括回车、换行
  206. *
  207. * @param cmd
  208. * @param keyWords
  209. * @return
  210. */
  211. public String sendUserName(String name) throws Exception {
  212. name += "\r\n";
  213. os.write(name.getBytes());
  214. return readKeyWords("assword");
  215. }
  216. /**
  217. * 密码 命令中不要包括回车、换行
  218. *
  219. * @param cmd
  220. * @param keyWords
  221. * @return
  222. */
  223. public String sendUserPwd(String pwd) throws Exception {
  224. pwd += "\r\n";
  225. os.write(pwd.getBytes());
  226. return readKeyWords(allTags);
  227. }
  228. /**
  229. * 命令中不要包括回车、换行
  230. *
  231. * @param cmd
  232. * @param keyWords
  233. * @return
  234. */
  235. public String sendCmd(String cmd, String... keyWords) throws Exception {
  236. return sendCmd(cmd,false,keyWords);
  237. }
  238. /**
  239. * 命令中不要包括回车、换行
  240. *
  241. * @param cmd
  242. * @param keyWords
  243. * @return
  244. */
  245. public String sendCmd(String cmd,boolean excludeCommandCheck, String... keyWords) throws Exception {
  246. os.write((cmd + "\r\n").getBytes());
  247. if(!excludeCommandCheck){
  248. return readKeyWords(cmd,maxReadTimeout,keyWords);
  249. }else{
  250. return readKeyWords(keyWords);
  251. }
  252. }
  253. /**
  254. * 命令中不要包括回车、换行 默认搜索条件为$、#、>
  255. *  不包含执行命令中的关键字
  256. * @param cmd
  257. * @param keyWords
  258. * @return
  259. */
  260. public String sendCommand(String cmd) throws Exception {
  261. return sendCommand(cmd,false);
  262. }
  263. /**
  264. * 命令中不要包括回车、换行 默认搜索条件为$、#、>
  265. *  是否包含执行命令中的关键字
  266. * @param cmd
  267. * @param keyWords
  268. * @return
  269. */
  270. public String sendCommand(String cmd,boolean excludeCommandCheck) throws Exception {
  271. os.write((cmd + "\r\n").getBytes());
  272. if(!excludeCommandCheck){
  273. return readKeyWords(cmd,maxReadTimeout,commondEndTags);
  274. }else{
  275. return readKeyWords(commondEndTags);
  276. }
  277. }
  278. /**
  279. * 命令中不要包括回车、换行 默认搜索条件为$、#、>
  280. * 不包含执行命令中的关键字
  281. * @param cmd
  282. * @param timeOut
  283. * @param keyWords
  284. * @return
  285. */
  286. public String sendCommand(String cmd, long timeOut) throws Exception {
  287. return sendCommand(cmd,timeOut, false);
  288. }
  289. /**
  290. * 命令中不要包括回车、换行 默认搜索条件为$、#、>
  291. * 是否包含执行命令中的关键字
  292. * @param cmd
  293. * @param timeOut
  294. * @param keyWords
  295. * @return
  296. */
  297. public String sendCommand(String cmd, long timeOut,boolean excludeCommandCheck) throws Exception {
  298. os.write((cmd + "\r\n").getBytes());
  299. if(!excludeCommandCheck){
  300. return readKeyWords(cmd,timeOut, commondEndTags);
  301. }else{
  302. return readKeyWords(timeOut, commondEndTags);
  303. }
  304. }
  305. /**
  306. * 命令中不要包括回车、换行
  307. *
  308. * @param cmd
  309. * @param timeOut
  310. * @param keyWords
  311. * @return
  312. */
  313. public String sendCmd(String cmd, long timeOut, String... keyWords)
  314. throws Exception {
  315. return sendCmd(cmd,false,timeOut, keyWords);
  316. }
  317. /**
  318. * 命令中不要包括回车、换行
  319. *
  320. * @param cmd
  321. * @param timeOut
  322. * @param keyWords
  323. * @return
  324. */
  325. public String sendCmd(String cmd, boolean excludeCommandCheck,long timeOut, String... keyWords)
  326. throws Exception {
  327. os.write((cmd + "\r\n").getBytes());
  328. if(!excludeCommandCheck){
  329. return readKeyWords(cmd,timeOut, keyWords);
  330. }else{
  331. return readKeyWords(timeOut, keyWords);
  332. }
  333. }
  334. /**
  335. *
  336. * 关闭telnet连接
  337. */
  338. public void close() {
  339. if (is != null) {
  340. try {
  341. is.close();
  342. } catch (IOException e) {
  343. e.printStackTrace();
  344. }
  345. }
  346. if (os != null) {
  347. try {
  348. os.close();
  349. } catch (IOException e) {
  350. e.printStackTrace();
  351. }
  352. }
  353. if (client != null) {
  354. try {
  355. client.close();
  356. } catch (IOException e) {
  357. e.printStackTrace();
  358. }
  359. }
  360. }
  361. /**
  362. *
  363. * 读取期望值，使用默认超时时间5秒
  364. *
  365. * @param keyWords
  366. *
  367. * @return
  368. */
  369. public String readKeyWords(String... keyWords) {
  370. return this.readKeyWords(maxReadTimeout, keyWords);
  371. }
  372. /**
  373. *
  374. * 读取期望值
  375. *
  376. * @param timeOut
  377. *            超时时间
  378. *
  379. * @param keyWords
  380. *
  381. * @return
  382. *
  383. * @throws CmdException
  384. */
  385. public String readKeyWords(long timeOut, String... keyWords) {
  386. String rv = "";
  387. long nextTime = 0;
  388. long endTime = System.currentTimeMillis() + timeOut;
  389. do {
  390. try {
  391. String _rv = this.recieveEcho();
  392. rv += _rv;
  393. } catch (IOException e) {
  394. nextTime = endTime - System.currentTimeMillis();
  395. }
  396. } while (!this.findKeyWord(keyWords, rv) && nextTime >= 0);
  397. if (nextTime < 0)
  398. System.err.println("Read TimeOut...Echo:\n" + rv);
  399. return rv;
  400. }
  401. /**
  402. *
  403. * 读取期望值  排除command中含有的关键字
  404. *
  405. * @param timeOut
  406. *            超时时间
  407. *
  408. * @param keyWords
  409. *
  410. * @return
  411. *
  412. * @throws CmdException
  413. */
  414. public String readKeyWords(String command,long timeOut, String... keyWords) {
  415. String rv = "";
  416. long nextTime = 0;
  417. long endTime = System.currentTimeMillis() + timeOut;
  418. do {
  419. try {
  420. String _rv = this.recieveEcho();
  421. rv += _rv;
  422. } catch (IOException e) {
  423. nextTime = endTime - System.currentTimeMillis();
  424. }
  425. } while (!this.findKeyWord(command,keyWords, rv) && nextTime >= 0);
  426. if (nextTime < 0)
  427. System.err.println("Read TimeOut...Echo:\n" + rv);
  428. return rv;
  429. }
  430. /**
  431. *
  432. * 查找关键字
  433. *
  434. * @param keyWords
  435. *
  436. * @param str
  437. *
  438. * @return
  439. */
  440. public boolean findKeyWord(String[] keyWords, String str) {
  441. if (str == null || "".equals(str))
  442. return false;
  443. if (keyWords == null || keyWords.length == 0)
  444. return true;
  445. for (int i = 0; i < keyWords.length; i++) {
  446. if (str.indexOf(keyWords[i]) != -1)
  447. return true;
  448. }
  449. return false;
  450. }
  451. /**
  452. *
  453. * 查找关键字  排除command中含有的关键字
  454. *
  455. * @param keyWords
  456. *
  457. * @param str
  458. *
  459. * @return
  460. */
  461. public boolean findKeyWord(String command,String[] keyWords, String str) {
  462. if (str == null || "".equals(str))
  463. return false;
  464. if (keyWords == null || keyWords.length == 0)
  465. return true;
  466. System.out.println(str);
  467. if(-1 != str.indexOf(command)){
  468. str=str.substring(str.indexOf(command)+command.length());
  469. for (int i = 0; i < keyWords.length; i++) {
  470. if (str.indexOf(keyWords[i]) != -1)
  471. return true;
  472. }
  473. }
  474. return false;
  475. }
  476. /**
  477. * 最短读阻塞时间
  478. *
  479. * @return
  480. */
  481. public int getMiniReadIntervalMillSec() {
  482. return miniReadIntervalMillSec;
  483. }
  484. public void setMiniReadIntervalMillSec(int miniReadIntervalMillSec) {
  485. this.miniReadIntervalMillSec = miniReadIntervalMillSec;
  486. }
  487. /**
  488. * 连接超时时间
  489. *
  490. * @return
  491. */
  492. public int getConnectTimeout() {
  493. return connectTimeout;
  494. }
  495. public void setConnectTimeout(int connectTimeout) {
  496. this.connectTimeout = connectTimeout;
  497. }
  498. /**
  499. * 最大读阻塞时间
  500. *
  501. * @return
  502. */
  503. public int getMaxReadTimeout() {
  504. return maxReadTimeout;
  505. }
  506. public void setMaxReadTimeout(int maxReadTimeout) {
  507. this.maxReadTimeout = maxReadTimeout;
  508. }
  509. }

http://blog.csdn.net/chaofanwei/article/details/14130179

http://www.iteye.com/topic/284636

关于telnet协议的研究以及用java进行封装实现自己的telnet客户端(转)的更多相关文章

  1. Telnet 协议详解

    Telnet 协议详解 一.概述 ============================================================ Telnet 协议是 TCP/IP 协议族中 ...

  2. telnet协议的作用详解，以及telnet端口号介绍

    转:http://www.ctowhy.com/382.html Telnet协议,工作在TCP/IP协议栈的“应用层”,telnet是一种使用命令行的远程终端管理的协议,可以远程连接到网络设备上,并 ...

  3. Telnet协议详解

    转:http://www.cnblogs.com/dazhaxie/archive/2012/06/27/2566054.html 1. 概述 Telnet协议是TCP/IP协议族中的一员,是Inte ...

  4. Telnet协议详解（远程登陆协议）

    1. 概述 Telnet协议是TCP/IP协议族中的一员,是Internet远程登陆服务的标准协议.Telnet协议的目的是提供一个相对通用的,双向的,面向八位字节的通信方法,允许界面终端设备和面向终 ...

  5. 【Telnet】使用Telnet协议连接到远程Shell执行脚本

    介绍 本文介绍如何通过Telnet协议连接到远程Shell,执行脚本,并获取执行结果: 相关文章: <[Jsch]使用SSH协议连接到远程Shell执行脚本>http://www.cnbl ...

  6. Atitit onvif协议获取rtsp地址播放java语言 attilx总结

    Atitit onvif协议获取rtsp地址播放java语言 attilx总结 1.1. 获取rtsp地址的算法与流程1 1.2. Onvif摄像头的发现,ws的发现机制,使用xcf类库1 2. 调用 ...

  7. java 通过TCP\UDP 协议实现多人聊天，点对点，文件传送-----分服务器端和客户端

    java 通过TCP\UDP 协议实现多人聊天,点对点,文件传送-----分服务器端和客户端 启动界面如下图: 首先启动服务器: 客户端登陆,登陆成功后为: 默认发送是全部用户,是多人发送. 当在边列 ...

  8. telnet协议：简介与安装使用

    Telnet简介 Telnet协议是TCP/IP协议族中的一员,是Internet远程登陆服务的标准协议和主要方式.它为用户提供了在本地计算机上完成远程主机工作的能力.在终端使用者的电脑上使用teln ...

  9. 如何在Windows系统上利用Telnet协议连接Linux服务器

    Telnet协议是Internet远程登录服务的标准协议,它为用户提供了在本地计算机上完成远程主机工作的能力.很多终端使用者都习惯在计算机上利用Telnet会话来远程控制服务器.这里小编就分两步为大家 ...

随机推荐

  1. A Game of Thrones(17) - Bran

    It seemed as though he had been falling for years. Fly, a voice whispered in the darkness, but Bran ...

  2. Android----------WindowManager

    我们Android平台是一个又一个的Activity组成的,每个Activity有一个或者多个View构成.所以说.当我们想显示一个界面的时候,我们首先想到的是建立一个Activity,然后全部的操作 ...

  3. Python学习笔记22:Django下载并安装

    Django它是一个开源Web应用程序框架.由Python书面. 通过MVC软件设计模式,这种模式M,视图V和控制器C. 它最初是一个数字新闻内容为主的网站已经发展到管理劳伦斯出版集团.那是,CMS( ...

  4. UVA 11080 - Place the Guards(二分图判定)

    UVA 11080 - Place the Guards 题目链接 题意:一些城市.之间有道路相连,如今要安放警卫,警卫能看守到当前点周围的边,一条边仅仅能有一个警卫看守,问是否有方案,假设有最少放几 ...

  5. The Official Preppy Handbook

    The Official Preppy Handbook: Lisa Birnbach: 9780894801402: Amazon.com: Books The Official Preppy Ha ...

  6. 【剑指offer】复制的复杂链条

    转载请注明出处:http://blog.csdn.net/ns_code/article/details/26154691 题目描写叙述: 输入一个复杂链表(每一个节点中有节点值,以及两个指针,一个指 ...

  7. C：打印菱形（自己的方法）

    //-------------------*打印菱形*--------------------- int i,j,k; int n; printf("请输入一个奇数n:"); sc ...

  8. 为什么推荐std::string而不是char*

    例如如下: map<const char*, const char*> map_test; map_test["a"] = "a"; map_tes ...

  9. SVN的命令解析(感觉不错就转了)

    本文链接: http://www.php-oa.com/2008/03/12/svnminglingzailinuxxiadeshiyong.html .将文件checkout到本地目录 svn ch ...

  10. spring的长处 ioc aop

    spring 的长处? 1.减少了组件之间的耦合性 ,实现了软件各层之间的解耦 2.能够使用easy提供的众多服务.如事务管理,消息服务等 3.容器提供单例模式支持 4.容器提供了AOP技术,利用它非 ...