大家觉得做个telnet的特殊shell如何

tll

设想：
ssh连接到cb显示的还是普通shell，telnet连接上的，是针对新手的特殊shell，为什么我还要使用这种老掉牙而且不安全的连接方式？那是因为操作简单，可以少code，并且新手一般都在自家局域网里，不会出事的，这个shell与sunduino（前面提到过）兼容，可以方便新手使用，来源于我们学校的路由器，我们学校路由器是dlink的（应该说交换机还是什么的，不是很熟），然后电脑里是xp，我第一天无聊就用cmd把路由器给telnet了（学校电脑自带telnet），然后老师没改密码，直接用户名admin，密码空，登录成功，老师教鞭软件封锁无效，因为它只锁http，不知道我还能用telnet，于是进入路由器的cmd界面，发现有一种不同于普通shell的设置方式，感觉很新颖，想想能不能用到cb上？于是联合sunduino，想到了这个，先不说了，举个例子，例如我想新建一个叫a的程序：
add program a
然后跳出对新手友好的nano，自动填充开头的#!/..../sunduino
接着新手往后面写命令，命令都是极为简单的，使用python来解析
最后新手保存
新手要修改，就
edit program a
还是nano，就修改
我觉得这个和苹果的人性化script——apple script很相似，这个script的语法和英语很像，代码就可以作为一句话来理解，如果达到那种出神入化的程度，新手想不会都不行。
好吧，接着，删除大家应该知道了
del program a或者delete program a
如果直接写add a或edit a或del a，默认就当是编辑程序，add xxx还有其他用处如编辑配置文件（虽然我喜欢给新手菜单）
大家觉得如何？
我初学C，这是我的一个笔记http://user.qzone.qq.com/1040424979/infocenter#!app=2&via=QZ.HashRefresh&pos=1379519187
里面有关于这个的具体设想
如果好记得回复，坏也要回复啊！

tll

忙活了一个晚上，一个早上，一个中午
做出来了~~~
C代码（需要python_do_cmd解析器，sunduino中有）：

1. #include <stdlib.h>
   
2. #include <sys/types.h>
   
3. #include <stdio.h>
   
4. #include <sys/socket.h>
   
5. #include <netinet/in.h>
   
6. #include <string.h>
   
7. #include <ctype.h>
   
8. #include <fcntl.h>
   
9. #include <unistd.h>
   
10. #include   <stdarg.h>
    
11. 
    
12. #define run_in_backstage 0
    
13. #define nolog 0
    
14. 
    
15. int pid = -1;
    
16. 
    
17. void clear(char* txt){
    
18. //txt[0] = '\0';
    
19. int sz = sizeof(txt);
    
20. int i = 0;
    
21. for(i = 0;i < sz;i++){
    
22. txt[i] = '\0';
    
23. }
    
24. }
    
25. 
    
26. int print(char *fmt, ...)
    
27. {
    
28. if(pid != 0||nolog){
    
29. va_list argptr;
    
30. int cnt;
    
31. va_start(argptr, fmt);
    
32. cnt = vprintf(fmt, argptr);
    
33. va_end(argptr);
    
34. return(cnt);
    
35. }else{
    
36. return(0);
    
37. }
    
38. }
    
39. 
    
40. int main()
    
41. {
    
42. int sfp,nfp,recbytes;
    
43. FILE *fl;
    
44. char buffer[1025];
    
45. char text[100] = "Hey guy,you already login to the Cubieboard.\r\nThis is Sunduino shell.\r\n";
    
46. //May not Cb,another board?Than you can edit this.
    
47. char pmt[] = ">";
    
48. char cmd[1024];
    
49. struct sockaddr_in s_add,c_add;
    
50. int sin_size;
    
51. char result[1000] = "";
    
52. int size = sizeof(result)/sizeof(char);
    
53. unsigned short portnum=23;
    
54. char ers[1024] = "\n";
    
55. int rsz = 0;
    
56. char terminfo[50];
    
57. if(run_in_backstage){
    
58. pid = fork();
    
59. if(pid != 0){
    
60. print("Ok,runs in backstage!Backstage program's pid is %d\n",pid);
    
61. return 0;
    
62. }else{
    
63. print("Backstage started!\n");
    
64. }
    
65. }
    
66. setenv("remote","1",0);
    
67. sprintf(text,"%s%s",text,pmt);
    
68. print("Telnetd start\n");
    
69. sfp = socket(AF_INET, SOCK_STREAM, 0);
    
70. if(-1 == sfp)
    
71. {
    
72.     print("socket fail!\n");
    
73.     return -1;
    
74. }
    
75. print("socket ok!\n");
    
76. 
    
77. bzero(&s_add,sizeof(struct sockaddr_in));
    
78. s_add.sin_family=AF_INET;
    
79. s_add.sin_addr.s_addr=htonl(INADDR_ANY);
    
80. s_add.sin_port=htons(portnum);
    
81. 
    
82. if(-1 == bind(sfp,(struct sockaddr *)(&s_add), sizeof(struct sockaddr)))
    
83. {
    
84.     print("bind fail!\n");
    
85.     return -1;
    
86. }
    
87. print("bind ok!\n");
    
88. 
    
89. if(-1 == listen(sfp,5))
    
90. {
    
91.     print("listen fail!\n");
    
92.     return -1;
    
93. }
    
94. print("listen ok!\n");
    
95. while(1)
    
96. {
    
97. sin_size = sizeof(struct sockaddr_in);
    
98. 
    
99. nfp = accept(sfp, (struct sockaddr *)(&c_add), &sin_size);
    
100. if(-1 == nfp)
     
101. {
     
102.     print("accept fail!\n");
     
103.     return -1;
     
104. }
     
105. print("accept ok!\nServer start get connect from %#x : %#x\n",ntohl(c_add.sin_addr.s_addr),ntohs(c_add.sin_port));
     
106. print("Press any key to close this connection.\n");
     
107. if(-1 == (recbytes = read(nfp,buffer,1024)))
     
108. {
     
109.     print("read data1 fail !\n");
     
110.     return -1;
     
111. }
     
112. buffer[recbytes]='\0';
     
113. int i;
     
114. print("Source first:\n");
     
115. for(i=0;i<recbytes;i++){
     
116. print("%d:%d -- %c\n",i,buffer[i],buffer[i]);
     
117. }
     
118. char stxt[] = {255,253,24,255,250,24,1,255,240};
     
119. //These character will let server tells the client:
     
120. //"I want to know what term are you using".
     
121. //I get this from Baidu Baike and Baidu Wenku
     
122. print("%s %d\n",stxt,write(nfp,stxt,sizeof(stxt)));
     
123. if(-1 == (recbytes = read(nfp,buffer,1024)))
     
124. {
     
125.     print("read term type fail!\n");
     
126.     return -1;
     
127. }
     
128. buffer[recbytes]='\0';
     
129. if(buffer[0] == 255 && buffer[1] == 250 && buffer[3] == 0){
     
130. //From baike and wenku,start
     
131. print("Your terminal type:");
     
132. //Many telnet client's terminal type is in "Assigned Numbers RFC" document
     
133. //You may can get what's it means from termcap or terminfo database
     
134. //That's from baike
     
135. i=4;
     
136. while((i+1)<recbytes){
     
137. if(buffer[i] == 255 && buffer[i+1] == 240){
     
138. //If client says "end",then end,baike~
     
139. break;
     
140. }
     
141. if(isalpha(buffer[i])){
     
142. terminfo[i-4] = (buffer[i]+32);
     
143. }else{
     
144. terminfo[i-4] = buffer[i];
     
145. }
     
146. i++;
     
147. }
     
148. terminfo[i] = '\0';
     
149. print("%s\n",terminfo);
     
150. setenv("remote_term",terminfo,0);
     
151. }
     
152. if(-1 == write(nfp,text,sizeof(text)))
     
153. {
     
154.     print("write fail!\n");
     
155.     return -1;
     
156. }
     
157. print("write ok!\n");
     
158. //getchar();
     
159. //print("sre");
     
160. /*if(-1 == (recbytes = read(nfp,buffer,1024)))
     
161. {
     
162.     print("read data fail !\r\n");
     
163. }
     
164. buffer[recbytes]='\0';
     
165. print("Data:%s\r\n",buffer);
     
166. print("Source:\r\n");
     
167. for(i=0;i<recbytes;i++){
     
168. print("%d:%d -- %c\r\n",i,buffer[i],buffer[i]);
     
169. }*/
     
170. while(1){
     
171. //While while while...infinity while
     
172. if(-1 == (recbytes = read(nfp,buffer,1024)))
     
173. {
     
174.     print("read data fail!\n");
     
175. }
     
176. //Read data again,again and again
     
177. if(recbytes > 0){
     
178. //If it has some data
     
179. buffer[recbytes]='\0';
     
180. print("Data:%s\n",buffer);
     
181. print("Source:\n");
     
182. for(i=0;i<recbytes;i++){
     
183. print("%d:%d -- %c\n",i,buffer[i],buffer[i]);
     
184. }
     
185. if(sizeof(buffer)/sizeof(char) >= 3){
     
186. if(buffer[0] == 255 && buffer[1] == 251 && buffer[2] == 6){
     
187. //CTRL+C to exit(linux)
     
188. close(nfp);
     
189. break;
     
190. }
     
191. }
     
192. if(sizeof(buffer)/sizeof(char) >= 2){
     
193. if(buffer[0] == 255 && buffer[1] == 248){
     
194. //CTRL+C to exit(linux)
     
195. close(nfp);
     
196. break;
     
197. }
     
198. if(buffer[recbytes-2] == 13 && buffer[recbytes-1] == 10){
     
199. //if has \r\n
     
200. buffer[recbytes-2] = '\0';
     
201. buffer[recbytes-1] = '\0';
     
202. print("Run: %s\n",buffer);
     
203. sprintf(cmd,"python_do_cmd "%s" 2>&1",buffer);
     
204. clear(result);
     
205. fl = popen(cmd,"r");
     
206. print("RES1%s\n",result);
     
207. rsz = fread(result,sizeof(char),sizeof(result),fl);
     
208. //getResultFromSystemCall(cmd,result,size);
     
209. pclose(fl);
     
210. result[rsz] = '\0';
     
211. print("Count:%d\n",rsz);
     
212. print("RES2%s\n",result);
     
213. }else{
     
214. print("Run: %s",buffer);
     
215. sprintf(cmd,"python_do_cmd "%s" 2>&1",buffer);
     
216. clear(result);
     
217. fl = popen(cmd,"r");
     
218. print("RES1%s\n",result);
     
219. rsz = fread(result,sizeof(char),sizeof(result),fl);
     
220. //getResultFromSystemCall(cmd,result,size);
     
221. pclose(fl);
     
222. print("Count:%d\n",rsz);
     
223. result[rsz] = '\0';
     
224. print("RES%s\n",result);
     
225. }
     
226. }
     
227. int p=0,q=0;
     
228. for(i=0;i<sizeof(result)/sizeof(char);i++){
     
229. /*if(result[i] == '\0') break;
     
230. if(result[i] == '\r') result[i] == NULL;*/
     
231. if(result[q] == '\r'){
     
232. q++;
     
233. }else{
     
234. if(q != p){
     
235. result[p] = result[q];
     
236. }
     
237. p++;
     
238. q++;
     
239. }
     
240. if(result[q] == '\0'){
     
241. result[p] = '\0';
     
242. break;
     
243. }
     
244. }
     
245. sprintf(ers,"%s\r%s",result,pmt);
     
246. if(-1 == write(nfp,ers,(rsz+sizeof(pmt)+1)))
     
247. {
     
248.     print("write opt fail!\n");
     
249.     return -1;
     
250. }
     
251. print("ERS%s\n",ers);
     
252. print("write opt ok!\n");
     
253. clear(ers);
     
254. print("RES%s\n",result);
     
255. }
     
256. }
     
257. /*print("Source from client:\r\n");
     
258. print("%s\r\n",buffer);*/
     
259. close(nfp);
     
260. //break;
     
261. //Will not break and get the next connection
     
262. }
     
263. close(sfp);
     
264. return 0;
     
265. }
     

复制代码

yuruyi

精神上支持下。

学c不妨多参考下现有资源。
有现成东西的，ssh、netcat 连 bash 自己都支持 tcp udp。

myreg

个人认为，多此一举

tll

myreg 发表于 2013-9-27 15:45
个人认为，多此一举

对新手其实还是可以的

tll

yuruyi 发表于 2013-9-26 17:49
精神上支持下。

学c不妨多参考下现有资源。

参考了，现在遇到了点问题

joesonw

如果想要写复杂点用flex/bison 写脚本处理

tll

joesonw 发表于 2013-9-28 00:22
如果想要写复杂点用flex/bison 写脚本处理

这个不算复杂啦，一堆if处理即可

gnensis

不错啊，挺实用的。

rgwan

嗯，我觉得你可以试试用yacc做一个解释器。代码简单很多的。