Daniel Peter / Net

lwip/netif/ppp/pap.c@0:d616ece2d859, 2010-09-18 (annotated)

Committer:
mbed714
Date:
Sat Sep 18 23:05:49 2010 +0000
Revision:
0:d616ece2d859

        

        
Who changed what in which revision?

        

            
                
UserRevisionLine numberNew contents of line

            
            


mbed714

0:d616ece2d859


     1

/*****************************************************************************





mbed714

0:d616ece2d859


     2

* pap.c - Network Password Authentication Protocol program file.





mbed714

0:d616ece2d859


     3

*





mbed714

0:d616ece2d859


     4

* Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc.





mbed714

0:d616ece2d859


     5

* portions Copyright (c) 1997 by Global Election Systems Inc.





mbed714

0:d616ece2d859


     6

*





mbed714

0:d616ece2d859


     7

* The authors hereby grant permission to use, copy, modify, distribute,





mbed714

0:d616ece2d859


     8

* and license this software and its documentation for any purpose, provided





mbed714

0:d616ece2d859


     9

* that existing copyright notices are retained in all copies and that this





mbed714

0:d616ece2d859


    10

* notice and the following disclaimer are included verbatim in any 





mbed714

0:d616ece2d859


    11

* distributions. No written agreement, license, or royalty fee is required





mbed714

0:d616ece2d859


    12

* for any of the authorized uses.





mbed714

0:d616ece2d859


    13

*





mbed714

0:d616ece2d859


    14

* THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS *AS IS* AND ANY EXPRESS OR





mbed714

0:d616ece2d859


    15

* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES





mbed714

0:d616ece2d859


    16

* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 





mbed714

0:d616ece2d859


    17

* IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,





mbed714

0:d616ece2d859


    18

* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT





mbed714

0:d616ece2d859


    19

* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,





mbed714

0:d616ece2d859


    20

* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY





mbed714

0:d616ece2d859


    21

* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT





mbed714

0:d616ece2d859


    22

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF





mbed714

0:d616ece2d859


    23

* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.





mbed714

0:d616ece2d859


    24

*





mbed714

0:d616ece2d859


    25

******************************************************************************





mbed714

0:d616ece2d859


    26

* REVISION HISTORY





mbed714

0:d616ece2d859


    27

*





mbed714

0:d616ece2d859


    28

* 03-01-01 Marc Boucher <marc@mbsi.ca>





mbed714

0:d616ece2d859


    29

*   Ported to lwIP.





mbed714

0:d616ece2d859


    30

* 97-12-12 Guy Lancaster <lancasterg@acm.org>, Global Election Systems Inc.





mbed714

0:d616ece2d859


    31

*   Original.





mbed714

0:d616ece2d859


    32

*****************************************************************************/





mbed714

0:d616ece2d859


    33

/*





mbed714

0:d616ece2d859


    34

 * upap.c - User/Password Authentication Protocol.





mbed714

0:d616ece2d859


    35

 *





mbed714

0:d616ece2d859


    36

 * Copyright (c) 1989 Carnegie Mellon University.





mbed714

0:d616ece2d859


    37

 * All rights reserved.





mbed714

0:d616ece2d859


    38

 *





mbed714

0:d616ece2d859


    39

 * Redistribution and use in source and binary forms are permitted





mbed714

0:d616ece2d859


    40

 * provided that the above copyright notice and this paragraph are





mbed714

0:d616ece2d859


    41

 * duplicated in all such forms and that any documentation,





mbed714

0:d616ece2d859


    42

 * advertising materials, and other materials related to such





mbed714

0:d616ece2d859


    43

 * distribution and use acknowledge that the software was developed





mbed714

0:d616ece2d859


    44

 * by Carnegie Mellon University.  The name of the





mbed714

0:d616ece2d859


    45

 * University may not be used to endorse or promote products derived





mbed714

0:d616ece2d859


    46

 * from this software without specific prior written permission.





mbed714

0:d616ece2d859


    47

 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR





mbed714

0:d616ece2d859


    48

 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED





mbed714

0:d616ece2d859


    49

 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.





mbed714

0:d616ece2d859


    50

 */





mbed714

0:d616ece2d859


    51







mbed714

0:d616ece2d859


    52

#include "lwip/opt.h"





mbed714

0:d616ece2d859


    53







mbed714

0:d616ece2d859


    54

#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */





mbed714

0:d616ece2d859


    55







mbed714

0:d616ece2d859


    56

#if PAP_SUPPORT /* don't build if not configured for use in lwipopts.h */





mbed714

0:d616ece2d859


    57







mbed714

0:d616ece2d859


    58

#include "ppp.h"





mbed714

0:d616ece2d859


    59

#include "pppdebug.h"





mbed714

0:d616ece2d859


    60







mbed714

0:d616ece2d859


    61

#include "auth.h"





mbed714

0:d616ece2d859


    62

#include "pap.h"





mbed714

0:d616ece2d859


    63







mbed714

0:d616ece2d859


    64

#include <string.h>





mbed714

0:d616ece2d859


    65







mbed714

0:d616ece2d859


    66

#if 0 /* UNUSED */





mbed714

0:d616ece2d859


    67

static bool hide_password = 1;





mbed714

0:d616ece2d859


    68







mbed714

0:d616ece2d859


    69

/*





mbed714

0:d616ece2d859


    70

 * Command-line options.





mbed714

0:d616ece2d859


    71

 */





mbed714

0:d616ece2d859


    72

static option_t pap_option_list[] = {





mbed714

0:d616ece2d859


    73

    { "hide-password", o_bool, &hide_password,





mbed714

0:d616ece2d859


    74

      "Don't output passwords to log", 1 },





mbed714

0:d616ece2d859


    75

    { "show-password", o_bool, &hide_password,





mbed714

0:d616ece2d859


    76

      "Show password string in debug log messages", 0 },





mbed714

0:d616ece2d859


    77

    { "pap-restart", o_int, &upap[0].us_timeouttime,





mbed714

0:d616ece2d859


    78

      "Set retransmit timeout for PAP" },





mbed714

0:d616ece2d859


    79

    { "pap-max-authreq", o_int, &upap[0].us_maxtransmits,





mbed714

0:d616ece2d859


    80

      "Set max number of transmissions for auth-reqs" },





mbed714

0:d616ece2d859


    81

    { "pap-timeout", o_int, &upap[0].us_reqtimeout,





mbed714

0:d616ece2d859


    82

      "Set time limit for peer PAP authentication" },





mbed714

0:d616ece2d859


    83

    { NULL }





mbed714

0:d616ece2d859


    84

};





