#include "peap.h"
 #endif /* PPP_WITH_PEAP */
 
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
 #ifdef HAVE_TIME_H
 #include <time.h>
 #endif
 #include <t_server.h>
 #include <t_client.h>
 #include "pppcrypt.h"
-#endif /* USE_SRP */
+#endif /* PPP_WITH_SRP */
 
 #ifndef SHA_DIGESTSIZE
 #define        SHA_DIGESTSIZE 20
 #endif /* PPP_WITH_CHAPMS */
 
 eap_state eap_states[NUM_PPP];         /* EAP state; one for each unit */
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
 static char *pn_secret = NULL;         /* Pseudonym generating secret */
 #endif
 
       "Set max number of EAP Requests allows (client)" },
     { "eap-interval", o_int, &eap_states[0].es_rechallenge,
       "Set interval for EAP rechallenge" },
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
     { "srp-interval", o_int, &eap_states[0].es_lwrechallenge,
       "Set interval for SRP lightweight rechallenge" },
     { "srp-pn-secret", o_string, &pn_secret,
        NULL                    /* say whether to bring up link for this pkt */
 };
 
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
 /*
  * A well-known 2048 bit modulus.
  */
        0x9B, 0x65, 0xE3, 0x72, 0xFC, 0xD6, 0x8E, 0xF2,
        0x0F, 0xA7, 0x11, 0x1F, 0x9E, 0x4A, 0xFF, 0x73
 };
-#endif /* USE_SRP */
+#endif /* PPP_WITH_SRP */
 
 /* Local forward declarations. */
 static void eap_server_timeout (void *arg);
            esp->es_server.ea_peer, esp->es_server.ea_peerlen);
 }
 
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
 /*
  * Set DES key according to pseudonym-generating secret and current
  * date.
        }
        return (outlen);
 }
-#endif /* USE_SRP */
+#endif /* PPP_WITH_SRP */
 
 /*
  * Assume that current waiting server state is complete and figure
 static void
 eap_figure_next_state(eap_state *esp, int status)
 {
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
        unsigned char secbuf[MAXWORDLEN], clear[8], *sp, *dp;
        struct t_pw tpw;
        struct t_confent *tce, mytce;
        int id, i, plen, toffs;
        u_char vals[2];
        struct b64state bs;
-#endif /* USE_SRP */
+#endif /* PPP_WITH_SRP */
 #ifdef PPP_WITH_EAPTLS
        struct eaptls_session *ets;
        int secret_len;
                return;
 
        case eapIdentify:
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
                /* Discard any previous session. */
                ts = (struct t_server *)esp->es_server.ea_session;
                if (ts != NULL) {
                        esp->es_server.ea_session = NULL;
                        esp->es_server.ea_skey = NULL;
                }
