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

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

TCP/IP协议栈

开发平台：

Visual C++

pppipcp.c：源码内容
  1. /*
  2.  *  PPPIPCP.C -- negotiate IP parameters
  3.  *
  4.  * This implementation of PPP is declared to be in the public domain.
  5.  *
  6.  * Jan 91 Bill_Simpson@um.cc.umich.edu
  7.  * Computer Systems Consulting Services
  8.  *
  9.  * Acknowledgements and correction history may be found in PPP.C
  10.  */
  12. #include <stdio.h>
  13. #include <ctype.h>
  14. #include <time.h>
  15. #include "global.h"
  16. #include "mbuf.h"
  17. #include "iface.h"
  18. #include "slhc.h"
  19. #include "ppp.h"
  20. #include "pppfsm.h"
  21. #include "pppipcp.h"
  22. #include "cmdparse.h"
  23. #include "files.h"
  24. #include "trace.h"
  27. /* These defaults are defined in the PPP RFCs, and must not be changed */
  28. static struct ipcp_value_s ipcp_default = {
  29. FALSE, /* no need to negotiate defaults */
  31. 0L, /* no source address */
  32. 0L, /* no destination address */
  34. 0, /* no compression protocol */
  35. 0, /* no slots */
  36. 0 /* no slot compression */
  37. };
  39. /* for test purposes, accept anything we understand */
  40. static uint16 ipcp_negotiate = IPCP_N_ADDRESS | IPCP_N_COMPRESS;
  42. static byte_t option_length[] = {
  43.  0, /* unused */
  44. 10, /* address */
  45.  6 /* compression */
  46. };
  49. static int doipcp_local(int argc, char *argv[], void *p);
  50. static int doipcp_open(int argc, char *argv[], void *p);
  51. static int doipcp_pool(int argc, char *argv[], void *p);
  52. static int doipcp_remote(int argc, char *argv[], void *p);
  54. static int doipcp_address(int argc, char *argv[], void *p);
  55. static int doipcp_compress(int argc, char *argv[], void *p);
  56. static int doipcp_default(int argc, char *argv[], void *p);
  58. static void ipcp_option(struct mbuf **bpp,
  59. struct ipcp_value_s *value_p,
  60. byte_t o_type,
  61. byte_t o_length,
  62. struct mbuf **copy_bpp);
  63. static void ipcp_makeoptions(struct mbuf **bpp,
  64. struct ipcp_value_s *value_p,
  65. uint16 negotiating);
  66. static struct mbuf *ipcp_makereq(struct fsm_s *fsm_p);
  68. static int ipcp_check(struct mbuf **bpp,
  69. struct ipcp_s *ipcp_p,
  70. struct ipcp_side_s *side_p,
  71. struct option_hdr *option_p,
  72. int request);
  74. static int ipcp_request(struct fsm_s *fsm_p,
  75. struct config_hdr *config,
  76. struct mbuf **data);
  77. static int ipcp_ack(struct fsm_s *fsm_p,
  78. struct config_hdr *config,
  79. struct mbuf **data);
  80. static int ipcp_nak(struct fsm_s *fsm_p,
  81. struct config_hdr *config,
  82. struct mbuf **data);
  83. static int ipcp_reject(struct fsm_s *fsm_p,
  84. struct config_hdr *config,
  85. struct mbuf **data);
  87. static void ipcp_reset(struct fsm_s *fsm_p);
  89. static int32 ipcp_addr_idle(int32 addr);
  90. static int32 ipcp_lookuppeer(char *peerid);
  91. static int32 ipcp_poolnext(struct ipcp_s *ipcp_p);
  93. static void ipcp_starting(struct fsm_s *fsm_p);
  94. static void ipcp_stopping(struct fsm_s *fsm_p);
  96. static void ipcp_closing(struct fsm_s *fsm_p);
  97. static void ipcp_opening(struct fsm_s *fsm_p);
  99. static void ipcp_free(struct fsm_s *fsm_p);
  102. static struct fsm_constant_s ipcp_constants = {
  103. "IPcp",
  104. PPP_IPCP_PROTOCOL,
  105. 0x00FE, /* codes 1-7 recognized */
  107. IPcp,
  108. IPCP_REQ_TRY,
  109. IPCP_NAK_TRY,
  110. IPCP_TERM_TRY,
  111. IPCP_TIMEOUT * 1000L,
  113. ipcp_free,
  115. ipcp_reset,
  116. ipcp_starting,
  117. ipcp_opening,
  118. ipcp_closing,
  119. ipcp_stopping,
  121. ipcp_makereq,
  122. ipcp_request,
  123. ipcp_ack,
  124. ipcp_nak,
  125. ipcp_reject,
  126. };
  129. /************************************************************************/
  131. /* "ppp <iface> ipcp" subcommands */
  132. static struct cmds IPcpcmds[] = {
  133. "close", doppp_close, 0, 0, NULL,
  134. "listen", doppp_passive, 0, 0, NULL,
  135. "local", doipcp_local, 0, 0, NULL,
  136. "open", doipcp_open, 0, 0, NULL,
  137. "pool", doipcp_pool, 0, 0, NULL,
  138. "remote", doipcp_remote, 0, 0, NULL,
  139. "timeout", doppp_timeout, 0, 0, NULL,
  140. "try", doppp_try, 0, 0, NULL,
  141. NULL,
  142. };
  144. /* "ppp <iface> ipcp {local | remote}" subcommands */
  145. static struct cmds IPcpside_cmds[] = {
  146. "address", doipcp_address, 0, 0, NULL,
  147. "compress", doipcp_compress,0, 0, NULL,
  148. "default", doipcp_default, 0, 0, NULL,
  149. NULL,
  150. };
  153. int
  154. doppp_ipcp(argc,argv,p)
  155. int argc;
  156. char *argv[];
  157. void *p;
  158. {
  159. register struct iface *ifp = p;
  160. register struct ppp_s *ppp_p = ifp->edv;
  162. return subcmd(IPcpcmds, argc, argv, &(ppp_p->fsm[IPcp]));
  163. }
  166. static int
  167. doipcp_local(argc,argv,p)
  168. int argc;
  169. char *argv[];
  170. void *p;
  171. {
  172. struct fsm_s *fsm_p = p;
  173. struct ipcp_s *ipcp_p = fsm_p->pdv;
  174. return subcmd(IPcpside_cmds, argc, argv, &(ipcp_p->local));
  175. }
  178. static int
  179. doipcp_open(argc,argv,p)
  180. int argc;
  181. char *argv[];
  182. void *p;
  183. {
  184. struct fsm_s *fsm_p = p;
  186. doppp_active( argc, argv, p );
  188. if ( fsm_p->ppp_p->phase == pppREADY ) {
  189. fsm_start( fsm_p );
  190. }
  191. return 0;
  192. }
  195. /* Set a pool of peer addresses for PPP interface */
  196. static int
  197. doipcp_pool(argc,argv,p)
  198. int argc;
  199. char *argv[];
  200. void *p;
  201. {
  202. struct fsm_s *fsm_p = p;
  203. struct ipcp_s *ipcp_p = fsm_p->pdv;
  204. int32 pool_addr;
  205. int pool_cnt;
  207. if (argc < 2) {
  208. if ( ipcp_p->peer_min == 0L ) {
  209. printf("None");
  210. } else {
  211. printf("%s thru ", inet_ntoa(ipcp_p->peer_min));
  212. printf("%sn", inet_ntoa(ipcp_p->peer_max));
  213. }
  214. return 0;
  215. }
  217. if ((pool_addr = resolve(argv[1])) == 0L) {
  218. printf(Badhost,argv[1]);
  219. }
  221. /* May specify a consecutive range of addresses; otherwise assume 1 */
  222. if (argc < 3)
  223. pool_cnt = 1;
  224. else
  225. pool_cnt = (int)strtol( argv[2], NULL, 0 );
  227. if (pool_cnt <= 0) {
  228. printf("Pool count %s (%d) must be > 0n");
  229. return -1;
  230. }
  232. ipcp_p->peer_min = pool_addr;
  233. ipcp_p->peer_max = pool_addr + pool_cnt - 1;
  234. return 0;
  235. }
  238. static int
  239. doipcp_remote(argc,argv,p)
  240. int argc;
  241. char *argv[];
  242. void *p;
  243. {
  244. struct fsm_s *fsm_p = p;
  245. struct ipcp_s *ipcp_p = fsm_p->pdv;
  246. return subcmd(IPcpside_cmds, argc, argv, &(ipcp_p->remote));
  247. }
  250. /************************************************************************/
  251. /* Set addresses for PPP interface */
  252. static int
  253. doipcp_address(argc,argv,p)
  254. int argc;
  255. char *argv[];
  256. void *p;
  257. {
  258. struct ipcp_side_s *side_p = p;
  259. int32 x32;
  261. if (argc < 2) {
  262. printf("%sn", inet_ntoa(side_p->want.address));
  263. return 0;
  264. } else if ( stricmp(argv[1],"allow") == 0 ) {
  265. return bit16cmd( &(side_p->will_negotiate), IPCP_N_ADDRESS,
  266. "Allow Address", --argc, &argv[1] );
  267. }
  268. if ((x32 = resolve(argv[1])) == 0L) {
  269. printf(Badhost,argv[1]);
  270. }
  271. side_p->want.address = x32;
  272. side_p->want.negotiate |= IPCP_N_ADDRESS;
  273. return 0;
  274. }
  277. /* Set IP compression type for PPP interface */
  278. static int
  279. doipcp_compress(argc,argv,p)
  280. int argc;
  281. char *argv[];
  282. void *p;
  283. {
  284. struct ipcp_side_s *side_p = p;
  286. if (argc < 2) {
  287. if ( side_p->want.negotiate & IPCP_N_COMPRESS ) {
  288. switch ( side_p->want.compression ) {
  289. case PPP_COMPR_PROTOCOL:
  290. printf("TCP header compression enabled; "
  291. "Slots = %d, slot compress = %xn",
  292. side_p->want.slots,
  293. side_p->want.slot_compress);
  294. break;
  295. default:
  296. printf("0x%04xn", side_p->want.compression);
  297. break;
  298. };
  299. } else {
  300. printf("Nonen");
  301. }
  302. } else if ( stricmp(argv[1],"allow") == 0 ) {
  303. return bit16cmd( &(side_p->will_negotiate), IPCP_N_COMPRESS,
  304. "Allow Compression", --argc, &argv[1] );
  305. } else if ( stricmp(argv[1],"tcp") == 0
  306.  || stricmp(argv[1],"vj") == 0 ) {
  307. side_p->want.compression = PPP_COMPR_PROTOCOL;
  308. if ( argc >= 3 ) {
  309. side_p->want.slots = strtol(argv[2],NULL,0);
  310. if ( side_p->want.slots < 1 || side_p->want.slots > 255 ) {
  311. printf( "slots must be in range 1 to 255" );
  312. return 1;
  313. }
  314. } else {
  315. side_p->want.slots = IPCP_SLOT_DEFAULT;
  316. }
  317. if ( argc >= 4 ) {
  318. side_p->want.slot_compress = strtol(argv[3],NULL,0);
  319. } else {
  320. side_p->want.slot_compress = IPCP_SLOT_COMPRESS;
  321. }
  322. side_p->want.negotiate |= IPCP_N_COMPRESS;
  323. } else if (stricmp(argv[1],"none") == 0) {
  324. side_p->want.negotiate &= ~IPCP_N_COMPRESS;
  325. } else {
  326. printf("allow tcp nonen");
  327. return 1;
  328. }
  329. return 0;
  330. }
  333. static int
  334. doipcp_default(argc,argv,p)
  335. int argc;
  336. char *argv[];
  337. void *p;
  338. {
  339. struct ipcp_side_s *side_p = p;
  341. ASSIGN( side_p->want, ipcp_default );
  342. return 0;
  343. }
  346. /************************************************************************/
  347. /* E V E N T   P R O C E S S I N G */
  348. /************************************************************************/
  350. static void
  351. ipcp_option( bpp, value_p, o_type, o_length, copy_bpp )
  352. struct mbuf **bpp;
  353. struct ipcp_value_s *value_p;
  354. byte_t o_type;
  355. byte_t o_length;
  356. struct mbuf **copy_bpp;
  357. {
  358. struct mbuf *bp;
  359. register uint8 *cp;
  360. register int toss = o_length - OPTION_HDR_LEN;
  362. if ((bp = alloc_mbuf(o_length)) == NULL) {
  363. return;
  364. }
  365. cp = bp->data;
  366. *cp++ = o_type;
  367. *cp++ = o_length;
  369. switch ( o_type ) {
  370. case IPCP_ADDRESS:
  371. cp = put32(cp, value_p->address);
  372. cp = put32(cp, value_p->other);
  373. toss -= 8;
  374. #ifdef PPP_DEBUG_OPTIONS
  375. if (PPPtrace & PPP_DEBUG_OPTIONS) {
  376. trace_log(PPPiface, "    making IP source address: %s",
  377. inet_ntoa(value_p->address));
  378. trace_log(PPPiface, "    making IP destination address %s",
  379. inet_ntoa(value_p->other));
  380. }
  381. #endif
  382. break;
  384. case IPCP_COMPRESS:
  385. cp = put16(cp, value_p->compression);
  386. toss -= 2;
  387. #ifdef PPP_DEBUG_OPTIONS
  388. if (PPPtrace & PPP_DEBUG_OPTIONS)
  389. trace_log(PPPiface, "    making IP compression 0x%04x",
  390. value_p->compression);
  391. #endif
  392. if ( value_p->compression == PPP_COMPR_PROTOCOL ) {
  393. *cp++ = value_p->slots - 1;
  394. *cp++ = value_p->slot_compress;
  395. toss -= 2;
  396. #ifdef PPP_DEBUG_OPTIONS
  397. if (PPPtrace & PPP_DEBUG_OPTIONS)
  398. trace_log(PPPiface, "    with IP compression slots %d, flag %x",
  399. value_p->slots,
  400. value_p->slot_compress);
  401. #endif
  402. }
  403. break;
  405. default:
  406. #ifdef PPP_DEBUG_OPTIONS
  407. if (PPPtrace & PPP_DEBUG_OPTIONS)
  408. trace_log(PPPiface, "    making unimplemented type %d", o_type);
  409. #endif
  410. break;
  411. };
  413. while ( toss-- > 0 ) {
  414. *cp++ = pullchar(copy_bpp);
  415. }
  416. bp->cnt += o_length;
  417. append(bpp, &bp);
  418. }
  421. /************************************************************************/
  422. /* Build a list of options */
  423. static void
  424. ipcp_makeoptions(bpp, value_p, negotiating)
  425. struct mbuf **bpp;
  426. struct ipcp_value_s *value_p;
  427. uint16 negotiating;
  428. {
  429. register int o_type;
  431. PPP_DEBUG_ROUTINES("ipcp_makeoptions()");
  433. for ( o_type = 1; o_type <= IPCP_OPTION_LIMIT; o_type++ ) {
  434. if (negotiating & (1 << o_type)) {
  435. ipcp_option( bpp, value_p,
  436. o_type, option_length[ o_type ], NULL);
  437. }
  438. }
  439. }
  442. /************************************************************************/
  443. /* Build a request to send to remote host */
  444. static struct mbuf *
  445. ipcp_makereq(fsm_p)
  446. struct fsm_s *fsm_p;
  447. {
  448. struct ipcp_s *ipcp_p = fsm_p->pdv;
  449. struct mbuf *req_bp = NULL;
  451. PPP_DEBUG_ROUTINES("ipcp_makereq()");
  453. ipcp_makeoptions( &req_bp, &(ipcp_p->local.work),
  454. ipcp_p->local.work.negotiate );
  455. return(req_bp);
  456. }
  459. /************************************************************************/
  460. /* Check the options, updating the working values.
  461.  * Returns -1 if ran out of data, ACK/NAK/REJ as appropriate.
  462.  */
  463. static int
  464. ipcp_check( bpp, ipcp_p, side_p, option_p, request )
  465. struct mbuf **bpp;
  466. struct ipcp_s *ipcp_p;
  467. struct ipcp_side_s *side_p;
  468. struct option_hdr *option_p;
  469. int request;
  470. {
  471. int toss = option_p->len - OPTION_HDR_LEN;
  472. int option_result = CONFIG_ACK; /* Assume good values */
  473. int test;
  475. switch(option_p->type) {
  476. case IPCP_ADDRESS:
  477. side_p->work.address = pull32(bpp);
  478. side_p->work.other = pull32(bpp);
  479. toss -= 8;
  480. #ifdef PPP_DEBUG_OPTIONS
  481. if (PPPtrace & PPP_DEBUG_OPTIONS) {
  482. trace_log(PPPiface, "    checking IP source address: %s",
  483. inet_ntoa(side_p->work.address));
  484. trace_log(PPPiface, "    checking IP destination address %s",
  485. inet_ntoa(side_p->work.other));
  486. }
  487. #endif
  488. if ( !request ) {
  489. /* override any undesirable changes */
  490. if (ipcp_p->remote.want.address != 0L) {
  491. ipcp_p->local.work.other
  492. = ipcp_p->remote.want.address;
  493. }
  494. if (ipcp_p->local.want.address != 0L) {
  495. ipcp_p->local.work.address
  496. = ipcp_p->local.want.address;
  497. }
  498. break;
  499. }
  501. /* Ensure that addresses match */
  502. if (ipcp_p->remote.work.address == ipcp_p->remote.want.address) {
  503. if (ipcp_p->remote.want.address == 0L) {
  504. /* don't know address either */
  505. option_result = CONFIG_REJ;
  506. }
  507. } else if (ipcp_p->remote.want.address == 0L) {
  508. ipcp_p->local.work.other = ipcp_p->remote.work.address;
  509. } else {
  510. ipcp_p->remote.work.address = ipcp_p->remote.want.address;
  511. option_result = CONFIG_NAK;
  512. }
  514. if (ipcp_p->remote.work.other == ipcp_p->local.want.address) {
  515. if (ipcp_p->local.want.address == 0L) {
  516. /* don't know address either */
  517. option_result = CONFIG_REJ;
  518. }
  519. } else if (ipcp_p->local.want.address == 0L) {
  520. ipcp_p->local.work.address = ipcp_p->remote.work.other;
  521. } else {
  522. option_result = CONFIG_NAK;
  523. ipcp_p->remote.work.other = ipcp_p->local.want.address;
  524. }
  525. break;
  527. case IPCP_COMPRESS:
  528. side_p->work.compression = pull16(bpp);
  529. toss -= 2;
  530. #ifdef PPP_DEBUG_OPTIONS
  531. if (PPPtrace & PPP_DEBUG_OPTIONS)
  532. trace_log(PPPiface, "    checking IP compression 0x%04x",
  533. side_p->work.compression);
  534. #endif
  535. /* Check if requested type is acceptable */
  536. switch ( side_p->work.compression ) {
  537. case PPP_COMPR_PROTOCOL:
  538. if ( (test = pullchar(bpp)) == -1 ) {
  539. return -1;
  540. }
  541. if ( (side_p->work.slots = test + 1) < IPCP_SLOT_LO) {
  542. side_p->work.slots = IPCP_SLOT_LO;
  543. option_result = CONFIG_NAK;
  544. } else if (side_p->work.slots > IPCP_SLOT_HI) {
  545. side_p->work.slots = IPCP_SLOT_HI;
  546. option_result = CONFIG_NAK;
  547. }
  549. if ( (test = pullchar(bpp)) == -1 ) {
  550. return -1;
  551. }
  552. if ( (side_p->work.slot_compress = test) > 1 ) {
  553. side_p->work.slot_compress = 1;
  554. option_result = CONFIG_NAK;
  555. }
  556. toss -= 2;
  557. #ifdef PPP_DEBUG_OPTIONS
  558. if (PPPtrace & PPP_DEBUG_OPTIONS)
  559. trace_log(PPPiface, "    with IP compression slots %d, flag %x",
  560. side_p->work.slots,
  561. side_p->work.slot_compress);
  562. #endif
  563. break;
  565. default:
  566. if ( side_p->want.negotiate & IPCP_N_COMPRESS ) {
  567. side_p->work.compression = side_p->want.compression;
  568. side_p->work.slots = side_p->want.slots;
  569. side_p->work.slot_compress = side_p->want.slot_compress;
  570. } else {
  571. side_p->work.compression = PPP_COMPR_PROTOCOL;
  572. side_p->work.slots = IPCP_SLOT_DEFAULT;
  573. side_p->work.slot_compress = IPCP_SLOT_COMPRESS;
  574. }
  575. option_result = CONFIG_NAK;
  576. break;
  577. };
  578. break;
  580. default:
  581. option_result = CONFIG_REJ;
  582. break;
  583. };
  585. if (option_p->type > IPCP_OPTION_LIMIT
  586.  || !(side_p->will_negotiate & (1 << option_p->type))) {
  587. option_result = CONFIG_REJ;
  588. }
  590. if ( toss < 0 )
  591. return -1;
  593. if ( !request  &&  toss > 0 ) {
  594. /* toss extra bytes in option */
  595. while( toss-- > 0 ) {
  596. if ( pullchar(bpp) == -1 )
  597. return -1;
  598. }
  599. }
  601. return (option_result);
  602. }
  605. /************************************************************************/
  606. /* Check options requested by the remote host */
  607. static int
  608. ipcp_request(
  609. struct fsm_s *fsm_p,
  610. struct config_hdr *config,
  611. struct mbuf **data
  612. ){
  613. struct ipcp_s *ipcp_p = fsm_p->pdv;
  614. int32 signed_length = config->len;
  615. struct mbuf *reply_bp = NULL; /* reply packet */
  616. int reply_result = CONFIG_ACK; /* reply to request */
  617. uint16 desired; /* desired to negotiate */
  618. struct option_hdr option; /* option header storage */
  619. int option_result; /* option reply */
  621. PPP_DEBUG_ROUTINES("ipcp_request()");
  622. ipcp_p->remote.work.negotiate = FALSE; /* clear flags */
  624. /* Process options requested by remote host */
  625. while (signed_length > 0  &&  ntohopt(&option, data) != -1) {
  626. if ((signed_length -= option.len) < 0) {
  627. PPP_DEBUG_CHECKS("IPCP REQ: bad header length");
  628. free_p(data);
  629. free_p(&reply_bp);
  630. return -1;
  631. }
  633. if ( ( option_result = ipcp_check( data, ipcp_p,
  634. &(ipcp_p->remote), &option, TRUE ) ) == -1 ) {
  635. PPP_DEBUG_CHECKS("IPCP REQ: ran out of data");
  636. free_p(data);
  637. free_p(&reply_bp);
  638. return -1;
  639. }
  641. #ifdef PPP_DEBUG_OPTIONS
  642. if (PPPtrace & PPP_DEBUG_OPTIONS) {
  643. trace_log(PPPiface, "IPCP REQ: result %s, option %d, length %d",
  644. fsmCodes[option_result],
  645. option.type,
  646. option.len);
  647. }
  648. #endif
  649. if ( option_result < reply_result ) {
  650. continue;
  651. } else if ( option_result > reply_result ) {
  652. /* Discard current list of replies */
  653. free_p(&reply_bp);
  654. reply_bp = NULL;
  655. reply_result = option_result;
  656. }
  658. /* remember that we processed option */
  659. if ( option_result != CONFIG_REJ
  660.  && option.type <= IPCP_OPTION_LIMIT ) {
  661. ipcp_p->remote.work.negotiate |= (1 << option.type);
  662. }
  664. /* Add option response to the return list */
  665. ipcp_option( &reply_bp, &(ipcp_p->remote.work),
  666. option.type, option.len, data );
  667. }
  669. /* Now check for any missing options which are desired */
  670. if ( fsm_p->retry_nak > 0
  671.  &&  (desired = ipcp_p->remote.want.negotiate
  672.        & ~ipcp_p->remote.work.negotiate) != 0 ) {
  673. switch ( reply_result ) {
  674. case CONFIG_ACK:
  675. free_p(&reply_bp);
  676. reply_bp = NULL;
  677. reply_result = CONFIG_NAK;
  678. /* fallthru */
  679. case CONFIG_NAK:
  680. ipcp_makeoptions( &reply_bp, &(ipcp_p->remote.want),
  681. desired );
  682. fsm_p->retry_nak--;
  683. break;
  684. case CONFIG_REJ:
  685. /* do nothing */
  686. break;
  687. };
  688. } else if ( reply_result == CONFIG_NAK ) {
  689. /* if too many NAKs, reject instead */
  690. if ( fsm_p->retry_nak > 0 )
  691. fsm_p->retry_nak--;
  692. else
  693. reply_result = CONFIG_REJ;
  694. }
  696. /* Send ACK/NAK/REJ to remote host */
  697. fsm_send(fsm_p, reply_result, config->id, &reply_bp);
  698. free_p(data);
  699. return (reply_result != CONFIG_ACK);
  700. }
  703. /************************************************************************/
  704. /* Process configuration ACK sent by remote host */
  705. static int
  706. ipcp_ack(
  707. struct fsm_s *fsm_p,
  708. struct config_hdr *config,
  709. struct mbuf **data
  710. ){
  711. struct mbuf *req_bp;
  712. int error = FALSE;
  714. PPP_DEBUG_ROUTINES("ipcp_ack()");
  716. /* ID field must match last request we sent */
  717. if (config->id != fsm_p->lastid) {
  718. PPP_DEBUG_CHECKS("IPCP ACK: wrong ID");
  719. free_p(data);
  720. return -1;
  721. }
  723. /* Get a copy of last request we sent */
  724. req_bp = ipcp_makereq(fsm_p);
  726. /* Overall buffer length should match */
  727. if (config->len != len_p(req_bp)) {
  728. PPP_DEBUG_CHECKS("IPCP ACK: buffer length mismatch");
  729. error = TRUE;
  730. } else {
  731. register int req_char;
  732. register int ack_char;
  734. /* Each byte should match */
  735. while ((req_char = pullchar(&req_bp)) != -1) {
  736. if ((ack_char = pullchar(data)) == -1
  737.  || ack_char != req_char ) {
  738. PPP_DEBUG_CHECKS("IPCP ACK: data mismatch");
  739. error = TRUE;
  740. break;
  741. }
  742. }
  743. }
  744. free_p(&req_bp);
  745. free_p(data);
  747. if (error) {
  748. return -1;
  749. }
  751. PPP_DEBUG_CHECKS("IPCP ACK: valid");
  752. return 0;
  753. }
  756. /************************************************************************/
  757. /* Process configuration NAK sent by remote host */
  758. static int
  759. ipcp_nak(
  760. struct fsm_s *fsm_p,
  761. struct config_hdr *config,
  762. struct mbuf **data
  763. ){
  764. struct ipcp_s *ipcp_p = fsm_p->pdv;
  765. struct ipcp_side_s *local_p = &(ipcp_p->local);
  766. int32 signed_length = config->len;
  767. struct option_hdr option;
  768. int last_option = 0;
  769. int result;
  771. PPP_DEBUG_ROUTINES("ipcp_nak()");
  773. /* ID field must match last request we sent */
  774. if (config->id != fsm_p->lastid) {
  775. PPP_DEBUG_CHECKS("IPCP NAK: wrong ID");
  776. free_p(data);
  777. return -1;
  778. }
  780. /* First, process in order.  Then, process extra "important" options */
  781. while (signed_length > 0  &&  ntohopt(&option, data) != -1) {
  782. if ((signed_length -= option.len) < 0) {
  783. PPP_DEBUG_CHECKS("IPCP NAK: bad header length");
  784. free_p(data);
  785. return -1;
  786. }
  787. if ( option.type > IPCP_OPTION_LIMIT ) {
  788. PPP_DEBUG_CHECKS("IPCP NAK: option out of range");
  789. } else if ( option.type < last_option
  790.  || !(local_p->work.negotiate & (1 << option.type)) ) {
  791. if (local_p->work.negotiate & (1 << option.type)) {
  792. PPP_DEBUG_CHECKS("IPCP NAK: option out of order");
  793. free_p(data);
  794. return -1; /* was requested */
  795. }
  796. local_p->work.negotiate |= (1 << option.type);
  797. last_option = IPCP_OPTION_LIMIT + 1;
  798. } else {
  799. last_option = option.type;
  800. }
  801. if ( ( result = ipcp_check( data, ipcp_p,
  802. local_p, &option, FALSE ) ) == -1 ) {
  803. PPP_DEBUG_CHECKS("IPCP NAK: ran out of data");
  804. free_p(data);
  805. return -1;
  806. }
  807. /* update the negotiation status */
  808. if ( result == CONFIG_REJ
  809.   && option.type <= IPCP_OPTION_LIMIT ) {
  810. local_p->work.negotiate &= ~(1 << option.type);
  811. }
  812. }
  813. PPP_DEBUG_CHECKS("IPCP NAK: valid");
  814. free_p(data);
  815. return 0;
  816. }
  819. /************************************************************************/
  820. /* Process configuration reject sent by remote host */
  821. static int
  822. ipcp_reject(
  823. struct fsm_s *fsm_p,
  824. struct config_hdr *config,
  825. struct mbuf **data
  826. ){
  827. struct ipcp_s *ipcp_p = fsm_p->pdv;
  828. struct ipcp_side_s *local_p = &(ipcp_p->local);
  829. int32 signed_length = config->len;
  830. struct option_hdr option;
  831. int last_option = 0;
  833. PPP_DEBUG_ROUTINES("ipcp_reject()");
  835. /* ID field must match last request we sent */
  836. if (config->id != fsm_p->lastid) {
  837. PPP_DEBUG_CHECKS("IPCP REJ: wrong ID");
  838. free_p(data);
  839. return -1;
  840. }
  842. /* Process in order, checking for errors */
  843. while (signed_length > 0  &&  ntohopt(&option, data) != -1) {
  844. register int k;
  846. if ((signed_length -= option.len) < 0) {
  847. PPP_DEBUG_CHECKS("IPCP REJ: bad header length");
  848. free_p(data);
  849. return -1;
  850. }
  851. if ( option.type > IPCP_OPTION_LIMIT ) {
  852. PPP_DEBUG_CHECKS("IPCP REJ: option out of range");
  853. } else if (option.type < last_option
  854.  || !(local_p->work.negotiate & (1 << option.type))) {
  855. PPP_DEBUG_CHECKS("IPCP REJ: option out of order");
  856. free_p(data);
  857. return -1;
  858. }
  859. for ( k = option.len - OPTION_HDR_LEN; k-- > 0; ) {
  860. if ( pullchar(data) == -1 ) {
  861. PPP_DEBUG_CHECKS("IPCP REJ: ran out of data");
  862. free_p(data);
  863. return -1;
  864. }
  865. }
  866. last_option = option.type;
  868. if ( option.type <= IPCP_OPTION_LIMIT ) {
  869. local_p->work.negotiate &= ~(1 << option.type);
  870. }
  871. }
  872. PPP_DEBUG_CHECKS("IPCP REJ: valid");
  873. free_p(data);
  874. return 0;
  875. }
  878. /************************************************************************/
  879. /* I N I T I A L I Z A T I O N */
  880. /************************************************************************/
  882. /* Reset configuration options before request */
  883. static void
  884. ipcp_reset(fsm_p)
  885. struct fsm_s *fsm_p;
  886. {
  887. struct ipcp_s *ipcp_p = fsm_p->pdv;
  889. PPP_DEBUG_ROUTINES("ipcp_reset()");
  891. ASSIGN( ipcp_p->local.work, ipcp_p->local.want );
  892. ipcp_p->local.work.other = ipcp_p->remote.want.address;
  893. ipcp_p->local.will_negotiate |= ipcp_p->local.want.negotiate;
  895. ipcp_p->remote.work.negotiate = FALSE;
  896. ipcp_p->remote.will_negotiate |= ipcp_p->remote.want.negotiate;
  897. }
  900. /************************************************************************/
  901. /* After termination */
  902. static void
  903. ipcp_stopping(fsm_p)
  904. struct fsm_s *fsm_p;
  905. {
  906. PPP_DEBUG_ROUTINES("ipcp_stopping()");
  907. }
  910. /************************************************************************/
  911. /* Close IPCP */
  912. static void
  913. ipcp_closing(fsm_p)
  914. struct fsm_s *fsm_p;
  915. {
  916. struct ipcp_s *ipcp_p =  fsm_p->pdv;
  918. /* free old slhc configuration, if any */
  919. slhc_free( ipcp_p->slhcp );
  920. ipcp_p->slhcp = NULL;
  922. #ifdef notdef
  923. if (PPPtrace > 1)
  924. trace_log(PPPiface,"%s PPP/IPCP Drop route to peer (%s)",
  925. ifp->name,
  926. inet_ntoa(ipcp_p->local.work.other);
  928. rt_drop(ipcp_p->local.work.other, (unsigned int)32);
  929. #endif
  930. }
  933. /************************************************************************/
  934. /* configuration negotiation complete */
  935. static void
  936. ipcp_opening(fsm_p)
  937. struct fsm_s *fsm_p;
  938. {
  939. struct ipcp_s *ipcp_p =  fsm_p->pdv;
  940. struct iface *ifp =  fsm_p->ppp_p->iface;
  941. int32 address = ipcp_p->local.work.address;
  942. int rslots = 0;
  943. int tslots = 0;
  945. /* Set our IP address to reflect negotiated option */
  946. if (address != ifp->addr) {
  947. /* address not the same as last time */
  948. if (Ip_addr == 0L) {
  949. /* no global address */
  950. Ip_addr = address;
  951. } else if ( Ip_addr == ifp->addr ) {
  952. /* global was same as local; must be replaced */
  953. /* !!! TO DO: reset tcp connections */
  954. Ip_addr = address;
  955. }
  956. ifp->addr = address;
  958. if (PPPtrace > 1)
  959. trace_log(PPPiface,"%s PPP/IPCP Setting new IP address: %s",
  960. ifp->name,
  961. inet_ntoa(address));
  962. }
  964. #ifdef notdef
  965. rt_add(ipcp_p->local.work.other, (unsigned int)32, (int32)0,
  966. ifp, (int32)1, (int32)0, (char)1);
  968. if (PPPtrace > 1)
  969. trace_log(PPPiface,"%s PPP/IPCP Add route to peer (%s)",
  970. ifp->name,
  971. inet_ntoa(ipcp_p->local.work.other);
  972. #endif
  974. /* free old slhc configuration, if any */
  975. slhc_free( ipcp_p->slhcp );
  976. ipcp_p->slhcp = NULL;
  978. if (ipcp_p->local.work.negotiate & IPCP_N_COMPRESS) {
  979. rslots = ipcp_p->local.work.slots;
  980. }
  981. if (ipcp_p->remote.work.negotiate & IPCP_N_COMPRESS) {
  982. tslots = ipcp_p->remote.work.slots;
  983. }
  985. if ( rslots != 0 || tslots != 0 ) {
  986. ipcp_p->slhcp = slhc_init( rslots, tslots );
  988. if (PPPtrace > 1)
  989. trace_log(PPPiface,"%s PPP/IPCP Compression enabled;"
  990. " Recv slots = %d, flag = %x;"
  991. " Xmit slots = %d, flag = %x",
  992. ifp->name,
  993. rslots,
  994. ipcp_p->local.work.slot_compress,
  995. tslots,
  996. ipcp_p->remote.work.slot_compress);
  997. }
  998. }
  1001. /************************************************************************/
  1002. /* Check the address against all other assigned addresses */
  1003. static int32
  1004. ipcp_addr_idle(addr)
  1005. int32 addr;
  1006. {
  1007. struct iface *ifp;
  1009. /* Check if peer IP address is already in use on another interface */
  1010. /* !!! need to look at *remote* address, not local! */
  1011. for (ifp=Ifaces; ifp != NULL; ifp = ifp->next) {
  1012. if (ifp->addr == addr)
  1013. return 0L;
  1014. }
  1015. return addr;
  1016. }
  1019. /************************************************************************/
  1020. /* Assign the next unused address from a pool */
  1021. static int32
  1022. ipcp_poolnext(ipcp_p)
  1023. struct ipcp_s *ipcp_p;
  1024. {
  1025. int32 i = 1L + ipcp_p->peer_max - ipcp_p->peer_min;
  1026. int32 nextaddr = 0L;
  1028. while ( i-- > 0  &&  nextaddr == 0L ) {
  1029. if (++ipcp_p->local.want.other < ipcp_p->peer_min
  1030.  || ipcp_p->local.want.other > ipcp_p->peer_max)
  1031. ipcp_p->local.want.other = ipcp_p->peer_min;
  1033. nextaddr = ipcp_addr_idle(ipcp_p->local.want.other);
  1034. }
  1035. return(nextaddr);
  1036. }
  1039. /************************************************************************/
  1040. /* Check if we have a specific IP address to assign to remote peer host */
  1041. /* !!! TO DO: subnet mask, and routing */
  1042. static int32
  1043. ipcp_lookuppeer(peerid)
  1044. char *peerid;
  1045. {
  1046. char *buf;
  1047. int32 peer_addr = 0L;
  1049. if (peerid == NULL)
  1050. return 0L;
  1052. if ( (buf = userlookup( peerid, NULL, NULL,
  1053. NULL, &peer_addr )) != NULL ) {
  1054. free(buf);
  1055. }
  1056. return(peer_addr);
  1057. }
  1060. /************************************************************************/
  1061. /* Prepare to begin configuration exchange */
  1062. static void
  1063. ipcp_starting(fsm_p)
  1064. struct fsm_s *fsm_p;
  1065. {
  1066. struct ipcp_s *ipcp_p = fsm_p->pdv;
  1068. PPP_DEBUG_ROUTINES("ipcp_starting()");
  1070. /* If not already set, and we know the name of the peer,
  1071.  * look in login file for an address
  1072.  */
  1073. if ( ipcp_p->remote.want.address == 0L ){
  1074. ipcp_p->remote.want.address
  1075. = ipcp_lookuppeer(fsm_p->ppp_p->peername);
  1076. }
  1078. /* If available, get next address from PPP pool */
  1079. if ((ipcp_p->remote.want.address == 0L)
  1080.  && (ipcp_p->peer_min != 0L)) {
  1081. ipcp_p->remote.want.address = ipcp_poolnext(ipcp_p);
  1082. }
  1084. ipcp_p->local.want.address = fsm_p->ppp_p->iface->addr;
  1085. }
  1088. /************************************************************************/
  1089. static void
  1090. ipcp_free(fsm_p)
  1091. struct fsm_s *fsm_p;
  1092. {
  1093. struct ipcp_s *ipcp_p = fsm_p->pdv;
  1095. slhc_free( ipcp_p->slhcp );
  1096. }
  1099. /* Initialize configuration structure */
  1100. void
  1101. ipcp_init(ppp_p)
  1102. struct ppp_s *ppp_p;
  1103. {
  1104. struct fsm_s *fsm_p = &(ppp_p->fsm[IPcp]);
  1105. struct ipcp_s *ipcp_p;
  1107. PPPtrace = ppp_p->trace;
  1108. PPPiface = ppp_p->iface;
  1110. PPP_DEBUG_ROUTINES("ipcp_init()");
  1112. fsm_p->ppp_p = ppp_p;
  1113. fsm_p->pdc = &ipcp_constants;
  1114. fsm_p->pdv =
  1115. ipcp_p = callocw(1,sizeof(struct ipcp_s));
  1117. /* Set option parameters to first request defaults */
  1118. ASSIGN( ipcp_p->local.want, ipcp_default );
  1119. ipcp_p->local.will_negotiate = ipcp_negotiate;
  1121. ASSIGN( ipcp_p->remote.want, ipcp_default );
  1122. ASSIGN( ipcp_p->remote.work, ipcp_default);
  1123. ipcp_p->remote.will_negotiate = ipcp_negotiate;
  1125. fsm_init(fsm_p);
  1126. }