mbed714

0:d616ece2d859


    85

#endif





mbed714

0:d616ece2d859


    86







mbed714

0:d616ece2d859


    87

/*





mbed714

0:d616ece2d859


    88

 * Protocol entry points.





mbed714

0:d616ece2d859


    89

 */





mbed714

0:d616ece2d859


    90

static void upap_init      (int);





mbed714

0:d616ece2d859


    91

static void upap_lowerup   (int);





mbed714

0:d616ece2d859


    92

static void upap_lowerdown (int);





mbed714

0:d616ece2d859


    93

static void upap_input     (int, u_char *, int);





mbed714

0:d616ece2d859


    94

static void upap_protrej   (int);





mbed714

0:d616ece2d859


    95

#if PPP_ADDITIONAL_CALLBACKS





mbed714

0:d616ece2d859


    96

static int  upap_printpkt (u_char *, int, void (*)(void *, char *, ...), void *);





mbed714

0:d616ece2d859


    97

#endif /* PPP_ADDITIONAL_CALLBACKS */





mbed714

0:d616ece2d859


    98







mbed714

0:d616ece2d859


    99

struct protent pap_protent = {





mbed714

0:d616ece2d859


   100

  PPP_PAP,





mbed714

0:d616ece2d859


   101

  upap_init,





mbed714

0:d616ece2d859


   102

  upap_input,





mbed714

0:d616ece2d859


   103

  upap_protrej,





mbed714

0:d616ece2d859


   104

  upap_lowerup,





mbed714

0:d616ece2d859


   105

  upap_lowerdown,





mbed714

0:d616ece2d859


   106

  NULL,





mbed714

0:d616ece2d859


   107

  NULL,





mbed714

0:d616ece2d859


   108

#if PPP_ADDITIONAL_CALLBACKS





mbed714

0:d616ece2d859


   109

  upap_printpkt,





mbed714

0:d616ece2d859


   110

  NULL,





mbed714

0:d616ece2d859


   111

#endif /* PPP_ADDITIONAL_CALLBACKS */





mbed714

0:d616ece2d859


   112

  1,





mbed714

0:d616ece2d859


   113

  "PAP",





mbed714

0:d616ece2d859


   114

#if PPP_ADDITIONAL_CALLBACKS





mbed714

0:d616ece2d859


   115

  NULL,





mbed714

0:d616ece2d859


   116

  NULL,





mbed714

0:d616ece2d859


   117

  NULL





mbed714

0:d616ece2d859


   118

#endif /* PPP_ADDITIONAL_CALLBACKS */





mbed714

0:d616ece2d859


   119

};





mbed714

0:d616ece2d859


   120







mbed714

0:d616ece2d859


   121

upap_state upap[NUM_PPP]; /* UPAP state; one for each unit */





mbed714

0:d616ece2d859


   122







mbed714

0:d616ece2d859


   123

static void upap_timeout   (void *);





mbed714

0:d616ece2d859


   124

static void upap_reqtimeout(void *);





mbed714

0:d616ece2d859


   125

static void upap_rauthreq  (upap_state *, u_char *, u_char, int);





mbed714

0:d616ece2d859


   126

static void upap_rauthack  (upap_state *, u_char *, int, int);





mbed714

0:d616ece2d859


   127

static void upap_rauthnak  (upap_state *, u_char *, int, int);





mbed714

0:d616ece2d859


   128

static void upap_sauthreq  (upap_state *);





mbed714

0:d616ece2d859


   129

static void upap_sresp     (upap_state *, u_char, u_char, char *, int);





mbed714

0:d616ece2d859


   130







mbed714

0:d616ece2d859


   131







mbed714

0:d616ece2d859


   132

/*





mbed714

0:d616ece2d859


   133

 * upap_init - Initialize a UPAP unit.





mbed714

0:d616ece2d859


   134

 */





mbed714

0:d616ece2d859


   135

static void





mbed714

0:d616ece2d859


   136

upap_init(int unit)





mbed714

0:d616ece2d859


   137

{





mbed714

0:d616ece2d859


   138

  upap_state *u = &upap[unit];





mbed714

0:d616ece2d859


   139







mbed714

0:d616ece2d859


   140

  UPAPDEBUG(LOG_INFO, ("upap_init: %d\n", unit));





mbed714

0:d616ece2d859


   141

  u->us_unit         = unit;





mbed714

0:d616ece2d859


   142

  u->us_user         = NULL;





mbed714

0:d616ece2d859


   143

  u->us_userlen      = 0;





mbed714

0:d616ece2d859


   144

  u->us_passwd       = NULL;





mbed714

0:d616ece2d859


   145

  u->us_passwdlen    = 0;





mbed714

0:d616ece2d859


   146

  u->us_clientstate  = UPAPCS_INITIAL;





mbed714

0:d616ece2d859


   147

  u->us_serverstate  = UPAPSS_INITIAL;





mbed714

0:d616ece2d859


   148

  u->us_id           = 0;





mbed714

0:d616ece2d859


   149

  u->us_timeouttime  = UPAP_DEFTIMEOUT;





mbed714

0:d616ece2d859


   150

  u->us_maxtransmits = 10;





mbed714

0:d616ece2d859


   151

  u->us_reqtimeout   = UPAP_DEFREQTIME;





mbed714

0:d616ece2d859


   152

}





mbed714

0:d616ece2d859


   153







mbed714

0:d616ece2d859


   154

