source: azure_iot_hub_f767zi/trunk/asp_baseplatform/lwip/lwip-2.1.2/src/netif/ppp/chap-new.c@ 457

Last change on this file since 457 was 457, checked in by coas-nagasima, 4 years ago

ファイルを追加
  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-csrc;charset=UTF-8
File size: 18.7 KB
Line 
1/*
2 * chap-new.c - New CHAP implementation.
3 *
4 * Copyright (c) 2003 Paul Mackerras. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * 2. The name(s) of the authors of this software must not be used to
14 * endorse or promote products derived from this software without
15 * prior written permission.
16 *
17 * 3. Redistributions of any form whatsoever must retain the following
18 * acknowledgment:
19 * "This product includes software developed by Paul Mackerras
20 * <paulus@samba.org>".
21 *
22 * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
23 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
24 * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
25 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
26 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
27 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
28 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
29 */
30
31#include "netif/ppp/ppp_opts.h"
32#if PPP_SUPPORT && CHAP_SUPPORT /* don't build if not configured for use in lwipopts.h */
33
34#if 0 /* UNUSED */
35#include <stdlib.h>
36#include <string.h>
37#endif /* UNUSED */
38
39#include "netif/ppp/ppp_impl.h"
40
41#if 0 /* UNUSED */
42#include "session.h"
43#endif /* UNUSED */
44
45#include "netif/ppp/chap-new.h"
46#include "netif/ppp/chap-md5.h"
47#if MSCHAP_SUPPORT
48#include "netif/ppp/chap_ms.h"
49#endif
50#include "netif/ppp/magic.h"
51
52#if 0 /* UNUSED */
53/* Hook for a plugin to validate CHAP challenge */
54int (*chap_verify_hook)(const char *name, const char *ourname, int id,
55 const struct chap_digest_type *digest,
56 const unsigned char *challenge, const unsigned char *response,
57 char *message, int message_space) = NULL;
58#endif /* UNUSED */
59
60#if PPP_OPTIONS
61/*
62 * Command-line options.
63 */
64static option_t chap_option_list[] = {
65 { "chap-restart", o_int, &chap_timeout_time,
66 "Set timeout for CHAP", OPT_PRIO },
67 { "chap-max-challenge", o_int, &pcb->settings.chap_max_transmits,
68 "Set max #xmits for challenge", OPT_PRIO },
69 { "chap-interval", o_int, &pcb->settings.chap_rechallenge_time,
70 "Set interval for rechallenge", OPT_PRIO },
71 { NULL }
72};
73#endif /* PPP_OPTIONS */
74
75
76/* Values for flags in chap_client_state and chap_server_state */
77#define LOWERUP 1
78#define AUTH_STARTED 2
79#define AUTH_DONE 4
80#define AUTH_FAILED 8
81#define TIMEOUT_PENDING 0x10
82#define CHALLENGE_VALID 0x20
83
84/*
85 * Prototypes.
86 */
87static void chap_init(ppp_pcb *pcb);
88static void chap_lowerup(ppp_pcb *pcb);
89static void chap_lowerdown(ppp_pcb *pcb);
90#if PPP_SERVER
91static void chap_timeout(void *arg);
92static void chap_generate_challenge(ppp_pcb *pcb);
93static void chap_handle_response(ppp_pcb *pcb, int code,
94 unsigned char *pkt, int len);
95static int chap_verify_response(ppp_pcb *pcb, const char *name, const char *ourname, int id,
96 const struct chap_digest_type *digest,
97 const unsigned char *challenge, const unsigned char *response,
98 char *message, int message_space);
99#endif /* PPP_SERVER */
100static void chap_respond(ppp_pcb *pcb, int id,
101 unsigned char *pkt, int len);
102static void chap_handle_status(ppp_pcb *pcb, int code, int id,
103 unsigned char *pkt, int len);
104static void chap_protrej(ppp_pcb *pcb);
105static void chap_input(ppp_pcb *pcb, unsigned char *pkt, int pktlen);
106#if PRINTPKT_SUPPORT
107static int chap_print_pkt(const unsigned char *p, int plen,
108 void (*printer) (void *, const char *, ...), void *arg);
109#endif /* PRINTPKT_SUPPORT */
110
111/* List of digest types that we know about */
112static const struct chap_digest_type* const chap_digests[] = {
113 &md5_digest,
114#if MSCHAP_SUPPORT
115 &chapms_digest,
116 &chapms2_digest,
117#endif /* MSCHAP_SUPPORT */
118 NULL
119};
120
121/*
122 * chap_init - reset to initial state.
123 */
124static void chap_init(ppp_pcb *pcb) {
125 LWIP_UNUSED_ARG(pcb);
126
127#if 0 /* Not necessary, everything is cleared in ppp_new() */
128 memset(&pcb->chap_client, 0, sizeof(chap_client_state));
129#if PPP_SERVER
130 memset(&pcb->chap_server, 0, sizeof(chap_server_state));
131#endif /* PPP_SERVER */
132#endif /* 0 */
133}
134
135/*
136 * chap_lowerup - we can start doing stuff now.
137 */
138static void chap_lowerup(ppp_pcb *pcb) {
139
140 pcb->chap_client.flags |= LOWERUP;
141#if PPP_SERVER
142 pcb->chap_server.flags |= LOWERUP;
143 if (pcb->chap_server.flags & AUTH_STARTED)
144 chap_timeout(pcb);
145#endif /* PPP_SERVER */
146}
147
148static void chap_lowerdown(ppp_pcb *pcb) {
149
150 pcb->chap_client.flags = 0;
151#if PPP_SERVER
152 if (pcb->chap_server.flags & TIMEOUT_PENDING)
153 UNTIMEOUT(chap_timeout, pcb);
154 pcb->chap_server.flags = 0;
155#endif /* PPP_SERVER */
156}
157
158#if PPP_SERVER
159/*
160 * chap_auth_peer - Start authenticating the peer.
161 * If the lower layer is already up, we start sending challenges,
162 * otherwise we wait for the lower layer to come up.
163 */
164void chap_auth_peer(ppp_pcb *pcb, const char *our_name, int digest_code) {
165 const struct chap_digest_type *dp;
166 int i;
167
168 if (pcb->chap_server.flags & AUTH_STARTED) {
169 ppp_error("CHAP: peer authentication already started!");
170 return;
171 }
172 for (i = 0; (dp = chap_digests[i]) != NULL; ++i)
173 if (dp->code == digest_code)
174 break;
175 if (dp == NULL)
176 ppp_fatal("CHAP digest 0x%x requested but not available",
177 digest_code);
178
179 pcb->chap_server.digest = dp;
180 pcb->chap_server.name = our_name;
181 /* Start with a random ID value */
182 pcb->chap_server.id = magic();
183 pcb->chap_server.flags |= AUTH_STARTED;
184 if (pcb->chap_server.flags & LOWERUP)
185 chap_timeout(pcb);
186}
187#endif /* PPP_SERVER */
188
189/*
190 * chap_auth_with_peer - Prepare to authenticate ourselves to the peer.
191 * There isn't much to do until we receive a challenge.
192 */
193void chap_auth_with_peer(ppp_pcb *pcb, const char *our_name, int digest_code) {
194 const struct chap_digest_type *dp;
195 int i;
196
197 if(NULL == our_name)
198 return;
199
200 if (pcb->chap_client.flags & AUTH_STARTED) {
201 ppp_error("CHAP: authentication with peer already started!");
202 return;
203 }
204 for (i = 0; (dp = chap_digests[i]) != NULL; ++i)
205 if (dp->code == digest_code)
206 break;
207
208 if (dp == NULL)
209 ppp_fatal("CHAP digest 0x%x requested but not available",
210 digest_code);
211
212 pcb->chap_client.digest = dp;
213 pcb->chap_client.name = our_name;
214 pcb->chap_client.flags |= AUTH_STARTED;
215}
216
217#if PPP_SERVER
218/*
219 * chap_timeout - It's time to send another challenge to the peer.
220 * This could be either a retransmission of a previous challenge,
221 * or a new challenge to start re-authentication.
222 */
223static void chap_timeout(void *arg) {
224 ppp_pcb *pcb = (ppp_pcb*)arg;
225 struct pbuf *p;
226
227 pcb->chap_server.flags &= ~TIMEOUT_PENDING;
228 if ((pcb->chap_server.flags & CHALLENGE_VALID) == 0) {
229 pcb->chap_server.challenge_xmits = 0;
230 chap_generate_challenge(pcb);
231 pcb->chap_server.flags |= CHALLENGE_VALID;
232 } else if (pcb->chap_server.challenge_xmits >= pcb->settings.chap_max_transmits) {
233 pcb->chap_server.flags &= ~CHALLENGE_VALID;
234 pcb->chap_server.flags |= AUTH_DONE | AUTH_FAILED;
235 auth_peer_fail(pcb, PPP_CHAP);
236 return;
237 }
238
239 p = pbuf_alloc(PBUF_RAW, (u16_t)(pcb->chap_server.challenge_pktlen), PPP_CTRL_PBUF_TYPE);
240 if(NULL == p)
241 return;
242 if(p->tot_len != p->len) {
243 pbuf_free(p);
244 return;
245 }
246 MEMCPY(p->payload, pcb->chap_server.challenge, pcb->chap_server.challenge_pktlen);
247 ppp_write(pcb, p);
248 ++pcb->chap_server.challenge_xmits;
249 pcb->chap_server.flags |= TIMEOUT_PENDING;
250 TIMEOUT(chap_timeout, arg, pcb->settings.chap_timeout_time);
251}
252
253/*
254 * chap_generate_challenge - generate a challenge string and format
255 * the challenge packet in pcb->chap_server.challenge_pkt.
256 */
257static void chap_generate_challenge(ppp_pcb *pcb) {
258 int clen = 1, nlen, len;
259 unsigned char *p;
260
261 p = pcb->chap_server.challenge;
262 MAKEHEADER(p, PPP_CHAP);
263 p += CHAP_HDRLEN;
264 pcb->chap_server.digest->generate_challenge(pcb, p);
265 clen = *p;
266 nlen = strlen(pcb->chap_server.name);
267 memcpy(p + 1 + clen, pcb->chap_server.name, nlen);
268
269 len = CHAP_HDRLEN + 1 + clen + nlen;
270 pcb->chap_server.challenge_pktlen = PPP_HDRLEN + len;
271
272 p = pcb->chap_server.challenge + PPP_HDRLEN;
273 p[0] = CHAP_CHALLENGE;
274 p[1] = ++pcb->chap_server.id;
275 p[2] = len >> 8;
276 p[3] = len;
277}
278
279/*
280 * chap_handle_response - check the response to our challenge.
281 */
282static void chap_handle_response(ppp_pcb *pcb, int id,
283 unsigned char *pkt, int len) {
284 int response_len, ok, mlen;
285 const unsigned char *response;
286 unsigned char *outp;
287 struct pbuf *p;
288 const char *name = NULL; /* initialized to shut gcc up */
289#if 0 /* UNUSED */
290 int (*verifier)(const char *, const char *, int, const struct chap_digest_type *,
291 const unsigned char *, const unsigned char *, char *, int);
292#endif /* UNUSED */
293 char rname[MAXNAMELEN+1];
294 char message[256];
295
296 if ((pcb->chap_server.flags & LOWERUP) == 0)
297 return;
298 if (id != pcb->chap_server.challenge[PPP_HDRLEN+1] || len < 2)
299 return;
300 if (pcb->chap_server.flags & CHALLENGE_VALID) {
301 response = pkt;
302 GETCHAR(response_len, pkt);
303 len -= response_len + 1; /* length of name */
304 name = (char *)pkt + response_len;
305 if (len < 0)
306 return;
307
308 if (pcb->chap_server.flags & TIMEOUT_PENDING) {
309 pcb->chap_server.flags &= ~TIMEOUT_PENDING;
310 UNTIMEOUT(chap_timeout, pcb);
311 }
312#if PPP_REMOTENAME
313 if (pcb->settings.explicit_remote) {
314 name = pcb->remote_name;
315 } else
316#endif /* PPP_REMOTENAME */
317 {
318 /* Null terminate and clean remote name. */
319 ppp_slprintf(rname, sizeof(rname), "%.*v", len, name);
320 name = rname;
321 }
322
323#if 0 /* UNUSED */
324 if (chap_verify_hook)
325 verifier = chap_verify_hook;
326 else
327 verifier = chap_verify_response;
328 ok = (*verifier)(name, pcb->chap_server.name, id, pcb->chap_server.digest,
329 pcb->chap_server.challenge + PPP_HDRLEN + CHAP_HDRLEN,
330 response, pcb->chap_server.message, sizeof(pcb->chap_server.message));
331#endif /* UNUSED */
332 ok = chap_verify_response(pcb, name, pcb->chap_server.name, id, pcb->chap_server.digest,
333 pcb->chap_server.challenge + PPP_HDRLEN + CHAP_HDRLEN,
334 response, message, sizeof(message));
335#if 0 /* UNUSED */
336 if (!ok || !auth_number()) {
337#endif /* UNUSED */
338 if (!ok) {
339 pcb->chap_server.flags |= AUTH_FAILED;
340 ppp_warn("Peer %q failed CHAP authentication", name);
341 }
342 } else if ((pcb->chap_server.flags & AUTH_DONE) == 0)
343 return;
344
345 /* send the response */
346 mlen = strlen(message);
347 len = CHAP_HDRLEN + mlen;
348 p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN +len), PPP_CTRL_PBUF_TYPE);
349 if(NULL == p)
350 return;
351 if(p->tot_len != p->len) {
352 pbuf_free(p);
353 return;
354 }
355
356 outp = (unsigned char *)p->payload;
357 MAKEHEADER(outp, PPP_CHAP);
358
359 outp[0] = (pcb->chap_server.flags & AUTH_FAILED)? CHAP_FAILURE: CHAP_SUCCESS;
360 outp[1] = id;
361 outp[2] = len >> 8;
362 outp[3] = len;
363 if (mlen > 0)
364 memcpy(outp + CHAP_HDRLEN, message, mlen);
365 ppp_write(pcb, p);
366
367 if (pcb->chap_server.flags & CHALLENGE_VALID) {
368 pcb->chap_server.flags &= ~CHALLENGE_VALID;
369 if (!(pcb->chap_server.flags & AUTH_DONE) && !(pcb->chap_server.flags & AUTH_FAILED)) {
370
371#if 0 /* UNUSED */
372 /*
373 * Auth is OK, so now we need to check session restrictions
374 * to ensure everything is OK, but only if we used a
375 * plugin, and only if we're configured to check. This
376 * allows us to do PAM checks on PPP servers that
377 * authenticate against ActiveDirectory, and use AD for
378 * account info (like when using Winbind integrated with
379 * PAM).
380 */
381 if (session_mgmt &&
382 session_check(name, NULL, devnam, NULL) == 0) {
383 pcb->chap_server.flags |= AUTH_FAILED;
384 ppp_warn("Peer %q failed CHAP Session verification", name);
385 }
386#endif /* UNUSED */
387
388 }
389 if (pcb->chap_server.flags & AUTH_FAILED) {
390 auth_peer_fail(pcb, PPP_CHAP);
391 } else {
392 if ((pcb->chap_server.flags & AUTH_DONE) == 0)
393 auth_peer_success(pcb, PPP_CHAP,
394 pcb->chap_server.digest->code,
395 name, strlen(name));
396 if (pcb->settings.chap_rechallenge_time) {
397 pcb->chap_server.flags |= TIMEOUT_PENDING;
398 TIMEOUT(chap_timeout, pcb,
399 pcb->settings.chap_rechallenge_time);
400 }
401 }
402 pcb->chap_server.flags |= AUTH_DONE;
403 }
404}
405
406/*
407 * chap_verify_response - check whether the peer's response matches
408 * what we think it should be. Returns 1 if it does (authentication
409 * succeeded), or 0 if it doesn't.
410 */
411static int chap_verify_response(ppp_pcb *pcb, const char *name, const char *ourname, int id,
412 const struct chap_digest_type *digest,
413 const unsigned char *challenge, const unsigned char *response,
414 char *message, int message_space) {
415 int ok;
416 unsigned char secret[MAXSECRETLEN];
417 int secret_len;
418
419 /* Get the secret that the peer is supposed to know */
420 if (!get_secret(pcb, name, ourname, (char *)secret, &secret_len, 1)) {
421 ppp_error("No CHAP secret found for authenticating %q", name);
422 return 0;
423 }
424 ok = digest->verify_response(pcb, id, name, secret, secret_len, challenge,
425 response, message, message_space);
426 memset(secret, 0, sizeof(secret));
427
428 return ok;
429}
430#endif /* PPP_SERVER */
431
432/*
433 * chap_respond - Generate and send a response to a challenge.
434 */
435static void chap_respond(ppp_pcb *pcb, int id,
436 unsigned char *pkt, int len) {
437 int clen, nlen;
438 int secret_len;
439 struct pbuf *p;
440 u_char *outp;
441 char rname[MAXNAMELEN+1];
442 char secret[MAXSECRETLEN+1];
443
444 p = pbuf_alloc(PBUF_RAW, (u16_t)(RESP_MAX_PKTLEN), PPP_CTRL_PBUF_TYPE);
445 if(NULL == p)
446 return;
447 if(p->tot_len != p->len) {
448 pbuf_free(p);
449 return;
450 }
451
452 if ((pcb->chap_client.flags & (LOWERUP | AUTH_STARTED)) != (LOWERUP | AUTH_STARTED))
453 return; /* not ready */
454 if (len < 2 || len < pkt[0] + 1)
455 return; /* too short */
456 clen = pkt[0];
457 nlen = len - (clen + 1);
458
459 /* Null terminate and clean remote name. */
460 ppp_slprintf(rname, sizeof(rname), "%.*v", nlen, pkt + clen + 1);
461
462#if PPP_REMOTENAME
463 /* Microsoft doesn't send their name back in the PPP packet */
464 if (pcb->settings.explicit_remote || (pcb->settings.remote_name[0] != 0 && rname[0] == 0))
465 strlcpy(rname, pcb->settings.remote_name, sizeof(rname));
466#endif /* PPP_REMOTENAME */
467
468 /* get secret for authenticating ourselves with the specified host */
469 if (!get_secret(pcb, pcb->chap_client.name, rname, secret, &secret_len, 0)) {
470 secret_len = 0; /* assume null secret if can't find one */
471 ppp_warn("No CHAP secret found for authenticating us to %q", rname);
472 }
473
474 outp = (u_char*)p->payload;
475 MAKEHEADER(outp, PPP_CHAP);
476 outp += CHAP_HDRLEN;
477
478 pcb->chap_client.digest->make_response(pcb, outp, id, pcb->chap_client.name, pkt,
479 secret, secret_len, pcb->chap_client.priv);
480 memset(secret, 0, secret_len);
481
482 clen = *outp;
483 nlen = strlen(pcb->chap_client.name);
484 memcpy(outp + clen + 1, pcb->chap_client.name, nlen);
485
486 outp = (u_char*)p->payload + PPP_HDRLEN;
487 len = CHAP_HDRLEN + clen + 1 + nlen;
488 outp[0] = CHAP_RESPONSE;
489 outp[1] = id;
490 outp[2] = len >> 8;
491 outp[3] = len;
492
493 pbuf_realloc(p, PPP_HDRLEN + len);
494 ppp_write(pcb, p);
495}
496
497static void chap_handle_status(ppp_pcb *pcb, int code, int id,
498 unsigned char *pkt, int len) {
499 const char *msg = NULL;
500 LWIP_UNUSED_ARG(id);
501
502 if ((pcb->chap_client.flags & (AUTH_DONE|AUTH_STARTED|LOWERUP))
503 != (AUTH_STARTED|LOWERUP))
504 return;
505 pcb->chap_client.flags |= AUTH_DONE;
506
507 if (code == CHAP_SUCCESS) {
508 /* used for MS-CHAP v2 mutual auth, yuck */
509 if (pcb->chap_client.digest->check_success != NULL) {
510 if (!(*pcb->chap_client.digest->check_success)(pcb, pkt, len, pcb->chap_client.priv))
511 code = CHAP_FAILURE;
512 } else
513 msg = "CHAP authentication succeeded";
514 } else {
515 if (pcb->chap_client.digest->handle_failure != NULL)
516 (*pcb->chap_client.digest->handle_failure)(pcb, pkt, len);
517 else
518 msg = "CHAP authentication failed";
519 }
520 if (msg) {
521 if (len > 0)
522 ppp_info("%s: %.*v", msg, len, pkt);
523 else
524 ppp_info("%s", msg);
525 }
526 if (code == CHAP_SUCCESS)
527 auth_withpeer_success(pcb, PPP_CHAP, pcb->chap_client.digest->code);
528 else {
529 pcb->chap_client.flags |= AUTH_FAILED;
530 ppp_error("CHAP authentication failed");
531 auth_withpeer_fail(pcb, PPP_CHAP);
532 }
533}
534
535static void chap_input(ppp_pcb *pcb, unsigned char *pkt, int pktlen) {
536 unsigned char code, id;
537 int len;
538
539 if (pktlen < CHAP_HDRLEN)
540 return;
541 GETCHAR(code, pkt);
542 GETCHAR(id, pkt);
543 GETSHORT(len, pkt);
544 if (len < CHAP_HDRLEN || len > pktlen)
545 return;
546 len -= CHAP_HDRLEN;
547
548 switch (code) {
549 case CHAP_CHALLENGE:
550 chap_respond(pcb, id, pkt, len);
551 break;
552#if PPP_SERVER
553 case CHAP_RESPONSE:
554 chap_handle_response(pcb, id, pkt, len);
555 break;
556#endif /* PPP_SERVER */
557 case CHAP_FAILURE:
558 case CHAP_SUCCESS:
559 chap_handle_status(pcb, code, id, pkt, len);
560 break;
561 default:
562 break;
563 }
564}
565
566static void chap_protrej(ppp_pcb *pcb) {
567
568#if PPP_SERVER
569 if (pcb->chap_server.flags & TIMEOUT_PENDING) {
570 pcb->chap_server.flags &= ~TIMEOUT_PENDING;
571 UNTIMEOUT(chap_timeout, pcb);
572 }
573 if (pcb->chap_server.flags & AUTH_STARTED) {
574 pcb->chap_server.flags = 0;
575 auth_peer_fail(pcb, PPP_CHAP);
576 }
577#endif /* PPP_SERVER */
578 if ((pcb->chap_client.flags & (AUTH_STARTED|AUTH_DONE)) == AUTH_STARTED) {
579 pcb->chap_client.flags &= ~AUTH_STARTED;
580 ppp_error("CHAP authentication failed due to protocol-reject");
581 auth_withpeer_fail(pcb, PPP_CHAP);
582 }
583}
584
585#if PRINTPKT_SUPPORT
586/*
587 * chap_print_pkt - print the contents of a CHAP packet.
588 */
589static const char* const chap_code_names[] = {
590 "Challenge", "Response", "Success", "Failure"
591};
592
593static int chap_print_pkt(const unsigned char *p, int plen,
594 void (*printer) (void *, const char *, ...), void *arg) {
595 int code, id, len;
596 int clen, nlen;
597 unsigned char x;
598
599 if (plen < CHAP_HDRLEN)
600 return 0;
601 GETCHAR(code, p);
602 GETCHAR(id, p);
603 GETSHORT(len, p);
604 if (len < CHAP_HDRLEN || len > plen)
605 return 0;
606
607 if (code >= 1 && code <= (int)LWIP_ARRAYSIZE(chap_code_names))
608 printer(arg, " %s", chap_code_names[code-1]);
609 else
610 printer(arg, " code=0x%x", code);
611 printer(arg, " id=0x%x", id);
612 len -= CHAP_HDRLEN;
613 switch (code) {
614 case CHAP_CHALLENGE:
615 case CHAP_RESPONSE:
616 if (len < 1)
617 break;
618 clen = p[0];
619 if (len < clen + 1)
620 break;
621 ++p;
622 nlen = len - clen - 1;
623 printer(arg, " <");
624 for (; clen > 0; --clen) {
625 GETCHAR(x, p);
626 printer(arg, "%.2x", x);
627 }
628 printer(arg, ">, name = ");
629 ppp_print_string(p, nlen, printer, arg);
630 break;
631 case CHAP_FAILURE:
632 case CHAP_SUCCESS:
633 printer(arg, " ");
634 ppp_print_string(p, len, printer, arg);
635 break;
636 default:
637 for (clen = len; clen > 0; --clen) {
638 GETCHAR(x, p);
639 printer(arg, " %.2x", x);
640 }
641 /* no break */
642 }
643
644 return len + CHAP_HDRLEN;
645}
646#endif /* PRINTPKT_SUPPORT */
647
648const struct protent chap_protent = {
649 PPP_CHAP,
650 chap_init,
651 chap_input,
652 chap_protrej,
653 chap_lowerup,
654 chap_lowerdown,
655 NULL, /* open */
656 NULL, /* close */
657#if PRINTPKT_SUPPORT
658 chap_print_pkt,
659#endif /* PRINTPKT_SUPPORT */
660#if PPP_DATAINPUT
661 NULL, /* datainput */
662#endif /* PPP_DATAINPUT */
663#if PRINTPKT_SUPPORT
664 "CHAP", /* name */
665 NULL, /* data_name */
666#endif /* PRINTPKT_SUPPORT */
667#if PPP_OPTIONS
668 chap_option_list,
669 NULL, /* check_options */
670#endif /* PPP_OPTIONS */
671#if DEMAND_SUPPORT
672 NULL,
673 NULL
674#endif /* DEMAND_SUPPORT */
675};
676
677#endif /* PPP_SUPPORT && CHAP_SUPPORT */
Note: See TracBrowser for help on using the repository browser.