-#endif /* USE_SRP */
+#endif /* PPP_WITH_SRP */
                if (status != 0) {
                        esp->es_server.ea_state = eapBadAuth;
                        break;
                }
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
                /* If we've got a pseudonym, try to decode to real name. */
                if (esp->es_server.ea_peerlen > SRP_PSEUDO_LEN &&
                    strncmp(esp->es_server.ea_peer, SRP_PSEUDO_ID,
                        t_servergenexp(ts);
                        break;
                }
-#endif /* USE_SRP */
+#endif /* PPP_WITH_SRP */
 #ifdef PPP_WITH_EAPTLS
                 if (!get_secret(esp->es_unit, esp->es_server.ea_peer,
                     esp->es_server.ea_name, secret, &secret_len, 1)) {
 #endif /* PPP_WITH_EAPTLS */
 
        case eapSRP1:
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
                ts = (struct t_server *)esp->es_server.ea_session;
                if (ts != NULL && status != 0) {
                        t_serverclose(ts);
                        esp->es_server.ea_session = NULL;
                        esp->es_server.ea_skey = NULL;
                }
-#endif /* USE_SRP */
+#endif /* PPP_WITH_SRP */
                if (status == 1) {
                        esp->es_server.ea_state = eapMD5Chall;
                } else if (status != 0 || esp->es_server.ea_session == NULL) {
                break;
 
        case eapSRP2:
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
                ts = (struct t_server *)esp->es_server.ea_session;
                if (ts != NULL && status != 0) {
                        t_serverclose(ts);
                        esp->es_server.ea_session = NULL;
                        esp->es_server.ea_skey = NULL;
                }
-#endif /* USE_SRP */
+#endif /* PPP_WITH_SRP */
                if (status != 0 || esp->es_server.ea_session == NULL) {
                        esp->es_server.ea_state = eapBadAuth;
                } else {
 
        case eapSRP3:
        case eapSRP4:
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
                ts = (struct t_server *)esp->es_server.ea_session;
                if (ts != NULL && status != 0) {
                        t_serverclose(ts);
                        esp->es_server.ea_session = NULL;
                        esp->es_server.ea_skey = NULL;
                }
-#endif /* USE_SRP */
+#endif /* PPP_WITH_SRP */
                if (status != 0 || esp->es_server.ea_session == NULL) {
                        esp->es_server.ea_state = eapBadAuth;
                } else {
        int outlen;
        int challen;
        char *str;
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
        struct t_server *ts;
        u_char clear[8], cipher[8], dig[SHA_DIGESTSIZE], *optr, *cp;
        int i, j;
        struct b64state b64;
        SHA1_CTX ctxt;
-#endif /* USE_SRP */
+#endif /* PPP_WITH_SRP */
 
        /* Handle both initial auth and restart */
        if (esp->es_server.ea_state < eapIdentify &&
                break;
 #endif /* PPP_WITH_EAPTLS */
 
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
        case eapSRP1:
                PUTCHAR(EAPT_SRP, outp);
                PUTCHAR(EAPSRP_CHALLENGE, outp);
                BCOPY(esp->es_challenge, outp, esp->es_challen);
                INCPTR(esp->es_challen, outp);
                break;
-#endif /* USE_SRP */
+#endif /* PPP_WITH_SRP */
 
        default:
                return;
        output(esp->es_unit, outpacket_buf, PPP_HDRLEN + msglen);
 }
 
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
 /*
  * Format and send a SRP EAP Response message.
  */
 
        output(esp->es_unit, outpacket_buf, PPP_HDRLEN + msglen);
 }
-#endif /* USE_SRP */
+#endif /* PPP_WITH_SRP */
 
 #ifdef PPP_WITH_EAPTLS
 /*
        output(esp->es_unit, outpacket_buf, PPP_HDRLEN + msglen);
 }
 
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
 static char *
 name_of_pn_file(void)
 {
                remove_pn_file();
        }
 }
-#endif /* USE_SRP */
+#endif /* PPP_WITH_SRP */
 
 #if PPP_WITH_CHAPMS
 /*
        struct eaptls_session *ets = esp->es_client.ea_session;
 #endif /* PPP_WITH_EAPTLS */
 
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
        struct t_client *tc;
        struct t_num sval, gval, Nval, *Ap, Bval;
        u_char vals[2];
        SHA1_CTX ctxt;
        u_char dig[SHA_DIGESTSIZE];
        int fd;
-#endif /* USE_SRP */
+#endif /* PPP_WITH_SRP */
 
        /*
         * Ignore requests if we're not open
        case EAPT_IDENTITY:
                if (len > 0)
                        info("EAP: Identity prompt \"%.*q\"", len, inp);
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
                if (esp->es_usepseudo &&
                    (esp->es_usedpseudo == 0 ||
                        (esp->es_usedpseudo == 1 &&
                        remove_pn_file();
                        esp->es_usedpseudo = 2;
                }
-#endif /* USE_SRP */
+#endif /* PPP_WITH_SRP */
                eap_send_response(esp, id, typenum, (u_char *)esp->es_client.ea_name,
                    esp->es_client.ea_namelen);
                break;
                break;
 #endif /* PPP_WITH_EAPTLS */
 
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
        case EAPT_SRP:
                if (len < 1) {
                        error("EAP: received empty SRP Request");
                        break;
                }
                break;
-#endif /* USE_SRP */
+#endif /* PPP_WITH_SRP */
     
 #ifdef PPP_WITH_CHAPMS
         case EAPT_MSCHAPV2:
                UNTIMEOUT(eap_client_timeout, (void *)esp);
        }
        esp->es_client.ea_session = NULL;
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
        t_clientclose(tc);
        auth_withpeer_fail(esp->es_unit, PPP_EAP);
-#endif /* USE_SRP */
+#endif /* PPP_WITH_SRP */
 }
 
 /*
        char rhostname[256];
        MD5_CTX mdContext;
        u_char hash[MD5_SIGNATURE_SIZE];
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
        struct t_server *ts;
        struct t_num A;
        SHA1_CTX ctxt;
        u_char dig[SHA_DIGESTSIZE];
-#endif /* USE_SRP */
+#endif /* PPP_WITH_SRP */
 
 #ifdef PPP_WITH_EAPTLS
        struct eaptls_session *ets;
                break;
 #endif /* PPP_WITH_CHAPMS */
 
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
        case EAPT_SRP:
                if (len < 1) {
                        error("EAP: empty SRP Response");
                        break;
                }
                break;
-#endif /* USE_SRP */
+#endif /* PPP_WITH_SRP */
 
        default:
                /* This can't happen. */
                        break;
 #endif /* PPP_WITH_EAPTLS */
 
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
                case EAPT_SRP:
                        if (len < 3)
                                goto truncated;
                                break;
                        }
                        break;
-#endif  /* USE_SRP */
+#endif  /* PPP_WITH_SRP */
                }
                break;
 
                        break;
 #endif /* PPP_WITH_CHAPMS */
 
-#ifdef USE_SRP
+#ifdef PPP_WITH_SRP
                case EAPT_SRP:
                        if (len < 1)
                                goto truncated;
                                break;
                        }
                        break;
-#endif  /* USE_SRP */
+#endif  /* PPP_WITH_SRP */
                }
                break;