/*





mbed714

0:d616ece2d859


   155

 * upap_authwithpeer - Authenticate us with our peer (start client).





mbed714

0:d616ece2d859


   156

 *





mbed714

0:d616ece2d859


   157

 * Set new state and send authenticate's.





mbed714

0:d616ece2d859


   158

 */





mbed714

0:d616ece2d859


   159

void





mbed714

0:d616ece2d859


   160

upap_authwithpeer(int unit, char *user, char *password)





mbed714

0:d616ece2d859


   161

{





mbed714

0:d616ece2d859


   162

  upap_state *u = &upap[unit];





mbed714

0:d616ece2d859


   163







mbed714

0:d616ece2d859


   164

  UPAPDEBUG(LOG_INFO, ("upap_authwithpeer: %d user=%s password=%s s=%d\n",





mbed714

0:d616ece2d859


   165

             unit, user, password, u->us_clientstate));





mbed714

0:d616ece2d859


   166







mbed714

0:d616ece2d859


   167

  /* Save the username and password we're given */





mbed714

0:d616ece2d859


   168

  u->us_user = user;





mbed714

0:d616ece2d859


   169

  u->us_userlen = (int)strlen(user);





mbed714

0:d616ece2d859


   170

  u->us_passwd = password;





mbed714

0:d616ece2d859


   171

  u->us_passwdlen = (int)strlen(password);





mbed714

0:d616ece2d859


   172







mbed714

0:d616ece2d859


   173

  u->us_transmits = 0;





mbed714

0:d616ece2d859


   174







mbed714

0:d616ece2d859


   175

  /* Lower layer up yet? */





mbed714

0:d616ece2d859


   176

  if (u->us_clientstate == UPAPCS_INITIAL ||





mbed714

0:d616ece2d859


   177

      u->us_clientstate == UPAPCS_PENDING) {





mbed714

0:d616ece2d859


   178

    u->us_clientstate = UPAPCS_PENDING;





mbed714

0:d616ece2d859


   179

    return;





mbed714

0:d616ece2d859


   180

  }





mbed714

0:d616ece2d859


   181







mbed714

0:d616ece2d859


   182

  upap_sauthreq(u);      /* Start protocol */





mbed714

0:d616ece2d859


   183

}





mbed714

0:d616ece2d859


   184







mbed714

0:d616ece2d859


   185







mbed714

0:d616ece2d859


   186

/*





mbed714

0:d616ece2d859


   187

 * upap_authpeer - Authenticate our peer (start server).





mbed714

0:d616ece2d859


   188

 *





mbed714

0:d616ece2d859


   189

 * Set new state.





mbed714

0:d616ece2d859


   190

 */





mbed714

0:d616ece2d859


   191

void





mbed714

0:d616ece2d859


   192

upap_authpeer(int unit)





mbed714

0:d616ece2d859


   193

{





mbed714

0:d616ece2d859


   194

  upap_state *u = &upap[unit];





mbed714

0:d616ece2d859


   195







mbed714

0:d616ece2d859


   196

  /* Lower layer up yet? */





mbed714

0:d616ece2d859


   197

  if (u->us_serverstate == UPAPSS_INITIAL ||





mbed714

0:d616ece2d859


   198

      u->us_serverstate == UPAPSS_PENDING) {





mbed714

0:d616ece2d859


   199

    u->us_serverstate = UPAPSS_PENDING;





mbed714

0:d616ece2d859


   200

    return;





mbed714

0:d616ece2d859


   201

  }





mbed714

0:d616ece2d859


   202







mbed714

0:d616ece2d859


   203

  u->us_serverstate = UPAPSS_LISTEN;





mbed714

0:d616ece2d859


   204

  if (u->us_reqtimeout > 0) {





mbed714

0:d616ece2d859


   205

    TIMEOUT(upap_reqtimeout, u, u->us_reqtimeout);





mbed714

0:d616ece2d859


   206

  }





mbed714

0:d616ece2d859


   207

}





mbed714

0:d616ece2d859


   208







mbed714

0:d616ece2d859


   209

/*





mbed714

0:d616ece2d859


   210

 * upap_timeout - Retransmission timer for sending auth-reqs expired.





mbed714

0:d616ece2d859


   211

 */





mbed714

0:d616ece2d859


   212

static void





mbed714

0:d616ece2d859


   213

upap_timeout(void *arg)





mbed714

0:d616ece2d859


   214

{





mbed714

0:d616ece2d859


   215

  upap_state *u = (upap_state *) arg;





mbed714

0:d616ece2d859


   216







mbed714

0:d616ece2d859


   217

  UPAPDEBUG(LOG_INFO, ("upap_timeout: %d timeout %d expired s=%d\n", 





mbed714

0:d616ece2d859


   218

        u->us_unit, u->us_timeouttime, u->us_clientstate));





mbed714

0:d616ece2d859


   219







mbed714

0:d616ece2d859


   220

  if (u->us_clientstate != UPAPCS_AUTHREQ) {





mbed714

0:d616ece2d859


   221

	UPAPDEBUG(LOG_INFO, ("upap_timeout: not in AUTHREQ state!\n"));





mbed714

0:d616ece2d859


   222

    return;





mbed714

0:d616ece2d859


   223

  }





mbed714

0:d616ece2d859


   224







mbed714

0:d616ece2d859


   225

  if (u->us_transmits >= u->us_maxtransmits) {





mbed714

0:d616ece2d859


   226

    /* give up in disgust */





mbed714

0:d616ece2d859


   227

    UPAPDEBUG(LOG_ERR, ("No response to PAP authenticate-requests\n"));





mbed714

0:d616ece2d859


   228

    u->us_clientstate = UPAPCS_BADAUTH;





mbed714

0:d616ece2d859


   229

    auth_withpeer_fail(u->us_unit, PPP_PAP);





mbed714

0:d616ece2d859


   230

    return;





mbed714

0:d616ece2d859


   231

  }





mbed714

0:d616ece2d859


   232







mbed714

0:d616ece2d859


   233

  upap_sauthreq(u);    /* Send Authenticate-Request and set upap timeout*/





mbed714

0:d616ece2d859


   234

}





mbed714

0:d616ece2d859


   235







mbed714

