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

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

TCP/IP协议栈

开发平台：

Visual C++

lapb.c：源码内容
  1. /* Link Access Procedures Balanced (LAPB), the upper sublayer of
  2.  * AX.25 Level 2.
  3.  *
  4.  * Copyright 1991 Phil Karn, KA9Q
  5.  */
  6. #include "global.h"
  7. #include "mbuf.h"
  8. #include "timer.h"
  9. #include "ax25.h"
  10. #include "lapb.h"
  11. #include "ip.h"
  12. #include "netrom.h"
  14. static void handleit(struct ax25_cb *axp,int pid,struct mbuf **bp);
  15. static void procdata(struct ax25_cb *axp,struct mbuf **bp);
  16. static int ackours(struct ax25_cb *axp,uint16 n);
  17. static void clr_ex(struct ax25_cb *axp);
  18. static void enq_resp(struct ax25_cb *axp);
  19. static void inv_rex(struct ax25_cb *axp);
  21. /* Process incoming frames */
  22. int
  23. lapb_input(
  24. struct ax25_cb *axp, /* Link control structure */
  25. int cmdrsp, /* Command/response flag */
  26. struct mbuf **bpp /* Rest of frame, starting with ctl */
  27. ){
  28. int control;
  29. int class; /* General class (I/S/U) of frame */
  30. uint16 type; /* Specific type (I/RR/RNR/etc) of frame */
  31. char pf; /* extracted poll/final bit */
  32. char poll = 0;
  33. char final = 0;
  34. uint16 nr; /* ACK number of incoming frame */
  35. uint16 ns; /* Seq number of incoming frame */
  36. uint16 tmp;
  38. if(bpp == NULL || *bpp == NULL || axp == NULL){
  39. free_p(bpp);
  40. return -1;
  41. }
  43. /* Extract the various parts of the control field for easy use */
  44. if((control = PULLCHAR(bpp)) == -1){
  45. free_p(bpp); /* Probably not necessary */
  46. return -1;
  47. }
  48. type = ftype(control);
  49. class = type & 0x3;
  50. pf = control & PF;
  51. /* Check for polls and finals */
  52. if(pf){
  53. switch(cmdrsp){
  54. case LAPB_COMMAND:
  55. poll = YES;
  56. break;
  57. case LAPB_RESPONSE:
  58. final = YES;
  59. break;
  60. }
  61. }
  62. /* Extract sequence numbers, if present */
  63. switch(class){
  64. case I:
  65. case I+2:
  66. ns = (control >> 1) & MMASK;
  67. case S: /* Note fall-thru */
  68. nr = (control >> 5) & MMASK;
  69. break;
  70. }
  71. /* This section follows the SDL diagrams by K3NA fairly closely */
  72. switch(axp->state){
  73. case LAPB_DISCONNECTED:
  74. switch(type){
  75. case SABM: /* Initialize or reset link */
  76. sendctl(axp,LAPB_RESPONSE,UA|pf); /* Always accept */
  77. clr_ex(axp);
  78. axp->unack = axp->vr = axp->vs = 0;
  79. lapbstate(axp,LAPB_CONNECTED);/* Resets state counters */
  80. axp->srt = Axirtt;
  81. axp->mdev = 0;
  82. set_timer(&axp->t1,2*axp->srt);
  83. start_timer(&axp->t3);
  84. break;
  85. case DM: /* Ignore to avoid infinite loops */
  86. break;
  87. default: /* All others get DM */
  88. if(poll)
  89. sendctl(axp,LAPB_RESPONSE,DM|pf);
  90. break;
  91. }
  92. break;
  93. case LAPB_SETUP:
  94. switch(type){
  95. case SABM: /* Simultaneous open */
  96. sendctl(axp,LAPB_RESPONSE,UA|pf);
  97. break;
  98. case DISC:
  99. sendctl(axp,LAPB_RESPONSE,DM|pf);
  100. break;
  101. case UA: /* Connection accepted */
  102. /* Note: xmit queue not cleared */
  103. stop_timer(&axp->t1);
  104. start_timer(&axp->t3);
  105. axp->unack = axp->vr = axp->vs = 0;
  106. lapbstate(axp,LAPB_CONNECTED);
  107. break;
  108. case DM: /* Connection refused */
  109. free_q(&axp->txq);
  110. stop_timer(&axp->t1);
  111. axp->reason = LB_DM;
  112. lapbstate(axp,LAPB_DISCONNECTED);
  113. break;
  114. default: /* All other frames ignored */
  115. break;
  116. }
  117. break;
  118. case LAPB_DISCPENDING:
  119. switch(type){
  120. case SABM:
  121. sendctl(axp,LAPB_RESPONSE,DM|pf);
  122. break;
  123. case DISC:
  124. sendctl(axp,LAPB_RESPONSE,UA|pf);
  125. break;
  126. case UA:
  127. case DM:
  128. stop_timer(&axp->t1);
  129. lapbstate(axp,LAPB_DISCONNECTED);
  130. break;
  131. default: /* Respond with DM only to command polls */
  132. if(poll)
  133. sendctl(axp,LAPB_RESPONSE,DM|pf);
  134. break;
  135. }
  136. break;
  137. case LAPB_CONNECTED:
  138. switch(type){
  139. case SABM:
  140. sendctl(axp,LAPB_RESPONSE,UA|pf);
  141. clr_ex(axp);
  142. free_q(&axp->txq);
  143. stop_timer(&axp->t1);
  144. start_timer(&axp->t3);
  145. axp->unack = axp->vr = axp->vs = 0;
  146. lapbstate(axp,LAPB_CONNECTED); /* Purge queues */
  147. break;
  148. case DISC:
  149. free_q(&axp->txq);
  150. sendctl(axp,LAPB_RESPONSE,UA|pf);
  151. stop_timer(&axp->t1);
  152. stop_timer(&axp->t3);
  153. axp->reason = LB_NORMAL;
  154. lapbstate(axp,LAPB_DISCONNECTED);
  155. break;
  156. case DM:
  157. axp->reason = LB_DM;
  158. lapbstate(axp,LAPB_DISCONNECTED);
  159. break;
  160. case UA:
  161. est_link(axp);
  162. lapbstate(axp,LAPB_SETUP); /* Re-establish */
  163. break;
  164. case FRMR:
  165. est_link(axp);
  166. lapbstate(axp,LAPB_SETUP); /* Re-establish link */
  167. break;
  168. case RR:
  169. case RNR:
  170. axp->flags.remotebusy = (control == RNR) ? YES : NO;
  171. if(poll)
  172. enq_resp(axp);
  173. ackours(axp,nr);
  174. break;
  175. case REJ:
  176. axp->flags.remotebusy = NO;
  177. if(poll)
  178. enq_resp(axp);
  179. ackours(axp,nr);
  180. stop_timer(&axp->t1);
  181. start_timer(&axp->t3);
  182. /* This may or may not actually invoke transmission,
  183.  * depending on whether this REJ was caused by
  184.  * our losing his prior ACK.
  185.  */
  186. inv_rex(axp);
  187. break;
  188. case I:
  189. ackours(axp,nr); /** == -1) */
  190. if(len_p(axp->rxq) >= axp->window){
  191. /* Too bad he didn't listen to us; he'll
  192.  * have to resend the frame later. This
  193.  * drastic action is necessary to avoid
  194.  * deadlock.
  195.  */
  196. if(poll)
  197. sendctl(axp,LAPB_RESPONSE,RNR|pf);
  198. free_p(bpp);
  199. break;
  200. }
  201. /* Reject or ignore I-frames with receive sequence number errors */
  202. if(ns != axp->vr){
  203. if(axp->proto == V1 || !axp->flags.rejsent){
  204. axp->flags.rejsent = YES;
  205. sendctl(axp,LAPB_RESPONSE,REJ | pf);
  206. } else if(poll)
  207. enq_resp(axp);
  208. axp->response = 0;
  209. break;
  210. }
  211. axp->flags.rejsent = NO;
  212. axp->vr = (axp->vr+1) & MMASK;
  213. tmp = len_p(axp->rxq) >= axp->window ? RNR : RR;
  214. if(poll){
  215. sendctl(axp,LAPB_RESPONSE,tmp|PF);
  216. } else {
  217. axp->response = tmp;
  218. }
  219. procdata(axp,bpp);
  220. break;
  221. default: /* All others ignored */
  222. break;
  223. }
  224. break;
  225. case LAPB_RECOVERY:
  226. switch(type){
  227. case SABM:
  228. sendctl(axp,LAPB_RESPONSE,UA|pf);
  229. clr_ex(axp);
  230. stop_timer(&axp->t1);
  231. start_timer(&axp->t3);
  232. axp->unack = axp->vr = axp->vs = 0;
  233. lapbstate(axp,LAPB_CONNECTED); /* Purge queues */
  234. break;
  235. case DISC:
  236. free_q(&axp->txq);
  237. sendctl(axp,LAPB_RESPONSE,UA|pf);
  238. stop_timer(&axp->t1);
  239. stop_timer(&axp->t3);
  240. axp->response = UA;
  241. axp->reason = LB_NORMAL;
  242. lapbstate(axp,LAPB_DISCONNECTED);
  243. break;
  244. case DM:
  245. axp->reason = LB_DM;
  246. lapbstate(axp,LAPB_DISCONNECTED);
  247. break;
  248. case UA:
  249. est_link(axp);
  250. lapbstate(axp,LAPB_SETUP); /* Re-establish */
  251. break;
  252. case FRMR:
  253. est_link(axp);
  254. lapbstate(axp,LAPB_SETUP); /* Re-establish link */
  255. break;
  256. case RR:
  257. case RNR:
  258. axp->flags.remotebusy = (control == RNR) ? YES : NO;
  259. if(axp->proto == V1 || final){
  260. stop_timer(&axp->t1);
  261. ackours(axp,nr);
  262. if(axp->unack != 0){
  263. inv_rex(axp);
  264. } else {
  265. start_timer(&axp->t3);
  266. lapbstate(axp,LAPB_CONNECTED);
  267. }
  268. } else {
  269. if(poll)
  270. enq_resp(axp);
  271. ackours(axp,nr);
  272. /* Keep timer running even if all frames
  273.  * were acked, since we must see a Final
  274.  */
  275. if(!run_timer(&axp->t1))
  276. start_timer(&axp->t1);
  277. }
  278. break;
  279. case REJ:
  280. axp->flags.remotebusy = NO;
  281. /* Don't insist on a Final response from the old proto */
  282. if(axp->proto == V1 || final){
  283. stop_timer(&axp->t1);
  284. ackours(axp,nr);
  285. if(axp->unack != 0){
  286. inv_rex(axp);
  287. } else {
  288. start_timer(&axp->t3);
  289. lapbstate(axp,LAPB_CONNECTED);
  290. }
  291. } else {
  292. if(poll)
  293. enq_resp(axp);
  294. ackours(axp,nr);
  295. if(axp->unack != 0){
  296. /* This is certain to trigger output */
  297. inv_rex(axp);
  298. }
  299. /* A REJ that acks everything but doesn't
  300.  * have the F bit set can cause a deadlock.
  301.  * So make sure the timer is running.
  302.  */
  303. if(!run_timer(&axp->t1))
  304. start_timer(&axp->t1);
  305. }
  306. break;
  307. case I:
  308. ackours(axp,nr); /** == -1) */
  309. /* Make sure timer is running, since an I frame
  310.  * cannot satisfy a poll
  311.  */
  312. if(!run_timer(&axp->t1))
  313. start_timer(&axp->t1);
  314. if(len_p(axp->rxq) >= axp->window){
  315. /* Too bad he didn't listen to us; he'll
  316.  * have to resend the frame later. This
  317.  * drastic action is necessary to avoid
  318.  * memory deadlock.
  319.  */
  320. sendctl(axp,LAPB_RESPONSE,RNR | pf);
  321. free_p(bpp);
  322. break;
  323. }
  324. /* Reject or ignore I-frames with receive sequence number errors */
  325. if(ns != axp->vr){
  326. if(axp->proto == V1 || !axp->flags.rejsent){
  327. axp->flags.rejsent = YES;
  328. sendctl(axp,LAPB_RESPONSE,REJ | pf);
  329. } else if(poll)
  330. enq_resp(axp);
  332. axp->response = 0;
  333. break;
  334. }
  335. axp->flags.rejsent = NO;
  336. axp->vr = (axp->vr+1) & MMASK;
  337. tmp = len_p(axp->rxq) >= axp->window ? RNR : RR;
  338. if(poll){
  339. sendctl(axp,LAPB_RESPONSE,tmp|PF);
  340. } else {
  341. axp->response = tmp;
  342. }
  343. procdata(axp,bpp);
  344. break;
  345. default:
  346. break; /* Ignored */
  347. }
  348. break;
  349. }
  350. free_p(bpp); /* In case anything's left */
  352. /* See if we can send some data, perhaps piggybacking an ack.
  353.  * If successful, lapb_output will clear axp->response.
  354.  */
  355. lapb_output(axp);
  356. if(axp->response != 0){
  357. sendctl(axp,LAPB_RESPONSE,axp->response);
  358. axp->response = 0;
  359. }
  360. return 0;
  361. }
  362. /* Handle incoming acknowledgements for frames we've sent.
  363.  * Free frames being acknowledged.
  364.  * Return -1 to cause a frame reject if number is bad, 0 otherwise
  365.  */
  366. static int
  367. ackours(
  368. struct ax25_cb *axp,
  369. uint16 n
  370. ){
  371. struct mbuf *bp;
  372. int acked = 0; /* Count of frames acked by this ACK */
  373. uint16 oldest; /* Seq number of oldest unacked I-frame */
  374. int32 rtt,abserr;
  376. /* Free up acknowledged frames by purging frames from the I-frame
  377.  * transmit queue. Start at the remote end's last reported V(r)
  378.  * and keep going until we reach the new sequence number.
  379.  * If we try to free a null pointer,
  380.  * then we have a frame reject condition.
  381.  */
  382. oldest = (axp->vs - axp->unack) & MMASK;
  383. while(axp->unack != 0 && oldest != n){
  384. if((bp = dequeue(&axp->txq)) == NULL){
  385. /* Acking unsent frame */
  386. return -1;
  387. }
  388. free_p(&bp);
  389. axp->unack--;
  390. acked++;
  391. if(axp->flags.rtt_run && axp->rtt_seq == oldest){
  392. /* A frame being timed has been acked */
  393. axp->flags.rtt_run = 0;
  394. /* Update only if frame wasn't retransmitted */
  395. if(!axp->flags.retrans){
  396. rtt = msclock() - axp->rtt_time;
  397. abserr = (rtt > axp->srt) ? rtt - axp->srt :
  398.  axp->srt - rtt;
  400. /* Run SRT and mdev integrators */
  401. axp->srt = ((axp->srt * 7) + rtt + 4) >> 3;
  402. axp->mdev = ((axp->mdev*3) + abserr + 2) >> 2;
  403. /* Update timeout */
  404. set_timer(&axp->t1,4*axp->mdev+axp->srt);
  405. }
  406. }
  407. axp->flags.retrans = 0;
  408. axp->retries = 0;
  409. oldest = (oldest + 1) & MMASK;
  410. }
  411. if(axp->unack == 0){
  412. /* All frames acked, stop timeout */
  413. stop_timer(&axp->t1);
  414. start_timer(&axp->t3);
  415. } else if(acked != 0) { 
  416. /* Partial ACK; restart timer */
  417. start_timer(&axp->t1);
  418. }
  419. if(acked != 0){
  420. /* If user has set a transmit upcall, indicate how many frames
  421.  * may be queued
  422.  */
  423. if(axp->t_upcall != NULL)
  424. (*axp->t_upcall)(axp,axp->paclen * (axp->maxframe - axp->unack));
  425. }
  426. return 0;
  427. }
  429. /* Establish data link */
  430. void
  431. est_link(axp)
  432. struct ax25_cb *axp;
  433. {
  434. clr_ex(axp);
  435. axp->retries = 0;
  436. sendctl(axp,LAPB_COMMAND,SABM|PF);
  437. stop_timer(&axp->t3);
  438. start_timer(&axp->t1);
  439. }
  440. /* Clear exception conditions */
  441. static void
  442. clr_ex(axp)
  443. struct ax25_cb *axp;
  444. {
  445. axp->flags.remotebusy = NO;
  446. axp->flags.rejsent = NO;
  447. axp->response = 0;
  448. stop_timer(&axp->t3);
  449. }
  450. /* Enquiry response */
  451. static void
  452. enq_resp(axp)
  453. struct ax25_cb *axp;
  454. {
  455. char ctl;
  457. ctl = len_p(axp->rxq) >= axp->window ? RNR|PF : RR|PF;
  458. sendctl(axp,LAPB_RESPONSE,ctl);
  459. axp->response = 0;
  460. stop_timer(&axp->t3);
  461. }
  462. /* Invoke retransmission */
  463. static void
  464. inv_rex(axp)
  465. struct ax25_cb *axp;
  466. {
  467. axp->vs -= axp->unack;
  468. axp->vs &= MMASK;
  469. axp->unack = 0;
  470. }
  471. /* Send S or U frame to currently connected station */
  472. int
  473. sendctl(axp,cmdrsp,cmd)
  474. struct ax25_cb *axp;
  475. int cmdrsp;
  476. int cmd;
  477. {
  478. if((ftype((char)cmd) & 0x3) == S) /* Insert V(R) if S frame */
  479. cmd |= (axp->vr << 5);
  480. return sendframe(axp,cmdrsp,cmd,NULL);
  481. }
  482. /* Start data transmission on link, if possible
  483.  * Return number of frames sent
  484.  */
  485. int
  486. lapb_output(axp)
  487. register struct ax25_cb *axp;
  488. {
  489. register struct mbuf *bp;
  490. struct mbuf *tbp;
  491. char control;
  492. int sent = 0;
  493. int i;
  495. if(axp == NULL
  496.  || (axp->state != LAPB_RECOVERY && axp->state != LAPB_CONNECTED)
  497.  || axp->flags.remotebusy)
  498. return 0;
  500. /* Dig into the send queue for the first unsent frame */
  501. bp = axp->txq;
  502. for(i = 0; i < axp->unack; i++){
  503. if(bp == NULL)
  504. break; /* Nothing to do */
  505. bp = bp->anext;
  506. }
  507. /* Start at first unsent I-frame, stop when either the
  508.  * number of unacknowledged frames reaches the maxframe limit,
  509.  * or when there are no more frames to send
  510.  */
  511. while(bp != NULL && axp->unack < axp->maxframe){
  512. control = I | (axp->vs++ << 1) | (axp->vr << 5);
  513. axp->vs &= MMASK;
  514. dup_p(&tbp,bp,0,len_p(bp));
  515. if(tbp == NULL)
  516. return sent; /* Probably out of memory */
  517. sendframe(axp,LAPB_COMMAND,control,&tbp);
  518. axp->unack++;
  519. /* We're implicitly acking any data he's sent, so stop any
  520.  * delayed ack
  521.  */
  522. axp->response = 0;
  523. if(!run_timer(&axp->t1)){
  524. stop_timer(&axp->t3);
  525. start_timer(&axp->t1);
  526. }
  527. sent++;
  528. bp = bp->anext;
  529. if(!axp->flags.rtt_run){
  530. /* Start round trip timer */
  531. axp->rtt_seq = (control >> 1) & MMASK;
  532. axp->rtt_time = msclock();
  533. axp->flags.rtt_run = 1;
  534. }
  535. }
  536. return sent;
  537. }
  538. /* General purpose AX.25 frame output */
  539. int
  540. sendframe(
  541. struct ax25_cb *axp,
  542. int cmdrsp,
  543. int ctl,
  544. struct mbuf **data
  545. ){
  546. return axsend(axp->iface,axp->remote,axp->local,cmdrsp,ctl,data);
  547. }
  548. /* Set new link state */
  549. void
  550. lapbstate(
  551. struct ax25_cb *axp,
  552. int s
  553. ){
  554. int oldstate;
  556. oldstate = axp->state;
  557. axp->state = s;
  558. if(s == LAPB_DISCONNECTED){
  559. stop_timer(&axp->t1);
  560. stop_timer(&axp->t3);
  561. free_q(&axp->txq);
  562. }
  563. /* Don't bother the client unless the state is really changing */
  564. if(oldstate != s && axp->s_upcall != NULL)
  565. (*axp->s_upcall)(axp,oldstate,s);
  566. }
  567. /* Process a valid incoming I frame */
  568. static void
  569. procdata(
  570. struct ax25_cb *axp,
  571. struct mbuf **bpp
  572. ){
  573. int pid;
  574. int seq;
  576. /* Extract level 3 PID */
  577. if((pid = PULLCHAR(bpp)) == -1)
  578. return; /* No PID */
  580. if(axp->segremain != 0){
  581. /* Reassembly in progress; continue */
  582. seq = PULLCHAR(bpp);
  583. if(pid == PID_SEGMENT
  584.  && (seq & SEG_REM) == axp->segremain - 1){
  585. /* Correct, in-order segment */
  586. append(&axp->rxasm,bpp);
  587. if((axp->segremain = (seq & SEG_REM)) == 0){
  588. /* Done; kick it upstairs */
  589. *bpp = axp->rxasm;
  590. axp->rxasm = NULL;
  591. pid = PULLCHAR(bpp);
  592. handleit(axp,pid,bpp);
  593. }
  594. } else {
  595. /* Error! */
  596. free_p(&axp->rxasm);
  597. axp->rxasm = NULL;
  598. axp->segremain = 0;
  599. free_p(bpp);
  600. }
  601. } else {
  602. /* No reassembly in progress */
  603. if(pid == PID_SEGMENT){
  604. /* Start reassembly */
  605. seq = PULLCHAR(bpp);
  606. if(!(seq & SEG_FIRST)){
  607. free_p(bpp); /* not first seg - error! */
  608. } else {
  609. /* Put first segment on list */
  610. axp->segremain = seq & SEG_REM;
  611. axp->rxasm = (*bpp);
  612. *bpp = NULL;
  613. }
  614. } else {
  615. /* Normal frame; send upstairs */
  616. handleit(axp,pid,bpp);
  617. }
  618. }
  619. }
  620. /* New-style frame segmenter. Returns queue of segmented fragments, or
  621.  * original packet if small enough
  622.  */
  623. struct mbuf *
  624. segmenter(
  625. struct mbuf **bpp, /* Complete packet */
  626. uint16 ssize /* Max size of frame segments */
  627. ){
  628. struct mbuf *result = NULL;
  629. struct mbuf *bptmp;
  630. uint16 len,offset;
  631. int segments;
  633. /* See if packet is too small to segment. Note 1-byte grace factor
  634.  * so the PID will not cause segmentation of a 256-byte IP datagram.
  635.  */
  636. len = len_p(*bpp);
  637. if(len <= ssize+1){
  638. result = *bpp;
  639. *bpp = NULL;
  640. return result; /* Too small to segment */
  641. }
  642. ssize -= 2; /* ssize now equal to data portion size */
  643. segments = 1 + (len - 1) / ssize; /* # segments  */
  644. offset = 0;
  646. while(segments != 0){
  647. offset += dup_p(&bptmp,*bpp,offset,ssize);
  648. if(bptmp == NULL){
  649. free_q(&result);
  650. break;
  651. }
  652. /* Make room for segmentation header */
  653. pushdown(&bptmp,NULL,2);
  654. bptmp->data[0] = PID_SEGMENT;
  655. bptmp->data[1] = --segments;
  656. if(offset == ssize)
  657. bptmp->data[1] |= SEG_FIRST;
  658. enqueue(&result,&bptmp);
  659. }
  660. free_p(bpp);
  661. return result;
  662. }
  664. static void
  665. handleit(
  666. struct ax25_cb *axp,
  667. int pid,
  668. struct mbuf **bpp
  669. ){
  670. struct axlink *ipp;
  672. for(ipp = Axlink;ipp->funct != NULL;ipp++){
  673. if(ipp->pid == pid)
  674. break;
  675. }
  676. if(ipp->funct != NULL)
  677. (*ipp->funct)(axp->iface,axp,NULL,NULL,bpp,0);
  678. else
  679. free_p(bpp);
  680. }
  681. /* Handle ordinary incoming data (no network protocol) */
  682. void
  683. axnl3(
  684. struct iface *iface,
  685. struct ax25_cb *axp,
  686. uint8 *src,
  687. uint8 *dest,
  688. struct mbuf **bpp,
  689. int mcast
  690. ){
  691. if(axp == NULL){
  692. beac_input(iface,src,bpp);
  693. } else {
  694. append(&axp->rxq,bpp);
  695. if(axp->r_upcall != NULL)
  696. (*axp->r_upcall)(axp,len_p(axp->rxq));
  697. }
  698. }