]>
Commit | Line | Data |
---|---|---|
1 | /***************************************************************************** | |
2 | * pap.c - Network Password Authentication Protocol program file. | |
3 | * | |
4 | * Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc. | |
5 | * portions Copyright (c) 1997 by 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 <marc@mbsi.ca> | |
29 | * Ported to lwIP. | |
30 | * 97-12-12 Guy Lancaster <lancasterg@acm.org>, Global Election Systems Inc. | |
31 | * Original. | |
32 | *****************************************************************************/ | |
33 | /* | |
34 | * upap.c - User/Password Authentication Protocol. | |
35 | * | |
36 | * Copyright (c) 1989 Carnegie Mellon University. | |
37 | * All rights reserved. | |
38 | * | |
39 | * Redistribution and use in source and binary forms are permitted | |
40 | * provided that the above copyright notice and this paragraph are | |
41 | * duplicated in all such forms and that any documentation, | |
42 | * advertising materials, and other materials related to such | |
43 | * distribution and use acknowledge that the software was developed | |
44 | * by Carnegie Mellon University. The name of the | |
45 | * University may not be used to endorse or promote products derived | |
46 | * from this software without specific prior written permission. | |
47 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR | |
48 | * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED | |
49 | * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. | |
50 | */ | |
51 | ||
52 | #include "lwip/opt.h" | |
53 | ||
54 | #if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ | |
55 | ||
56 | #if PAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ | |
57 | ||
58 | #include "ppp.h" | |
59 | #include "pppdebug.h" | |
60 | ||
61 | #include "auth.h" | |
62 | #include "pap.h" | |
63 | ||
64 | /***********************************/ | |
65 | /*** LOCAL FUNCTION DECLARATIONS ***/ | |
66 | /***********************************/ | |
67 | /* | |
68 | * Protocol entry points. | |
69 | */ | |
70 | static void upap_init (int); | |
71 | static void upap_lowerup (int); | |
72 | static void upap_lowerdown (int); | |
73 | static void upap_input (int, u_char *, int); | |
74 | static void upap_protrej (int); | |
75 | ||
76 | static void upap_timeout (void *); | |
77 | static void upap_reqtimeout(void *); | |
78 | static void upap_rauthreq (upap_state *, u_char *, int, int); | |
79 | static void upap_rauthack (upap_state *, u_char *, int, int); | |
80 | static void upap_rauthnak (upap_state *, u_char *, int, int); | |
81 | static void upap_sauthreq (upap_state *); | |
82 | static void upap_sresp (upap_state *, u_char, u_char, char *, int); | |
83 | ||
84 | ||
85 | /******************************/ | |
86 | /*** PUBLIC DATA STRUCTURES ***/ | |
87 | /******************************/ | |
88 | struct protent pap_protent = { | |
89 | PPP_PAP, | |
90 | upap_init, | |
91 | upap_input, | |
92 | upap_protrej, | |
93 | upap_lowerup, | |
94 | upap_lowerdown, | |
95 | NULL, | |
96 | NULL, | |
97 | #if 0 | |
98 | upap_printpkt, | |
99 | NULL, | |
100 | #endif | |
101 | 1, | |
102 | "PAP", | |
103 | #if 0 | |
104 | NULL, | |
105 | NULL, | |
106 | NULL | |
107 | #endif | |
108 | }; | |
109 | ||
110 | upap_state upap[NUM_PPP]; /* UPAP state; one for each unit */ | |
111 | ||
112 | ||
113 | ||
114 | /***********************************/ | |
115 | /*** PUBLIC FUNCTION DEFINITIONS ***/ | |
116 | /***********************************/ | |
117 | /* | |
118 | * Set the default login name and password for the pap sessions | |
119 | */ | |
120 | void | |
121 | upap_setloginpasswd(int unit, const char *luser, const char *lpassword) | |
122 | { | |
123 | upap_state *u = &upap[unit]; | |
124 | ||
125 | /* Save the username and password we're given */ | |
126 | u->us_user = luser; | |
127 | u->us_userlen = strlen(luser); | |
128 | u->us_passwd = lpassword; | |
129 | u->us_passwdlen = strlen(lpassword); | |
130 | } | |
131 | ||
132 | ||
133 | /* | |
134 | * upap_authwithpeer - Authenticate us with our peer (start client). | |
135 | * | |
136 | * Set new state and send authenticate's. | |
137 | */ | |
138 | void | |
139 | upap_authwithpeer(int unit, char *user, char *password) | |
140 | { | |
141 | upap_state *u = &upap[unit]; | |
142 | ||
143 | UPAPDEBUG((LOG_INFO, "upap_authwithpeer: %d user=%s password=%s s=%d\n", | |
144 | unit, user, password, u->us_clientstate)); | |
145 | ||
146 | upap_setloginpasswd(unit, user, password); | |
147 | ||
148 | u->us_transmits = 0; | |
149 | ||
150 | /* Lower layer up yet? */ | |
151 | if (u->us_clientstate == UPAPCS_INITIAL || | |
152 | u->us_clientstate == UPAPCS_PENDING) { | |
153 | u->us_clientstate = UPAPCS_PENDING; | |
154 | return; | |
155 | } | |
156 | ||
157 | upap_sauthreq(u); /* Start protocol */ | |
158 | } | |
159 | ||
160 | ||
161 | /* | |
162 | * upap_authpeer - Authenticate our peer (start server). | |
163 | * | |
164 | * Set new state. | |
165 | */ | |
166 | void | |
167 | upap_authpeer(int unit) | |
168 | { | |
169 | upap_state *u = &upap[unit]; | |
170 | ||
171 | /* Lower layer up yet? */ | |
172 | if (u->us_serverstate == UPAPSS_INITIAL || | |
173 | u->us_serverstate == UPAPSS_PENDING) { | |
174 | u->us_serverstate = UPAPSS_PENDING; | |
175 | return; | |
176 | } | |
177 | ||
178 | u->us_serverstate = UPAPSS_LISTEN; | |
179 | if (u->us_reqtimeout > 0) { | |
180 | TIMEOUT(upap_reqtimeout, u, u->us_reqtimeout); | |
181 | } | |
182 | } | |
183 | ||
184 | ||
185 | ||
186 | /**********************************/ | |
187 | /*** LOCAL FUNCTION DEFINITIONS ***/ | |
188 | /**********************************/ | |
189 | /* | |
190 | * upap_init - Initialize a UPAP unit. | |
191 | */ | |
192 | static void | |
193 | upap_init(int unit) | |
194 | { | |
195 | upap_state *u = &upap[unit]; | |
196 | ||
197 | UPAPDEBUG((LOG_INFO, "upap_init: %d\n", unit)); | |
198 | u->us_unit = unit; | |
199 | u->us_user = NULL; | |
200 | u->us_userlen = 0; | |
201 | u->us_passwd = NULL; | |
202 | u->us_passwdlen = 0; | |
203 | u->us_clientstate = UPAPCS_INITIAL; | |
204 | u->us_serverstate = UPAPSS_INITIAL; | |
205 | u->us_id = 0; | |
206 | u->us_timeouttime = UPAP_DEFTIMEOUT; | |
207 | u->us_maxtransmits = 10; | |
208 | u->us_reqtimeout = UPAP_DEFREQTIME; | |
209 | } | |
210 | ||
211 | /* | |
212 | * upap_timeout - Retransmission timer for sending auth-reqs expired. | |
213 | */ | |
214 | static void | |
215 | upap_timeout(void *arg) | |
216 | { | |
217 | upap_state *u = (upap_state *) arg; | |
218 | ||
219 | UPAPDEBUG((LOG_INFO, "upap_timeout: %d timeout %d expired s=%d\n", | |
220 | u->us_unit, u->us_timeouttime, u->us_clientstate)); | |
221 | ||
222 | if (u->us_clientstate != UPAPCS_AUTHREQ) { | |
223 | return; | |
224 | } | |
225 | ||
226 | if (u->us_transmits >= u->us_maxtransmits) { | |
227 | /* give up in disgust */ | |
228 | UPAPDEBUG((LOG_ERR, "No response to PAP authenticate-requests\n")); | |
229 | u->us_clientstate = UPAPCS_BADAUTH; | |
230 | auth_withpeer_fail(u->us_unit, PPP_PAP); | |
231 | return; | |
232 | } | |
233 | ||
234 | upap_sauthreq(u); /* Send Authenticate-Request */ | |
235 | } | |
236 | ||
237 | ||
238 | /* | |
239 | * upap_reqtimeout - Give up waiting for the peer to send an auth-req. | |
240 | */ | |
241 | static void | |
242 | upap_reqtimeout(void *arg) | |
243 | { | |
244 | upap_state *u = (upap_state *) arg; | |
245 | ||
246 | if (u->us_serverstate != UPAPSS_LISTEN) { | |
247 | return; /* huh?? */ | |
248 | } | |
249 | ||
250 | auth_peer_fail(u->us_unit, PPP_PAP); | |
251 | u->us_serverstate = UPAPSS_BADAUTH; | |
252 | } | |
253 | ||
254 | ||
255 | /* | |
256 | * upap_lowerup - The lower layer is up. | |
257 | * | |
258 | * Start authenticating if pending. | |
259 | */ | |
260 | static void | |
261 | upap_lowerup(int unit) | |
262 | { | |
263 | upap_state *u = &upap[unit]; | |
264 | ||
265 | UPAPDEBUG((LOG_INFO, "upap_lowerup: %d s=%d\n", unit, u->us_clientstate)); | |
266 | ||
267 | if (u->us_clientstate == UPAPCS_INITIAL) { | |
268 | u->us_clientstate = UPAPCS_CLOSED; | |
269 | } else if (u->us_clientstate == UPAPCS_PENDING) { | |
270 | upap_sauthreq(u); /* send an auth-request */ | |
271 | } | |
272 | ||
273 | if (u->us_serverstate == UPAPSS_INITIAL) { | |
274 | u->us_serverstate = UPAPSS_CLOSED; | |
275 | } else if (u->us_serverstate == UPAPSS_PENDING) { | |
276 | u->us_serverstate = UPAPSS_LISTEN; | |
277 | if (u->us_reqtimeout > 0) { | |
278 | TIMEOUT(upap_reqtimeout, u, u->us_reqtimeout); | |
279 | } | |
280 | } | |
281 | } | |
282 | ||
283 | ||
284 | /* | |
285 | * upap_lowerdown - The lower layer is down. | |
286 | * | |
287 | * Cancel all timeouts. | |
288 | */ | |
289 | static void | |
290 | upap_lowerdown(int unit) | |
291 | { | |
292 | upap_state *u = &upap[unit]; | |
293 | ||
294 | UPAPDEBUG((LOG_INFO, "upap_lowerdown: %d s=%d\n", unit, u->us_clientstate)); | |
295 | ||
296 | if (u->us_clientstate == UPAPCS_AUTHREQ) { /* Timeout pending? */ | |
297 | UNTIMEOUT(upap_timeout, u); /* Cancel timeout */ | |
298 | } | |
299 | if (u->us_serverstate == UPAPSS_LISTEN && u->us_reqtimeout > 0) { | |
300 | UNTIMEOUT(upap_reqtimeout, u); | |
301 | } | |
302 | ||
303 | u->us_clientstate = UPAPCS_INITIAL; | |
304 | u->us_serverstate = UPAPSS_INITIAL; | |
305 | } | |
306 | ||
307 | ||
308 | /* | |
309 | * upap_protrej - Peer doesn't speak this protocol. | |
310 | * | |
311 | * This shouldn't happen. In any case, pretend lower layer went down. | |
312 | */ | |
313 | static void | |
314 | upap_protrej(int unit) | |
315 | { | |
316 | upap_state *u = &upap[unit]; | |
317 | ||
318 | if (u->us_clientstate == UPAPCS_AUTHREQ) { | |
319 | UPAPDEBUG((LOG_ERR, "PAP authentication failed due to protocol-reject\n")); | |
320 | auth_withpeer_fail(unit, PPP_PAP); | |
321 | } | |
322 | if (u->us_serverstate == UPAPSS_LISTEN) { | |
323 | UPAPDEBUG((LOG_ERR, "PAP authentication of peer failed (protocol-reject)\n")); | |
324 | auth_peer_fail(unit, PPP_PAP); | |
325 | } | |
326 | upap_lowerdown(unit); | |
327 | } | |
328 | ||
329 | ||
330 | /* | |
331 | * upap_input - Input UPAP packet. | |
332 | */ | |
333 | static void | |
334 | upap_input(int unit, u_char *inpacket, int l) | |
335 | { | |
336 | upap_state *u = &upap[unit]; | |
337 | u_char *inp; | |
338 | u_char code, id; | |
339 | int len; | |
340 | ||
341 | /* | |
342 | * Parse header (code, id and length). | |
343 | * If packet too short, drop it. | |
344 | */ | |
345 | inp = inpacket; | |
346 | if (l < UPAP_HEADERLEN) { | |
347 | UPAPDEBUG((LOG_INFO, "pap_input: rcvd short header.\n")); | |
348 | return; | |
349 | } | |
350 | GETCHAR(code, inp); | |
351 | GETCHAR(id, inp); | |
352 | GETSHORT(len, inp); | |
353 | if (len < UPAP_HEADERLEN) { | |
354 | UPAPDEBUG((LOG_INFO, "pap_input: rcvd illegal length.\n")); | |
355 | return; | |
356 | } | |
357 | if (len > l) { | |
358 | UPAPDEBUG((LOG_INFO, "pap_input: rcvd short packet.\n")); | |
359 | return; | |
360 | } | |
361 | len -= UPAP_HEADERLEN; | |
362 | ||
363 | /* | |
364 | * Action depends on code. | |
365 | */ | |
366 | switch (code) { | |
367 | case UPAP_AUTHREQ: | |
368 | upap_rauthreq(u, inp, id, len); | |
369 | break; | |
370 | ||
371 | case UPAP_AUTHACK: | |
372 | upap_rauthack(u, inp, id, len); | |
373 | break; | |
374 | ||
375 | case UPAP_AUTHNAK: | |
376 | upap_rauthnak(u, inp, id, len); | |
377 | break; | |
378 | ||
379 | default: /* XXX Need code reject */ | |
380 | break; | |
381 | } | |
382 | } | |
383 | ||
384 | ||
385 | /* | |
386 | * upap_rauth - Receive Authenticate. | |
387 | */ | |
388 | static void | |
389 | upap_rauthreq(upap_state *u, u_char *inp, int id, int len) | |
390 | { | |
391 | u_char ruserlen, rpasswdlen; | |
392 | char *ruser, *rpasswd; | |
393 | int retcode; | |
394 | char *msg; | |
395 | int msglen; | |
396 | ||
397 | UPAPDEBUG((LOG_INFO, "pap_rauth: Rcvd id %d.\n", id)); | |
398 | ||
399 | if (u->us_serverstate < UPAPSS_LISTEN) { | |
400 | return; | |
401 | } | |
402 | ||
403 | /* | |
404 | * If we receive a duplicate authenticate-request, we are | |
405 | * supposed to return the same status as for the first request. | |
406 | */ | |
407 | if (u->us_serverstate == UPAPSS_OPEN) { | |
408 | upap_sresp(u, UPAP_AUTHACK, id, "", 0); /* return auth-ack */ | |
409 | return; | |
410 | } | |
411 | if (u->us_serverstate == UPAPSS_BADAUTH) { | |
412 | upap_sresp(u, UPAP_AUTHNAK, id, "", 0); /* return auth-nak */ | |
413 | return; | |
414 | } | |
415 | ||
416 | /* | |
417 | * Parse user/passwd. | |
418 | */ | |
419 | if (len < sizeof (u_char)) { | |
420 | UPAPDEBUG((LOG_INFO, "pap_rauth: rcvd short packet.\n")); | |
421 | return; | |
422 | } | |
423 | GETCHAR(ruserlen, inp); | |
424 | len -= sizeof (u_char) + ruserlen + sizeof (u_char); | |
425 | if (len < 0) { | |
426 | UPAPDEBUG((LOG_INFO, "pap_rauth: rcvd short packet.\n")); | |
427 | return; | |
428 | } | |
429 | ruser = (char *) inp; | |
430 | INCPTR(ruserlen, inp); | |
431 | GETCHAR(rpasswdlen, inp); | |
432 | if (len < rpasswdlen) { | |
433 | UPAPDEBUG((LOG_INFO, "pap_rauth: rcvd short packet.\n")); | |
434 | return; | |
435 | } | |
436 | rpasswd = (char *) inp; | |
437 | ||
438 | /* | |
439 | * Check the username and password given. | |
440 | */ | |
441 | retcode = check_passwd(u->us_unit, ruser, ruserlen, rpasswd, rpasswdlen, &msg, &msglen); | |
442 | BZERO(rpasswd, rpasswdlen); | |
443 | ||
444 | upap_sresp(u, retcode, id, msg, msglen); | |
445 | ||
446 | if (retcode == UPAP_AUTHACK) { | |
447 | u->us_serverstate = UPAPSS_OPEN; | |
448 | auth_peer_success(u->us_unit, PPP_PAP, ruser, ruserlen); | |
449 | } else { | |
450 | u->us_serverstate = UPAPSS_BADAUTH; | |
451 | auth_peer_fail(u->us_unit, PPP_PAP); | |
452 | } | |
453 | ||
454 | if (u->us_reqtimeout > 0) { | |
455 | UNTIMEOUT(upap_reqtimeout, u); | |
456 | } | |
457 | } | |
458 | ||
459 | ||
460 | /* | |
461 | * upap_rauthack - Receive Authenticate-Ack. | |
462 | */ | |
463 | static void | |
464 | upap_rauthack(upap_state *u, u_char *inp, int id, int len) | |
465 | { | |
466 | u_char msglen; | |
467 | char *msg; | |
468 | ||
469 | LWIP_UNUSED_ARG(id); | |
470 | ||
471 | UPAPDEBUG((LOG_INFO, "pap_rauthack: Rcvd id %d s=%d\n", id, u->us_clientstate)); | |
472 | ||
473 | if (u->us_clientstate != UPAPCS_AUTHREQ) { /* XXX */ | |
474 | return; | |
475 | } | |
476 | ||
477 | /* | |
478 | * Parse message. | |
479 | */ | |
480 | if (len < sizeof (u_char)) { | |
481 | UPAPDEBUG((LOG_INFO, "pap_rauthack: rcvd short packet.\n")); | |
482 | return; | |
483 | } | |
484 | GETCHAR(msglen, inp); | |
485 | len -= sizeof (u_char); | |
486 | if (len < msglen) { | |
487 | UPAPDEBUG((LOG_INFO, "pap_rauthack: rcvd short packet.\n")); | |
488 | return; | |
489 | } | |
490 | msg = (char *) inp; | |
491 | PRINTMSG(msg, msglen); | |
492 | ||
493 | u->us_clientstate = UPAPCS_OPEN; | |
494 | ||
495 | auth_withpeer_success(u->us_unit, PPP_PAP); | |
496 | } | |
497 | ||
498 | ||
499 | /* | |
500 | * upap_rauthnak - Receive Authenticate-Nakk. | |
501 | */ | |
502 | static void | |
503 | upap_rauthnak(upap_state *u, u_char *inp, int id, int len) | |
504 | { | |
505 | u_char msglen; | |
506 | char *msg; | |
507 | ||
508 | LWIP_UNUSED_ARG(id); | |
509 | ||
510 | UPAPDEBUG((LOG_INFO, "pap_rauthnak: Rcvd id %d s=%d\n", id, u->us_clientstate)); | |
511 | ||
512 | if (u->us_clientstate != UPAPCS_AUTHREQ) { /* XXX */ | |
513 | return; | |
514 | } | |
515 | ||
516 | /* | |
517 | * Parse message. | |
518 | */ | |
519 | if (len < sizeof (u_char)) { | |
520 | UPAPDEBUG((LOG_INFO, "pap_rauthnak: rcvd short packet.\n")); | |
521 | return; | |
522 | } | |
523 | GETCHAR(msglen, inp); | |
524 | len -= sizeof (u_char); | |
525 | if (len < msglen) { | |
526 | UPAPDEBUG((LOG_INFO, "pap_rauthnak: rcvd short packet.\n")); | |
527 | return; | |
528 | } | |
529 | msg = (char *) inp; | |
530 | PRINTMSG(msg, msglen); | |
531 | ||
532 | u->us_clientstate = UPAPCS_BADAUTH; | |
533 | ||
534 | UPAPDEBUG((LOG_ERR, "PAP authentication failed\n")); | |
535 | auth_withpeer_fail(u->us_unit, PPP_PAP); | |
536 | } | |
537 | ||
538 | ||
539 | /* | |
540 | * upap_sauthreq - Send an Authenticate-Request. | |
541 | */ | |
542 | static void | |
543 | upap_sauthreq(upap_state *u) | |
544 | { | |
545 | u_char *outp; | |
546 | int outlen; | |
547 | ||
548 | outlen = UPAP_HEADERLEN + 2 * sizeof (u_char) | |
549 | + u->us_userlen + u->us_passwdlen; | |
550 | outp = outpacket_buf[u->us_unit]; | |
551 | ||
552 | MAKEHEADER(outp, PPP_PAP); | |
553 | ||
554 | PUTCHAR(UPAP_AUTHREQ, outp); | |
555 | PUTCHAR(++u->us_id, outp); | |
556 | PUTSHORT(outlen, outp); | |
557 | PUTCHAR(u->us_userlen, outp); | |
558 | BCOPY(u->us_user, outp, u->us_userlen); | |
559 | INCPTR(u->us_userlen, outp); | |
560 | PUTCHAR(u->us_passwdlen, outp); | |
561 | BCOPY(u->us_passwd, outp, u->us_passwdlen); | |
562 | ||
563 | pppWrite(u->us_unit, outpacket_buf[u->us_unit], outlen + PPP_HDRLEN); | |
564 | ||
565 | UPAPDEBUG((LOG_INFO, "pap_sauth: Sent id %d\n", u->us_id)); | |
566 | ||
567 | TIMEOUT(upap_timeout, u, u->us_timeouttime); | |
568 | ++u->us_transmits; | |
569 | u->us_clientstate = UPAPCS_AUTHREQ; | |
570 | } | |
571 | ||
572 | ||
573 | /* | |
574 | * upap_sresp - Send a response (ack or nak). | |
575 | */ | |
576 | static void | |
577 | upap_sresp(upap_state *u, u_char code, u_char id, char *msg, int msglen) | |
578 | { | |
579 | u_char *outp; | |
580 | int outlen; | |
581 | ||
582 | outlen = UPAP_HEADERLEN + sizeof (u_char) + msglen; | |
583 | outp = outpacket_buf[u->us_unit]; | |
584 | MAKEHEADER(outp, PPP_PAP); | |
585 | ||
586 | PUTCHAR(code, outp); | |
587 | PUTCHAR(id, outp); | |
588 | PUTSHORT(outlen, outp); | |
589 | PUTCHAR(msglen, outp); | |
590 | BCOPY(msg, outp, msglen); | |
591 | pppWrite(u->us_unit, outpacket_buf[u->us_unit], outlen + PPP_HDRLEN); | |
592 | ||
593 | UPAPDEBUG((LOG_INFO, "pap_sresp: Sent code %d, id %d s=%d\n", code, id, u->us_clientstate)); | |
594 | } | |
595 | ||
596 | #if 0 | |
597 | /* | |
598 | * upap_printpkt - print the contents of a PAP packet. | |
599 | */ | |
600 | static int upap_printpkt( | |
601 | u_char *p, | |
602 | int plen, | |
603 | void (*printer) (void *, char *, ...), | |
604 | void *arg | |
605 | ) | |
606 | { | |
607 | LWIP_UNUSED_ARG(p); | |
608 | LWIP_UNUSED_ARG(plen); | |
609 | LWIP_UNUSED_ARG(printer); | |
610 | LWIP_UNUSED_ARG(arg); | |
611 | return 0; | |
612 | } | |
613 | #endif /* 0 */ | |
614 | ||
615 | #endif /* PAP_SUPPORT */ | |
616 | ||
617 | #endif /* PPP_SUPPORT */ |