Massively cleaned up #include's, so they're in a consistent

[freeradius.git] / src / main / acct.c

diff --git a/src/main/acct.c b/src/main/acct.c
index b726bf4..367f118 100644 (file)
--- a/src/main/acct.c
+++ b/src/main/acct.c
@@ -15,19 +15,19 @@
  *
  *   You should have received a copy of the GNU General Public License
  *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  *
- * Copyright 2000  The FreeRADIUS server project
+ * Copyright 2000,2006  The FreeRADIUS server project
  * Copyright 2000  Miquel van Smoorenburg <miquels@cistron.nl>
  * Copyright 2000  Alan DeKok <aland@ox.org>
  * Copyright 2000  Alan Curry <pacman@world.std.com>
  */
 
-static const char rcsid[] = "$Id$";
+#include <freeradius-devel/ident.h>
+RCSID("$Id$")
 
-#include "autoconf.h"
-#include "radiusd.h"
-#include "modules.h"
+#include <freeradius-devel/radiusd.h>
+#include <freeradius-devel/modules.h>
 
 /*
  *     rad_accounting: call modules.
@@ -37,7 +37,7 @@ static const char rcsid[] = "$Id$";
  */
 int rad_accounting(REQUEST *request)
 {
-       int             reply = RLM_MODULE_OK;
+       int result = RLM_MODULE_OK;
 
        /*
         *      Run the modules only once, before proxying.
@@ -46,32 +46,69 @@ int rad_accounting(REQUEST *request)
                VALUE_PAIR      *vp;
                int             acct_type = 0;
 
-               reply = module_preacct(request);
-               if (reply != RLM_MODULE_NOOP &&
-                   reply != RLM_MODULE_OK &&
-                   reply != RLM_MODULE_HANDLED &&
-                   reply != RLM_MODULE_UPDATED)
-                       return reply;
+               result = module_preacct(request);
+               switch (result) {
+                       /*
+                        *      The module has a number of OK return codes.
+                        */
+                       case RLM_MODULE_NOOP:
+                       case RLM_MODULE_OK:
+                       case RLM_MODULE_UPDATED:
+                               break;
+                       /*
+                        *      The module handled the request, stop here.
+                        */
+                       case RLM_MODULE_HANDLED:
+                               return result;
+                       /*
+                        *      The module failed, or said the request is
+                        *      invalid, therefore we stop here.
+                        */
+                       case RLM_MODULE_FAIL:
+                       case RLM_MODULE_INVALID:
+                       case RLM_MODULE_NOTFOUND:
+                       case RLM_MODULE_REJECT:
+                       case RLM_MODULE_USERLOCK:
+                       default:
+                               return result;
+               }
 
                /*
                 *      Do the data storage before proxying. This is to ensure
                 *      that we log the packet, even if the proxy never does.
-                *
-                *      In case the accounting module returns FAIL, it's still
-                *      useful to send the data to the proxy.
                 */
                vp = pairfind(request->config_items, PW_ACCT_TYPE);
                if (vp) {
                        DEBUG2("  Found Acct-Type %s", vp->vp_strvalue);
                        acct_type = vp->lvalue;
                }
-               reply = module_accounting(acct_type, request);
-               if (reply != RLM_MODULE_NOOP &&
-                   reply != RLM_MODULE_OK &&
-                   reply != RLM_MODULE_HANDLED &&
-                   reply != RLM_MODULE_UPDATED &&
-                   reply != RLM_MODULE_FAIL)
-                       return reply;
+               result = module_accounting(acct_type, request);
+               switch (result) {
+                       /*
+                        *      In case the accounting module returns FAIL,
+                        *      it's still useful to send the data to the
+                        *      proxy.
+                        */
+                       case RLM_MODULE_FAIL:
+                       case RLM_MODULE_NOOP:
+                       case RLM_MODULE_OK:
+                       case RLM_MODULE_UPDATED:
+                               break;
+                       /*
+                        *      The module handled the request, don't reply.
+                        */
+                       case RLM_MODULE_HANDLED:
+                               return result;
+                       /*
+                        *      Neither proxy, nor reply to invalid requests.
+                        */
+                       case RLM_MODULE_INVALID:
+                       case RLM_MODULE_NOTFOUND:
+                       case RLM_MODULE_REJECT:
+                       case RLM_MODULE_USERLOCK:
+                       default:
+                               return result;
+               }
 
                /*
                 *      Maybe one of the preacct modules has decided
@@ -84,11 +121,9 @@ int rad_accounting(REQUEST *request)
                         *      Check whether Proxy-To-Realm is
                         *      a LOCAL realm.
                         */
-                       realm = realm_find(vp->vp_strvalue, TRUE);
-                       if (realm != NULL &&
-                           realm->acct_ipaddr.af == AF_INET &&
-                           realm->acct_ipaddr.ipaddr.ip4addr.s_addr == htonl(INADDR_NONE)) {
-                               DEBUG("rad_accounting: Cancelling proxy to realm %s, as it is a LOCAL realm.", realm->realm);
+                       realm = realm_find(vp->vp_strvalue);
+                       if (realm && !realm->acct_pool) {
+                               DEBUG("rad_accounting: Cancelling proxy to realm %s, as it is a LOCAL realm.", realm->name);
                                pairdelete(&request->config_items, PW_PROXY_TO_REALM);
                        } else {
                                /*
@@ -96,7 +131,7 @@ int rad_accounting(REQUEST *request)
                                 *      we have to send the proxied packet
                                 *      before that.
                                 */
-                               return reply;
+                               return result;
                        }
                }
        }
@@ -109,15 +144,31 @@ int rad_accounting(REQUEST *request)
         *      storage did not succeed, so radiusd should not send
         *      Accounting-Response.
         */
-       if (reply == RLM_MODULE_OK ||
-           reply == RLM_MODULE_HANDLED ||
-           reply == RLM_MODULE_UPDATED) {
-
+       switch (result) {
                /*
-                *      Now send back an ACK to the NAS.
+                *      Send back an ACK to the NAS.
                 */
-               request->reply->code = PW_ACCOUNTING_RESPONSE;
+               case RLM_MODULE_OK:
+               case RLM_MODULE_UPDATED:
+                       request->reply->code = PW_ACCOUNTING_RESPONSE;
+                       break;
+               /*
+                *      The module handled the request, don't reply.
+                */
+               case RLM_MODULE_HANDLED:
+                       break;
+               /*
+                *      Failed to log or to proxy the accounting data,
+                *      therefore don't reply to the NAS.
+                */
+               case RLM_MODULE_FAIL:
+               case RLM_MODULE_INVALID:
+               case RLM_MODULE_NOOP:
+               case RLM_MODULE_NOTFOUND:
+               case RLM_MODULE_REJECT:
+               case RLM_MODULE_USERLOCK:
+               default:
+                       break;
        }
-
-       return reply;
+       return result;
 }