开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > TCP/IP协议栈 > 查看源码
ax25cmd.c
资源名称：export.zip　[点击查看]
上传用户：hepax88
上传日期：2007-01-03
资源大小：1101k
文件大小：12k
源码类别：

TCP/IP协议栈

开发平台：

Visual C++

ax25cmd.c：源码内容
  1. /* AX25 control commands
  2.  * Copyright 1991 Phil Karn, KA9Q
  3.  */
  4. #include <stdio.h>
  5. #include "global.h"
  6. #include "mbuf.h"
  7. #include "timer.h"
  8. #include "proc.h"
  9. #include "iface.h"
  10. #include "ax25.h"
  11. #include "lapb.h"
  12. #include "cmdparse.h"
  13. #include "socket.h"
  14. #include "mailbox.h"
  15. #include "session.h"
  16. #include "tty.h"
  17. #include "nr4.h"
  18. #include "commands.h"
  20. static int axdest(struct iface *ifp);
  21. static int axheard(struct iface *ifp);
  22. static void axflush(struct iface *ifp);
  23. static int doaxflush(int argc,char *argv[],void *p);
  24. static int doaxirtt(int argc,char *argv[],void *p);
  25. static int doaxkick(int argc,char *argv[],void *p);
  26. static int doaxreset(int argc,char *argv[],void *p);
  27. static int doaxroute(int argc,char *argv[],void *p);
  28. static int doaxstat(int argc,char *argv[],void *p);
  29. static int doaxwindow(int argc,char *argv[],void *p);
  30. static int doblimit(int argc,char *argv[],void *p);
  31. static int dodigipeat(int argc,char *argv[],void *p);
  32. static int domaxframe(int argc,char *argv[],void *p);
  33. static int domycall(int argc,char *argv[],void *p);
  34. static int don2(int argc,char *argv[],void *p);
  35. static int dopaclen(int argc,char *argv[],void *p);
  36. static int dopthresh(int argc,char *argv[],void *p);
  37. static int dot3(int argc,char *argv[],void *p);
  38. static int doversion(int argc,char *argv[],void *p);
  40. char *Ax25states[] = {
  41. "",
  42. "Disconn",
  43. "Listening",
  44. "Conn pend",
  45. "Disc pend",
  46. "Connected",
  47. "Recovery",
  48. };
  50. /* Ascii explanations for the disconnect reasons listed in lapb.h under
  51.  * "reason" in ax25_cb
  52.  */
  53. char *Axreasons[] = {
  54. "Normal",
  55. "DM received",
  56. "Timeout"
  57. };
  59. static struct cmds Axcmds[] = {
  60. "blimit", doblimit, 0, 0, NULL,
  61. "destlist", doaxdest, 0, 0, NULL,
  62. "digipeat", dodigipeat, 0, 0, NULL,
  63. "flush", doaxflush, 0, 0, NULL,
  64. "heard", doaxheard, 0, 0, NULL,
  65. "irtt", doaxirtt, 0, 0, NULL,
  66. "kick", doaxkick, 0, 2, "ax25 kick <axcb>",
  67. "maxframe", domaxframe, 0, 0, NULL,
  68. "mycall", domycall, 0, 0, NULL,
  69. "paclen", dopaclen, 0, 0, NULL,
  70. "pthresh", dopthresh, 0, 0, NULL,
  71. "reset", doaxreset, 0, 2, "ax25 reset <axcb>",
  72. "retry", don2, 0, 0, NULL,
  73. "route", doaxroute, 0, 0, NULL,
  74. "status", doaxstat, 0, 0, NULL,
  75. "t3", dot3, 0, 0, NULL,
  76. "version", doversion, 0, 0, NULL,
  77. "window", doaxwindow, 0, 0, NULL,
  78. NULL,
  79. };
  80. static int keychar(int c);
  83. /* Multiplexer for top-level ax25 command */
  84. int
  85. doax25(argc,argv,p)
  86. int argc;
  87. char *argv[];
  88. void *p;
  89. {
  90. return subcmd(Axcmds,argc,argv,p);
  91. }
  93. int
  94. doaxheard(argc,argv,p)
  95. int argc;
  96. char *argv[];
  97. void *p;
  98. {
  99. struct iface *ifp;
  101. if(argc > 1){
  102. if((ifp = if_lookup(argv[1])) == NULL){
  103. printf("Interface %s unknownn",argv[1]);
  104. return 1;
  105. }
  106. if(ifp->output != ax_output){
  107. printf("Interface %s not AX.25n",argv[1]);
  108. return 1;
  109. }
  110. axheard(ifp);
  111. return 0;
  112. }
  113. for(ifp = Ifaces;ifp != NULL;ifp = ifp->next){
  114. if(ifp->output != ax_output)
  115. continue; /* Not an ax.25 interface */
  116. if(axheard(ifp) == EOF)
  117. break;
  118. }
  119. return 0;
  120. }
  121. static int
  122. axheard(ifp)
  123. struct iface *ifp;
  124. {
  125. struct lq *lp;
  126. char tmp[AXBUF];
  128. if(ifp->hwaddr == NULL)
  129. return 0;
  130. printf("%s:n",ifp->name);
  131. printf("Station   Last heard           Pktsn");
  132. for(lp = Lq;lp != NULL;lp = lp->next){
  133. if(lp->iface != ifp)
  134. continue;
  135. printf("%-10s%-17s%8lun",pax25(tmp,lp->addr),
  136.  tformat(secclock() - lp->time),lp->currxcnt);
  137. }
  138. return 0;
  139. }
  140. int
  141. doaxdest(argc,argv,p)
  142. int argc;
  143. char *argv[];
  144. void *p;
  145. {
  146. struct iface *ifp;
  148. if(argc > 1){
  149. if((ifp = if_lookup(argv[1])) == NULL){
  150. printf("Interface %s unknownn",argv[1]);
  151. return 1;
  152. }
  153. if(ifp->output != ax_output){
  154. printf("Interface %s not AX.25n",argv[1]);
  155. return 1;
  156. }
  157. axdest(ifp);
  158. return 0;
  159. }
  160. for(ifp = Ifaces;ifp != NULL;ifp = ifp->next){
  161. if(ifp->output != ax_output)
  162. continue; /* Not an ax.25 interface */
  163. if(axdest(ifp) == EOF)
  164. break;
  165. }
  166. return 0;
  167. }
  168. static int
  169. axdest(ifp)
  170. struct iface *ifp;
  171. {
  172. struct ld *lp;
  173. struct lq *lq;
  174. char tmp[AXBUF];
  176. if(ifp->hwaddr == NULL)
  177. return 0;
  178. printf("%s:n",ifp->name);
  179. printf("Station   Last ref         Last heard           Pktsn");
  180. for(lp = Ld;lp != NULL;lp = lp->next){
  181. if(lp->iface != ifp)
  182. continue;
  184. printf("%-10s%-17s",
  185.  pax25(tmp,lp->addr),tformat(secclock() - lp->time));
  187. if(addreq(lp->addr,ifp->hwaddr)){
  188. /* Special case; it's our address */
  189. printf("%-17s",tformat(secclock() - ifp->lastsent));
  190. } else if((lq = al_lookup(ifp,lp->addr,0)) == NULL){
  191. printf("%-17s","");
  192. } else {
  193. printf("%-17s",tformat(secclock() - lq->time));
  194. }
  195. printf("%8lun",lp->currxcnt);
  196. }
  197. return 0;
  198. }
  199. static int
  200. doaxflush(argc,argv,p)
  201. int argc;
  202. char *argv[];
  203. void *p;
  204. {
  205. struct iface *ifp;
  207. for(ifp = Ifaces;ifp != NULL;ifp = ifp->next){
  208. if(ifp->output != ax_output)
  209. continue; /* Not an ax.25 interface */
  210. axflush(ifp);
  211. }
  212. return 0;
  213. }
  214. static void
  215. axflush(ifp)
  216. struct iface *ifp;
  217. {
  218. struct lq *lp,*lp1;
  219. struct ld *ld,*ld1;
  221. ifp->rawsndcnt = 0;
  222. for(lp = Lq;lp != NULL;lp = lp1){
  223. lp1 = lp->next;
  224. free(lp);
  225. }
  226. Lq = NULL;
  227. for(ld = Ld;ld != NULL;ld = ld1){
  228. ld1 = ld->next;
  229. free(ld);
  230. }
  231. Ld = NULL;
  232. }
  234. static
  235. doaxreset(argc,argv,p)
  236. int argc;
  237. char *argv[];
  238. void *p;
  239. {
  240. struct ax25_cb *axp;
  242. axp = (struct ax25_cb *)ltop(htol(argv[1]));
  243. if(!ax25val(axp)){
  244. printf(Notval);
  245. return 1;
  246. }
  247. reset_ax25(axp);
  248. return 0;
  249. }
  251. /* Display AX.25 link level control blocks */
  252. static
  253. doaxstat(argc,argv,p)
  254. int argc;
  255. char *argv[];
  256. void *p;
  257. {
  258. register struct ax25_cb *axp;
  259. char tmp[AXBUF];
  261. if(argc < 2){
  262. printf("&AXB      Snd-Q   Rcv-Q   Remote    Staten");
  263. for(axp = Ax25_cb;axp != NULL; axp = axp->next){
  264. printf("%9p %-8d%-8d%-10s%sn",
  265.  axp,
  266.  len_q(axp->txq),len_p(axp->rxq),
  267.  pax25(tmp,axp->remote),
  268.  Ax25states[axp->state]);
  269. }
  270. return 0;
  271. }
  272. axp = (struct ax25_cb *)ltop(htol(argv[1]));
  273. if(!ax25val(axp)){
  274. printf(Notval);
  275. return 1;
  276. }
  277. st_ax25(axp);
  278. return 0;
  279. }
  280. /* Dump one control block */
  281. void
  282. st_ax25(axp)
  283. register struct ax25_cb *axp;
  284. {
  285. char tmp[AXBUF];
  287. if(axp == NULL)
  288. return;
  289. printf("     &AXB Remote   RB V(S) V(R) Unack P Retry Staten");
  291. printf("%9p %-9s%c%c",axp,pax25(tmp,axp->remote),
  292.  axp->flags.rejsent ? 'R' : ' ',
  293.  axp->flags.remotebusy ? 'B' : ' ');
  294. printf(" %4d %4d",axp->vs,axp->vr);
  295. printf(" %02u/%02u %u",axp->unack,axp->maxframe,axp->proto);
  296. printf(" %02u/%02u",axp->retries,axp->n2);
  297. printf(" %sn",Ax25states[axp->state]);
  299. printf("srtt = %lu mdev = %lu ",axp->srt,axp->mdev);
  300. printf("T1: ");
  301. if(run_timer(&axp->t1))
  302. printf("%lu",read_timer(&axp->t1));
  303. else
  304. printf("stop");
  305. printf("/%lu ms; ",dur_timer(&axp->t1));
  307. printf("T3: ");
  308. if(run_timer(&axp->t3))
  309. printf("%lu",read_timer(&axp->t3));
  310. else
  311. printf("stop");
  312. printf("/%lu msn",dur_timer(&axp->t3));
  314. }
  316. /* Display or change our AX.25 address */
  317. static
  318. domycall(argc,argv,p)
  319. int argc;
  320. char *argv[];
  321. void *p;
  322. {
  323. char tmp[AXBUF];
  325. if(argc < 2){
  326. printf("%sn",pax25(tmp,Mycall));
  327. return 0;
  328. }
  329. if(setcall(Mycall,argv[1]) == -1)
  330. return -1;
  331. return 0;
  332. }
  334. /* Control AX.25 digipeating */
  335. static
  336. dodigipeat(argc,argv,p)
  337. int argc;
  338. char *argv[];
  339. void *p;
  340. {
  341. return setbool(&Digipeat,"Digipeat",argc,argv);
  342. }
  343. /* Set limit on retransmission backoff */
  344. static
  345. doblimit(argc,argv,p)
  346. int argc;
  347. char *argv[];
  348. void *p;
  349. {
  350. return setlong(&Blimit,"blimit",argc,argv);
  351. }
  352. static
  353. doversion(argc,argv,p)
  354. int argc;
  355. char *argv[];
  356. void *p;
  357. {
  358. return setshort(&Axversion,"AX25 version",argc,argv);
  359. }
  361. static
  362. doaxirtt(argc,argv,p)
  363. int argc;
  364. char *argv[];
  365. void *p;
  366. {
  367. return setlong(&Axirtt,"Initial RTT (ms)",argc,argv);
  368. }
  370. /* Set idle timer */
  371. static
  372. dot3(argc,argv,p)
  373. int argc;
  374. char *argv[];
  375. void *p;
  376. {
  377. return setlong(&T3init,"Idle poll timer (ms)",argc,argv);
  378. }
  380. /* Set retry limit count */
  381. static
  382. don2(argc,argv,p)
  383. int argc;
  384. char *argv[];
  385. void *p;
  386. {
  387. return setshort(&N2,"Retry limit",argc,argv);
  388. }
  389. /* Force a retransmission */
  390. static
  391. doaxkick(argc,argv,p)
  392. int argc;
  393. char *argv[];
  394. void *p;
  395. {
  396. struct ax25_cb *axp;
  398. axp = (struct ax25_cb *)ltop(htol(argv[1]));
  399. if(!ax25val(axp)){
  400. printf(Notval);
  401. return 1;
  402. }
  403. kick_ax25(axp);
  404. return 0;
  405. }
  406. /* Set maximum number of frames that will be allowed in flight */
  407. static
  408. domaxframe(argc,argv,p)
  409. int argc;
  410. char *argv[];
  411. void *p;
  412. {
  413. return setshort(&Maxframe,"Window size (frames)",argc,argv);
  414. }
  416. /* Set maximum length of I-frame data field */
  417. static
  418. dopaclen(argc,argv,p)
  419. int argc;
  420. char *argv[];
  421. void *p;
  422. {
  423. return setshort(&Paclen,"Max frame length (bytes)",argc,argv);
  424. }
  425. /* Set size of I-frame above which polls will be sent after a timeout */
  426. static
  427. dopthresh(argc,argv,p)
  428. int argc;
  429. char *argv[];
  430. void *p;
  431. {
  432. return setshort(&Pthresh,"Poll threshold (bytes)",argc,argv);
  433. }
  435. /* Set high water mark on receive queue that triggers RNR */
  436. static
  437. doaxwindow(argc,argv,p)
  438. int argc;
  439. char *argv[];
  440. void *p;
  441. {
  442. return setshort(&Axwindow,"AX25 receive window (bytes)",argc,argv);
  443. }
  444. /* End of ax25 subcommands */
  446. /* Initiate interactive AX.25 connect to remote station */
  447. int
  448. doconnect(argc,argv,p)
  449. int argc;
  450. char *argv[];
  451. void *p;
  452. {
  453. struct sockaddr_ax fsocket;
  454. struct session *sp;
  455. int ndigis,i,s;
  456. uint8 digis[MAXDIGIS][AXALEN];
  457. uint8 target[AXALEN];
  459. /* If digipeaters are given, put them in the routing table */
  460. if(argc > 3){
  461. setcall(target,argv[2]);
  462. ndigis = argc - 3;
  463. if(ndigis > MAXDIGIS){
  464. printf("Too many digipeatersn");
  465. return 1;
  466. }
  467. for(i=0;i<ndigis;i++){
  468. if(setcall(digis[i],argv[i+3]) == -1){
  469. printf("Bad digipeater %sn",argv[i+3]);
  470. return 1;
  471. }
  472. }
  473. if(ax_add(target,AX_LOCAL,digis,ndigis) == NULL){
  474. printf("Route add failedn");
  475. return 1;
  476. }
  477. }
  478. /* Allocate a session descriptor */
  479. if((sp = newsession(Cmdline,AX25TNC,1)) == NULL){
  480. printf("Too many sessionsn");
  481. return 1;
  482. }
  483. sp->inproc = keychar; /* Intercept ^C */
  484. if((s = socket(AF_AX25,SOCK_STREAM,0)) == -1){
  485. printf("Can't create socketn");
  486. freesession(sp);
  487. keywait(NULL,1);
  488. return 1;
  489. }
  490. fsocket.sax_family = AF_AX25;
  491. setcall(fsocket.ax25_addr,argv[2]);
  492. strncpy(fsocket.iface,argv[1],ILEN);
  493. sp->network = fdopen(s,"r+t");
  494. setvbuf(sp->network,NULL,_IOLBF,BUFSIZ);
  495. if(SETSIG(EABORT)){
  496. keywait(NULL,1);
  497. freesession(sp);
  498. return 1;
  499. }
  500. return tel_connect(sp, (struct sockaddr *)&fsocket, sizeof(struct sockaddr_ax));
  501. }
  503. /* Display and modify AX.25 routing table */
  504. static int
  505. doaxroute(argc,argv,p)
  506. int argc;
  507. char *argv[];
  508. void *p;
  509. {
  510. char tmp[AXBUF];
  511. int i,ndigis;
  512. register struct ax_route *axr;
  513. uint8 target[AXALEN],digis[MAXDIGIS][AXALEN];
  515. if(argc < 2){
  516. printf("Target    Type   Digipeatersn");
  517. for(axr = Ax_routes;axr != NULL;axr = axr->next){
  518. printf("%-10s%-6s",pax25(tmp,axr->target),
  519.  axr->type == AX_LOCAL ? "Local":"Auto");
  520. for(i=0;i<axr->ndigis;i++){
  521. printf(" %s",pax25(tmp,axr->digis[i]));
  522. }
  523. printf("n");
  524. }
  525. return 0;
  526. }
  527. if(argc < 3){
  528. printf("Usage: ax25 route add <target> [digis...]n");
  529. printf("       ax25 route drop <target>n");
  530. return 1;
  531. }
  532. if(setcall(target,argv[2]) == -1){
  533. printf("Bad target %sn",argv[2]);
  534. return 1;
  535. }
  536. switch(argv[1][0]){
  537. case 'a': /* Add route */
  538. if(argc < 3){
  539. printf("Usage: ax25 route add <target> [digis...]n");
  540. return 1;
  541. }
  542. ndigis = argc - 3;
  543. if(ndigis > MAXDIGIS){
  544. printf("Too many digipeatersn");
  545. return 1;
  546. }
  547. for(i=0;i<ndigis;i++){
  548. if(setcall(digis[i],argv[i+3]) == -1){
  549. printf("Bad digipeater %sn",argv[i+3]);
  550. return 1;
  551. }
  552. }
  553. if(ax_add(target,AX_LOCAL,digis,ndigis) == NULL){
  554. printf("Failedn");
  555. return 1;
  556. }
  557. break;
  558. case 'd': /* Drop route */
  559. if(ax_drop(target) == -1){
  560. printf("Not in tablen");
  561. return 1;
  562. }
  563. break;
  564. default:
  565. printf("Unknown command %sn",argv[1]);
  566. return 1;
  567. }
  568. return 0;
  569. }
  570. static int
  571. keychar(c)
  572. int c;
  573. {
  574. if(c != CTLC)
  575. return 1; /* Ignore all but ^C */
  577. fprintf(Current->output,"^Cn");
  578. alert(Current->proc,EABORT);
  579. return 0;
  580. }