src/main/nas.c

   1 /*
   2  * nas.c        Functions to do with a NASLIST. This is here because
   3  *              radzap needs it as well.
   4  *
   5  * Version:     $Id$
   6  *
   7  *   This program is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU General Public License as published by
   9  *   the Free Software Foundation; either version 2 of the License, or
  10  *   (at your option) any later version.
  11  *
  12  *   This program is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with this program; if not, write to the Free Software
  19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  * Copyright 2000  The FreeRADIUS server project
  22  * Copyright 2000  Miquel van Smoorenburg <miquels@cistron.nl>
  23  * Copyright 2000  Alan DeKok <aland@ox.org>
  24  */
  25
  26 static const char rcsid[] = "$Id$";
  27
  28 #include "autoconf.h"
  29 #include "libradius.h"
  30
  31 #include <sys/stat.h>
  32
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36
  37 #include "radiusd.h"
  38
  39 static NAS *naslist = NULL;
  40
  41 /*
  42  *      Free a NAS list.
  43  */
  44 static void nas_free(NAS *cl)
  45 {
  46         NAS *next;
  47
  48         while(cl) {
  49                 next = cl->next;
  50                 free(cl);
  51                 cl = next;
  52         }
  53 }
  54
  55 /*
  56  *      Read the nas file.
  57  */
  58 int read_naslist_file(char *file)
  59 {
  60         FILE *fp;
  61         char buffer[256];
  62         char hostnm[256];
  63         char shortnm[256];
  64         char nastype[256];
  65         int lineno = 0;
  66         char *p;
  67         NAS *nas;
  68
  69         nas_free(naslist);
  70         naslist = NULL;
  71
  72         if ((fp = fopen(file, "r")) == NULL) {
  73                 /* The naslist file is no longer required.  All configuration
  74                    information comes from radiusd.conf.  If naslist exists it
  75                    will be used, but if it doesn't exist it will be silently
  76                    ignored. */
  77                 return 0;
  78         }
  79         radlog(L_INFO, "Using deprecated naslist file.  Support for this will go away soon.");
  80         while(fgets(buffer, 256, fp) != NULL) {
  81                 lineno++;
  82                 if (!feof(fp) && (strchr(buffer, '\n') == NULL)) {
  83                         radlog(L_ERR, "%s[%d]: line too long", file, lineno);
  84                         return -1;
  85                 }
  86                 if (buffer[0] == '#' || buffer[0] == '\n')
  87                         continue;
  88
  89                 p = buffer;
  90                 if (!getword(&p, hostnm, sizeof(hostnm)) ||
  91                     !getword(&p, shortnm, sizeof(shortnm))) {
  92                         radlog(L_ERR, "%s[%d]: unexpected end of line", file, lineno);
  93                         continue;
  94                 }
  95                 (void)getword(&p, nastype, sizeof(nastype));
  96
  97                 /*
  98                  *      Double-check lengths to be sure they're sane
  99                  */
 100                 if (strlen(hostnm) >= sizeof(nas->longname)) {
 101                         radlog(L_ERR, "%s[%d]: host name of length %d is greater than the allowed maximum of %d.",
 102                                         file, lineno,
 103                                         strlen(hostnm), sizeof(nas->longname) - 1);
 104                         return -1;
 105                 }
 106                 if (strlen(shortnm) > sizeof(nas->shortname)) {
 107                         radlog(L_ERR, "%s[%d]: short name of length %d is greater than the allowed maximum of %d.",
 108                                         file, lineno,
 109                                         strlen(shortnm), sizeof(nas->shortname) - 1);
 110                         return -1;
 111                 }
 112                 if (strlen(nastype) >= sizeof(nas->nastype)) {
 113                         radlog(L_ERR, "%s[%d]: NAS type of length %d is greater than the allowed maximum of %d.",
 114                                         file, lineno,
 115                                         strlen(nastype), sizeof(nas->nastype) - 1);
 116                         return -1;
 117                 }
 118
 119                 /*
 120                  *      It should be OK now, let's create the buffer.
 121                  */
 122                 nas = rad_malloc(sizeof(NAS));
 123                 memset(nas, 0, sizeof(*nas));
 124
 125                 strcpy(nas->nastype, nastype);
 126                 strcpy(nas->shortname, shortnm);
 127
 128                 if (strcmp(hostnm, "DEFAULT") == 0) {
 129                         nas->ipaddr = 0;
 130                         strcpy(nas->longname, hostnm);
 131                 } else {
 132                         nas->ipaddr = ip_getaddr(hostnm);
 133                         ip_hostname(nas->longname, sizeof(nas->longname),
 134                                         nas->ipaddr);
 135                 }
 136
 137                 nas->next = naslist;
 138                 naslist = nas;
 139         }
 140         fclose(fp);
 141
 142         return 0;
 143 }
 144
 145
 146 /*
 147  *      Find a nas by IP address.
 148  *      If it can't be found, return the DEFAULT nas, instead.
 149  */
 150 NAS *nas_find(uint32_t ipaddr)
 151 {
 152         NAS *nas;
 153         NAS *default_nas;
 154
 155         default_nas = NULL;
 156
 157         for (nas = naslist; nas; nas = nas->next) {
 158                 if (ipaddr == nas->ipaddr)
 159                         return nas;
 160                 if (strcmp(nas->longname, "DEFAULT") == 0)
 161                         default_nas = nas;
 162         }
 163
 164         return default_nas;
 165 }
 166
 167
 168 /*
 169  *      Find a nas by name.
 170  *      If it can't be found, return the DEFAULT nas, instead.
 171  */
 172 NAS *nas_findbyname(char *nasname)
 173 {
 174         NAS     *nas;
 175         NAS     *default_nas;
 176
 177         default_nas = NULL;
 178
 179         for (nas = naslist; nas; nas = nas->next) {
 180                 if (strcmp(nasname, nas->shortname) == 0 ||
 181                                 strcmp(nasname, nas->longname) == 0)
 182                         return nas;
 183                 if (strcmp(nas->longname, "DEFAULT") == 0)
 184                         default_nas = nas;
 185         }
 186
 187         return default_nas;
 188 }
 189
 190
 191 /*
 192  *      Find the name of a nas (prefer short name).
 193  */
 194 const char *nas_name(uint32_t ipaddr)
 195 {
 196         NAS *nas;
 197
 198         if ((nas = nas_find(ipaddr)) != NULL) {
 199                 if (nas->shortname[0])
 200                         return nas->shortname;
 201                 else
 202                         return nas->longname;
 203         }
 204
 205         return "UNKNOWN-NAS";
 206 }
 207
 208 /*
 209  *      Find the name of a nas (prefer short name) based on the request.
 210  */
 211 const char *nas_name2(RADIUS_PACKET *packet)
 212 {
 213         NAS *nas;
 214
 215         if ((nas = nas_find(packet->src_ipaddr)) != NULL) {
 216                 if (nas->shortname[0])
 217                         return nas->shortname;
 218                 else
 219                         return nas->longname;
 220         }
 221
 222         return "UNKNOWN-NAS";
 223 }
 224
 225 /*
 226  *      Find the name of a nas (prefer short name) based on ipaddr,
 227  *      store in passed buffer.  If NAS is unknown, return dotted quad.
 228  */
 229 char * nas_name3(char *buf, size_t buflen, uint32_t ipaddr)
 230 {
 231         NAS *nas;
 232
 233         if ((nas = nas_find(ipaddr)) != NULL) {
 234                 if (nas->shortname[0]) {
 235                         strNcpy(buf, (char *)nas->shortname, buflen);
 236                         return buf;
 237                 }
 238                 else {
 239                         strNcpy(buf, (char *)nas->longname, buflen);
 240                         return buf;
 241                 }
 242         }
 243         ip_ntoa(buf, ipaddr);
 244         return buf;
 245 }
 246
 247