lib/sgwdynspeed/src/speedFile.c

   1 #include "speedFile.h"
   2
   3 /* Plugin includes */
   4 #include "sgwDynSpeed.h"
   5
   6 /* OLSRD includes */
   7 #include "olsr_cfg.h"
   8 #include "gateway.h"
   9
  10 /* System includes */
  11 #include <stddef.h>
  12 #include <unistd.h>
  13 #include <fcntl.h>
  14 #include <stdlib.h>
  15 #include <regex.h>
  16 #include <errno.h>
  17 #include <sys/stat.h>
  18 #include <stdio.h>
  19 #include <assert.h>
  20
  21 #define SPEED_UPLINK_NAME   "upstream"
  22 #define SPEED_DOWNLINK_NAME "downstream"
  23
  24 /** the maximal length of a line that is read from the file */
  25 #define LINE_LENGTH 256
  26
  27 /** regular expression describing a comment */
  28 static const char * regexCommentString = "^([[:space:]]*|[[:space:]#]+.*)$";
  29
  30 /** regular expression describing a key/value pair */
  31 static const char * regexNameValueString =
  32                 "^[[:space:]]*([^[:space:]]+)[[:space:]]*=[[:space:]]*([[:digit:]]+)[[:space:]]*$";
  33
  34 /** the number of matches in regexNameValueString */
  35 static const size_t regexNameValuematchCount = 3;
  36
  37 /** the compiled regular expression describing a comment */
  38 static regex_t regexComment;
  39
  40 /** the compiled regular expression describing a key/value pair */
  41 static regex_t regexNameValue;
  42
  43 /** true when the plugin has been started */
  44 static bool started = false;
  45
  46 /** type to hold the cached stat result */
  47 typedef struct _CachedStat {
  48         time_t timeStamp; /* Time of last modification (second resolution) */
  49 } CachedStat;
  50
  51 /** the cached stat result */
  52 static CachedStat cachedStat;
  53
  54 /**
  55  Read an unsigned long number from a value string
  56
  57  @param valueName
  58  the name of the value
  59  @param value
  60  the string to convert to a number
  61  @param valueNumber
  62  a pointer to the location where to store the number upon successful conversion
  63
  64  @return
  65  - true on success
  66  - false otherwise
  67  */
  68 static bool readUL(const char * valueName, const char * value, unsigned long * valueNumber) {
  69         char * endPtr = NULL;
  70         unsigned long valueNew;
  71
  72         assert(valueName != NULL);
  73         assert(value != NULL);
  74         assert(valueNumber != NULL);
  75
  76         errno = 0;
  77         valueNew = strtoul(value, &endPtr, 10);
  78
  79         if (!((endPtr != value) && (*value != '\0') && (*endPtr == '\0'))) {
  80                 /* invalid conversion */
  81                 sgwDynSpeedError(false, "Value of parameter %s (%s) could not be converted to a number", valueName, value);
  82                 return false;
  83         }
  84
  85         *valueNumber = valueNew;
  86
  87         return true;
  88 }
  89
  90 /**
  91  * Initialises the speedFile reader.
  92  * @return true upon success, false otherwise
  93  */
  94 bool startSpeedFile(void) {
  95         if (started) {
  96                 return true;
  97         }
  98
  99         if (regcomp(&regexComment, regexCommentString, REG_EXTENDED | REG_ICASE)) {
 100                 sgwDynSpeedError(false, "Could not compile regex \"%s\"", regexCommentString);
 101                 return false;
 102         }
 103
 104         if (regcomp(&regexNameValue, regexNameValueString, REG_EXTENDED | REG_ICASE)) {
 105                 sgwDynSpeedError(false, "Could not compile regex \"%s\"", regexNameValueString);
 106                 regfree(&regexComment);
 107                 return false;
 108         }
 109
 110         cachedStat.timeStamp = -1;
 111
 112         started = true;
 113         return true;
 114 }
 115
 116 /**
 117  * Cleans up the speedFile reader.
 118  */
 119 void stopSpeedFile(void) {
 120         if (started) {
 121                 regfree(&regexNameValue);
 122                 regfree(&regexComment);
 123                 started = false;
 124         }
 125 }
 126
 127 /**
 128  * Performs a regex match
 129  * @param regex the compiled regex to match against
 130  * @param line the line to match
 131  * @param nmatch the number of matches to produce
 132  * @param pmatch the array with match information
 133  * @return true upon success, false otherwise
 134  */
 135 static bool regexMatch(regex_t * regex, char * line, size_t nmatch, regmatch_t pmatch[]) {
 136         int result = regexec(regex, line, nmatch, pmatch, 0);
 137         if (!result) {
 138                 return true;
 139         }
 140
 141         if (result == REG_NOMATCH) {
 142                 return false;
 143         }
 144
 145         {
 146                 char msgbuf[256];
 147                 regerror(result, regex, msgbuf, sizeof(msgbuf));
 148                 sgwDynSpeedError(false, "Regex match failed: %s", msgbuf);
 149         }
 150
 151         return false;
 152 }
 153
 154 /** the buffer in which to store a line read from the file */
 155 static char line[LINE_LENGTH];
 156
 157 /**
 158  * Read the speed file
 159  * @param fileName the filename
 160  */
 161 void readSpeedFile(char * fileName) {
 162         int fd;
 163         struct stat statBuf;
 164         FILE * fp = NULL;
 165         unsigned int lineNumber = 0;
 166         char * name = NULL;
 167         char * value = NULL;
 168         unsigned long uplink = DEF_UPLINK_SPEED;
 169         unsigned long downlink = DEF_DOWNLINK_SPEED;
 170         bool uplinkSet = false;
 171         bool downlinkSet = false;
 172
 173         fd = open(fileName, O_RDONLY);
 174         if (fd < 0) {
 175                 /* could not access the file */
 176                 goto out;
 177         }
 178
 179         if (fstat(fd, &statBuf)) {
 180                 /* could not access the file */
 181                 goto out;
 182         }
 183
 184         if (!memcmp(&cachedStat.timeStamp, &statBuf.st_mtime, sizeof(cachedStat.timeStamp))) {
 185                 /* file did not change since last read */
 186                 goto out;
 187         }
 188
 189         fp = fdopen(fd, "r");
 190         if (!fp) {
 191                 goto out;
 192         }
 193
 194         memcpy(&cachedStat.timeStamp, &statBuf.st_mtime, sizeof(cachedStat.timeStamp));
 195
 196         while (fgets(line, LINE_LENGTH, fp)) {
 197                 regmatch_t pmatch[regexNameValuematchCount];
 198
 199                 lineNumber++;
 200
 201                 if (regexMatch(&regexComment, line, 0, NULL)) {
 202                         continue;
 203                 }
 204
 205                 if (!regexMatch(&regexNameValue, line, regexNameValuematchCount, pmatch)) {
 206                         sgwDynSpeedError(false, "Gateway speed file \"%s\", line %d uses invalid syntax: %s", fileName, lineNumber,
 207                                         line);
 208                         goto out;
 209                 }
 210
 211                 /* determine name/value */
 212                 name = &line[pmatch[1].rm_so];
 213                 line[pmatch[1].rm_eo] = '\0';
 214                 value = &line[pmatch[2].rm_so];
 215                 line[pmatch[2].rm_eo] = '\0';
 216
 217                 if (!strncasecmp(SPEED_UPLINK_NAME, name, sizeof(line))) {
 218                         if (!readUL(SPEED_UPLINK_NAME, value, &uplink)) {
 219                                 goto out;
 220                         }
 221                         uplinkSet = true;
 222                 } else if (!strncasecmp(SPEED_DOWNLINK_NAME, name, sizeof(line))) {
 223                         if (!readUL(SPEED_DOWNLINK_NAME, value, &downlink)) {
 224                                 goto out;
 225                         }
 226                         downlinkSet = true;
 227                 } else {
 228                         sgwDynSpeedError(false, "Gateway speed file \"%s\", line %d uses an invalid option \"%s\","
 229                                         " valid options are [%s|%s]", fileName, lineNumber, name, SPEED_UPLINK_NAME, SPEED_DOWNLINK_NAME);
 230                         goto out;
 231                 }
 232         }
 233
 234         fclose(fp);
 235         fp = NULL;
 236
 237         if (uplinkSet) {
 238                 olsr_cnf->smart_gw_uplink = uplink;
 239         }
 240         if (downlinkSet) {
 241                 olsr_cnf->smart_gw_downlink = downlink;
 242         }
 243         if (uplinkSet || downlinkSet) {
 244           refresh_smartgw_netmask();
 245         }
 246
 247         out: if (fp) {
 248                 fclose(fp);
 249         }
 250         if (fd >= 0) {
 251                 close(fd);
 252         }
 253         return;
 254 }