0:d616ece2d859


   236







mbed714

0:d616ece2d859


   237

/*





mbed714

0:d616ece2d859


   238

 * upap_reqtimeout - Give up waiting for the peer to send an auth-req.





mbed714

0:d616ece2d859


   239

 */





mbed714

0:d616ece2d859


   240

static void





mbed714

0:d616ece2d859


   241

upap_reqtimeout(void *arg)





mbed714

0:d616ece2d859


   242

{





mbed714

0:d616ece2d859


   243

  upap_state *u = (upap_state *) arg;





mbed714

0:d616ece2d859


   244







mbed714

0:d616ece2d859


   245

  if (u->us_serverstate != UPAPSS_LISTEN) {





mbed714

0:d616ece2d859


   246

    return; /* huh?? */





mbed714

0:d616ece2d859


   247

  }





mbed714

0:d616ece2d859


   248







mbed714

0:d616ece2d859


   249

  auth_peer_fail(u->us_unit, PPP_PAP);





mbed714

0:d616ece2d859


   250

  u->us_serverstate = UPAPSS_BADAUTH;





mbed714

0:d616ece2d859


   251

}





mbed714

0:d616ece2d859


   252







mbed714

0:d616ece2d859


   253







mbed714

0:d616ece2d859


   254

/*





mbed714

0:d616ece2d859


   255

 * upap_lowerup - The lower layer is up.





mbed714

0:d616ece2d859


   256

 *





mbed714

0:d616ece2d859


   257

 * Start authenticating if pending.





mbed714

0:d616ece2d859


   258

 */





mbed714

0:d616ece2d859


   259

static void





mbed714

0:d616ece2d859


   260

upap_lowerup(int unit)





mbed714

0:d616ece2d859


   261

{





mbed714

0:d616ece2d859


   262

  upap_state *u = &upap[unit];





mbed714

0:d616ece2d859


   263







mbed714

0:d616ece2d859


   264

  UPAPDEBUG(LOG_INFO, ("upap_lowerup: init %d clientstate s=%d\n", unit, u->us_clientstate));





mbed714

0:d616ece2d859


   265







mbed714

0:d616ece2d859


   266

  if (u->us_clientstate == UPAPCS_INITIAL) {





mbed714

0:d616ece2d859


   267

    u->us_clientstate = UPAPCS_CLOSED;





mbed714

0:d616ece2d859


   268

  } else if (u->us_clientstate == UPAPCS_PENDING) {





mbed714

0:d616ece2d859


   269

    upap_sauthreq(u);  /* send an auth-request */





mbed714

0:d616ece2d859


   270

    /* now client state is UPAPCS__AUTHREQ */





mbed714

0:d616ece2d859


   271

  }





mbed714

0:d616ece2d859


   272







mbed714

0:d616ece2d859


   273

  if (u->us_serverstate == UPAPSS_INITIAL) {





mbed714

0:d616ece2d859


   274

    u->us_serverstate = UPAPSS_CLOSED;





mbed714

0:d616ece2d859


   275

  } else if (u->us_serverstate == UPAPSS_PENDING) {





mbed714

0:d616ece2d859


   276

    u->us_serverstate = UPAPSS_LISTEN;





mbed714

0:d616ece2d859


   277

    if (u->us_reqtimeout > 0) {





mbed714

0:d616ece2d859


   278

      TIMEOUT(upap_reqtimeout, u, u->us_reqtimeout);





mbed714

0:d616ece2d859


   279

    }





mbed714

0:d616ece2d859


   280

  }





mbed714

0:d616ece2d859


   281

}





mbed714

0:d616ece2d859


   282







mbed714

0:d616ece2d859


   283







mbed714

0:d616ece2d859


   284

/*





mbed714

0:d616ece2d859


   285

 * upap_lowerdown - The lower layer is down.





mbed714

0:d616ece2d859


   286

 *





mbed714

0:d616ece2d859


   287

 * Cancel all timeouts.





mbed714

0:d616ece2d859


   288

 */





mbed714

0:d616ece2d859


   289

static void





mbed714

0:d616ece2d859


   290

upap_lowerdown(int unit)





mbed714

0:d616ece2d859


   291

{





mbed714

0:d616ece2d859


   292

  upap_state *u = &upap[unit];





mbed714

0:d616ece2d859


   293







mbed714

0:d616ece2d859


   294

  UPAPDEBUG(LOG_INFO, ("upap_lowerdown: %d s=%d\n", unit, u->us_clientstate));





mbed714

0:d616ece2d859


   295







mbed714

0:d616ece2d859


   296

  if (u->us_clientstate == UPAPCS_AUTHREQ) { /* Timeout pending? */





mbed714

0:d616ece2d859


   297

    UNTIMEOUT(upap_timeout, u);    /* Cancel timeout */





mbed714

0:d616ece2d859


   298

  }





mbed714

0:d616ece2d859


   299

  if (u->us_serverstate == UPAPSS_LISTEN && u->us_reqtimeout > 0) {





mbed714

0:d616ece2d859


   300

    UNTIMEOUT(upap_reqtimeout, u);





mbed714

0:d616ece2d859


   301

  }





mbed714

0:d616ece2d859


   302







mbed714

0:d616ece2d859


   303

  u->us_clientstate = UPAPCS_INITIAL;





mbed714

0:d616ece2d859


   304

  u->us_serverstate = UPAPSS_INITIAL;





mbed714

0:d616ece2d859


   305

}





mbed714

0:d616ece2d859


   306







mbed714

0:d616ece2d859


   307







mbed714

0:d616ece2d859


   308

/*





mbed714

0:d616ece2d859


   309

 * upap_protrej - Peer doesn't speak this protocol.





mbed714

0:d616ece2d859


   310

 *





mbed714

0:d616ece2d859


   311

 * This shouldn't happen.  In any case, pretend lower layer went down.





mbed714

0:d616ece2d859


   312

 */





mbed714

0:d616ece2d859


   313

static void





mbed714

0:d616ece2d859


   314

upap_protrej(int unit)





mbed714

0:d616ece2d859


   315

