1 /***************************************************************************** 2 * ppp.h - Network Point to Point Protocol header file. 3 * 4 * Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc. 5 * portions Copyright (c) 1997 Global Election Systems Inc. 6 * 7 * The authors hereby grant permission to use, copy, modify, distribute, 8 * and license this software and its documentation for any purpose, provided 9 * that existing copyright notices are retained in all copies and that this 10 * notice and the following disclaimer are included verbatim in any 11 * distributions. No written agreement, license, or royalty fee is required 12 * for any of the authorized uses. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS *AS IS* AND ANY EXPRESS OR 15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 17 * IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24 * 25 ****************************************************************************** 26 * REVISION HISTORY 27 * 28 * 03-01-01 Marc Boucher <[email protected]> 29 * Ported to lwIP. 30 * 97-11-05 Guy Lancaster <[email protected]>, Global Election Systems Inc. 31 * Original derived from BSD codes. 32 *****************************************************************************/ 33 34 #include "netif/ppp/ppp_opts.h" 35 #if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ 36 37 #ifndef PPP_H 38 #define PPP_H 39 40 #include "lwip/def.h" 41 #include "lwip/stats.h" 42 #include "lwip/mem.h" 43 #include "lwip/netif.h" 44 #include "lwip/sys.h" 45 #include "lwip/timeouts.h" 46 #if PPP_IPV6_SUPPORT 47 #include "lwip/ip6_addr.h" 48 #endif /* PPP_IPV6_SUPPORT */ 49 50 /* Disable non-working or rarely used PPP feature, so rarely that we don't want to bloat ppp_opts.h with them */ 51 #ifndef PPP_OPTIONS 52 #define PPP_OPTIONS 0 53 #endif 54 55 #ifndef PPP_NOTIFY 56 #define PPP_NOTIFY 0 57 #endif 58 59 #ifndef PPP_REMOTENAME 60 #define PPP_REMOTENAME 0 61 #endif 62 63 #ifndef PPP_IDLETIMELIMIT 64 #define PPP_IDLETIMELIMIT 0 65 #endif 66 67 #ifndef PPP_LCP_ADAPTIVE 68 #define PPP_LCP_ADAPTIVE 0 69 #endif 70 71 #ifndef PPP_MAXCONNECT 72 #define PPP_MAXCONNECT 0 73 #endif 74 75 #ifndef PPP_ALLOWED_ADDRS 76 #define PPP_ALLOWED_ADDRS 0 77 #endif 78 79 #ifndef PPP_PROTOCOLNAME 80 #define PPP_PROTOCOLNAME 0 81 #endif 82 83 #ifndef PPP_STATS_SUPPORT 84 #define PPP_STATS_SUPPORT 0 85 #endif 86 87 #ifndef DEFLATE_SUPPORT 88 #define DEFLATE_SUPPORT 0 89 #endif 90 91 #ifndef BSDCOMPRESS_SUPPORT 92 #define BSDCOMPRESS_SUPPORT 0 93 #endif 94 95 #ifndef PREDICTOR_SUPPORT 96 #define PREDICTOR_SUPPORT 0 97 #endif 98 99 /************************* 100 *** PUBLIC DEFINITIONS *** 101 *************************/ 102 103 /* 104 * The basic PPP frame. 105 */ 106 #define PPP_HDRLEN 4 /* octets for standard ppp header */ 107 #define PPP_FCSLEN 2 /* octets for FCS */ 108 109 /* 110 * Values for phase. 111 */ 112 #define PPP_PHASE_DEAD 0 113 #define PPP_PHASE_MASTER 1 114 #define PPP_PHASE_HOLDOFF 2 115 #define PPP_PHASE_INITIALIZE 3 116 #define PPP_PHASE_SERIALCONN 4 117 #define PPP_PHASE_DORMANT 5 118 #define PPP_PHASE_ESTABLISH 6 119 #define PPP_PHASE_AUTHENTICATE 7 120 #define PPP_PHASE_CALLBACK 8 121 #define PPP_PHASE_NETWORK 9 122 #define PPP_PHASE_RUNNING 10 123 #define PPP_PHASE_TERMINATE 11 124 #define PPP_PHASE_DISCONNECT 12 125 126 /* Error codes. */ 127 #define PPPERR_NONE 0 /* No error. */ 128 #define PPPERR_PARAM 1 /* Invalid parameter. */ 129 #define PPPERR_OPEN 2 /* Unable to open PPP session. */ 130 #define PPPERR_DEVICE 3 /* Invalid I/O device for PPP. */ 131 #define PPPERR_ALLOC 4 /* Unable to allocate resources. */ 132 #define PPPERR_USER 5 /* User interrupt. */ 133 #define PPPERR_CONNECT 6 /* Connection lost. */ 134 #define PPPERR_AUTHFAIL 7 /* Failed authentication challenge. */ 135 #define PPPERR_PROTOCOL 8 /* Failed to meet protocol. */ 136 #define PPPERR_PEERDEAD 9 /* Connection timeout */ 137 #define PPPERR_IDLETIMEOUT 10 /* Idle Timeout */ 138 #define PPPERR_CONNECTTIME 11 /* Max connect time reached */ 139 #define PPPERR_LOOPBACK 12 /* Loopback detected */ 140 141 /* Whether auth support is enabled at all */ 142 #define PPP_AUTH_SUPPORT (PAP_SUPPORT || CHAP_SUPPORT || EAP_SUPPORT) 143 144 /************************ 145 *** PUBLIC DATA TYPES *** 146 ************************/ 147 148 /* 149 * Other headers require ppp_pcb definition for prototypes, but ppp_pcb 150 * require some structure definition from other headers as well, we are 151 * fixing the dependency loop here by declaring the ppp_pcb type then 152 * by including headers containing necessary struct definition for ppp_pcb 153 */ 154 typedef struct ppp_pcb_s ppp_pcb; 155 156 /* Type definitions for BSD code. */ 157 #ifndef __u_char_defined 158 typedef unsigned long u_long; 159 typedef unsigned int u_int; 160 typedef unsigned short u_short; 161 typedef unsigned char u_char; 162 #endif 163 164 #include "fsm.h" 165 #include "lcp.h" 166 #if CCP_SUPPORT 167 #include "ccp.h" 168 #endif /* CCP_SUPPORT */ 169 #if MPPE_SUPPORT 170 #include "mppe.h" 171 #endif /* MPPE_SUPPORT */ 172 #if PPP_IPV4_SUPPORT 173 #include "ipcp.h" 174 #endif /* PPP_IPV4_SUPPORT */ 175 #if PPP_IPV6_SUPPORT 176 #include "ipv6cp.h" 177 #endif /* PPP_IPV6_SUPPORT */ 178 #if PAP_SUPPORT 179 #include "upap.h" 180 #endif /* PAP_SUPPORT */ 181 #if CHAP_SUPPORT 182 #include "chap-new.h" 183 #endif /* CHAP_SUPPORT */ 184 #if EAP_SUPPORT 185 #include "eap.h" 186 #endif /* EAP_SUPPORT */ 187 #if VJ_SUPPORT 188 #include "vj.h" 189 #endif /* VJ_SUPPORT */ 190 191 /* Link status callback function prototype */ 192 typedef void (*ppp_link_status_cb_fn)(ppp_pcb *pcb, int err_code, void *ctx); 193 194 /* 195 * PPP configuration. 196 */ 197 typedef struct ppp_settings_s { 198 199 #if PPP_SERVER && PPP_AUTH_SUPPORT 200 unsigned int auth_required :1; /* Peer is required to authenticate */ 201 unsigned int null_login :1; /* Username of "" and a password of "" are acceptable */ 202 #endif /* PPP_SERVER && PPP_AUTH_SUPPORT */ 203 #if PPP_REMOTENAME 204 unsigned int explicit_remote :1; /* remote_name specified with remotename opt */ 205 #endif /* PPP_REMOTENAME */ 206 #if PAP_SUPPORT 207 unsigned int refuse_pap :1; /* Don't proceed auth. with PAP */ 208 #endif /* PAP_SUPPORT */ 209 #if CHAP_SUPPORT 210 unsigned int refuse_chap :1; /* Don't proceed auth. with CHAP */ 211 #endif /* CHAP_SUPPORT */ 212 #if MSCHAP_SUPPORT 213 unsigned int refuse_mschap :1; /* Don't proceed auth. with MS-CHAP */ 214 unsigned int refuse_mschap_v2 :1; /* Don't proceed auth. with MS-CHAPv2 */ 215 #endif /* MSCHAP_SUPPORT */ 216 #if EAP_SUPPORT 217 unsigned int refuse_eap :1; /* Don't proceed auth. with EAP */ 218 #endif /* EAP_SUPPORT */ 219 #if LWIP_DNS 220 unsigned int usepeerdns :1; /* Ask peer for DNS adds */ 221 #endif /* LWIP_DNS */ 222 unsigned int persist :1; /* Persist mode, always try to open the connection */ 223 #if PRINTPKT_SUPPORT 224 unsigned int hide_password :1; /* Hide password in dumped packets */ 225 #endif /* PRINTPKT_SUPPORT */ 226 unsigned int noremoteip :1; /* Let him have no IP address */ 227 unsigned int lax_recv :1; /* accept control chars in asyncmap */ 228 unsigned int noendpoint :1; /* don't send/accept endpoint discriminator */ 229 #if PPP_LCP_ADAPTIVE 230 unsigned int lcp_echo_adaptive :1; /* request echo only if the link was idle */ 231 #endif /* PPP_LCP_ADAPTIVE */ 232 #if MPPE_SUPPORT 233 unsigned int require_mppe :1; /* Require MPPE (Microsoft Point to Point Encryption) */ 234 unsigned int refuse_mppe_40 :1; /* Allow MPPE 40-bit mode? */ 235 unsigned int refuse_mppe_128 :1; /* Allow MPPE 128-bit mode? */ 236 unsigned int refuse_mppe_stateful :1; /* Allow MPPE stateful mode? */ 237 #endif /* MPPE_SUPPORT */ 238 239 u16_t listen_time; /* time to listen first (ms), waiting for peer to send LCP packet */ 240 241 #if PPP_IDLETIMELIMIT 242 u16_t idle_time_limit; /* Disconnect if idle for this many seconds */ 243 #endif /* PPP_IDLETIMELIMIT */ 244 #if PPP_MAXCONNECT 245 u32_t maxconnect; /* Maximum connect time (seconds) */ 246 #endif /* PPP_MAXCONNECT */ 247 248 #if PPP_AUTH_SUPPORT 249 /* auth data */ 250 const char *user; /* Username for PAP */ 251 const char *passwd; /* Password for PAP, secret for CHAP */ 252 #if PPP_REMOTENAME 253 char remote_name[MAXNAMELEN + 1]; /* Peer's name for authentication */ 254 #endif /* PPP_REMOTENAME */ 255 256 #if PAP_SUPPORT 257 u8_t pap_timeout_time; /* Timeout (seconds) for auth-req retrans. */ 258 u8_t pap_max_transmits; /* Number of auth-reqs sent */ 259 #if PPP_SERVER 260 u8_t pap_req_timeout; /* Time to wait for auth-req from peer */ 261 #endif /* PPP_SERVER */ 262 #endif /* PAP_SUPPPORT */ 263 264 #if CHAP_SUPPORT 265 u8_t chap_timeout_time; /* Timeout (seconds) for retransmitting req */ 266 u8_t chap_max_transmits; /* max # times to send challenge */ 267 #if PPP_SERVER 268 u8_t chap_rechallenge_time; /* Time to wait for auth-req from peer */ 269 #endif /* PPP_SERVER */ 270 #endif /* CHAP_SUPPPORT */ 271 272 #if EAP_SUPPORT 273 u8_t eap_req_time; /* Time to wait (for retransmit/fail) */ 274 u8_t eap_allow_req; /* Max Requests allowed */ 275 #if PPP_SERVER 276 u8_t eap_timeout_time; /* Time to wait (for retransmit/fail) */ 277 u8_t eap_max_transmits; /* Max Requests allowed */ 278 #endif /* PPP_SERVER */ 279 #endif /* EAP_SUPPORT */ 280 281 #endif /* PPP_AUTH_SUPPORT */ 282 283 u8_t fsm_timeout_time; /* Timeout time in seconds */ 284 u8_t fsm_max_conf_req_transmits; /* Maximum Configure-Request transmissions */ 285 u8_t fsm_max_term_transmits; /* Maximum Terminate-Request transmissions */ 286 u8_t fsm_max_nak_loops; /* Maximum number of nak loops tolerated */ 287 288 u8_t lcp_loopbackfail; /* Number of times we receive our magic number from the peer 289 before deciding the link is looped-back. */ 290 u8_t lcp_echo_interval; /* Interval between LCP echo-requests */ 291 u8_t lcp_echo_fails; /* Tolerance to unanswered echo-requests */ 292 293 } ppp_settings; 294 295 #if PPP_SERVER 296 struct ppp_addrs { 297 #if PPP_IPV4_SUPPORT 298 ip4_addr_t our_ipaddr, his_ipaddr, netmask; 299 #if LWIP_DNS 300 ip4_addr_t dns1, dns2; 301 #endif /* LWIP_DNS */ 302 #endif /* PPP_IPV4_SUPPORT */ 303 #if PPP_IPV6_SUPPORT 304 ip6_addr_t our6_ipaddr, his6_ipaddr; 305 #endif /* PPP_IPV6_SUPPORT */ 306 }; 307 #endif /* PPP_SERVER */ 308 309 /* 310 * PPP interface control block. 311 */ 312 struct ppp_pcb_s { 313 ppp_settings settings; 314 const struct link_callbacks *link_cb; 315 void *link_ctx_cb; 316 void (*link_status_cb)(ppp_pcb *pcb, int err_code, void *ctx); /* Status change callback */ 317 #if PPP_NOTIFY_PHASE 318 void (*notify_phase_cb)(ppp_pcb *pcb, u8_t phase, void *ctx); /* Notify phase callback */ 319 #endif /* PPP_NOTIFY_PHASE */ 320 void *ctx_cb; /* Callbacks optional pointer */ 321 struct netif *netif; /* PPP interface */ 322 u8_t phase; /* where the link is at */ 323 u8_t err_code; /* Code indicating why interface is down. */ 324 325 /* flags */ 326 #if PPP_IPV4_SUPPORT 327 unsigned int ask_for_local :1; /* request our address from peer */ 328 unsigned int ipcp_is_open :1; /* haven't called np_finished() */ 329 unsigned int ipcp_is_up :1; /* have called ipcp_up() */ 330 unsigned int if4_up :1; /* True when the IPv4 interface is up. */ 331 #if 0 /* UNUSED - PROXY ARP */ 332 unsigned int proxy_arp_set :1; /* Have created proxy arp entry */ 333 #endif /* UNUSED - PROXY ARP */ 334 #endif /* PPP_IPV4_SUPPORT */ 335 #if PPP_IPV6_SUPPORT 336 unsigned int ipv6cp_is_up :1; /* have called ip6cp_up() */ 337 unsigned int if6_up :1; /* True when the IPv6 interface is up. */ 338 #endif /* PPP_IPV6_SUPPORT */ 339 unsigned int lcp_echo_timer_running :1; /* set if a timer is running */ 340 #if VJ_SUPPORT 341 unsigned int vj_enabled :1; /* Flag indicating VJ compression enabled. */ 342 #endif /* VJ_SUPPORT */ 343 #if CCP_SUPPORT 344 unsigned int ccp_all_rejected :1; /* we rejected all peer's options */ 345 #endif /* CCP_SUPPORT */ 346 #if MPPE_SUPPORT 347 unsigned int mppe_keys_set :1; /* Have the MPPE keys been set? */ 348 #endif /* MPPE_SUPPORT */ 349 350 #if PPP_AUTH_SUPPORT 351 /* auth data */ 352 #if PPP_SERVER && defined(HAVE_MULTILINK) 353 char peer_authname[MAXNAMELEN + 1]; /* The name by which the peer authenticated itself to us. */ 354 #endif /* PPP_SERVER && defined(HAVE_MULTILINK) */ 355 u16_t auth_pending; /* Records which authentication operations haven't completed yet. */ 356 u16_t auth_done; /* Records which authentication operations have been completed. */ 357 358 #if PAP_SUPPORT 359 upap_state upap; /* PAP data */ 360 #endif /* PAP_SUPPORT */ 361 362 #if CHAP_SUPPORT 363 chap_client_state chap_client; /* CHAP client data */ 364 #if PPP_SERVER 365 chap_server_state chap_server; /* CHAP server data */ 366 #endif /* PPP_SERVER */ 367 #endif /* CHAP_SUPPORT */ 368 369 #if EAP_SUPPORT 370 eap_state eap; /* EAP data */ 371 #endif /* EAP_SUPPORT */ 372 #endif /* PPP_AUTH_SUPPORT */ 373 374 fsm lcp_fsm; /* LCP fsm structure */ 375 lcp_options lcp_wantoptions; /* Options that we want to request */ 376 lcp_options lcp_gotoptions; /* Options that peer ack'd */ 377 lcp_options lcp_allowoptions; /* Options we allow peer to request */ 378 lcp_options lcp_hisoptions; /* Options that we ack'd */ 379 u16_t peer_mru; /* currently negotiated peer MRU */ 380 u8_t lcp_echos_pending; /* Number of outstanding echo msgs */ 381 u8_t lcp_echo_number; /* ID number of next echo frame */ 382 383 u8_t num_np_open; /* Number of network protocols which we have opened. */ 384 u8_t num_np_up; /* Number of network protocols which have come up. */ 385 386 #if VJ_SUPPORT 387 struct vjcompress vj_comp; /* Van Jacobson compression header. */ 388 #endif /* VJ_SUPPORT */ 389 390 #if CCP_SUPPORT 391 fsm ccp_fsm; /* CCP fsm structure */ 392 ccp_options ccp_wantoptions; /* what to request the peer to use */ 393 ccp_options ccp_gotoptions; /* what the peer agreed to do */ 394 ccp_options ccp_allowoptions; /* what we'll agree to do */ 395 ccp_options ccp_hisoptions; /* what we agreed to do */ 396 u8_t ccp_localstate; /* Local state (mainly for handling reset-reqs and reset-acks). */ 397 u8_t ccp_receive_method; /* Method chosen on receive path */ 398 u8_t ccp_transmit_method; /* Method chosen on transmit path */ 399 #if MPPE_SUPPORT 400 ppp_mppe_state mppe_comp; /* MPPE "compressor" structure */ 401 ppp_mppe_state mppe_decomp; /* MPPE "decompressor" structure */ 402 #endif /* MPPE_SUPPORT */ 403 #endif /* CCP_SUPPORT */ 404 405 #if PPP_IPV4_SUPPORT 406 fsm ipcp_fsm; /* IPCP fsm structure */ 407 ipcp_options ipcp_wantoptions; /* Options that we want to request */ 408 ipcp_options ipcp_gotoptions; /* Options that peer ack'd */ 409 ipcp_options ipcp_allowoptions; /* Options we allow peer to request */ 410 ipcp_options ipcp_hisoptions; /* Options that we ack'd */ 411 #endif /* PPP_IPV4_SUPPORT */ 412 413 #if PPP_IPV6_SUPPORT 414 fsm ipv6cp_fsm; /* IPV6CP fsm structure */ 415 ipv6cp_options ipv6cp_wantoptions; /* Options that we want to request */ 416 ipv6cp_options ipv6cp_gotoptions; /* Options that peer ack'd */ 417 ipv6cp_options ipv6cp_allowoptions; /* Options we allow peer to request */ 418 ipv6cp_options ipv6cp_hisoptions; /* Options that we ack'd */ 419 #endif /* PPP_IPV6_SUPPORT */ 420 }; 421 422 /************************ 423 *** PUBLIC FUNCTIONS *** 424 ************************/ 425 426 /* 427 * WARNING: For multi-threads environment, all ppp_set_* functions most 428 * only be called while the PPP is in the dead phase (i.e. disconnected). 429 */ 430 431 #if PPP_AUTH_SUPPORT 432 /* 433 * Set PPP authentication. 434 * 435 * Warning: Using PPPAUTHTYPE_ANY might have security consequences. 436 * RFC 1994 says: 437 * 438 * In practice, within or associated with each PPP server, there is a 439 * database which associates "user" names with authentication 440 * information ("secrets"). It is not anticipated that a particular 441 * named user would be authenticated by multiple methods. This would 442 * make the user vulnerable to attacks which negotiate the least secure 443 * method from among a set (such as PAP rather than CHAP). If the same 444 * secret was used, PAP would reveal the secret to be used later with 445 * CHAP. 446 * 447 * Instead, for each user name there should be an indication of exactly 448 * one method used to authenticate that user name. If a user needs to 449 * make use of different authentication methods under different 450 * circumstances, then distinct user names SHOULD be employed, each of 451 * which identifies exactly one authentication method. 452 * 453 * Default is none auth type, unset (NULL) user and passwd. 454 */ 455 #define PPPAUTHTYPE_NONE 0x00 456 #define PPPAUTHTYPE_PAP 0x01 457 #define PPPAUTHTYPE_CHAP 0x02 458 #define PPPAUTHTYPE_MSCHAP 0x04 459 #define PPPAUTHTYPE_MSCHAP_V2 0x08 460 #define PPPAUTHTYPE_EAP 0x10 461 #define PPPAUTHTYPE_ANY 0xff 462 void ppp_set_auth(ppp_pcb *pcb, u8_t authtype, const char *user, const char *passwd); 463 464 /* 465 * If set, peer is required to authenticate. This is mostly necessary for PPP server support. 466 * 467 * Default is false. 468 */ 469 #define ppp_set_auth_required(ppp, boolval) (ppp->settings.auth_required = boolval) 470 #endif /* PPP_AUTH_SUPPORT */ 471 472 #if PPP_IPV4_SUPPORT 473 /* 474 * Set PPP interface "our" and "his" IPv4 addresses. This is mostly necessary for PPP server 475 * support but it can also be used on a PPP link where each side choose its own IP address. 476 * 477 * Default is unset (0.0.0.0). 478 */ 479 #define ppp_set_ipcp_ouraddr(ppp, addr) do { ppp->ipcp_wantoptions.ouraddr = ip4_addr_get_u32(addr); \ 480 ppp->ask_for_local = ppp->ipcp_wantoptions.ouraddr != 0; } while(0) 481 #define ppp_set_ipcp_hisaddr(ppp, addr) (ppp->ipcp_wantoptions.hisaddr = ip4_addr_get_u32(addr)) 482 #if LWIP_DNS 483 /* 484 * Set DNS server addresses that are sent if the peer asks for them. This is mostly necessary 485 * for PPP server support. 486 * 487 * Default is unset (0.0.0.0). 488 */ 489 #define ppp_set_ipcp_dnsaddr(ppp, index, addr) (ppp->ipcp_allowoptions.dnsaddr[index] = ip4_addr_get_u32(addr)) 490 491 /* 492 * If set, we ask the peer for up to 2 DNS server addresses. Received DNS server addresses are 493 * registered using the dns_setserver() function. 494 * 495 * Default is false. 496 */ 497 #define ppp_set_usepeerdns(ppp, boolval) (ppp->settings.usepeerdns = boolval) 498 #endif /* LWIP_DNS */ 499 #endif /* PPP_IPV4_SUPPORT */ 500 501 #if MPPE_SUPPORT 502 /* Disable MPPE (Microsoft Point to Point Encryption). This parameter is exclusive. */ 503 #define PPP_MPPE_DISABLE 0x00 504 /* Require the use of MPPE (Microsoft Point to Point Encryption). */ 505 #define PPP_MPPE_ENABLE 0x01 506 /* Allow MPPE to use stateful mode. Stateless mode is still attempted first. */ 507 #define PPP_MPPE_ALLOW_STATEFUL 0x02 508 /* Refuse the use of MPPE with 40-bit encryption. Conflict with PPP_MPPE_REFUSE_128. */ 509 #define PPP_MPPE_REFUSE_40 0x04 510 /* Refuse the use of MPPE with 128-bit encryption. Conflict with PPP_MPPE_REFUSE_40. */ 511 #define PPP_MPPE_REFUSE_128 0x08 512 /* 513 * Set MPPE configuration 514 * 515 * Default is disabled. 516 */ 517 void ppp_set_mppe(ppp_pcb *pcb, u8_t flags); 518 #endif /* MPPE_SUPPORT */ 519 520 /* 521 * Wait for up to intval milliseconds for a valid PPP packet from the peer. 522 * At the end of this time, or when a valid PPP packet is received from the 523 * peer, we commence negotiation by sending our first LCP packet. 524 * 525 * Default is 0. 526 */ 527 #define ppp_set_listen_time(ppp, intval) (ppp->settings.listen_time = intval) 528 529 /* 530 * If set, we will attempt to initiate a connection but if no reply is received from 531 * the peer, we will then just wait passively for a valid LCP packet from the peer. 532 * 533 * Default is false. 534 */ 535 #define ppp_set_passive(ppp, boolval) (ppp->lcp_wantoptions.passive = boolval) 536 537 /* 538 * If set, we will not transmit LCP packets to initiate a connection until a valid 539 * LCP packet is received from the peer. This is what we usually call the server mode. 540 * 541 * Default is false. 542 */ 543 #define ppp_set_silent(ppp, boolval) (ppp->lcp_wantoptions.silent = boolval) 544 545 /* 546 * If set, enable protocol field compression negotiation in both the receive and 547 * the transmit direction. 548 * 549 * Default is true. 550 */ 551 #define ppp_set_neg_pcomp(ppp, boolval) (ppp->lcp_wantoptions.neg_pcompression = \ 552 ppp->lcp_allowoptions.neg_pcompression = boolval) 553 554 /* 555 * If set, enable Address/Control compression in both the receive and the transmit 556 * direction. 557 * 558 * Default is true. 559 */ 560 #define ppp_set_neg_accomp(ppp, boolval) (ppp->lcp_wantoptions.neg_accompression = \ 561 ppp->lcp_allowoptions.neg_accompression = boolval) 562 563 /* 564 * If set, enable asyncmap negotiation. Otherwise forcing all control characters to 565 * be escaped for both the transmit and the receive direction. 566 * 567 * Default is true. 568 */ 569 #define ppp_set_neg_asyncmap(ppp, boolval) (ppp->lcp_wantoptions.neg_asyncmap = \ 570 ppp->lcp_allowoptions.neg_asyncmap = boolval) 571 572 /* 573 * This option sets the Async-Control-Character-Map (ACCM) for this end of the link. 574 * The ACCM is a set of 32 bits, one for each of the ASCII control characters with 575 * values from 0 to 31, where a 1 bit indicates that the corresponding control 576 * character should not be used in PPP packets sent to this system. The map is 577 * an unsigned 32 bits integer where the least significant bit (00000001) represents 578 * character 0 and the most significant bit (80000000) represents character 31. 579 * We will then ask the peer to send these characters as a 2-byte escape sequence. 580 * 581 * Default is 0. 582 */ 583 #define ppp_set_asyncmap(ppp, intval) (ppp->lcp_wantoptions.asyncmap = intval) 584 585 /* 586 * Set a PPP interface as the default network interface 587 * (used to output all packets for which no specific route is found). 588 */ 589 #define ppp_set_default(ppp) netif_set_default(ppp->netif) 590 591 #if PPP_NOTIFY_PHASE 592 /* 593 * Set a PPP notify phase callback. 594 * 595 * This can be used for example to set a LED pattern depending on the 596 * current phase of the PPP session. 597 */ 598 typedef void (*ppp_notify_phase_cb_fn)(ppp_pcb *pcb, u8_t phase, void *ctx); 599 void ppp_set_notify_phase_callback(ppp_pcb *pcb, ppp_notify_phase_cb_fn notify_phase_cb); 600 #endif /* PPP_NOTIFY_PHASE */ 601 602 /* 603 * Initiate a PPP connection. 604 * 605 * This can only be called if PPP is in the dead phase. 606 * 607 * Holdoff is the time to wait (in seconds) before initiating 608 * the connection. 609 * 610 * If this port connects to a modem, the modem connection must be 611 * established before calling this. 612 */ 613 err_t ppp_connect(ppp_pcb *pcb, u16_t holdoff); 614 615 #if PPP_SERVER 616 /* 617 * Listen for an incoming PPP connection. 618 * 619 * This can only be called if PPP is in the dead phase. 620 * 621 * If this port connects to a modem, the modem connection must be 622 * established before calling this. 623 */ 624 err_t ppp_listen(ppp_pcb *pcb); 625 #endif /* PPP_SERVER */ 626 627 /* 628 * Initiate the end of a PPP connection. 629 * Any outstanding packets in the queues are dropped. 630 * 631 * Setting nocarrier to 1 close the PPP connection without initiating the 632 * shutdown procedure. Always using nocarrier = 0 is still recommended, 633 * this is going to take a little longer time if your link is down, but 634 * is a safer choice for the PPP state machine. 635 * 636 * Return 0 on success, an error code on failure. 637 */ 638 err_t ppp_close(ppp_pcb *pcb, u8_t nocarrier); 639 640 /* 641 * Release the control block. 642 * 643 * This can only be called if PPP is in the dead phase. 644 * 645 * You must use ppp_close() before if you wish to terminate 646 * an established PPP session. 647 * 648 * Return 0 on success, an error code on failure. 649 */ 650 err_t ppp_free(ppp_pcb *pcb); 651 652 /* 653 * PPP IOCTL commands. 654 * 655 * Get the up status - 0 for down, non-zero for up. The argument must 656 * point to an int. 657 */ 658 #define PPPCTLG_UPSTATUS 0 659 660 /* 661 * Get the PPP error code. The argument must point to an int. 662 * Returns a PPPERR_* value. 663 */ 664 #define PPPCTLG_ERRCODE 1 665 666 /* 667 * Get the fd associated with a PPP over serial 668 */ 669 #define PPPCTLG_FD 2 670 671 /* 672 * Get and set parameters for the given connection. 673 * Return 0 on success, an error code on failure. 674 */ 675 err_t ppp_ioctl(ppp_pcb *pcb, u8_t cmd, void *arg); 676 677 /* Get the PPP netif interface */ 678 #define ppp_netif(ppp) (ppp->netif) 679 680 /* Set an lwIP-style status-callback for the selected PPP device */ 681 #define ppp_set_netif_statuscallback(ppp, status_cb) \ 682 netif_set_status_callback(ppp->netif, status_cb); 683 684 /* Set an lwIP-style link-callback for the selected PPP device */ 685 #define ppp_set_netif_linkcallback(ppp, link_cb) \ 686 netif_set_link_callback(ppp->netif, link_cb); 687 688 #endif /* PPP_H */ 689 690 #endif /* PPP_SUPPORT */ 691