lib/fko_message.c

   1 /*
   2  *****************************************************************************
   3  *
   4  * File:    fko_message.c
   5  *
   6  * Author:  Damien S. Stuart
   7  *
   8  * Purpose: Set/Get the spa message (access req/command/etc) based
   9  *          on the current spa data.
  10  *
  11  * Copyright 2009-2010 Damien Stuart (dstuart@dstuart.org)
  12  *
  13  *  License (GNU Public License):
  14  *
  15  *  This program is free software; you can redistribute it and/or
  16  *  modify it under the terms of the GNU General Public License
  17  *  as published by the Free Software Foundation; either version 2
  18  *  of the License, or (at your option) any later version.
  19  *
  20  *  This program is distributed in the hope that it will be useful,
  21  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  *  GNU General Public License for more details.
  24  *
  25  *  You should have received a copy of the GNU General Public License
  26  *  along with this program; if not, write to the Free Software
  27  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  28  *  USA
  29  *
  30  *****************************************************************************
  31 */
  32 #include "fko_common.h"
  33 #include "fko.h"
  34
  35 /* SPA message format validation functions.
  36  * (These called from the spa_message function here only).
  37 */
  38 int validate_cmd_msg(const char *msg);
  39 int validate_access_msg(const char *msg);
  40 int validate_proto_port_spec(const char *msg);
  41 int validate_nat_access_msg(const char *msg);
  42 int got_allow_ip(const char *msg);
  43
  44 /* Set the SPA message type.
  45 */
  46 int
  47 fko_set_spa_message_type(fko_ctx_t ctx, const short msg_type)
  48 {
  49     /* Must be initialized
  50     */
  51     if(!CTX_INITIALIZED(ctx))
  52         return FKO_ERROR_CTX_NOT_INITIALIZED;
  53
  54     if(msg_type < 0 || msg_type >= FKO_LAST_MSG_TYPE)
  55         return(FKO_ERROR_INVALID_DATA);
  56
  57     ctx->message_type = msg_type;
  58
  59     ctx->state |= FKO_SPA_MSG_TYPE_MODIFIED;
  60
  61     return(FKO_SUCCESS);
  62 }
  63
  64 /* Return the SPA message type.
  65 */
  66 int
  67 fko_get_spa_message_type(fko_ctx_t ctx, short *msg_type)
  68 {
  69     /* Must be initialized
  70     */
  71     if(!CTX_INITIALIZED(ctx))
  72         return FKO_ERROR_CTX_NOT_INITIALIZED;
  73
  74     *msg_type = ctx->message_type;
  75
  76     return(FKO_SUCCESS);
  77 }
  78
  79 /* Set the SPA MESSAGE data
  80 */
  81 int
  82 fko_set_spa_message(fko_ctx_t ctx, const char *msg)
  83 {
  84     int res = FKO_ERROR_UNKNOWN;
  85
  86     /* Context must be initialized.
  87     */
  88     if(!CTX_INITIALIZED(ctx))
  89         return FKO_ERROR_CTX_NOT_INITIALIZED;
  90
  91     /* Gotta have a valid string.
  92     */
  93     if(msg == NULL || strlen(msg) == 0)
  94         return(FKO_ERROR_INVALID_DATA);
  95
  96     /* --DSS XXX: Bail out for now.  But consider just
  97      *            truncating in the future...
  98     */
  99     if(strlen(msg) > MAX_SPA_MESSAGE_SIZE)
 100         return(FKO_ERROR_DATA_TOO_LARGE);
 101
 102     /* Basic message type and format checking...
 103     */
 104     switch(ctx->message_type)
 105     {
 106         case FKO_COMMAND_MSG:
 107             res = validate_cmd_msg(msg);
 108             break;
 109
 110         case FKO_ACCESS_MSG:
 111         case FKO_CLIENT_TIMEOUT_ACCESS_MSG:
 112             res = validate_access_msg(msg);
 113             break;
 114
 115         case FKO_NAT_ACCESS_MSG:
 116         case FKO_LOCAL_NAT_ACCESS_MSG:
 117         case FKO_CLIENT_TIMEOUT_NAT_ACCESS_MSG:
 118         case FKO_CLIENT_TIMEOUT_LOCAL_NAT_ACCESS_MSG:
 119             res = validate_nat_access_msg(msg);
 120             break;
 121     }
 122
 123     if(res != FKO_SUCCESS)
 124         return(res);
 125
 126     /* Just in case this is a subsquent call to this function.  We
 127      * do not want to be leaking memory.
 128     */
 129     if(ctx->message != NULL)
 130         free(ctx->message);
 131
 132     ctx->message = strdup(msg);
 133
 134     ctx->state |= FKO_DATA_MODIFIED;
 135
 136     if(ctx->message == NULL)
 137         return(FKO_ERROR_MEMORY_ALLOCATION);
 138
 139     return(FKO_SUCCESS);
 140 }
 141
 142 /* Return the SPA message data.
 143 */
 144 int
 145 fko_get_spa_message(fko_ctx_t ctx, char **msg)
 146 {
 147     /* Must be initialized
 148     */
 149     if(!CTX_INITIALIZED(ctx))
 150         return(FKO_ERROR_CTX_NOT_INITIALIZED);
 151
 152     *msg = ctx->message;
 153
 154     return(FKO_SUCCESS);
 155 }
 156
 157 /* Validate a command message format.
 158 */
 159 int
 160 validate_cmd_msg(const char *msg)
 161 {
 162     const char   *ndx;
 163     int     res         = FKO_SUCCESS;
 164     int     startlen    = strlen(msg);
 165
 166
 167     /* Should have a valid allow IP.
 168     */
 169     if((res = got_allow_ip(msg)) != FKO_SUCCESS)
 170         return(res);
 171
 172     /* Commands are fairly free-form so all we can really verify is
 173      * there is something at all. Get past the IP and comma, and make
 174      * sure we have some string leftover...
 175     */
 176     ndx = strchr(msg, ',');
 177     if(ndx == NULL || (1+(ndx - msg)) >= startlen)
 178         return(FKO_ERROR_INVALID_SPA_COMMAND_MSG);
 179
 180     return(FKO_SUCCESS);
 181 }
 182
 183 int
 184 validate_access_msg(const char *msg)
 185 {
 186     const char   *ndx;
 187     int     res         = FKO_SUCCESS;
 188     int     startlen    = strlen(msg);
 189
 190     /* Should have a valid allow IP.
 191     */
 192     if((res = got_allow_ip(msg)) != FKO_SUCCESS)
 193         return(res);
 194
 195     /* Position ourselves beyond the allow IP and make sure we are
 196      * still good.
 197     */
 198     ndx = strchr(msg, ',');
 199     if(ndx == NULL || (1+(ndx - msg)) >= startlen)
 200         return(FKO_ERROR_INVALID_SPA_ACCESS_MSG);
 201
 202     /* Look for a comma to see if this is a multi-part access request.
 203     */
 204     do {
 205         ndx++;
 206         res = validate_proto_port_spec(ndx);
 207     } while((ndx = strchr(ndx, ',')));
 208
 209     return(res);
 210 }
 211
 212 int
 213 validate_proto_port_spec(const char *msg)
 214 {
 215     int     startlen    = strlen(msg);
 216
 217     const char   *ndx   = msg;
 218
 219     /* Now check for proto/port string.  Currenly we only allow protos
 220      * 'tcp', 'udp', and 'icmp'.
 221     */
 222     if(strncmp(ndx, "tcp", 3)
 223       && strncmp(ndx, "udp", 3)
 224       && strncmp(ndx, "icmp", 4)
 225       && strncmp(ndx, "none", 4))
 226         return(FKO_ERROR_INVALID_SPA_ACCESS_MSG);
 227
 228     ndx = strchr(ndx, '/');
 229     if(ndx == NULL || (1+(ndx - msg)) >= startlen)
 230         return(FKO_ERROR_INVALID_SPA_ACCESS_MSG);
 231
 232     /* Skip over the ',' and make sure we only have digits.
 233     */
 234     ndx++;
 235     while(*ndx != '\0')
 236     {
 237         if(isdigit(*ndx) == 0)
 238             return(FKO_ERROR_INVALID_SPA_ACCESS_MSG);
 239         ndx++;
 240     }
 241
 242     return(FKO_SUCCESS);
 243 }
 244
 245 int
 246 validate_nat_access_msg(const char *msg)
 247 {
 248     int res = FKO_SUCCESS;
 249
 250     /* Should have a valid access message.
 251     */
 252     if((res = validate_access_msg(msg)) != FKO_SUCCESS)
 253         return(res);
 254
 255     // --DSS TODO: XXX: Put nat_access validation code here
 256
 257     return(FKO_SUCCESS);
 258 }
 259
 260 int
 261 got_allow_ip(const char *msg)
 262 {
 263     const char *ndx     = msg;
 264     int         dot_cnt = 0;
 265     int         res     = FKO_SUCCESS;
 266
 267     while(*ndx != ',' && *ndx != '\0')
 268     {
 269         if(*ndx == '.')
 270             dot_cnt++;
 271         else if(isdigit(*ndx) == 0)
 272         {
 273             res = FKO_ERROR_INVALID_ALLOW_IP;
 274             break;
 275         }
 276
 277         ndx++;
 278     }
 279
 280     if(dot_cnt != 3)
 281         res = FKO_ERROR_INVALID_ALLOW_IP;
 282
 283     return(res);
 284 }
 285
 286 /***EOF***/