{





mbed714

0:d616ece2d859


   316

  upap_state *u = &upap[unit];





mbed714

0:d616ece2d859


   317







mbed714

0:d616ece2d859


   318

  if (u->us_clientstate == UPAPCS_AUTHREQ) {





mbed714

0:d616ece2d859


   319

    UPAPDEBUG(LOG_ERR, ("PAP authentication failed due to protocol-reject\n"));





mbed714

0:d616ece2d859


   320

    auth_withpeer_fail(unit, PPP_PAP);





mbed714

0:d616ece2d859


   321

  }





mbed714

0:d616ece2d859


   322

  if (u->us_serverstate == UPAPSS_LISTEN) {





mbed714

0:d616ece2d859


   323

    UPAPDEBUG(LOG_ERR, ("PAP authentication of peer failed (protocol-reject)\n"));





mbed714

0:d616ece2d859


   324

    auth_peer_fail(unit, PPP_PAP);





mbed714

0:d616ece2d859


   325

  }





mbed714

0:d616ece2d859


   326

  upap_lowerdown(unit);





mbed714

0:d616ece2d859


   327

}





mbed714

0:d616ece2d859


   328







mbed714

0:d616ece2d859


   329







mbed714

0:d616ece2d859


   330

/*





mbed714

0:d616ece2d859


   331

 * upap_input - Input UPAP packet.





mbed714

0:d616ece2d859


   332

 */





mbed714

0:d616ece2d859


   333

static void





mbed714

0:d616ece2d859


   334

upap_input(int unit, u_char *inpacket, int l)





mbed714

0:d616ece2d859


   335

{





mbed714

0:d616ece2d859


   336

  upap_state *u = &upap[unit];





mbed714

0:d616ece2d859


   337

  u_char *inp;





mbed714

0:d616ece2d859


   338

  u_char code, id;





mbed714

0:d616ece2d859


   339

  int len;





mbed714

0:d616ece2d859


   340







mbed714

0:d616ece2d859


   341

  /*





mbed714

0:d616ece2d859


   342

   * Parse header (code, id and length).





mbed714

0:d616ece2d859


   343

   * If packet too short, drop it.





mbed714

0:d616ece2d859


   344

   */





mbed714

0:d616ece2d859


   345

  inp = inpacket;





mbed714

0:d616ece2d859


   346

  if (l < (int)UPAP_HEADERLEN) {





mbed714

0:d616ece2d859


   347

    UPAPDEBUG(LOG_INFO, ("pap_input: rcvd short header.\n"));





mbed714

0:d616ece2d859


   348

    return;





mbed714

0:d616ece2d859


   349

  }





mbed714

0:d616ece2d859


   350

  GETCHAR(code, inp);





mbed714

0:d616ece2d859


   351

  GETCHAR(id, inp);





mbed714

0:d616ece2d859


   352

  GETSHORT(len, inp);





mbed714

0:d616ece2d859


   353

  if (len < (int)UPAP_HEADERLEN) {





mbed714

0:d616ece2d859


   354

    UPAPDEBUG(LOG_INFO, ("pap_input: rcvd illegal length.\n"));





mbed714

0:d616ece2d859


   355

    return;





mbed714

0:d616ece2d859


   356

  }





mbed714

0:d616ece2d859


   357

  if (len > l) {





mbed714

0:d616ece2d859


   358

    UPAPDEBUG(LOG_INFO, ("pap_input: rcvd short packet.\n"));





mbed714

0:d616ece2d859


   359

    return;





mbed714

0:d616ece2d859


   360

  }





mbed714

0:d616ece2d859


   361

  len -= UPAP_HEADERLEN;





mbed714

0:d616ece2d859


   362







mbed714

0:d616ece2d859


   363

  /*





mbed714

0:d616ece2d859


   364

   * Action depends on code.





mbed714

0:d616ece2d859


   365

   */





mbed714

0:d616ece2d859


   366

  switch (code) {





mbed714

0:d616ece2d859


   367

    case UPAP_AUTHREQ:





mbed714

0:d616ece2d859


   368

      upap_rauthreq(u, inp, id, len);





mbed714

0:d616ece2d859


   369

      break;





mbed714

0:d616ece2d859


   370







mbed714

0:d616ece2d859


   371

    case UPAP_AUTHACK:





mbed714

0:d616ece2d859


   372

      upap_rauthack(u, inp, id, len);





mbed714

0:d616ece2d859


   373

      break;





mbed714

0:d616ece2d859


   374







mbed714

0:d616ece2d859


   375

    case UPAP_AUTHNAK:





mbed714

0:d616ece2d859


   376

      upap_rauthnak(u, inp, id, len);





mbed714

0:d616ece2d859


   377

      break;





mbed714

0:d616ece2d859


   378







mbed714

0:d616ece2d859


   379

    default:        /* XXX Need code reject */





mbed714

0:d616ece2d859


   380

      UPAPDEBUG(LOG_INFO, ("pap_input: UNHANDLED default: code: %d, id: %d, len: %d.\n", code, id, len));





mbed714

0:d616ece2d859


   381

      break;





mbed714

0:d616ece2d859


   382

  }





mbed714

0:d616ece2d859


   383

}





mbed714

0:d616ece2d859


   384







mbed714

0:d616ece2d859


   385







mbed714

0:d616ece2d859


   386

/*





mbed714

0:d616ece2d859


   387

 * upap_rauth - Receive Authenticate.





mbed714

0:d616ece2d859


   388

 */





mbed714

0:d616ece2d859


   389

static void





mbed714

0:d616ece2d859


   390

upap_rauthreq(upap_state *u, u_char *inp, u_char id, int len)





mbed714

0:d616ece2d859


   391

