Use sane macro names for codes. PW_CODE_AUTHENTICATION_ACK, PW_CODE_AUTHENTICATION_RE...

diff --git a/src/include/radius.h b/src/include/radius.h
index 860b6f8..2ef4098 100644 (file)
--- a/src/include/radius.h
+++ b/src/include/radius.h
@@ -36,9 +36,9 @@ typedef enum {
 
 typedef enum {
        PW_CODE_UNDEFINED               = 0,    //!< Packet code has not been set
-       PW_CODE_AUTHENTICATION_REQUEST  = 1,    //!< RFC2865 - Access-Request
-       PW_CODE_AUTHENTICATION_ACK      = 2,    //!< RFC2865 - Access-Accept
-       PW_CODE_AUTHENTICATION_REJECT   = 3,    //!< RFC2865 - Access-Reject
+       PW_CODE_ACCESS_REQUEST  = 1,    //!< RFC2865 - Access-Request
+       PW_CODE_ACCESS_ACCEPT   = 2,    //!< RFC2865 - Access-Accept
+       PW_CODE_ACCESS_REJECT   = 3,    //!< RFC2865 - Access-Reject
        PW_CODE_ACCOUNTING_REQUEST      = 4,    //!< RFC2866 - Accounting-Request
        PW_CODE_ACCOUNTING_RESPONSE     = 5,    //!< RFC2866 - Accounting-Response
        PW_CODE_ACCOUNTING_STATUS       = 6,    //!< RFC3575 - Reserved

diff --git a/src/lib/radius.c b/src/lib/radius.c
index 13f2112..feb7c19 100644 (file)
--- a/src/lib/radius.c
+++ b/src/lib/radius.c
@@ -945,8 +945,8 @@ static ssize_t vp2data_any(RADIUS_PACKET const *packet,
                if (room < (18 + lvalue)) return 0;
 
                switch (packet->code) {
-               case PW_CODE_AUTHENTICATION_ACK:
-               case PW_CODE_AUTHENTICATION_REJECT:
+               case PW_CODE_ACCESS_ACCEPT:
+               case PW_CODE_ACCESS_REJECT:
                case PW_CODE_ACCESS_CHALLENGE:
                default:
                        if (!original) {
@@ -1736,8 +1736,8 @@ int rad_encode(RADIUS_PACKET *packet, RADIUS_PACKET const *original,
         *      Double-check some things based on packet code.
         */
        switch (packet->code) {
-       case PW_CODE_AUTHENTICATION_ACK:
-       case PW_CODE_AUTHENTICATION_REJECT:
+       case PW_CODE_ACCESS_ACCEPT:
+       case PW_CODE_ACCESS_REJECT:
        case PW_CODE_ACCESS_CHALLENGE:
                if (!original) {
                        fr_strerror_printf("ERROR: Cannot sign response packet without a request packet");
@@ -1932,8 +1932,8 @@ int rad_sign(RADIUS_PACKET *packet, RADIUS_PACKET const *original,
                        break;
 
                do_ack:
-               case PW_CODE_AUTHENTICATION_ACK:
-               case PW_CODE_AUTHENTICATION_REJECT:
+               case PW_CODE_ACCESS_ACCEPT:
+               case PW_CODE_ACCESS_REJECT:
                case PW_CODE_ACCESS_CHALLENGE:
                        if (!original) {
                                fr_strerror_printf("ERROR: Cannot sign response packet without a request packet");
@@ -1975,7 +1975,7 @@ int rad_sign(RADIUS_PACKET *packet, RADIUS_PACKET const *original,
                 *      Request packets are not signed, bur
                 *      have a random authentication vector.
                 */
-       case PW_CODE_AUTHENTICATION_REQUEST:
+       case PW_CODE_ACCESS_REQUEST:
        case PW_CODE_STATUS_SERVER:
                break;
 
@@ -2786,8 +2786,8 @@ int rad_verify(RADIUS_PACKET *packet, RADIUS_PACKET *original,
                                break;
 
                        do_ack:
-                       case PW_CODE_AUTHENTICATION_ACK:
-                       case PW_CODE_AUTHENTICATION_REJECT:
+                       case PW_CODE_ACCESS_ACCEPT:
+                       case PW_CODE_ACCESS_REJECT:
                        case PW_CODE_ACCESS_CHALLENGE:
                        case PW_CODE_DISCONNECT_ACK:
                        case PW_CODE_DISCONNECT_NAK:
@@ -2849,7 +2849,7 @@ int rad_verify(RADIUS_PACKET *packet, RADIUS_PACKET *original,
                int rcode;
                char buffer[32];
 
-               case PW_CODE_AUTHENTICATION_REQUEST:
+               case PW_CODE_ACCESS_REQUEST:
                case PW_CODE_STATUS_SERVER:
                        /*
                         *      The authentication vector is random
@@ -2872,8 +2872,8 @@ int rad_verify(RADIUS_PACKET *packet, RADIUS_PACKET *original,
                        break;
 
                        /* Verify the reply digest */
-               case PW_CODE_AUTHENTICATION_ACK:
-               case PW_CODE_AUTHENTICATION_REJECT:
+               case PW_CODE_ACCESS_ACCEPT:
+               case PW_CODE_ACCESS_REJECT:
                case PW_CODE_ACCESS_CHALLENGE:
                case PW_CODE_ACCOUNTING_RESPONSE:
                case PW_CODE_DISCONNECT_ACK:

diff --git a/src/main/auth.c b/src/main/auth.c
index a05fd6a..9073c64 100644 (file)
--- a/src/main/auth.c
+++ b/src/main/auth.c
@@ -310,7 +310,7 @@ int rad_postauth(REQUEST *request)
                case RLM_MODULE_REJECT:
                case RLM_MODULE_USERLOCK:
                default:
-                       request->reply->code = PW_CODE_AUTHENTICATION_REJECT;
+                       request->reply->code = PW_CODE_ACCESS_REJECT;
                        result = RLM_MODULE_REJECT;
                        break;
                /*
@@ -368,7 +368,7 @@ int rad_authenticate(REQUEST *request)
                 *      Reply of ACCEPT means accept, thus set Auth-Type
                 *      accordingly.
                 */
-               case PW_CODE_AUTHENTICATION_ACK:
+               case PW_CODE_ACCESS_ACCEPT:
                        tmp = radius_paircreate(request,
                                                &request->config_items,
                                                PW_AUTH_TYPE, 0);
@@ -390,10 +390,10 @@ int rad_authenticate(REQUEST *request)
                 *      are being rejected, so we minimize the amount of work
                 *      done by the server, by rejecting them here.
                 */
-               case PW_CODE_AUTHENTICATION_REJECT:
+               case PW_CODE_ACCESS_REJECT:
                        rad_authlog("Login incorrect (Home Server says so)",
                                    request, 0);
-                       request->reply->code = PW_CODE_AUTHENTICATION_REJECT;
+                       request->reply->code = PW_CODE_ACCESS_REJECT;
                        return RLM_MODULE_REJECT;
 
                default:
@@ -439,7 +439,7 @@ autz_redo:
                        } else {
                                rad_authlog("Invalid user", request, 0);
                        }
-                       request->reply->code = PW_CODE_AUTHENTICATION_REJECT;
+                       request->reply->code = PW_CODE_ACCESS_REJECT;
                        return result;
        }
        if (!autz_retry) {
@@ -514,7 +514,7 @@ autz_redo:
         */
        if (result < 0) {
                RDEBUG2("Failed to authenticate the user");
-               request->reply->code = PW_CODE_AUTHENTICATION_REJECT;
+               request->reply->code = PW_CODE_ACCESS_REJECT;
 
                if ((module_msg = pairfind(request->packet->vps, PW_MODULE_FAILURE_MESSAGE, 0, TAG_ANY)) != NULL){
                        char msg[MAX_STRING_LEN+19];
@@ -592,7 +592,7 @@ autz_redo:
                                                 main_config.denied_msg);
                                }
 
-                               request->reply->code = PW_CODE_AUTHENTICATION_REJECT;
+                               request->reply->code = PW_CODE_ACCESS_REJECT;
 
                                /*
                                 *      They're trying to log in too many times.
@@ -626,7 +626,7 @@ autz_redo:
         *      been set to something.  (i.e. Access-Challenge)
         */
        if (request->reply->code == 0)
-         request->reply->code = PW_CODE_AUTHENTICATION_ACK;
+         request->reply->code = PW_CODE_ACCESS_ACCEPT;
 
        if ((module_msg = pairfind(request->packet->vps, PW_MODULE_SUCCESS_MESSAGE, 0, TAG_ANY)) != NULL){
                char msg[MAX_STRING_LEN+12];
@@ -654,17 +654,17 @@ int rad_virtual_server(REQUEST *request)
         *      We currently only handle AUTH packets here.
         *      This could be expanded to handle other packets as well if required.
         */
-       rad_assert(request->packet->code == PW_CODE_AUTHENTICATION_REQUEST);
+       rad_assert(request->packet->code == PW_CODE_ACCESS_REQUEST);
 
        result = rad_authenticate(request);
 
-       if (request->reply->code == PW_CODE_AUTHENTICATION_REJECT) {
+       if (request->reply->code == PW_CODE_ACCESS_REJECT) {
                pairdelete(&request->config_items, PW_POST_AUTH_TYPE, 0, TAG_ANY);
                vp = pairmake_config("Post-Auth-Type", "Reject", T_OP_SET);
                if (vp) rad_postauth(request);
        }
 
-       if (request->reply->code == PW_CODE_AUTHENTICATION_ACK) {
+       if (request->reply->code == PW_CODE_ACCESS_ACCEPT) {
                rad_postauth(request);
        }
 

diff --git a/src/main/command.c b/src/main/command.c
index b100d8a..14a0c40 100644 (file)
--- a/src/main/command.c
+++ b/src/main/command.c
@@ -1313,7 +1313,7 @@ static int command_inject_file(rad_listen_t *listener, int argc, char *argv[])
        packet->id = inject_id++;
 
        if (fake->type == RAD_LISTEN_AUTH) {
-               packet->code = PW_CODE_AUTHENTICATION_REQUEST;
+               packet->code = PW_CODE_ACCESS_REQUEST;
                fun = rad_authenticate;
 
        } else {

diff --git a/src/main/listen.c b/src/main/listen.c
index 5727f92..492eb17 100644 (file)
--- a/src/main/listen.c
+++ b/src/main/listen.c
@@ -331,7 +331,7 @@ int rad_status_server(REQUEST *request)
                switch (rcode) {
                case RLM_MODULE_OK:
                case RLM_MODULE_UPDATED:
-                       request->reply->code = PW_CODE_AUTHENTICATION_ACK;
+                       request->reply->code = PW_CODE_ACCESS_ACCEPT;
                        break;
 
                case RLM_MODULE_FAIL:
@@ -341,7 +341,7 @@ int rad_status_server(REQUEST *request)
 
                default:
                case RLM_MODULE_REJECT:
-                       request->reply->code = PW_CODE_AUTHENTICATION_REJECT;
+                       request->reply->code = PW_CODE_ACCESS_REJECT;
                        break;
                }
                break;
@@ -486,7 +486,7 @@ static int dual_tcp_recv(rad_listen_t *listener)
         *      Some sanity checks, based on the packet code.
         */
        switch(packet->code) {
-       case PW_CODE_AUTHENTICATION_REQUEST:
+       case PW_CODE_ACCESS_REQUEST:
                if (listener->type != RAD_LISTEN_AUTH) goto bad_packet;
                FR_STATS_INC(auth, total_requests);
                fun = rad_authenticate;
@@ -1444,7 +1444,7 @@ static int auth_socket_recv(rad_listen_t *listener)
         *      Some sanity checks, based on the packet code.
         */
        switch(code) {
-       case PW_CODE_AUTHENTICATION_REQUEST:
+       case PW_CODE_ACCESS_REQUEST:
                fun = rad_authenticate;
                break;
 
@@ -1857,9 +1857,9 @@ static int proxy_socket_recv(rad_listen_t *listener)
         *      FIXME: Client MIB updates?
         */
        switch(packet->code) {
-       case PW_CODE_AUTHENTICATION_ACK:
+       case PW_CODE_ACCESS_ACCEPT:
        case PW_CODE_ACCESS_CHALLENGE:
-       case PW_CODE_AUTHENTICATION_REJECT:
+       case PW_CODE_ACCESS_REJECT:
                break;
 
 #ifdef WITH_ACCOUNTING
@@ -1919,9 +1919,9 @@ static int proxy_socket_tcp_recv(rad_listen_t *listener)
         *      FIXME: Client MIB updates?
         */
        switch(packet->code) {
-       case PW_CODE_AUTHENTICATION_ACK:
+       case PW_CODE_ACCESS_ACCEPT:
        case PW_CODE_ACCESS_CHALLENGE:
-       case PW_CODE_AUTHENTICATION_REJECT:
+       case PW_CODE_ACCESS_REJECT:
                break;
 
 #ifdef WITH_ACCOUNTING

diff --git a/src/main/process.c b/src/main/process.c
index 60cdadc..963cb83 100644 (file)
--- a/src/main/process.c
+++ b/src/main/process.c
@@ -1285,16 +1285,16 @@ STATE_MACHINE_DECL(request_finish)
        /*
         *      Catch Auth-Type := Reject BEFORE proxying the packet.
         */
-       else if (request->packet->code == PW_CODE_AUTHENTICATION_REQUEST) {
+       else if (request->packet->code == PW_CODE_ACCESS_REQUEST) {
                if (request->reply->code == 0) {
                        vp = pairfind(request->config_items, PW_AUTH_TYPE, 0, TAG_ANY);
 
-                       if (!vp || (vp->vp_integer != PW_CODE_AUTHENTICATION_REJECT)) {
+                       if (!vp || (vp->vp_integer != PW_CODE_ACCESS_REJECT)) {
                                RDEBUG2("There was no response configured: "
                                        "rejecting request");
                        }
 
-                       request->reply->code = PW_CODE_AUTHENTICATION_REJECT;
+                       request->reply->code = PW_CODE_ACCESS_REJECT;
                }
        }
 
@@ -1306,7 +1306,7 @@ STATE_MACHINE_DECL(request_finish)
        if (vp) pairadd(&request->reply->vps, vp);
 
        switch (request->reply->code) {
-       case PW_CODE_AUTHENTICATION_ACK:
+       case PW_CODE_ACCESS_ACCEPT:
                rad_postauth(request);
                break;
        case PW_CODE_ACCESS_CHALLENGE:
@@ -1327,7 +1327,7 @@ STATE_MACHINE_DECL(request_finish)
         *      We do this separately so ACK and challenge can change the code
         *      to reject if a module returns reject.
         */
-       if (request->reply->code == PW_CODE_AUTHENTICATION_REJECT) {
+       if (request->reply->code == PW_CODE_ACCESS_REJECT) {
                pairdelete(&request->config_items, PW_POST_AUTH_TYPE, 0, TAG_ANY);
                vp = pairmake_config("Post-Auth-Type", "Reject", T_OP_SET);
                if (vp) rad_postauth(request);
@@ -1364,7 +1364,7 @@ STATE_MACHINE_DECL(request_finish)
        /*
         *      See if we need to delay an Access-Reject packet.
         */
-       if ((request->reply->code == PW_CODE_AUTHENTICATION_REJECT) &&
+       if ((request->reply->code == PW_CODE_ACCESS_REJECT) &&
            (request->root->reject_delay > 0)) {
                request->response_delay = request->root->reject_delay;
 
@@ -1553,7 +1553,7 @@ int request_receive(rad_listen_t *listener, RADIUS_PACKET *packet,
 
 #ifdef WITH_STATS
                                switch (packet->code) {
-                               case PW_CODE_AUTHENTICATION_REQUEST:
+                               case PW_CODE_ACCESS_REQUEST:
                                        FR_STATS_INC(auth, total_dup_requests);
                                        break;
 
@@ -1712,7 +1712,7 @@ static REQUEST *request_setup(rad_listen_t *listener, RADIUS_PACKET *packet,
 
 #ifdef WITH_STATS
        request->listener->stats.last_packet = request->packet->timestamp.tv_sec;
-       if (packet->code == PW_CODE_AUTHENTICATION_REQUEST) {
+       if (packet->code == PW_CODE_ACCESS_REQUEST) {
                request->client->auth.last_packet = request->packet->timestamp.tv_sec;
                radius_auth_stats.last_packet = request->packet->timestamp.tv_sec;
 #ifdef WITH_ACCOUNTING
@@ -2156,7 +2156,7 @@ static int process_proxy_reply(REQUEST *request, RADIUS_PACKET *reply)
         *      post-proxy-type Reject
         */
        if (!vp && reply &&
-           reply->code == PW_CODE_AUTHENTICATION_REJECT) {
+           reply->code == PW_CODE_ACCESS_REJECT) {
                DICT_VALUE      *dval;
 
                dval = dict_valbyname(PW_POST_PROXY_TYPE, 0, "Reject");
@@ -2342,7 +2342,7 @@ int request_proxy_reply(RADIUS_PACKET *packet)
        request->home_server->stats.last_packet = packet->timestamp.tv_sec;
        request->proxy_listener->stats.last_packet = packet->timestamp.tv_sec;
 
-       if (request->proxy->code == PW_CODE_AUTHENTICATION_REQUEST) {
+       if (request->proxy->code == PW_CODE_ACCESS_REQUEST) {
                proxy_auth_stats.last_packet = packet->timestamp.tv_sec;
 #ifdef WITH_ACCOUNTING
        } else if (request->proxy->code == PW_CODE_ACCOUNTING_REQUEST) {
@@ -2377,7 +2377,7 @@ static int setup_post_proxy_fail(REQUEST *request)
        DICT_VALUE const *dval = NULL;
        VALUE_PAIR *vp;
 
-       if (request->proxy->code == PW_CODE_AUTHENTICATION_REQUEST) {
+       if (request->proxy->code == PW_CODE_ACCESS_REQUEST) {
                dval = dict_valbyname(PW_POST_PROXY_TYPE, 0,
                                      "Fail-Authentication");
 
@@ -2496,7 +2496,7 @@ static int request_will_proxy(REQUEST *request)
                /*
                 *      Figure out which pool to use.
                 */
-               if (request->packet->code == PW_CODE_AUTHENTICATION_REQUEST) {
+               if (request->packet->code == PW_CODE_ACCESS_REQUEST) {
                        pool = realm->auth_pool;
 
 #ifdef WITH_ACCOUNTING
@@ -2521,7 +2521,7 @@ static int request_will_proxy(REQUEST *request)
                if (!vp) return 0;
 
                switch (request->packet->code) {
-               case PW_CODE_AUTHENTICATION_REQUEST:
+               case PW_CODE_ACCESS_REQUEST:
                        pool_type = HOME_TYPE_AUTH;
                        break;
 
@@ -2623,7 +2623,7 @@ static int request_will_proxy(REQUEST *request)
         *      since we can't use the request authenticator
         *      anymore - we changed it.
         */
-       if ((request->packet->code == PW_CODE_AUTHENTICATION_REQUEST) &&
+       if ((request->packet->code == PW_CODE_ACCESS_REQUEST) &&
            pairfind(request->proxy->vps, PW_CHAP_PASSWORD, 0, TAG_ANY) &&
            pairfind(request->proxy->vps, PW_CHAP_CHALLENGE, 0, TAG_ANY) == NULL) {
                vp = radius_paircreate(request->proxy, &request->proxy->vps, PW_CHAP_CHALLENGE, 0);
@@ -3025,7 +3025,7 @@ static void ping_home_server(void *ctx)
                         "Message-Authenticator", "0x00", T_OP_SET);
 
        } else if (home->type == HOME_TYPE_AUTH) {
-               request->proxy->code = PW_CODE_AUTHENTICATION_REQUEST;
+               request->proxy->code = PW_CODE_ACCESS_REQUEST;
 
                pairmake(request->proxy, &request->proxy->vps,
                         "User-Name", home->ping_user_name, T_OP_SET);

diff --git a/src/main/radclient.c b/src/main/radclient.c
index bf641a8..b27336b 100644 (file)
--- a/src/main/radclient.c
+++ b/src/main/radclient.c
@@ -114,7 +114,7 @@ static void NEVER_RETURNS usage(void)
 }
 
 static const FR_NAME_NUMBER request_types[] = {
-       { "auth",       PW_CODE_AUTHENTICATION_REQUEST },
+       { "auth",       PW_CODE_ACCESS_REQUEST },
        { "challenge",  PW_CODE_ACCESS_CHALLENGE },
        { "acct",       PW_CODE_ACCOUNTING_REQUEST },
        { "status",     PW_CODE_STATUS_SERVER },
@@ -215,7 +215,7 @@ static void radclient_get_port(PW_CODE type, uint16_t *port)
 {
        switch (type) {
        default:
-       case PW_CODE_AUTHENTICATION_REQUEST:
+       case PW_CODE_ACCESS_REQUEST:
        case PW_CODE_ACCESS_CHALLENGE:
        case PW_CODE_STATUS_SERVER:
                if (*port == 0) *port = getport("radius");
@@ -245,7 +245,7 @@ static void radclient_get_port(PW_CODE type, uint16_t *port)
 static PW_CODE radclient_get_code(port)
 {
        if ((port == getport("radius")) || (port == PW_AUTH_UDP_PORT) || (port == PW_AUTH_UDP_PORT_ALT)) {
-               return PW_CODE_AUTHENTICATION_REQUEST;
+               return PW_CODE_ACCESS_REQUEST;
        }
        if ((port == getport("radacct")) || (port == PW_ACCT_UDP_PORT) || (port == PW_ACCT_UDP_PORT_ALT)) {
                return PW_CODE_ACCOUNTING_REQUEST;
@@ -538,8 +538,8 @@ static int radclient_init(TALLOC_CTX *ctx, rc_file_pair_t *files)
                 */
                if (request->filter_code == PW_CODE_UNDEFINED) {
                        switch (request->packet->code) {
-                       case PW_CODE_AUTHENTICATION_REQUEST:
-                               request->filter_code = PW_CODE_AUTHENTICATION_ACK;
+                       case PW_CODE_ACCESS_REQUEST:
+                               request->filter_code = PW_CODE_ACCESS_ACCEPT;
                                break;
 
                        case PW_CODE_ACCOUNTING_REQUEST:
@@ -556,8 +556,8 @@ static int radclient_init(TALLOC_CTX *ctx, rc_file_pair_t *files)
 
                        case PW_CODE_STATUS_SERVER:
                                switch (radclient_get_code(request->packet->dst_port)) {
-                               case PW_CODE_AUTHENTICATION_REQUEST:
-                                       request->filter_code = PW_CODE_AUTHENTICATION_ACK;
+                               case PW_CODE_ACCESS_REQUEST:
+                                       request->filter_code = PW_CODE_ACCESS_ACCEPT;
                                        break;
 
                                case PW_CODE_ACCOUNTING_REQUEST:
@@ -587,9 +587,9 @@ static int radclient_init(TALLOC_CTX *ctx, rc_file_pair_t *files)
                 */
                } else if (request->packet->code == PW_CODE_UNDEFINED) {
                        switch (request->filter_code) {
-                       case PW_CODE_AUTHENTICATION_ACK:
-                       case PW_CODE_AUTHENTICATION_REJECT:
-                               request->packet->code = PW_CODE_AUTHENTICATION_REQUEST;
+                       case PW_CODE_ACCESS_ACCEPT:
+                       case PW_CODE_ACCESS_REJECT:
+                               request->packet->code = PW_CODE_ACCESS_REQUEST;
                                break;
 
                        case PW_CODE_ACCOUNTING_RESPONSE:
@@ -1065,7 +1065,7 @@ static int recv_one_packet(int wait_time)
         *      Increment counters...
         */
        switch (request->reply->code) {
-       case PW_CODE_AUTHENTICATION_ACK:
+       case PW_CODE_ACCESS_ACCEPT:
        case PW_CODE_ACCOUNTING_RESPONSE:
        case PW_CODE_COA_ACK:
        case PW_CODE_DISCONNECT_ACK:

diff --git a/src/main/radsniff.c b/src/main/radsniff.c
index 3c05c49..cc9f46d 100644 (file)
--- a/src/main/radsniff.c
+++ b/src/main/radsniff.c
@@ -61,9 +61,9 @@ static char const *radsniff_version = "radsniff version " RADIUSD_VERSION_STRING
 ", built on " __DATE__ " at " __TIME__;
 
 static int rs_useful_codes[] = {
-       PW_CODE_AUTHENTICATION_REQUEST,         //!< RFC2865 - Authentication request
-       PW_CODE_AUTHENTICATION_ACK,             //!< RFC2865 - Access-Accept
-       PW_CODE_AUTHENTICATION_REJECT,          //!< RFC2865 - Access-Reject
+       PW_CODE_ACCESS_REQUEST,         //!< RFC2865 - Authentication request
+       PW_CODE_ACCESS_ACCEPT,          //!< RFC2865 - Access-Accept
+       PW_CODE_ACCESS_REJECT,          //!< RFC2865 - Access-Reject
        PW_CODE_ACCOUNTING_REQUEST,             //!< RFC2866 - Accounting-Request
        PW_CODE_ACCOUNTING_RESPONSE,            //!< RFC2866 - Accounting-Response
        PW_CODE_ACCESS_CHALLENGE,               //!< RFC2865 - Access-Challenge
@@ -1065,8 +1065,8 @@ static void rs_packet_process(uint64_t count, rs_event_t *event, struct pcap_pkt
 
        switch (current->code) {
        case PW_CODE_ACCOUNTING_RESPONSE:
-       case PW_CODE_AUTHENTICATION_REJECT:
-       case PW_CODE_AUTHENTICATION_ACK:
+       case PW_CODE_ACCESS_REJECT:
+       case PW_CODE_ACCESS_ACCEPT:
        case PW_CODE_ACCESS_CHALLENGE:
        case PW_CODE_COA_NAK:
        case PW_CODE_COA_ACK:
@@ -1182,7 +1182,7 @@ static void rs_packet_process(uint64_t count, rs_event_t *event, struct pcap_pkt
        }
 
        case PW_CODE_ACCOUNTING_REQUEST:
-       case PW_CODE_AUTHENTICATION_REQUEST:
+       case PW_CODE_ACCESS_REQUEST:
        case PW_CODE_COA_REQUEST:
        case PW_CODE_DISCONNECT_REQUEST:
        case PW_CODE_STATUS_SERVER:

diff --git a/src/main/realms.c b/src/main/realms.c
index a1637a5..9aec6bc 100644 (file)
--- a/src/main/realms.c
+++ b/src/main/realms.c
@@ -2042,7 +2042,7 @@ void home_server_update_request(home_server_t *home, REQUEST *request)
         *      Access-Requests have a Message-Authenticator added,
         *      unless one already exists.
         */
-       if ((request->packet->code == PW_CODE_AUTHENTICATION_REQUEST) &&
+       if ((request->packet->code == PW_CODE_ACCESS_REQUEST) &&
            !pairfind(request->proxy->vps, PW_MESSAGE_AUTHENTICATOR, 0, TAG_ANY)) {
                pairmake(request->proxy, &request->proxy->vps,
                         "Message-Authenticator", "0x00",
@@ -2334,7 +2334,7 @@ home_server_t *home_server_ldb(char const *realmname,
                if (!rd) return NULL;
 
                pool = NULL;
-               if (request->packet->code == PW_CODE_AUTHENTICATION_REQUEST) {
+               if (request->packet->code == PW_CODE_ACCESS_REQUEST) {
                        pool = rd->auth_pool;
 
                } else if (request->packet->code == PW_CODE_ACCOUNTING_REQUEST) {

diff --git a/src/main/stats.c b/src/main/stats.c
index 1b1c223..dc69727 100644 (file)
--- a/src/main/stats.c
+++ b/src/main/stats.c
@@ -164,7 +164,7 @@ void request_stats_final(REQUEST *request)
         *      this function, which makes it thread-safe.
         */
        if (request->reply && (request->packet->code != PW_CODE_STATUS_SERVER)) switch (request->reply->code) {
-       case PW_CODE_AUTHENTICATION_ACK:
+       case PW_CODE_ACCESS_ACCEPT:
                INC_AUTH(total_access_accepts);
 
                auth_stats:
@@ -184,7 +184,7 @@ void request_stats_final(REQUEST *request)
                           &request->reply->timestamp);
                break;
 
-       case PW_CODE_AUTHENTICATION_REJECT:
+       case PW_CODE_ACCESS_REJECT:
                INC_AUTH(total_access_rejects);
                goto auth_stats;
 
@@ -237,7 +237,7 @@ void request_stats_final(REQUEST *request)
                 *      authenticator.
                 */
        case 0:
-               if (request->packet->code == PW_CODE_AUTHENTICATION_REQUEST) {
+               if (request->packet->code == PW_CODE_ACCESS_REQUEST) {
                        if (request->reply->offset == -2) {
                                INC_AUTH(total_bad_authenticators);
                        } else {
@@ -260,7 +260,7 @@ void request_stats_final(REQUEST *request)
        if (!request->proxy || !request->proxy_listener) goto done;     /* simplifies formatting */
 
        switch (request->proxy->code) {
-       case PW_CODE_AUTHENTICATION_REQUEST:
+       case PW_CODE_ACCESS_REQUEST:
                proxy_auth_stats.total_requests += request->num_proxied_requests;
                request->proxy_listener->stats.total_requests += request->num_proxied_requests;
                request->home_server->stats.total_requests += request->num_proxied_requests;
@@ -284,7 +284,7 @@ void request_stats_final(REQUEST *request)
 #define INC(_x) proxy_auth_stats._x += request->num_proxied_responses; request->proxy_listener->stats._x += request->num_proxied_responses; request->home_server->stats._x += request->num_proxied_responses;
 
        switch (request->proxy_reply->code) {
-       case PW_CODE_AUTHENTICATION_ACK:
+       case PW_CODE_ACCESS_ACCEPT:
                INC(total_access_accepts);
        proxy_stats:
                INC(total_responses);
@@ -296,7 +296,7 @@ void request_stats_final(REQUEST *request)
                           &request->proxy_reply->timestamp);
                break;
 
-       case PW_CODE_AUTHENTICATION_REJECT:
+       case PW_CODE_ACCESS_REJECT:
                INC(total_access_rejects);
                goto proxy_stats;
 

diff --git a/src/main/tls_listen.c b/src/main/tls_listen.c
index a631475..a134f09 100644 (file)
--- a/src/main/tls_listen.c
+++ b/src/main/tls_listen.c
@@ -355,7 +355,7 @@ int dual_tls_recv(rad_listen_t *listener)
         *      set.
         */
        switch(packet->code) {
-       case PW_CODE_AUTHENTICATION_REQUEST:
+       case PW_CODE_ACCESS_REQUEST:
                if (listener->type != RAD_LISTEN_AUTH) goto bad_packet;
                FR_STATS_INC(auth, total_requests);
                fun = rad_authenticate;
@@ -644,9 +644,9 @@ int proxy_tls_recv(rad_listen_t *listener)
         *      FIXME: Client MIB updates?
         */
        switch(packet->code) {
-       case PW_CODE_AUTHENTICATION_ACK:
+       case PW_CODE_ACCESS_ACCEPT:
        case PW_CODE_ACCESS_CHALLENGE:
-       case PW_CODE_AUTHENTICATION_REJECT:
+       case PW_CODE_ACCESS_REJECT:
                break;
 
 #ifdef WITH_ACCOUNTING

diff --git a/src/main/unittest.c b/src/main/unittest.c
index 958da7f..abee1fa 100644 (file)
--- a/src/main/unittest.c
+++ b/src/main/unittest.c
@@ -149,7 +149,7 @@ static REQUEST *request_setup(FILE *fp)
        /*
         *      Set the defaults for IPs, etc.
         */
-       request->packet->code = PW_CODE_AUTHENTICATION_REQUEST;
+       request->packet->code = PW_CODE_ACCESS_REQUEST;
 
        request->packet->src_ipaddr.af = AF_INET;
        request->packet->src_ipaddr.ipaddr.ip4addr.s_addr = htonl(INADDR_LOOPBACK);

diff --git a/src/main/util.c b/src/main/util.c
index 5f82535..d569517 100644 (file)
--- a/src/main/util.c
+++ b/src/main/util.c
@@ -452,7 +452,7 @@ REQUEST *request_alloc_coa(REQUEST *request)
        /*
         *      Originate CoA requests only when necessary.
         */
-       if ((request->packet->code != PW_CODE_AUTHENTICATION_REQUEST) &&
+       if ((request->packet->code != PW_CODE_ACCESS_REQUEST) &&
            (request->packet->code != PW_CODE_ACCOUNTING_REQUEST)) return NULL;
 
        request->coa = request_alloc_fake(request);

diff --git a/src/modules/proto_vmps/vmps.c b/src/modules/proto_vmps/vmps.c
index 1b34ce2..02a8830 100644 (file)
--- a/src/modules/proto_vmps/vmps.c
+++ b/src/modules/proto_vmps/vmps.c
@@ -37,7 +37,7 @@ static int vmps_process(REQUEST *request)
        process_post_auth(0, request);
        DEBUG2("Done VMPS");
 
-       request->reply->code = PW_CODE_AUTHENTICATION_ACK;
+       request->reply->code = PW_CODE_ACCESS_ACCEPT;
 
        return 0;
 }

diff --git a/src/modules/proto_vmps/vqp.c b/src/modules/proto_vmps/vqp.c
index 64cecab..20c44d8 100644 (file)
--- a/src/modules/proto_vmps/vqp.c
+++ b/src/modules/proto_vmps/vqp.c
@@ -384,7 +384,7 @@ RADIUS_PACKET *vqp_recv(int sockfd)
        /*
         *      This is more than a bit of a hack.
         */
-       packet->code = PW_CODE_AUTHENTICATION_REQUEST;
+       packet->code = PW_CODE_ACCESS_REQUEST;
 
        memcpy(&id, packet->data + 4, 4);
        packet->id = ntohl(id);

diff --git a/src/modules/rlm_attr_filter/rlm_attr_filter.c b/src/modules/rlm_attr_filter/rlm_attr_filter.c
index f910741..8f292ba 100644 (file)
--- a/src/modules/rlm_attr_filter/rlm_attr_filter.c
+++ b/src/modules/rlm_attr_filter/rlm_attr_filter.c
@@ -308,7 +308,7 @@ static rlm_rcode_t CC_HINT(nonnull(1,2)) attr_filter_common(void *instance, REQU
        pairfree(&packet->vps);
        packet->vps = output;
 
-       if (request->packet->code == PW_CODE_AUTHENTICATION_REQUEST) {
+       if (request->packet->code == PW_CODE_ACCESS_REQUEST) {
                request->username = pairfind(request->packet->vps, PW_STRIPPED_USER_NAME, 0, TAG_ANY);
                if (!request->username) {
                        request->username = pairfind(request->packet->vps, PW_USER_NAME, 0, TAG_ANY);

diff --git a/src/modules/rlm_eap/eap.c b/src/modules/rlm_eap/eap.c
index 321cb0a..ea7a8b3 100644 (file)
--- a/src/modules/rlm_eap/eap.c
+++ b/src/modules/rlm_eap/eap.c
@@ -610,15 +610,15 @@ rlm_rcode_t eap_compose(eap_handler_t *handler)
        rcode = RLM_MODULE_OK;
        if (!request->reply->code) switch(reply->code) {
        case PW_EAP_RESPONSE:
-               request->reply->code = PW_CODE_AUTHENTICATION_ACK;
+               request->reply->code = PW_CODE_ACCESS_ACCEPT;
                rcode = RLM_MODULE_HANDLED; /* leap weirdness */
                break;
        case PW_EAP_SUCCESS:
-               request->reply->code = PW_CODE_AUTHENTICATION_ACK;
+               request->reply->code = PW_CODE_ACCESS_ACCEPT;
                rcode = RLM_MODULE_OK;
                break;
        case PW_EAP_FAILURE:
-               request->reply->code = PW_CODE_AUTHENTICATION_REJECT;
+               request->reply->code = PW_CODE_ACCESS_REJECT;
                rcode = RLM_MODULE_REJECT;
                break;
        case PW_EAP_REQUEST:
@@ -637,7 +637,7 @@ rlm_rcode_t eap_compose(eap_handler_t *handler)
 
                /* Should never enter here */
                ERROR("rlm_eap: reply code %d is unknown, Rejecting the request.", reply->code);
-               request->reply->code = PW_CODE_AUTHENTICATION_REJECT;
+               request->reply->code = PW_CODE_ACCESS_REJECT;
                reply->code = PW_EAP_FAILURE;
                rcode = RLM_MODULE_REJECT;
                break;

diff --git a/src/modules/rlm_eap/libeap/eapcommon.c b/src/modules/rlm_eap/libeap/eapcommon.c
index e6ea2b2..0c30431 100644 (file)
--- a/src/modules/rlm_eap/libeap/eapcommon.c
+++ b/src/modules/rlm_eap/libeap/eapcommon.c
@@ -225,11 +225,11 @@ int eap_basic_compose(RADIUS_PACKET *packet, eap_packet_t *reply)
        if (!packet->code) switch(reply->code) {
        case PW_EAP_RESPONSE:
        case PW_EAP_SUCCESS:
-               packet->code = PW_CODE_AUTHENTICATION_ACK;
+               packet->code = PW_CODE_ACCESS_ACCEPT;
                rcode = RLM_MODULE_HANDLED;
                break;
        case PW_EAP_FAILURE:
-               packet->code = PW_CODE_AUTHENTICATION_REJECT;
+               packet->code = PW_CODE_ACCESS_REJECT;
                rcode = RLM_MODULE_REJECT;
                break;
        case PW_EAP_REQUEST:
@@ -239,7 +239,7 @@ int eap_basic_compose(RADIUS_PACKET *packet, eap_packet_t *reply)
        default:
                /* Should never enter here */
                ERROR("rlm_eap: reply code %d is unknown, Rejecting the request.", reply->code);
-               packet->code = PW_CODE_AUTHENTICATION_REJECT;
+               packet->code = PW_CODE_ACCESS_REJECT;
                break;
        }
 

diff --git a/src/modules/rlm_eap/radeapclient.c b/src/modules/rlm_eap/radeapclient.c
index 6efcf66..c16b8d8 100644 (file)
--- a/src/modules/rlm_eap/radeapclient.c
+++ b/src/modules/rlm_eap/radeapclient.c
@@ -243,9 +243,9 @@ static int send_packet(RADIUS_PACKET *req, RADIUS_PACKET **rep)
        if (!fr_debug_flag && do_output) {
                debug_packet(*rep, R_RECV);
        }
-       if((*rep)->code == PW_CODE_AUTHENTICATION_ACK) {
+       if((*rep)->code == PW_CODE_ACCESS_ACCEPT) {
                totalapp++;
-       } else if ((*rep)->code == PW_CODE_AUTHENTICATION_REJECT) {
+       } else if ((*rep)->code == PW_CODE_ACCESS_REJECT) {
                totaldeny++;
        }
 
@@ -1209,7 +1209,7 @@ int main(int argc, char **argv)
        if (strcmp(argv[2], "auth") == 0) {
                if (port == 0) port = getport("radius");
                if (port == 0) port = PW_AUTH_UDP_PORT;
-               req->code = PW_CODE_AUTHENTICATION_REQUEST;
+               req->code = PW_CODE_ACCESS_REQUEST;
 
        } else if (strcmp(argv[2], "acct") == 0) {
                if (port == 0) port = getport("radacct");

diff --git a/src/modules/rlm_eap/rlm_eap.c b/src/modules/rlm_eap/rlm_eap.c
index 8d229c1..d462fd5 100644 (file)
--- a/src/modules/rlm_eap/rlm_eap.c
+++ b/src/modules/rlm_eap/rlm_eap.c
@@ -434,7 +434,7 @@ static rlm_rcode_t CC_HINT(nonnull) mod_authenticate(void *instance, REQUEST *re
         *      says that we MUST include a User-Name attribute in the
         *      Access-Accept.
         */
-       if ((request->reply->code == PW_CODE_AUTHENTICATION_ACK) &&
+       if ((request->reply->code == PW_CODE_ACCESS_ACCEPT) &&
            request->username) {
                VALUE_PAIR *vp;
 
@@ -615,7 +615,7 @@ static rlm_rcode_t CC_HINT(nonnull) mod_post_proxy(void *inst, REQUEST *request)
                 *      says that we MUST include a User-Name attribute in the
                 *      Access-Accept.
                 */
-               if ((request->reply->code == PW_CODE_AUTHENTICATION_ACK) &&
+               if ((request->reply->code == PW_CODE_ACCESS_ACCEPT) &&
                    request->username) {
                        /*
                         *      Doesn't exist, add it in.

diff --git a/src/modules/rlm_eap/types/rlm_eap_mschapv2/rlm_eap_mschapv2.c b/src/modules/rlm_eap/types/rlm_eap_mschapv2/rlm_eap_mschapv2.c
index 13beb38..8653df1 100644 (file)
--- a/src/modules/rlm_eap/types/rlm_eap_mschapv2/rlm_eap_mschapv2.c
+++ b/src/modules/rlm_eap/types/rlm_eap_mschapv2/rlm_eap_mschapv2.c
@@ -302,7 +302,7 @@ static int CC_HINT(nonnull) mschap_postproxy(eap_handler_t *handler, UNUSED void
         *      There is only a limited number of possibilities.
         */
        switch (request->reply->code) {
-       case PW_CODE_AUTHENTICATION_ACK:
+       case PW_CODE_ACCESS_ACCEPT:
                RDEBUG2("Proxied authentication succeeded");
 
                /*
@@ -313,7 +313,7 @@ static int CC_HINT(nonnull) mschap_postproxy(eap_handler_t *handler, UNUSED void
                break;
 
        default:
-       case PW_CODE_AUTHENTICATION_REJECT:
+       case PW_CODE_ACCESS_REJECT:
                RDEBUG("Proxied authentication did not succeed");
                return 0;
        }

diff --git a/src/modules/rlm_eap/types/rlm_eap_peap/peap.c b/src/modules/rlm_eap/types/rlm_eap_peap/peap.c
index 1f7bbb1..aa03422 100644 (file)
--- a/src/modules/rlm_eap/types/rlm_eap_peap/peap.c
+++ b/src/modules/rlm_eap/types/rlm_eap_peap/peap.c
@@ -431,7 +431,7 @@ static int CC_HINT(nonnull) process_reply(eap_handler_t *handler, tls_session_t
        }
 
        switch (reply->code) {
-       case PW_CODE_AUTHENTICATION_ACK:
+       case PW_CODE_ACCESS_ACCEPT:
                RDEBUG2("Tunneled authentication was successful");
                t->status = PEAP_STATUS_SENT_TLV_SUCCESS;
                eappeap_success(handler, tls_session);
@@ -469,7 +469,7 @@ static int CC_HINT(nonnull) process_reply(eap_handler_t *handler, tls_session_t
                }
                break;
 
-       case PW_CODE_AUTHENTICATION_REJECT:
+       case PW_CODE_ACCESS_REJECT:
                RDEBUG2("Tunneled authentication was rejected");
                t->status = PEAP_STATUS_SENT_TLV_FAILURE;
                eappeap_failure(handler, tls_session);
@@ -561,7 +561,7 @@ static int CC_HINT(nonnull) eappeap_postproxy(eap_handler_t *handler, void *data
        /*
         *      Do the callback, if it exists, and if it was a success.
         */
-       if (fake && (handler->request->proxy_reply->code == PW_CODE_AUTHENTICATION_ACK)) {
+       if (fake && (handler->request->proxy_reply->code == PW_CODE_ACCESS_ACCEPT)) {
                peap_tunnel_t *t = tls_session->opaque;
 
                t->home_access_accept = true;
@@ -823,7 +823,7 @@ rlm_rcode_t eappeap_process(eap_handler_t *handler, tls_session_t *tls_session)
                RDEBUG("Got SoH reply");
                debug_pair_list(fake->reply->vps);
 
-               if (fake->reply->code != PW_CODE_AUTHENTICATION_ACK) {
+               if (fake->reply->code != PW_CODE_ACCESS_ACCEPT) {
                        RDEBUG2("SoH was rejected");
                        talloc_free(fake);
                        t->status = PEAP_STATUS_SENT_TLV_FAILURE;
@@ -1083,7 +1083,7 @@ rlm_rcode_t eappeap_process(eap_handler_t *handler, tls_session_t *tls_session)
                                        /*
                                         *      Authentication succeeded! Rah!
                                         */
-                                       fake->reply->code = PW_CODE_AUTHENTICATION_ACK;
+                                       fake->reply->code = PW_CODE_ACCESS_ACCEPT;
                                        goto do_process;
                                }
 

diff --git a/src/modules/rlm_eap/types/rlm_eap_tls/rlm_eap_tls.c b/src/modules/rlm_eap/types/rlm_eap_tls/rlm_eap_tls.c
index 43db95c..6d960f7 100644 (file)
--- a/src/modules/rlm_eap/types/rlm_eap_tls/rlm_eap_tls.c
+++ b/src/modules/rlm_eap/types/rlm_eap_tls/rlm_eap_tls.c
@@ -182,7 +182,7 @@ static int CC_HINT(nonnull) mod_authenticate(void *type_arg, eap_handler_t *hand
                                  &fake->reply->vps, 0, 0, TAG_ANY);
 
                        /* reject if virtual server didn't return accept */
-                       if (fake->reply->code != PW_CODE_AUTHENTICATION_ACK) {
+                       if (fake->reply->code != PW_CODE_ACCESS_ACCEPT) {
                                RDEBUG2("Certificates were rejected by the virtual server");
                                talloc_free(fake);
                                eaptls_fail(handler, 0);

diff --git a/src/modules/rlm_eap/types/rlm_eap_ttls/rlm_eap_ttls.c b/src/modules/rlm_eap/types/rlm_eap_ttls/rlm_eap_ttls.c
index c51d438..0c499e5 100644 (file)
--- a/src/modules/rlm_eap/types/rlm_eap_ttls/rlm_eap_ttls.c
+++ b/src/modules/rlm_eap/types/rlm_eap_ttls/rlm_eap_ttls.c
@@ -328,7 +328,7 @@ static int mod_authenticate(void *arg, eap_handler_t *handler)
         */
        rcode = eapttls_process(handler, tls_session);
        switch (rcode) {
-       case PW_CODE_AUTHENTICATION_REJECT:
+       case PW_CODE_ACCESS_REJECT:
                eaptls_fail(handler, 0);
                return 0;
 
@@ -342,7 +342,7 @@ static int mod_authenticate(void *arg, eap_handler_t *handler)
                /*
                 *      Success: Automatically return MPPE keys.
                 */
-       case PW_CODE_AUTHENTICATION_ACK:
+       case PW_CODE_ACCESS_ACCEPT:
                return eaptls_success(handler, 0);
 
                /*

diff --git a/src/modules/rlm_eap/types/rlm_eap_ttls/ttls.c b/src/modules/rlm_eap/types/rlm_eap_ttls/ttls.c
index dc767f4..2872e48 100644 (file)
--- a/src/modules/rlm_eap/types/rlm_eap_ttls/ttls.c
+++ b/src/modules/rlm_eap/types/rlm_eap_ttls/ttls.c
@@ -642,7 +642,7 @@ static rlm_rcode_t CC_HINT(nonnull) process_reply(UNUSED eap_handler_t *handler,
         *      NOT 'eap start', so we should check for that....
         */
        switch (reply->code) {
-       case PW_CODE_AUTHENTICATION_ACK:
+       case PW_CODE_ACCESS_ACCEPT:
                RDEBUG("Got tunneled Access-Accept");
 
                rcode = RLM_MODULE_OK;
@@ -719,7 +719,7 @@ static rlm_rcode_t CC_HINT(nonnull) process_reply(UNUSED eap_handler_t *handler,
                break;
 
 
-       case PW_CODE_AUTHENTICATION_REJECT:
+       case PW_CODE_ACCESS_REJECT:
                RDEBUG("Got tunneled Access-Reject");
                rcode = RLM_MODULE_REJECT;
                break;
@@ -805,7 +805,7 @@ static int CC_HINT(nonnull) eapttls_postproxy(eap_handler_t *handler, void *data
        /*
         *      Do the callback, if it exists, and if it was a success.
         */
-       if (fake && (handler->request->proxy_reply->code == PW_CODE_AUTHENTICATION_ACK)) {
+       if (fake && (handler->request->proxy_reply->code == PW_CODE_ACCESS_ACCEPT)) {
                /*
                 *      Terrible hacks.
                 */
@@ -913,7 +913,7 @@ static int CC_HINT(nonnull) eapttls_postproxy(eap_handler_t *handler, void *data
  */
 int eapttls_process(eap_handler_t *handler, tls_session_t *tls_session)
 {
-       int code = PW_CODE_AUTHENTICATION_REJECT;
+       int code = PW_CODE_ACCESS_REJECT;
        rlm_rcode_t rcode;
        REQUEST *fake;
        VALUE_PAIR *vp;
@@ -939,7 +939,7 @@ int eapttls_process(eap_handler_t *handler, tls_session_t *tls_session)
        if (data_len == 0) {
                if (t->authenticated) {
                        RDEBUG("Got ACK, and the user was already authenticated");
-                       return PW_CODE_AUTHENTICATION_ACK;
+                       return PW_CODE_ACCESS_ACCEPT;
                } /* else no session, no data, die. */
 
                /*
@@ -947,7 +947,7 @@ int eapttls_process(eap_handler_t *handler, tls_session_t *tls_session)
                 *      wrong.
                 */
                RDEBUG2("SSL_read Error");
-               return PW_CODE_AUTHENTICATION_REJECT;
+               return PW_CODE_ACCESS_REJECT;
        }
 
 #ifndef NDEBUG
@@ -966,7 +966,7 @@ int eapttls_process(eap_handler_t *handler, tls_session_t *tls_session)
 #endif
 
        if (!diameter_verify(request, data, data_len)) {
-               return PW_CODE_AUTHENTICATION_REJECT;
+               return PW_CODE_ACCESS_REJECT;
        }
 
        /*
@@ -982,7 +982,7 @@ int eapttls_process(eap_handler_t *handler, tls_session_t *tls_session)
        fake->packet->vps = diameter2vp(request, fake, tls_session->ssl, data, data_len);
        if (!fake->packet->vps) {
                talloc_free(fake);
-               return PW_CODE_AUTHENTICATION_REJECT;
+               return PW_CODE_ACCESS_REJECT;
        }
 
        /*
@@ -1251,7 +1251,7 @@ int eapttls_process(eap_handler_t *handler, tls_session_t *tls_session)
                  {
                        RDEBUG("No tunneled reply was found for request %d , and the request was not proxied: rejecting the user.",
                               request->number);
-                       code = PW_CODE_AUTHENTICATION_REJECT;
+                       code = PW_CODE_ACCESS_REJECT;
                }
                break;
 
@@ -1262,7 +1262,7 @@ int eapttls_process(eap_handler_t *handler, tls_session_t *tls_session)
                rcode = process_reply(handler, tls_session, request, fake->reply);
                switch (rcode) {
                case RLM_MODULE_REJECT:
-                       code = PW_CODE_AUTHENTICATION_REJECT;
+                       code = PW_CODE_ACCESS_REJECT;
                        break;
 
                case RLM_MODULE_HANDLED:
@@ -1270,11 +1270,11 @@ int eapttls_process(eap_handler_t *handler, tls_session_t *tls_session)
                        break;
 
                case RLM_MODULE_OK:
-                       code = PW_CODE_AUTHENTICATION_ACK;
+                       code = PW_CODE_ACCESS_ACCEPT;
                        break;
 
                default:
-                       code = PW_CODE_AUTHENTICATION_REJECT;
+                       code = PW_CODE_ACCESS_REJECT;
                        break;
                }
                break;

diff --git a/src/modules/rlm_exec/rlm_exec.c b/src/modules/rlm_exec/rlm_exec.c
index 77316c9..173f768 100644 (file)
--- a/src/modules/rlm_exec/rlm_exec.c
+++ b/src/modules/rlm_exec/rlm_exec.c
@@ -410,7 +410,7 @@ static rlm_rcode_t CC_HINT(nonnull) mod_post_auth(void *instance, REQUEST *reque
                case RLM_MODULE_FAIL:
                case RLM_MODULE_INVALID:
                case RLM_MODULE_REJECT:
-                       request->reply->code = PW_CODE_AUTHENTICATION_REJECT;
+                       request->reply->code = PW_CODE_ACCESS_REJECT;
                        break;
                default:
                        break;

diff --git a/src/modules/rlm_realm/rlm_realm.c b/src/modules/rlm_realm/rlm_realm.c
index 892812b..3a2dbf8 100644 (file)
--- a/src/modules/rlm_realm/rlm_realm.c
+++ b/src/modules/rlm_realm/rlm_realm.c
@@ -227,7 +227,7 @@ static int check_for_realm(void *instance, REQUEST *request, REALM **returnrealm
                /*
                 *      Perhaps authentication proxying was turned off.
                 */
-       case PW_CODE_AUTHENTICATION_REQUEST:
+       case PW_CODE_ACCESS_REQUEST:
                if (!realm->auth_pool) {
                        RDEBUG2("Authentication realm is LOCAL");
                        return RLM_MODULE_OK;

diff --git a/src/modules/rlm_replicate/rlm_replicate.c b/src/modules/rlm_replicate/rlm_replicate.c
index 2ed4e71..8b3e7ab 100644 (file)
--- a/src/modules/rlm_replicate/rlm_replicate.c
+++ b/src/modules/rlm_replicate/rlm_replicate.c
@@ -83,7 +83,7 @@ static int replicate_packet(UNUSED void *instance, REQUEST *request, pair_lists_
                        cleanup(packet);
                        return RLM_MODULE_FAIL;
 
-               case PW_CODE_AUTHENTICATION_REQUEST:
+               case PW_CODE_ACCESS_REQUEST:
                        pool = realm->auth_pool;
                        break;
 
@@ -156,7 +156,7 @@ static int replicate_packet(UNUSED void *instance, REQUEST *request, pair_lists_
                         *      For CHAP, create the CHAP-Challenge if
                         *      it doesn't exist.
                         */
-                       if ((code == PW_CODE_AUTHENTICATION_REQUEST) &&
+                       if ((code == PW_CODE_ACCESS_REQUEST) &&
                            (pairfind(request->packet->vps, PW_CHAP_PASSWORD, 0, TAG_ANY) != NULL) &&
                            (pairfind(request->packet->vps, PW_CHAP_CHALLENGE, 0, TAG_ANY) == NULL)) {
                                uint8_t *p;

diff --git a/src/modules/rlm_sometimes/rlm_sometimes.c b/src/modules/rlm_sometimes/rlm_sometimes.c
index 3738d45..27ce5d5 100644 (file)
--- a/src/modules/rlm_sometimes/rlm_sometimes.c
+++ b/src/modules/rlm_sometimes/rlm_sometimes.c
@@ -118,8 +118,8 @@ static rlm_rcode_t sometimes_return(void *instance, RADIUS_PACKET *packet, RADIU
         */
        if ((inst->rcode == RLM_MODULE_HANDLED) && reply) {
                switch (packet->code) {
-               case PW_CODE_AUTHENTICATION_REQUEST:
-                       reply->code = PW_CODE_AUTHENTICATION_ACK;
+               case PW_CODE_ACCESS_REQUEST:
+                       reply->code = PW_CODE_ACCESS_ACCEPT;
                        break;
 
                case PW_CODE_ACCOUNTING_REQUEST: