fcb3ac2450e98073f3e52419e2990c7548465cd9
[fwknop.git] / 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***/