{





mbed714

0:d616ece2d859


   392

  u_char ruserlen, rpasswdlen;





mbed714

0:d616ece2d859


   393

  char *ruser, *rpasswd;





mbed714

0:d616ece2d859


   394

  u_char retcode;





mbed714

0:d616ece2d859


   395

  char *msg;





mbed714

0:d616ece2d859


   396

  int msglen;





mbed714

0:d616ece2d859


   397







mbed714

0:d616ece2d859


   398

  UPAPDEBUG(LOG_INFO, ("pap_rauth: Rcvd id %d.\n", id));





mbed714

0:d616ece2d859


   399







mbed714

0:d616ece2d859


   400

  if (u->us_serverstate < UPAPSS_LISTEN) {





mbed714

0:d616ece2d859


   401

    return;





mbed714

0:d616ece2d859


   402

  }





mbed714

0:d616ece2d859


   403







mbed714

0:d616ece2d859


   404

  /*





mbed714

0:d616ece2d859


   405

   * If we receive a duplicate authenticate-request, we are





mbed714

0:d616ece2d859


   406

   * supposed to return the same status as for the first request.





mbed714

0:d616ece2d859


   407

   */





mbed714

0:d616ece2d859


   408

  if (u->us_serverstate == UPAPSS_OPEN) {





mbed714

0:d616ece2d859


   409

    upap_sresp(u, UPAP_AUTHACK, id, "", 0);  /* return auth-ack */





mbed714

0:d616ece2d859


   410

    return;





mbed714

0:d616ece2d859


   411

  }





mbed714

0:d616ece2d859


   412

  if (u->us_serverstate == UPAPSS_BADAUTH) {





mbed714

0:d616ece2d859


   413

    upap_sresp(u, UPAP_AUTHNAK, id, "", 0);  /* return auth-nak */





mbed714

0:d616ece2d859


   414

    return;





mbed714

0:d616ece2d859


   415

  }





mbed714

0:d616ece2d859


   416







mbed714

0:d616ece2d859


   417

  /*





mbed714

0:d616ece2d859


   418

   * Parse user/passwd.





mbed714

0:d616ece2d859


   419

   */





mbed714

0:d616ece2d859


   420

  if (len < (int)sizeof (u_char)) {





mbed714

0:d616ece2d859


   421

    UPAPDEBUG(LOG_INFO, ("pap_rauth: rcvd short packet.\n"));





mbed714

0:d616ece2d859


   422

    return;





mbed714

0:d616ece2d859


   423

  }





mbed714

0:d616ece2d859


   424

  GETCHAR(ruserlen, inp);





mbed714

0:d616ece2d859


   425

  len -= sizeof (u_char) + ruserlen + sizeof (u_char);





mbed714

0:d616ece2d859


   426

  if (len < 0) {





mbed714

0:d616ece2d859


   427

    UPAPDEBUG(LOG_INFO, ("pap_rauth: rcvd short packet.\n"));





mbed714

0:d616ece2d859


   428

    return;





mbed714

0:d616ece2d859


   429

  }





mbed714

0:d616ece2d859


   430

  ruser = (char *) inp;





mbed714

0:d616ece2d859


   431

  INCPTR(ruserlen, inp);





mbed714

0:d616ece2d859


   432

  GETCHAR(rpasswdlen, inp);





mbed714

0:d616ece2d859


   433

  if (len < rpasswdlen) {





mbed714

0:d616ece2d859


   434

    UPAPDEBUG(LOG_INFO, ("pap_rauth: rcvd short packet.\n"));





mbed714

0:d616ece2d859


   435

    return;





mbed714

0:d616ece2d859


   436

  }





mbed714

0:d616ece2d859


   437

  rpasswd = (char *) inp;





mbed714

0:d616ece2d859


   438







mbed714

0:d616ece2d859


   439

  /*





mbed714

0:d616ece2d859


   440

   * Check the username and password given.





mbed714

0:d616ece2d859


   441

   */





mbed714

0:d616ece2d859


   442

  retcode = check_passwd(u->us_unit, ruser, ruserlen, rpasswd, rpasswdlen, &msg, &msglen);





mbed714

0:d616ece2d859


   443

  /* lwip: currently retcode is always UPAP_AUTHACK */





mbed714

0:d616ece2d859


   444

  BZERO(rpasswd, rpasswdlen);





mbed714

0:d616ece2d859


   445







mbed714

0:d616ece2d859


   446

  upap_sresp(u, retcode, id, msg, msglen);





mbed714

0:d616ece2d859


   447







mbed714

0:d616ece2d859


   448

  if (retcode == UPAP_AUTHACK) {





mbed714

0:d616ece2d859


   449

    u->us_serverstate = UPAPSS_OPEN;





mbed714

0:d616ece2d859


   450

    auth_peer_success(u->us_unit, PPP_PAP, ruser, ruserlen);





mbed714

0:d616ece2d859


   451

  } else {





mbed714

0:d616ece2d859


   452

    u->us_serverstate = UPAPSS_BADAUTH;





mbed714

0:d616ece2d859


   453

    auth_peer_fail(u->us_unit, PPP_PAP);





mbed714

0:d616ece2d859


   454

  }





mbed714

0:d616ece2d859


   455







mbed714

0:d616ece2d859


   456

  if (u->us_reqtimeout > 0) {





mbed714

0:d616ece2d859


   457

    UNTIMEOUT(upap_reqtimeout, u);





mbed714

0:d616ece2d859


   458

  }





mbed714

0:d616ece2d859


   459

}





mbed714

0:d616ece2d859


   460







mbed714

0:d616ece2d859


   461







mbed714

0:d616ece2d859


   462

/*





mbed714

0:d616ece2d859


   463

 * upap_rauthack - Receive Authenticate-Ack.





mbed714

0:d616ece2d859


   464

 */





mbed714

0:d616ece2d859


   465

static void





mbed714

0:d616ece2d859


   466

upap_rauthack(upap_state *u, u_char *inp, int id, int len)





mbed714

0:d616ece2d859


   467

