home *** CD-ROM | disk | FTP | other *** search
/ The Pier Shareware 6 / The_Pier_Shareware_Number_6_(The_Pier_Exchange)_(1995).iso / 024 / psi110g.zip / AX25CMD.C < prev    next >
C/C++ Source or Header  |  1994-04-17  |  36KB  |  1,480 lines
  1. /* AX25 control commands
  2.  * Copyright 1991 Phil Karn, KA9Q
  3.  *
  4.  * Mods by G1EMM
  5.  * Mods by PA0GRI
  6.  * Mods by N1BEE
  7.  */
  8. /*
  9. ** FILE: ax25cmd.c
  10. **
  11. ** AX.25 command handler.
  12. **
  13. ** 09/24/90 Bob Applegate, wa2zzx
  14. **    Added BCTEXT, BC, and BCINTERVAL commands for broadcasting an id
  15. **    string using UI frames.
  16. **
  17. ** 27/09/91 Mike Bilow, N1BEE
  18. **    Added Filter command for axheard control
  19. */
  20.   
  21. #ifdef MSDOS
  22. #include <dos.h>
  23. #endif
  24. #include "global.h"
  25. #ifdef AX25
  26. #include "mbuf.h"
  27. #include "timer.h"
  28. #include "proc.h"
  29. #include "iface.h"
  30. #include "ax25.h"
  31. #include "lapb.h"
  32. #include "cmdparse.h"
  33. #include "socket.h"
  34. #include "mailbox.h"
  35. #include "session.h"
  36. #include "tty.h"
  37. #include "nr4.h"
  38. #include "commands.h"
  39. #include "pktdrvr.h"
  40. #include "netrom.h"
  41.   
  42. int axheard __ARGS((struct iface *ifp));
  43. static int doaxfilter __ARGS((int argc,char *argv[],void *p));
  44. static int doaxflush __ARGS((int argc,char *argv[],void *p));
  45. static int doaxirtt __ARGS((int argc,char *argv[],void *p));
  46. static int doaxkick __ARGS((int argc,char *argv[],void *p));
  47. static int doaxreset __ARGS((int argc,char *argv[],void *p));
  48. static int doaxroute __ARGS((int argc,char *argv[],void *p));
  49. int doaxstat __ARGS((int argc,char *argv[],void *p));
  50. static int dobc __ARGS((int argc,char *argv[],void *p));
  51. static int dobcint __ARGS((int argc,char *argv[],void *p));
  52. static int dobcport __ARGS((int argc,char *argv[],void *p));
  53. static int dobctext __ARGS((int argc,char *argv[],void *p));
  54. static int doaxhport __ARGS((int argc,char *argv[],void *p));
  55. static int doaxhsize __ARGS((int argc,char *argv[],void *p));
  56. static int dodigipeat __ARGS((int argc,char *argv[],void *p));
  57. static int domycall __ARGS((int argc,char *argv[],void *p));
  58. static int dobbscall __ARGS((int argc,char *argv[],void *p));
  59. int donralias __ARGS((int argc,char *argv[],void *p));
  60. static void ax_bc __ARGS((struct iface *axif));
  61. static int axdest __ARGS((struct iface *ifp));
  62. #ifdef TTYCALL
  63. static int dottycall __ARGS((int argc, char *argv[], void *p));
  64. #endif
  65.   
  66. static int doaxwindow __ARGS((int argc,char *argv[],void *p));
  67. static int doblimit __ARGS((int argc,char *argv[],void *p));
  68. static int domaxframe __ARGS((int argc,char *argv[],void *p));
  69. static int don2 __ARGS((int argc,char *argv[],void *p));
  70. static int dopaclen __ARGS((int argc,char *argv[],void *p));
  71. static int dopthresh __ARGS((int argc,char *argv[],void *p));
  72. static int dot3 __ARGS((int argc,char *argv[],void *p));
  73. static int doaxtype __ARGS((int argc,char *argv[],void *p));
  74. static int dot4 __ARGS((int argc,char *argv[],void *p));
  75. static int doversion __ARGS((int argc,char *argv[],void *p));
  76. static int doaxmaxwait __ARGS((int argc,char *argv[],void *p));
  77.   
  78. long Axmaxwait;
  79.   
  80. extern char Myalias[AXALEN];    /* the NETROM alias in 'call' form */
  81. extern char Nralias[ALEN+1];      /* the NETROM alias in 'alias' form */
  82. #ifdef TTYCALL
  83. extern char Ttycall[AXALEN];  /* the ttylink call in 'call' form */
  84. #endif
  85. extern int axheard_filter_flag;     /* in axheard.c */
  86. /* Defaults for IDing. */
  87. char *axbctext;     /* Text to send */
  88. static struct timer Broadtimer; /* timer for broadcasts */
  89.   
  90. char *Ax25states[] = {
  91.     "",
  92.     "Disconnected",
  93.     "Listening",
  94.     "Conn pending",
  95.     "Disc pending",
  96.     "Connected",
  97.     "Recovery",
  98. };
  99.   
  100. /* Ascii explanations for the disconnect reasons listed in lapb.h under
  101.  * "reason" in ax25_cb
  102.  */
  103. char *Axreasons[] = {
  104.     "Normal",
  105.     "DM received",
  106.     "Timeout"
  107. };
  108.   
  109. static struct cmds DFAR Axcmds[] = {
  110.     "alias",    donralias,  0, 0, NULLCHAR,
  111. #ifdef MAILBOX
  112.     "bbscall",  dobbscall,  0, 0, NULLCHAR,
  113. #endif
  114.     "bc",       dobc,       0, 0, NULLCHAR,
  115.     "bcinterval",dobcint,   0, 0, NULLCHAR,
  116.     "bcport",   dobcport,   0, 0, NULLCHAR,
  117.     "blimit",       doblimit,       0, 0, NULLCHAR,
  118.     "bctext",       dobctext,       0, 0, NULLCHAR,
  119.     "dest",     doaxdest,   0, 0, NULLCHAR,
  120.     "digipeat", dodigipeat, 0, 0, NULLCHAR,
  121.     "filter",       doaxfilter,     0, 0, NULLCHAR,
  122.     "flush",        doaxflush,      0, 0, NULLCHAR,
  123.     "heard",        doaxheard,      0, 0, NULLCHAR,
  124.     "hearddest",    doaxdest,       0, 0, NULLCHAR,
  125.     "hport",    doaxhport,  0, 0, NULLCHAR,
  126.     "hsize",    doaxhsize,  0, 0, NULLCHAR,
  127.     "irtt",     doaxirtt,   0, 0, NULLCHAR,
  128.     "kick",         doaxkick,       0, 2, "ax25 kick <axcb>",
  129.     "maxframe",     domaxframe,     0, 0, NULLCHAR,
  130.     "maxwait",      doaxmaxwait,    0, 0, NULLCHAR,
  131.     "mycall",       domycall,       0, 0, NULLCHAR,
  132.     "paclen",       dopaclen,       0, 0, NULLCHAR,
  133.     "pthresh",      dopthresh,      0, 0, NULLCHAR,
  134.     "reset",        doaxreset,      0, 2, "ax25 reset <axcb>",
  135.     "retry",        don2,           0, 0, NULLCHAR,
  136.     "route",        doaxroute,      0, 0, NULLCHAR,
  137.     "status",       doaxstat,       0, 0, NULLCHAR,
  138.     "t3",           dot3,           0, 0, NULLCHAR,
  139.     "t4",           dot4,           0, 0, NULLCHAR,
  140.     "timertype",    doaxtype,       0, 0, NULLCHAR,
  141. #ifdef TTYCALL
  142.     "ttycall",      dottycall,  0, 0, NULLCHAR,
  143. #endif
  144.     "version",      doversion,      0, 0, NULLCHAR,
  145.     "window",       doaxwindow,     0, 0, NULLCHAR,
  146.     NULLCHAR,
  147. };
  148.   
  149. /* Multiplexer for top-level ax25 command */
  150. int
  151. doax25(argc,argv,p)
  152. int argc;
  153. char *argv[];
  154. void *p;
  155. {
  156.     return subcmd(Axcmds,argc,argv,p);
  157. }
  158.   
  159. /* define the system's alias callsign ,
  160.  * if netrom is used, this is also the netrom alias ! - WG7J
  161.  */
  162.   
  163. #ifdef MAILBOX
  164. extern char Mbnrid[];
  165. extern void setmbnrid();
  166. #endif
  167.   
  168. int
  169. donralias(argc,argv,p)
  170. int argc ;
  171. char *argv[] ;
  172. void *p;
  173. {
  174.     int len;
  175.     char tmp[AXBUF];
  176.   
  177.     if(argc < 2) {
  178.         tprintf("%s\n",pax25(tmp,Myalias));
  179.         return 0;
  180.     }
  181.     if( (setcall(Myalias,argv[1]) == -1)
  182. #ifdef NETROM
  183.         || (putalias(Nralias,argv[1],1) == -1)
  184. #endif
  185.     ){
  186.         tputs("can't set alias\n");
  187.         Myalias[0] = '\0';
  188. #ifdef NETROM
  189.         Nralias[0] = '\0';
  190. #endif
  191.         return 0;
  192.     }
  193. #ifdef MAILBOX
  194.     setmbnrid();
  195. #endif
  196.     return 0;
  197. }
  198.   
  199. /*
  200. ** This function is called to send the current broadcast message
  201. ** and reset the timer.
  202. */
  203.   
  204. static int dobc(argc,argv,p)
  205. int argc;
  206. char *argv[];
  207. void *p;
  208. {
  209.     struct iface *ifa;
  210.   
  211.     if (argc < 2)
  212.     {
  213.         tprintf("you need to specify an interface\n");
  214.         return 1;
  215.     }
  216.   
  217.     if((ifa=if_lookup(argv[1])) == NULLIF)
  218.         tprintf(Badinterface,argv[1]);
  219.     else if (ifa->type != CL_AX25)
  220.         tputs("not an AX.25 interface\n");
  221.     else
  222.     {
  223.         ax_bc(ifa);
  224.         stop_timer(&Broadtimer) ;       /* in case it's already running */
  225.         start_timer(&Broadtimer);               /* and fire it up */
  226.     }
  227.     return 0;
  228. }
  229.   
  230.   
  231.   
  232. /*
  233. ** View/Change the message we broadcast.
  234. */
  235.   
  236. static int dobctext(argc,argv,p)
  237. int argc;
  238. char *argv[];
  239. void *p;
  240. {
  241.     struct iface *ifp;
  242.   
  243.     if (argc < 2) {
  244.         if(axbctext)
  245.             tprintf("Broadcast text: %s\n",axbctext);
  246.         else
  247.             tputs("not set\n");
  248.     } else {
  249.         if (axbctext != NULL)
  250.             free(axbctext);
  251.         axbctext = strdup(argv[1]);
  252.         /* Set all ax.25 interfaces with no bc text */
  253.         for(ifp=Ifaces;ifp->next;ifp=ifp->next)
  254.             if(ifp->type == CL_AX25 && ifp->ax25->bctext == NULL)
  255.                 ifp->ax25->bctext = strdup(axbctext);
  256.     }
  257.     return 0;
  258. }
  259.   
  260.   
  261.   
  262. #define TICKSPERSEC     (1000L / MSPTICK)       /* Ticks per second */
  263.   
  264. /*
  265. ** Examine/change the broadcast interval.
  266. */
  267.   
  268. static int dobcint(argc,argv,p)
  269. int argc;
  270. char *argv[];
  271. void *p;
  272. {
  273.     void dobroadtick();
  274.   
  275.     if(argc < 2)
  276.     {
  277.         tprintf("Broadcast timer %lu/%lu seconds\n",
  278.         read_timer(&Broadtimer)/1000L,
  279.         dur_timer(&Broadtimer)/1000L);
  280.         return 0;
  281.     }
  282.     stop_timer(&Broadtimer) ;       /* in case it's already running */
  283.     Broadtimer.func = (void (*)())dobroadtick;/* what to call on timeout */
  284.     Broadtimer.arg = NULLCHAR;              /* dummy value */
  285.     set_timer(&Broadtimer,atoi(argv[1])*1000L);     /* set timer duration */
  286.     start_timer(&Broadtimer);               /* and fire it up */
  287.     return 0;
  288. }
  289.   
  290. /* Configure a port to do ax.25 beacon broadcasting */
  291. static int
  292. dobcport(argc,argv,p)
  293. int argc;
  294. char *argv[];
  295. void *p;
  296. {
  297.     return setflag(argc,argv[1],AX25_BEACON,argv[2]);
  298. }
  299.   
  300. int Maxax25heard;
  301.   
  302. /* Set the size of the ax.25 heard list */
  303. int doaxhsize(int argc,char *argv[],void *p) {
  304.     return setint(&Maxax25heard,"Max ax-heard",argc,argv);
  305. }
  306.   
  307. /* Configure a port to do ax.25 heard logging */
  308. static int
  309. doaxhport(argc,argv,p)
  310. int argc;
  311. char *argv[];
  312. void *p;
  313. {
  314.     return setflag(argc,argv[1],LOG_AXHEARD,argv[2]);
  315. }
  316.   
  317. void
  318. dobroadtick()
  319. {
  320.     struct iface *ifa;
  321.   
  322.     ifa = Ifaces;
  323.   
  324.     while (ifa != NULL)
  325.     {
  326.         if (ifa->flags & AX25_BEACON)
  327.             ax_bc(ifa);
  328.         ifa = ifa->next;
  329.     }
  330.   
  331.     /* Restart timer */
  332.     start_timer(&Broadtimer) ;
  333. }
  334.   
  335.   
  336.   
  337. /*
  338. ** This is the low-level broadcast function.
  339. */
  340.   
  341. static void ax_bc(axiface)
  342. struct iface *axiface;
  343. {
  344.     struct mbuf *hbp;
  345.     int i;
  346.   
  347.     /* prepare the header */
  348.     i = 0;
  349.     if(axiface->ax25->bctext)
  350.         i = strlen(axiface->ax25->bctext);
  351.     if((hbp = alloc_mbuf(i)) == NULLBUF)
  352.         return;
  353.   
  354.     hbp->cnt = i;
  355.     if(i)
  356.         memcpy(hbp->data,axiface->ax25->bctext,i);
  357.   
  358.     (*axiface->output)(axiface, Ax25multi[IDCALL], axiface->hwaddr,
  359.     PID_NO_L3, hbp);        /* send it */
  360.   
  361.     /*
  362.     ** Call another function to reset the timer...
  363.     reset_bc_timer();
  364.     */
  365. }
  366.   
  367.   
  368. int
  369. doaxheard(argc,argv,p)
  370. int argc;
  371. char *argv[];
  372. void *p;
  373. {
  374.     struct iface *ifp;
  375.   
  376.     if(argc > 1){
  377.         if((ifp = if_lookup(argv[1])) == NULLIF){
  378.             tprintf(Badinterface,argv[1]);
  379.             return 1;
  380.         }
  381.         if(ifp->type != CL_AX25){
  382.             tprintf("Interface %s not AX.25\n",argv[1]);
  383.             return 1;
  384.         }
  385.         if(ifp->flags & LOG_AXHEARD)
  386.             axheard(ifp);
  387.         else
  388.             tputs("not active\n");
  389.         return 0;
  390.     }
  391.     for(ifp = Ifaces;ifp != NULLIF;ifp = ifp->next){
  392.         if(ifp->type != CL_AX25 || !(ifp->flags & LOG_AXHEARD))
  393.             continue;       /* Not an ax.25 interface */
  394.         if(axheard(ifp) == EOF)
  395.             break;
  396.     }
  397.     return 0;
  398. }
  399. int
  400. axheard(ifp)
  401. struct iface *ifp;
  402. {
  403.     int col = 0;
  404.     struct lq *lp;
  405.     char tmp[AXBUF];
  406.   
  407.     if(ifp->hwaddr == NULLCHAR)
  408.         return 0;
  409.   
  410.     tputs("Interface  Station   Time since send  Pkts sent\n");
  411.     tprintf("%-9s  %-9s   %12s    %7lu\n",ifp->name,pax25(tmp,ifp->hwaddr),
  412.     tformat(secclock() - ifp->lastsent),ifp->rawsndcnt);
  413.   
  414.     tputs("Station   Time since heard Pkts rcvd : ");
  415.     tputs("Station   Time since heard Pkts rcvd\n");
  416.     for(lp = Lq;lp != NULLLQ;lp = lp->next){
  417.         if(lp->iface != ifp)
  418.             continue;
  419.         if(col)
  420.             tputs("  : ");
  421.         if(tprintf("%-9s   %12s    %7lu",pax25(tmp,lp->addr),
  422.             tformat(secclock() - lp->time),lp->currxcnt) == EOF)
  423.             return EOF;
  424.         if(col){
  425.             if(tputc('\n') == EOF){
  426.                 return EOF;
  427.             } else {
  428.                 col = 0;
  429.             }
  430.         } else {
  431.             col = 1;
  432.         }
  433.     }
  434.     if(col)
  435.         tputc('\n');
  436.     return 0;
  437. }
  438. int
  439. doaxdest(argc,argv,p)
  440. int argc;
  441. char *argv[];
  442. void *p;
  443. {
  444.     struct iface *ifp;
  445.   
  446.     if(argc > 1){
  447.         if((ifp = if_lookup(argv[1])) == NULLIF){
  448.             tprintf(Badinterface,argv[1]);
  449.             return 1;
  450.         }
  451.         if(ifp->output != ax_output){
  452.             tprintf("Interface %s not AX.25\n",argv[1]);
  453.             return 1;
  454.         }
  455.         axdest(ifp);
  456.         return 0;
  457.     }
  458.     for(ifp = Ifaces;ifp != NULLIF;ifp = ifp->next){
  459.         if(ifp->output != ax_output)
  460.             continue;       /* Not an ax.25 interface */
  461.         if(axdest(ifp) == EOF)
  462.             break;
  463.     }
  464.     return 0;
  465. }
  466. static int
  467. axdest(ifp)
  468. struct iface *ifp;
  469. {
  470.     struct ld *lp;
  471.     struct lq *lq;
  472.     char tmp[AXBUF];
  473.   
  474.     if(ifp->hwaddr == NULLCHAR)
  475.         return 0;
  476.     tprintf("%s:\n",ifp->name);
  477.     tputs("Station   Last ref         Last heard           Pkts\n");
  478.     for(lp = Ld;lp != NULLLD;lp = lp->next){
  479.         if(lp->iface != ifp)
  480.             continue;
  481.   
  482.         tprintf("%-10s%-17s",
  483.         pax25(tmp,lp->addr),tformat(secclock() - lp->time));
  484.   
  485.         if(addreq(lp->addr,ifp->hwaddr)){
  486.             /* Special case; it's our address */
  487.             tprintf("%-17s",tformat(secclock() - ifp->lastsent));
  488.         } else if((lq = al_lookup(ifp,lp->addr,0)) == NULLLQ){
  489.             tprintf("%-17s","");
  490.         } else {
  491.             tprintf("%-17s",tformat(secclock() - lq->time));
  492.         }
  493.         if(tprintf("%8lu\n",lp->currxcnt) == EOF)
  494.             return EOF;
  495.     }
  496.     return 0;
  497. }
  498.   
  499. static int
  500. doaxfilter(argc,argv,p)
  501. int argc;
  502. char *argv[];
  503. void *p;
  504. {
  505.     if(argc >= 2){
  506.         setint(&axheard_filter_flag,"ax25 heard filter",argc,argv);
  507.     } else {
  508.         tputs("Usage: ax25 filter <0|1|2|3>\n");
  509.         return 1;
  510.     }
  511.   
  512.     tputs("Callsign loggin by source ");
  513.     if(axheard_filter_flag & AXHEARD_NOSRC)
  514.         tputs("disabled, ");
  515.     else
  516.         tputs("enabled, ");
  517.     tputs("by destination ");
  518.     if(axheard_filter_flag & AXHEARD_NODST)
  519.         tputs("disabled\n");
  520.     else
  521.         tputs("enabled\n");
  522.     return 0;
  523. }
  524.   
  525. static int
  526. doaxflush(argc,argv,p)
  527. int argc;
  528. char *argv[];
  529. void *p;
  530. {
  531.     struct lq *lp,*lp1;
  532.     struct ld *ld,*ld1;
  533.   
  534.     for(lp = Lq;lp != NULLLQ;lp = lp1){
  535.         lp1 = lp->next;
  536.         free((char *)lp);
  537.     }
  538.     Lq = NULLLQ;
  539.     for(ld = Ld;ld != NULLLD;ld = ld1){
  540.         ld1 = ld->next;
  541.         free((char *)ld);
  542.     }
  543.     Ld = NULLLD;
  544.     return 0;
  545. }
  546.   
  547. static int
  548. doaxreset(argc,argv,p)
  549. int argc;
  550. char *argv[];
  551. void *p;
  552. {
  553.     struct ax25_cb *axp;
  554.   
  555.     axp = MK_FP(htoi(argv[1]),8);
  556.     if(!ax25val(axp)){
  557.         tputs(Notval);
  558.         return 1;
  559.     }
  560.     reset_ax25(axp);
  561.     return 0;
  562. }
  563.   
  564. /* Display AX.25 link level control blocks */
  565. int
  566. doaxstat(argc,argv,p)
  567. int argc;
  568. char *argv[];
  569. void *p;
  570. {
  571.     register struct ax25_cb *axp;
  572.     char tmp[AXBUF];
  573.     char tmp2[AXBUF];
  574.   
  575.     if(argc < 2){
  576. #ifdef UNIX
  577.         tprintf("&AXB     Snd-Q   Rcv-Q   Remote    Local     Iface  State\n");
  578. #else
  579.         tputs("&AXB Snd-Q   Rcv-Q   Remote    Local     Iface  State\n");
  580. #endif
  581.         for(axp = Ax25_cb;axp != NULLAX25; axp = axp->next){
  582. #ifdef UNIX
  583.             if(tprintf("%8.8x %-8d%-8d%-10s%-10s%-7s%s\n",
  584. #else
  585.                 if(tprintf("%4.4x %-8d%-8d%-10s%-10s%-7s%s\n",
  586. #endif
  587.                     FP_SEG(axp),
  588.                     len_q(axp->txq),len_p(axp->rxq),
  589.                     pax25(tmp,axp->remote),
  590.                     pax25(tmp2,axp->local),
  591.                     axp->iface?axp->iface->name:"",
  592.                     Ax25states[axp->state]) == EOF)
  593.                     return 0;
  594.         }
  595.         return 0;
  596.     }
  597.     axp = MK_FP(htoi(argv[1]),8);
  598.     if(!ax25val(axp)){
  599.         tputs(Notval);
  600.         return 1;
  601.     }
  602.     st_ax25(axp);
  603.     return 0;
  604. }
  605. /* Dump one control block */
  606. void
  607. st_ax25(axp)
  608. register struct ax25_cb *axp;
  609. {
  610.     char tmp[AXBUF];
  611.     char tmp2[AXBUF];
  612.   
  613.     if(axp == NULLAX25)
  614.         return;
  615. #ifdef UNIX
  616.     tprintf("&AXB     Local     Remote    Iface  RB V(S) V(R) Unack P Retry State\n");
  617.     tprintf("%8.8x %-9s %-9s %-6s %c%c",FP_SEG(axp),
  618. #else
  619.     tputs("&AXB Local     Remote    Iface  RB V(S) V(R) Unack P Retry State\n");
  620.     tprintf("%4.4x %-9s %-9s %-6s %c%c",FP_SEG(axp),
  621. #endif
  622.     pax25(tmp,axp->local),
  623.     pax25(tmp2,axp->remote),
  624.     axp->iface?axp->iface->name:"",
  625.     axp->flags.rejsent ? 'R' : ' ',
  626.     axp->flags.remotebusy ? 'B' : ' ');
  627.     tprintf(" %4d %4d",axp->vs,axp->vr);
  628.     tprintf(" %02u/%02u %u",axp->unack,axp->maxframe,axp->proto);
  629.     tprintf(" %02u/%02u",axp->retries,axp->n2);
  630.     tprintf(" %s\n",Ax25states[axp->state]);
  631.     tprintf("srtt = %lu mdev = %lu ",axp->srt,axp->mdev);
  632.     tputs("T1: ");
  633.     if(run_timer(&axp->t1))
  634.         tprintf("%lu",read_timer(&axp->t1));
  635.     else
  636.         tputs("stop");
  637.     tprintf("/%lu ms; ",dur_timer(&axp->t1));
  638.   
  639.     tputs("T3: ");
  640.     if(run_timer(&axp->t3))
  641.         tprintf("%lu",read_timer(&axp->t3));
  642.     else
  643.         tputs("stop");
  644.     tprintf("/%lu ms; ",dur_timer(&axp->t3));
  645.   
  646.     tputs("T4: ");
  647.     if(run_timer(&axp->t4))
  648.         tprintf("%lu",(read_timer(&axp->t4)/1000L));
  649.     else
  650.         tputs("stop");
  651.     tprintf("/%lu sec\n",(dur_timer(&axp->t4)/1000L));
  652. }
  653.   
  654. /* Set limit on retransmission backoff */
  655. int
  656. doax25blimit(argc,argv,p)
  657. int argc;
  658. char *argv[];
  659. void *p;
  660. {
  661.     return setlong((long *)p,"blimit",argc,argv);
  662. }
  663.   
  664. static int
  665. doblimit(argc,argv,p)
  666. int argc;
  667. char *argv[];
  668. void *p;
  669. {
  670.     return doax25blimit(argc,argv,(void *)&Blimit);
  671. }
  672.   
  673. /* Set limit on retransmission in ms */
  674. int
  675. doax25maxwait(argc,argv,p)
  676. int argc;
  677. char *argv[];
  678. void *p;
  679. {
  680.     return setlong((long *)p,"retry maxwait",argc,argv);
  681. }
  682.   
  683. static int
  684. doaxmaxwait(argc,argv,p)
  685. int argc;
  686. char *argv[];
  687. void *p;
  688. {
  689.     return doax25maxwait(argc,argv,(void *)&Axmaxwait);
  690. }
  691.   
  692. /* Display or change our AX.25 address */
  693. static int
  694. domycall(argc,argv,p)
  695. int argc;
  696. char *argv[];
  697. void *p;
  698. {
  699. #ifdef MAILBOX
  700.     extern void setmbnrid();
  701. #endif
  702.     char tmp[AXBUF];
  703.   
  704.     if(argc < 2){
  705.         tprintf("%s\n",pax25(tmp,Mycall));
  706.         return 0;
  707.     }
  708.     if(setcall(Mycall,argv[1]) == -1)
  709.         return -1;
  710. #ifdef MAILBOX
  711.     if(Bbscall[0] == 0)
  712.         memcpy(Bbscall,Mycall,AXALEN);
  713.     setmbnrid();
  714. #endif
  715.     return 0;
  716. }
  717.   
  718. #ifdef MAILBOX
  719. /* Display or change our BBS address */
  720. static int
  721. dobbscall(argc,argv,p)
  722. int argc;
  723. char *argv[];
  724. void *p;
  725. {
  726.     char tmp[AXBUF];
  727.     struct iface *ifp;
  728.   
  729.     if(argc < 2){
  730.         tprintf("%s\n",pax25(tmp,Bbscall));
  731.         return 0;
  732.     }
  733.     if(setcall(Bbscall,argv[1]) == -1)
  734.         return -1;
  735.     /* Set the bbs call on all appropriate interfaces
  736.      * that don't have a bbs call set yet.
  737.      */
  738.     for(ifp = Ifaces;ifp != NULLIF;ifp = ifp->next)
  739.         if(ifp->type == CL_AX25 && ifp->ax25->bbscall[0] == 0)
  740.             memcpy(ifp->ax25->bbscall,Bbscall,AXALEN);
  741.     return 0;
  742. }
  743. #endif
  744.   
  745. #ifdef TTYCALL
  746. /* Display or change ttylink AX.25 address */
  747. static int
  748. dottycall(argc,argv,p)
  749. int argc;
  750. char *argv[];
  751. void *p;
  752. {
  753.     char tmp[AXBUF];
  754.   
  755.     if(argc < 2){
  756.         tprintf("%s\n",pax25(tmp,Ttycall));
  757.         return 0;
  758.     }
  759.     if(setcall(Ttycall,argv[1]) == -1)
  760.         return -1;
  761.     return 0;
  762. }
  763. #endif
  764.   
  765. /* Control AX.25 digipeating */
  766. static int
  767. dodigipeat(argc,argv,p)
  768. int argc;
  769. char *argv[];
  770. void *p;
  771. {
  772.     return setflag(argc,argv[1],AX25_DIGI,argv[2]);
  773. }
  774.   
  775. int
  776. doax25version(argc,argv,p)
  777. int argc;
  778. char *argv[];
  779. void *p;
  780. {
  781.     return setshort((unsigned short *)p,"AX25 version",argc,argv);
  782. }
  783.   
  784. static int
  785. doversion(argc,argv,p)
  786. int argc;
  787. char *argv[];
  788. void *p;
  789. {
  790.     return doax25version(argc,argv,(void *)&Axversion);
  791. }
  792.   
  793. static int
  794. doax25irtt(argc,argv,p)
  795. int argc;
  796. char *argv[];
  797. void *p;
  798. {
  799.     return setlong((long *)p,"Initial RTT (ms)",argc,argv);
  800. }
  801.   
  802. static int
  803. doaxirtt(argc,argv,p)
  804. int argc;
  805. char *argv[];
  806. void *p;
  807. {
  808.     return doax25irtt(argc,argv,(void *)&Axirtt);
  809. }
  810.   
  811. /* Set idle timer */
  812. int
  813. doax25t3(argc,argv,p)
  814. int argc;
  815. char *argv[];
  816. void *p;
  817. {
  818.     return setlong((long *)p,"Idle poll timer (ms)",argc,argv);
  819. }
  820.   
  821. /* Set idle timer */
  822. static int
  823. dot3(argc,argv,p)
  824. int argc;
  825. char *argv[];
  826. void *p;
  827. {
  828.     return doax25t3(argc,argv,&T3init);
  829. }
  830.   
  831. /* Set link redundancy timer */
  832. int
  833. doax25t4(argc,argv,p)
  834. int argc;
  835. char *argv[];
  836. void *p;
  837. {
  838.     return setlong((long *)p,"Link redundancy timer (sec)",argc,argv);
  839. }
  840.   
  841. /* Set link redundancy timer */
  842. static int
  843. dot4(argc,argv,p)
  844. int argc;
  845. char *argv[];
  846. void *p;
  847. {
  848.     return doax25t4(argc,argv,(long *)&T4init);
  849. }
  850.   
  851. /* Set retry limit count */
  852. int
  853. doax25n2(argc,argv,p)
  854. int argc;
  855. char *argv[];
  856. void *p;
  857. {
  858.     return setshort((unsigned short *)p,"Retry limit",argc,argv);
  859. }
  860.   
  861. static int
  862. don2(argc,argv,p)
  863. int argc;
  864. char *argv[];
  865. void *p;
  866. {
  867.     return doax25n2(argc,argv,(void *)&N2);
  868. }
  869.   
  870. /* Force a retransmission */
  871. static int
  872. doaxkick(argc,argv,p)
  873. int argc;
  874. char *argv[];
  875. void *p;
  876. {
  877.     struct ax25_cb *axp;
  878.   
  879.     axp = MK_FP(htoi(argv[1]),8);
  880.     if(!ax25val(axp)){
  881.         tputs(Notval);
  882.         return 1;
  883.     }
  884.     kick_ax25(axp);
  885.     return 0;
  886. }
  887.   
  888. /* Set maximum number of frames that will be allowed in flight */
  889. int
  890. doax25maxframe(argc,argv,p)
  891. int argc;
  892. char *argv[];
  893. void *p;
  894. {
  895.     return setshort((unsigned short *)p,"Window size (frames)",argc,argv);
  896. }
  897.   
  898. static int
  899. domaxframe(argc,argv,p)
  900. int argc;
  901. char *argv[];
  902. void *p;
  903. {
  904.     return doax25maxframe(argc,argv,(void *)&Maxframe);
  905. }
  906.   
  907. /* Set maximum length of I-frame data field */
  908. int
  909. doax25paclen(argc,argv,p)
  910. int argc;
  911. char *argv[];
  912. void *p;
  913. {
  914.     return setshort((unsigned short *)p,"Max frame length (bytes)",argc,argv);
  915. }
  916.   
  917. static int
  918. dopaclen(argc,argv,p)
  919. int argc;
  920. char *argv[];
  921. void *p;
  922. {
  923.     return doax25paclen(argc,argv,(void *)&Paclen);
  924. }
  925.   
  926. /* Set size of I-frame above which polls will be sent after a timeout */
  927. int
  928. doax25pthresh(argc,argv,p)
  929. int argc;
  930. char *argv[];
  931. void *p;
  932. {
  933.     return setshort((unsigned short *)p,"Poll threshold (bytes)",argc,argv);
  934. }
  935.   
  936. static int
  937. dopthresh(argc,argv,p)
  938. int argc;
  939. char *argv[];
  940. void *p;
  941. {
  942.     return doax25pthresh(argc,argv,(void *)&Pthresh);
  943. }
  944.   
  945. /* Set high water mark on receive queue that triggers RNR */
  946. int
  947. doax25window(argc,argv,p)
  948. int argc;
  949. char *argv[];
  950. void *p;
  951. {
  952.     return setshort((unsigned short *)p,"AX25 receive window (bytes)",argc,argv);
  953. }
  954.   
  955. static int
  956. doaxwindow(argc,argv,p)
  957. int argc;
  958. char *argv[];
  959. void *p;
  960. {
  961.     return doax25window(argc,argv,(void *)&Axwindow);
  962. }
  963. /* End of ax25 subcommands */
  964.   
  965. #ifdef AX25SESSION
  966. /* Initiate interactive AX.25 connect to remote station */
  967. int
  968. doconnect(argc,argv,p)
  969. int argc;
  970. char *argv[];
  971. void *p;
  972. {
  973.     struct sockaddr_ax fsocket;
  974.     struct session *sp;
  975.     struct iface *ifp;
  976.     int ndigis,i;
  977.     char digis[MAXDIGIS][AXALEN];
  978.     char target[AXALEN];
  979.     int split = 0;
  980.   
  981.     /*Make sure this comes from console - WG7J*/
  982.     if(Curproc->input != Command->input)
  983.         return 0;
  984.   
  985. #ifdef SPLITSCREEN
  986.     if(argv[0][0] == 's')   /* use split screen */
  987.         split  = 1;
  988. #endif
  989.   
  990.     if(((ifp = if_lookup(argv[1])) != NULLIF) && (ifp->type != CL_AX25)) {
  991.         tprintf("Iface %s not an AX25 type interface\n",argv[1]);
  992.         return 1;
  993.     }
  994.   
  995.     if(setcall(target,argv[2]) == -1){
  996.         tprintf("Bad callsign %s\n", argv[2]);
  997.         return 1;
  998.     }
  999.   
  1000.     /* If digipeaters are given, put them in the routing table */
  1001.     if(argc > 3){
  1002.         if(setcall(target,argv[2]) == -1){
  1003.             tprintf("Bad callsign %s\n", argv[2]);
  1004.             return 1;
  1005.         }
  1006.         ndigis = argc - 3;
  1007.         if(ndigis > MAXDIGIS){
  1008.             tputs("Too many digipeaters\n");
  1009.             return 1;
  1010.         }
  1011.         for(i=0;i<ndigis;i++){
  1012.             if(setcall(digis[i],argv[i+3]) == -1){
  1013.                 tprintf("Bad digipeater %s\n",argv[i+3]);
  1014.                 return 1;
  1015.             }
  1016.         }
  1017.         if(ax_add(target,AX_AUTO,digis,ndigis,ifp) == NULLAXR){
  1018.             tputs("Route add failed\n");
  1019.             return 1;
  1020.         }
  1021.     }
  1022.     /* Allocate a session descriptor */
  1023.     if((sp = newsession(argv[2],AX25TNC,split)) == NULLSESSION){
  1024.         tputs(TooManySessions);
  1025.         return 1;
  1026.     }
  1027.     if((sp->s = socket(AF_AX25,SOCK_STREAM,0)) == -1){
  1028.         tputs(Nosock);
  1029.         freesession(sp);
  1030.         keywait(NULLCHAR,1);
  1031.         return 1;
  1032.     }
  1033.     fsocket.sax_family = AF_AX25;
  1034.     setcall(fsocket.ax25_addr,argv[2]);
  1035.     strncpy(fsocket.iface,argv[1],ILEN);
  1036.     return tel_connect(sp, (char *)&fsocket, sizeof(struct sockaddr_ax));
  1037. }
  1038. #endif
  1039.   
  1040. /* Display and modify AX.25 routing table */
  1041. static int
  1042. doaxroute(argc,argv,p)
  1043. int argc;
  1044. char *argv[];
  1045. void *p;
  1046. {
  1047.     char tmp[AXBUF];
  1048.     int i,ndigis;
  1049.     register struct ax_route *axr;
  1050.     char target[AXALEN],digis[MAXDIGIS][AXALEN];
  1051.     struct iface *iface;
  1052.   
  1053.     if(argc < 2){
  1054.         tputs("Target    Iface  Type  Mode Digipeaters\n");
  1055.         for(axr = Ax_routes;axr != NULLAXR;axr = axr->next){
  1056.             tprintf("%-10s%-7s%-6s",pax25(tmp,axr->target),
  1057.             axr->iface->name,axr->type == AX_LOCAL ? "Local":"Auto");
  1058.             switch(axr->mode){
  1059.                 case AX_VC_MODE:
  1060.                     tputs(" VC ");
  1061.                     break;
  1062.                 case AX_DATMODE:
  1063.                     tputs(" DG ");
  1064.                     break;
  1065.                 case AX_DEFMODE:
  1066.                     tputs(" IF ");
  1067.                     break;
  1068.                 default:
  1069.                     tputs(" ?? ");
  1070.                     break;
  1071.             }
  1072.   
  1073.             for(i=0;i<axr->ndigis;i++){
  1074.                 tprintf(" %s",pax25(tmp,axr->digis[i]));
  1075.             }
  1076.             if(tputc('\n') == EOF)
  1077.                 return 0;
  1078.         }
  1079.         return 0;
  1080.     }
  1081.     if(argc < 4){
  1082.         tputs("Usage: ax25 route add <target> <iface> [digis...]\n");
  1083.         tputs("       ax25 route drop <target> <iface>\n");
  1084.         tputs("       ax25 route mode <target> <iface> [mode]\n");
  1085.         return 1;
  1086.     }
  1087.     if(setcall(target,argv[2]) == -1){
  1088.         tprintf("Bad target %s\n",argv[2]);
  1089.         return 1;
  1090.     }
  1091.     if((iface = if_lookup(argv[3])) == NULLIF){
  1092.         tprintf(Badinterface,argv[3]);
  1093.         return 1;
  1094.     }
  1095.     switch(argv[1][0]){
  1096.         case 'a':       /* Add route */
  1097.             ndigis = argc - 4;
  1098.             if(ndigis > MAXDIGIS){
  1099.                 tputs("Too many digipeaters\n");
  1100.                 return 1;
  1101.             }
  1102.             for(i=0;i<ndigis;i++){
  1103.                 if(setcall(digis[i],argv[i+4]) == -1){
  1104.                     tprintf("Bad digipeater %s\n",argv[i+4]);
  1105.                     return 1;
  1106.                 }
  1107.             }
  1108.             if(ax_add(target,AX_LOCAL,digis,ndigis,iface) == NULLAXR){
  1109.                 tputs("Failed\n");
  1110.                 return 1;
  1111.             }
  1112.             break;
  1113.         case 'd':       /* Drop route */
  1114.             if(ax_drop(target,iface) == -1){
  1115.                 tputs("Not in table\n");
  1116.                 return 1;
  1117.             }
  1118.             break;
  1119.         case 'm':       /* Alter route mode */
  1120.             if((axr = ax_lookup(target,iface)) == NULLAXR){
  1121.                 tputs("Not in table\n");
  1122.                 return 1;
  1123.             }
  1124.             switch(argv[4][0]){
  1125.                 case 'i':       /* use default interface mode */
  1126.                     axr->mode = AX_DEFMODE;
  1127.                     break;
  1128.                 case 'v':       /* use virtual circuit mode */
  1129.                     axr->mode = AX_VC_MODE;
  1130.                     break;
  1131.                 case 'd':       /* use datagram mode */
  1132.                     axr->mode = AX_DATMODE;
  1133.                     break;
  1134.                 default:
  1135.                     tprintf("Unknown mode %s\n", argv[4]);
  1136.                     return 1;
  1137.             }
  1138.             break;
  1139.         default:
  1140.             tprintf("Unknown command %s\n",argv[1]);
  1141.             return 1;
  1142.     }
  1143.     return 0;
  1144. }
  1145.   
  1146. extern int lapbtimertype;
  1147.   
  1148. /* ax25 timers type - linear v exponential */
  1149. int
  1150. doax25timertype(argc,argv,p)
  1151. int argc ;
  1152. char *argv[] ;
  1153. void *p ;
  1154. {
  1155.     if (argc < 2) {
  1156.         tputs("AX25 timer type is ");
  1157.         switch(*(int *)p){
  1158.             case 2:
  1159.                 tputs("original\n");
  1160.                 break;
  1161.             case 1:
  1162.                 tputs("linear\n");
  1163.                 break;
  1164.             case 0:
  1165.                 tputs("exponential\n");
  1166.                 break;
  1167.         }
  1168.         return 0 ;
  1169.     }
  1170.   
  1171.     switch (argv[1][0]) {
  1172.         case 'o':
  1173.         case 'O':
  1174.             *(int *)p = 2 ;
  1175.             break ;
  1176.         case 'l':
  1177.         case 'L':
  1178.             *(int *)p = 1 ;
  1179.             break ;
  1180.         case 'e':
  1181.         case 'E':
  1182.             *(int *)p = 0 ;
  1183.             break ;
  1184.         default:
  1185.             tputs("usage: ax25 timertype [original|linear|exponential]\n") ;
  1186.             return -1 ;
  1187.     }
  1188.   
  1189.     return 0 ;
  1190. }
  1191.   
  1192. /* ax25 timers type - linear v exponential */
  1193. static int
  1194. doaxtype(argc,argv,p)
  1195. int argc ;
  1196. char *argv[] ;
  1197. void *p ;
  1198. {
  1199.     return doax25timertype(argc,argv,(void *)&lapbtimertype);
  1200. }
  1201.   
  1202.   
  1203. void init_ifax25(struct ifax25 *ax25) {
  1204.   
  1205.     if(!ax25)
  1206.         return;
  1207.     /* Set interface to the defaults */
  1208.     ax25->paclen = Paclen;
  1209.     ax25->lapbtimertype = lapbtimertype;
  1210.     ax25->irtt = Axirtt;
  1211.     ax25->version = Axversion;
  1212.     ax25->t3 = T3init;
  1213.     ax25->t4 = T4init;
  1214.     ax25->n2 = N2;
  1215.     ax25->maxframe = Maxframe;
  1216.     ax25->pthresh = Pthresh;
  1217.     ax25->window = Axwindow;
  1218.     ax25->blimit = Blimit;
  1219.     ax25->maxwait = Axmaxwait;
  1220.     if(axbctext)
  1221.         ax25->bctext = strdup(axbctext);
  1222. #ifdef MAILBOX
  1223.     memcpy(ax25->bbscall,Bbscall,AXALEN);
  1224. #endif
  1225. }
  1226.   
  1227. static int doifax25paclen __ARGS((int argc, char *argv[], void *p));
  1228. static int doifax25timertype __ARGS((int argc, char *argv[], void *p));
  1229. static int doifax25irtt __ARGS((int argc, char *argv[], void *p));
  1230. static int doifax25version __ARGS((int argc, char *argv[], void *p));
  1231. static int doifax25t3 __ARGS((int argc, char *argv[], void *p));
  1232. static int doifax25t4 __ARGS((int argc, char *argv[], void *p));
  1233. static int doifax25n2 __ARGS((int argc, char *argv[], void *p));
  1234. static int doifax25maxframe __ARGS((int argc, char *argv[], void *p));
  1235. static int doifax25pthresh __ARGS((int argc, char *argv[], void *p));
  1236. static int doifax25window __ARGS((int argc, char *argv[], void *p));
  1237. static int doifax25blimit __ARGS((int argc, char *argv[], void *p));
  1238. static int doifax25maxwait __ARGS((int argc, char *argv[], void *p));
  1239. static int doifax25bctext __ARGS((int argc, char *argv[], void *p));
  1240. static int doifax25bbscall __ARGS((int argc, char *argv[], void *p));
  1241. static int doifax25cdigi __ARGS((int argc, char *argv[], void *p));
  1242.   
  1243. /* These are the command that set ax.25 parameters per interface */
  1244. static struct cmds DFAR Ifaxcmds[] = {
  1245. #ifdef MAILBOX
  1246.     "bbscall",  doifax25bbscall,    0, 0, NULLCHAR,
  1247. #endif
  1248.     "bctext",   doifax25bctext,     0, 0, NULLCHAR,
  1249.     "blimit",   doifax25blimit,     0, 0, NULLCHAR,
  1250.     "cdigi",    doifax25cdigi,      0, 0, NULLCHAR,
  1251.     "irtt",     doifax25irtt,       0, 0, NULLCHAR,
  1252.     "maxframe", doifax25maxframe,   0, 0, NULLCHAR,
  1253.     "maxwait",  doifax25maxwait,    0, 0, NULLCHAR,
  1254.     "paclen",   doifax25paclen,     0, 0, NULLCHAR,
  1255.     "pthresh",  doifax25pthresh,    0, 0, NULLCHAR,
  1256.     "retry",    doifax25n2,         0, 0, NULLCHAR,
  1257.     "timertype",doifax25timertype,  0, 0, NULLCHAR,
  1258.     "t3",       doifax25t3,         0, 0, NULLCHAR,
  1259.     "t4",       doifax25t4,         0, 0, NULLCHAR,
  1260.     "version",  doifax25version,    0, 0, NULLCHAR,
  1261.     "window",   doifax25window,     0, 0, NULLCHAR,
  1262.     NULLCHAR
  1263. };
  1264.   
  1265. int ifax25(int argc,char *argv[],void *p) {
  1266.   
  1267.     if(((struct iface *)p)->type != CL_AX25)
  1268.         return tputs("not an AX.25 interface\n");
  1269.     return subcmd(Ifaxcmds,argc,argv,p);
  1270. };
  1271.   
  1272.   
  1273.   
  1274. #ifdef MAILBOX
  1275. /* Set bbs ax.25 address */
  1276. static int
  1277. doifax25bbscall(argc,argv,p)
  1278. int argc;
  1279. char *argv[];
  1280. void *p;
  1281. {
  1282.     struct iface *ifp = p;
  1283.     char tmp[AXBUF];
  1284.   
  1285.     if(argc == 1)
  1286.         tprintf("Bbscall %s\n",pax25(tmp,ifp->ax25->bbscall));
  1287.     else
  1288.         setcall(ifp->ax25->bbscall,argv[1]);
  1289.     return 0;
  1290. }
  1291. #endif
  1292.   
  1293. /* Set ax.25 bctext */
  1294. static int
  1295. doifax25bctext(argc,argv,p)
  1296. int argc;
  1297. char *argv[];
  1298. void *p;
  1299. {
  1300.     struct iface *ifp = p;
  1301.   
  1302.     if(argc == 1)
  1303.         tprintf("Bctext : %s\n",ifp->ax25->bctext);
  1304.     else {
  1305.         if(ifp->ax25->bctext)
  1306.             free(ifp->ax25->bctext);
  1307.         if(strlen(argv[1]) == 0)    /* clearing the buffer */
  1308.             ifp->ax25->bctext = NULL;
  1309.         else
  1310.             ifp->ax25->bctext = strdup(argv[1]);
  1311.     }
  1312.     return 0;
  1313. }
  1314.   
  1315. static int
  1316. doifax25blimit(argc,argv,p)
  1317. int argc;
  1318. char *argv[];
  1319. void *p;
  1320. {
  1321.     struct iface *ifp = p;
  1322.   
  1323.     return doax25blimit(argc,argv,(void *)&ifp->ax25->blimit);
  1324. }
  1325.   
  1326. /* Set cross band digi call address */
  1327. static int
  1328. doifax25cdigi(argc,argv,p)
  1329. int argc;
  1330. char *argv[];
  1331. void *p;
  1332. {
  1333.     struct iface *ifp = p;
  1334.     char tmp[AXBUF];
  1335.   
  1336.     if(argc == 1)
  1337.         tprintf("Cdigi %s\n",pax25(tmp,ifp->ax25->cdigi));
  1338.     else
  1339.         setcall(ifp->ax25->cdigi,argv[1]);
  1340.     return 0;
  1341. }
  1342.   
  1343. static int
  1344. doifax25irtt(argc,argv,p)
  1345. int argc;
  1346. char *argv[];
  1347. void *p;
  1348. {
  1349.     struct iface *ifp = p;
  1350.   
  1351.     return doax25irtt(argc,argv,(void *)&ifp->ax25->irtt);
  1352. }
  1353.   
  1354. static int
  1355. doifax25maxframe(argc,argv,p)
  1356. int argc;
  1357. char *argv[];
  1358. void *p;
  1359. {
  1360.     struct iface *ifp = p;
  1361.   
  1362.     return doax25maxframe(argc,argv,(void *)&ifp->ax25->maxframe);
  1363. }
  1364.   
  1365. static int
  1366. doifax25maxwait(argc,argv,p)
  1367. int argc;
  1368. char *argv[];
  1369. void *p;
  1370. {
  1371.     struct iface *ifp = p;
  1372.   
  1373.     return doax25maxwait(argc,argv,(void *)&ifp->ax25->maxwait);
  1374. }
  1375.   
  1376.   
  1377. /* Set interface AX.25 Paclen, and adjust the NETROM mtu for the
  1378.  * smallest paclen. - WG7J
  1379.  */
  1380. static int
  1381. doifax25paclen(argc,argv,p)
  1382. int argc;
  1383. char *argv[];
  1384. void *p;
  1385. {
  1386.     struct iface *ifp = p;
  1387. #ifdef NETROM
  1388.     int tmp;
  1389. #endif
  1390.   
  1391.     doax25paclen(argc,argv,(void *)&ifp->ax25->paclen);
  1392. #ifdef NETROM
  1393.     if(argc > 1 && ifp->flags & IS_NR_IFACE) {
  1394.         if((tmp=ifp->ax25->paclen - 20) < Nr_iface->mtu)
  1395.             Nr_iface->mtu = tmp;
  1396.     }
  1397. #endif
  1398.     return 0;
  1399. }
  1400.   
  1401. static int
  1402. doifax25pthresh(argc,argv,p)
  1403. int argc;
  1404. char *argv[];
  1405. void *p;
  1406. {
  1407.     struct iface *ifp = p;
  1408.   
  1409.     return doax25pthresh(argc,argv,(void *)&ifp->ax25->pthresh);
  1410. }
  1411.   
  1412. static int
  1413. doifax25n2(argc,argv,p)
  1414. int argc;
  1415. char *argv[];
  1416. void *p;
  1417. {
  1418.     struct iface *ifp = p;
  1419.   
  1420.     return doax25n2(argc,argv,(void *)&ifp->ax25->n2);
  1421. }
  1422.   
  1423. static int
  1424. doifax25timertype(argc,argv,p)
  1425. int argc;
  1426. char *argv[];
  1427. void *p;
  1428. {
  1429.     struct iface *ifp = p;
  1430.   
  1431.     return doax25timertype(argc,argv,(void *)&ifp->ax25->lapbtimertype);
  1432. }
  1433.   
  1434. static int
  1435. doifax25t3(argc,argv,p)
  1436. int argc;
  1437. char *argv[];
  1438. void *p;
  1439. {
  1440.     struct iface *ifp = p;
  1441.   
  1442.     return doax25t3(argc,argv,(void *)&ifp->ax25->t3);
  1443. }
  1444.   
  1445. static int
  1446. doifax25t4(argc,argv,p)
  1447. int argc;
  1448. char *argv[];
  1449. void *p;
  1450. {
  1451.     struct iface *ifp = p;
  1452.   
  1453.     return doax25t4(argc,argv,(void *)&ifp->ax25->t4);
  1454. }
  1455.   
  1456. static int
  1457. doifax25version(argc,argv,p)
  1458. int argc;
  1459. char *argv[];
  1460. void *p;
  1461. {
  1462.     struct iface *ifp = p;
  1463.   
  1464.     return doax25version(argc,argv,(void *)&ifp->ax25->version);
  1465. }
  1466.   
  1467. static int
  1468. doifax25window(argc,argv,p)
  1469. int argc;
  1470. char *argv[];
  1471. void *p;
  1472. {
  1473.     struct iface *ifp = p;
  1474.   
  1475.     return doax25window(argc,argv,(void *)&ifp->ax25->window);
  1476. }
  1477.   
  1478. #endif /* AX25 */
  1479.   
  1480.