{





mbed714

0:d616ece2d859


   468

  u_char msglen;





mbed714

0:d616ece2d859


   469

  char *msg;





mbed714

0:d616ece2d859


   470







mbed714

0:d616ece2d859


   471

  LWIP_UNUSED_ARG(id);





mbed714

0:d616ece2d859


   472







mbed714

0:d616ece2d859


   473

  UPAPDEBUG(LOG_INFO, ("pap_rauthack: Rcvd id %d s=%d\n", id, u->us_clientstate));





mbed714

0:d616ece2d859


   474







mbed714

0:d616ece2d859


   475

  if (u->us_clientstate != UPAPCS_AUTHREQ) { /* XXX */





mbed714

0:d616ece2d859


   476

    UPAPDEBUG(LOG_INFO, ("pap_rauthack: us_clientstate != UPAPCS_AUTHREQ\n"));





mbed714

0:d616ece2d859


   477

    return;





mbed714

0:d616ece2d859


   478

  }





mbed714

0:d616ece2d859


   479







mbed714

0:d616ece2d859


   480

  /*





mbed714

0:d616ece2d859


   481

   * Parse message.





mbed714

0:d616ece2d859


   482

   */





mbed714

0:d616ece2d859


   483

  if (len < (int)sizeof (u_char)) {





mbed714

0:d616ece2d859


   484

    UPAPDEBUG(LOG_INFO, ("pap_rauthack: ignoring missing msg-length.\n"));





mbed714

0:d616ece2d859


   485

  } else {





mbed714

0:d616ece2d859


   486

    GETCHAR(msglen, inp);





mbed714

0:d616ece2d859


   487

    if (msglen > 0) {





mbed714

0:d616ece2d859


   488

      len -= sizeof (u_char);





mbed714

0:d616ece2d859


   489

      if (len < msglen) {





mbed714

0:d616ece2d859


   490

        UPAPDEBUG(LOG_INFO, ("pap_rauthack: rcvd short packet.\n"));





mbed714

0:d616ece2d859


   491

        return;





mbed714

0:d616ece2d859


   492

      }





mbed714

0:d616ece2d859


   493

      msg = (char *) inp;





mbed714

0:d616ece2d859


   494

      PRINTMSG(msg, msglen);





mbed714

0:d616ece2d859


   495

    }





mbed714

0:d616ece2d859


   496

  }





mbed714

0:d616ece2d859


   497

  UNTIMEOUT(upap_timeout, u);    /* Cancel timeout */





mbed714

0:d616ece2d859


   498

  u->us_clientstate = UPAPCS_OPEN;





mbed714

0:d616ece2d859


   499







mbed714

0:d616ece2d859


   500

  auth_withpeer_success(u->us_unit, PPP_PAP);





mbed714

0:d616ece2d859


   501

}





mbed714

0:d616ece2d859


   502







mbed714

0:d616ece2d859


   503







mbed714

0:d616ece2d859


   504

/*





mbed714

0:d616ece2d859


   505

 * upap_rauthnak - Receive Authenticate-Nak.





mbed714

0:d616ece2d859


   506

 */





mbed714

0:d616ece2d859


   507

static void





mbed714

0:d616ece2d859


   508

upap_rauthnak(upap_state *u, u_char *inp, int id, int len)





mbed714

0:d616ece2d859


   509

{





mbed714

0:d616ece2d859


   510

  u_char msglen;





mbed714

0:d616ece2d859


   511

  char *msg;





mbed714

0:d616ece2d859


   512







mbed714

0:d616ece2d859


   513

  LWIP_UNUSED_ARG(id);





mbed714

0:d616ece2d859


   514







mbed714

0:d616ece2d859


   515

  UPAPDEBUG(LOG_INFO, ("pap_rauthnak: Rcvd id %d s=%d\n", id, u->us_clientstate));





mbed714

0:d616ece2d859


   516







mbed714

0:d616ece2d859


   517

  if (u->us_clientstate != UPAPCS_AUTHREQ) { /* XXX */





mbed714

0:d616ece2d859


   518

    return;





mbed714

0:d616ece2d859


   519

  }





mbed714

0:d616ece2d859


   520







mbed714

0:d616ece2d859


   521

  /*





mbed714

0:d616ece2d859


   522

   * Parse message.





mbed714

0:d616ece2d859


   523

   */





mbed714

0:d616ece2d859


   524

  if (len < sizeof (u_char)) {





mbed714

0:d616ece2d859


   525

    UPAPDEBUG(LOG_INFO, ("pap_rauthnak: ignoring missing msg-length.\n"));





mbed714

0:d616ece2d859


   526

  } else {





mbed714

0:d616ece2d859


   527

    GETCHAR(msglen, inp);





mbed714

0:d616ece2d859


   528

    if(msglen > 0) {





mbed714

0:d616ece2d859


   529

      len -= sizeof (u_char);





mbed714

0:d616ece2d859


   530

      if (len < msglen) {





mbed714

0:d616ece2d859


   531

        UPAPDEBUG(LOG_INFO, ("pap_rauthnak: rcvd short packet.\n"));





mbed714

0:d616ece2d859


   532

        return;





mbed714

0:d616ece2d859


   533

      }





mbed714

0:d616ece2d859


   534

      msg = (char *) inp;





mbed714

0:d616ece2d859


   535

      PRINTMSG(msg, msglen);





mbed714

0:d616ece2d859


   536

    }





mbed714

0:d616ece2d859


   537

  }





mbed714

0:d616ece2d859


   538







mbed714

0:d616ece2d859


   539

  u->us_clientstate = UPAPCS_BADAUTH;





mbed714

0:d616ece2d859


   540







mbed714

0:d616ece2d859


   541

  UPAPDEBUG(LOG_ERR, ("PAP authentication failed\n"));





mbed714

0:d616ece2d859


   542

  auth_withpeer_fail(u->us_unit, PPP_PAP);





mbed714

0:d616ece2d859


   543

}





mbed714

0:d616ece2d859


   544







mbed714

0:d616ece2d859


   545







mbed714

0:d616ece2d859


   546

/*





mbed714

0:d616ece2d859


   547

 * upap_sauthreq - Send an Authenticate-Request.





mbed714

0:d616ece2d859


   548

 */





mbed714

0:d616ece2d859


   549

static void





mbed714

0:d616ece2d859


   550

upap_sauthreq(upap_state *u)





mbed714

0:d616ece2d859


   551

{





mbed714

0:d616ece2d859


   552

  u_char *outp;





mbed714

0:d616ece2d859


   553

  int outlen;





mbed714

0:d616ece2d859


   554







mbed714

0:d616ece2d859


   555

  outlen = UPAP_HEADERLEN + 2 * sizeof (u_char) 





mbed714

0:d616ece2d859


   556

         + u->us_userlen + u->us_passwdlen;





mbed714

0:d616ece2d859


   557

  outp = outpacket_buf[u->us_unit];





mbed714

0:d616ece2d859


   558







mbed714

0:d616ece2d859


   559

  MAKEHEADER(outp, PPP_PAP);





mbed714

0:d616ece2d859


   560







mbed714

0:d616ece2d859


   561

  PUTCHAR(UPAP_AUTHREQ, outp);





mbed714

0:d616ece2d859


   562

  PUTCHAR(++u->us_id, outp);





mbed714

0:d616ece2d859


   563

  PUTSHORT(outlen, outp);





mbed714

0:d616ece2d859


   564

  PUTCHAR(u->us_userlen, outp);





mbed714

0:d616ece2d859


   565

  BCOPY(u->us_user, outp, u->us_userlen);





mbed714

0:d616ece2d859


   566

  INCPTR(u->us_userlen, outp);





mbed714

0:d616ece2d859


   567

  PUTCHAR(u->us_passwdlen, outp);





mbed714

0:d616ece2d859


   568

  BCOPY(u->us_passwd, outp, u->us_passwdlen);





mbed714

0:d616ece2d859


   569







mbed714

0:d616ece2d859


   570

  pppWrite(u->us_unit, outpacket_buf[u->us_unit], outlen + PPP_HDRLEN);





mbed714

0:d616ece2d859


   571







mbed714

0:d616ece2d859


   572

  UPAPDEBUG(LOG_INFO, ("pap_sauth: Sent id %d\n", u->us_id));





mbed714

0:d616ece2d859


   573







mbed714

0:d616ece2d859


   574

  TIMEOUT(upap_timeout, u, u->us_timeouttime);





mbed714

0:d616ece2d859


   575

  ++u->us_transmits;





mbed714

0:d616ece2d859


   576

  u->us_clientstate = UPAPCS_AUTHREQ;





mbed714

0:d616ece2d859


   577

}





mbed714

0:d616ece2d859


   578







mbed714

0:d616ece2d859


   579







mbed714

0:d616ece2d859


   580

/*





mbed714

0:d616ece2d859


   581

 * upap_sresp - Send a response (ack or nak).





mbed714

0:d616ece2d859


   582

 */





mbed714

0:d616ece2d859


   583

static void





mbed714

0:d616ece2d859


   584

upap_sresp(upap_state *u, u_char code, u_char id, char *msg, int msglen)





mbed714

0:d616ece2d859


   585

{





mbed714

0:d616ece2d859


   586

  u_char *outp;





mbed714

0:d616ece2d859


   587

  int outlen;





mbed714

0:d616ece2d859


   588







mbed714

0:d616ece2d859


   589

  outlen = UPAP_HEADERLEN + sizeof (u_char) + msglen;





mbed714

0:d616ece2d859


   590

  outp = outpacket_buf[u->us_unit];





mbed714

0:d616ece2d859


   591

  MAKEHEADER(outp, PPP_PAP);





mbed714

0:d616ece2d859


   592







mbed714

0:d616ece2d859


   593

  PUTCHAR(code, outp);





mbed714

0:d616ece2d859


   594

  PUTCHAR(id, outp);





mbed714

0:d616ece2d859


   595

  PUTSHORT(outlen, outp);





mbed714

0:d616ece2d859


   596

  PUTCHAR(msglen, outp);





mbed714

0:d616ece2d859


   597

  BCOPY(msg, outp, msglen);





mbed714

0:d616ece2d859


   598

  pppWrite(u->us_unit, outpacket_buf[u->us_unit], outlen + PPP_HDRLEN);





mbed714

0:d616ece2d859


   599







mbed714

0:d616ece2d859


   600

  UPAPDEBUG(LOG_INFO, ("pap_sresp: Sent code %d, id %d s=%d\n", code, id, u->us_clientstate));





mbed714

0:d616ece2d859


   601

}





mbed714

0:d616ece2d859


   602







mbed714

0:d616ece2d859


   603

#if PPP_ADDITIONAL_CALLBACKS





mbed714

0:d616ece2d859


   604

static char *upap_codenames[] = {





mbed714

0:d616ece2d859


   605

    "AuthReq", "AuthAck", "AuthNak"





mbed714

0:d616ece2d859


   606

};





mbed714

0:d616ece2d859


   607







mbed714

0:d616ece2d859


   608

/*





mbed714

0:d616ece2d859


   609

 * upap_printpkt - print the contents of a PAP packet.





mbed714

0:d616ece2d859


   610

 */





mbed714

0:d616ece2d859


   611

static int upap_printpkt(





mbed714

0:d616ece2d859


   612

  u_char *p,





mbed714

0:d616ece2d859


   613

  int plen,





mbed714

0:d616ece2d859


   614

  void (*printer) (void *, char *, ...),





mbed714

0:d616ece2d859


   615

  void *arg





mbed714

0:d616ece2d859


   616

)





mbed714

0:d616ece2d859


   617

{





mbed714

0:d616ece2d859


   618

  LWIP_UNUSED_ARG(p);





mbed714

0:d616ece2d859


   619

  LWIP_UNUSED_ARG(plen);





mbed714

0:d616ece2d859


   620

  LWIP_UNUSED_ARG(printer);





mbed714

0:d616ece2d859


   621

  LWIP_UNUSED_ARG(arg);





mbed714

0:d616ece2d859


   622

  return 0;





mbed714

0:d616ece2d859


   623

}





mbed714

0:d616ece2d859


   624

#endif /* PPP_ADDITIONAL_CALLBACKS */





mbed714

0:d616ece2d859


   625







mbed714

0:d616ece2d859


   626

#endif /* PAP_SUPPORT */





mbed714

0:d616ece2d859


   627







mbed714

0:d616ece2d859


   628

#endif /* PPP_SUPPORT */