add some basic infrastructure for cookies
[olsrd.git] / src / olsr_cookie.c
1
2 /*
3  * The olsr.org Optimized Link-State Routing daemon(olsrd)
4  * Copyright (c) 2008, Hannes Gredler (hannes@gredler.at)
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without 
8  * modification, are permitted provided that the following conditions 
9  * are met:
10  *
11  * * Redistributions of source code must retain the above copyright 
12  *   notice, this list of conditions and the following disclaimer.
13  * * Redistributions in binary form must reproduce the above copyright 
14  *   notice, this list of conditions and the following disclaimer in 
15  *   the documentation and/or other materials provided with the 
16  *   distribution.
17  * * Neither the name of olsr.org, olsrd nor the names of its 
18  *   contributors may be used to endorse or promote products derived 
19  *   from this software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
25  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
29  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
31  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
32  * POSSIBILITY OF SUCH DAMAGE.
33  *
34  * Visit http://www.olsr.org for more information.
35  *
36  * If you find this software useful feel free to make a donation
37  * to the project. For more information see the website or contact
38  * the copyright holders.
39  */
40
41 #include "olsr.h"
42 #include "defs.h"
43 #include "olsr_cookie.h"
44 #include "log.h"
45
46 #include <assert.h>
47
48 /* Root directory of the cookies we have in the system */
49 struct olsr_cookie_info *cookies[COOKIE_ID_MAX];
50
51 /*
52  * Allocate a cookie for the next available cookie id.
53  */
54 struct olsr_cookie_info *
55 olsr_alloc_cookie(const char *cookie_name, olsr_cookie_type cookie_type)
56 {
57   static olsr_bool first = OLSR_TRUE;
58   struct olsr_cookie_info *ci;
59   int ci_index;
60
61   /* Clear the cookie root array on the first call */
62   if (first) {
63     for (ci_index = 0; ci_index < COOKIE_ID_MAX; ci_index++) {
64       cookies[ci_index] = NULL;
65     }
66     first = OLSR_FALSE;
67   }
68
69   /*
70    * Look for an unused index.
71    * For ease of troubleshooting (non-zero patterns) we start at index 1.
72    */
73   for (ci_index = 1; ci_index < COOKIE_ID_MAX; ci_index++) {
74     if (!cookies[ci_index]) {
75       break;
76     }
77   }
78
79   assert(ci_index < COOKIE_ID_MAX);     /* increase COOKIE_ID_MAX */
80
81   ci = calloc(1, sizeof(struct olsr_cookie_info));
82   cookies[ci_index] = ci;
83
84   /* Now populate the cookie info */
85   ci->ci_id = ci_index;
86   ci->ci_type = cookie_type;
87   if (cookie_name) {
88     ci->ci_name = strdup(cookie_name);
89   }
90
91   return ci;
92 }
93
94 /*
95  * Free a cookie that is no longer being used.
96  */
97 void
98 olsr_free_cookie(struct olsr_cookie_info *ci)
99 {
100
101   /* Mark the cookie as unused */
102   cookies[ci->ci_id] = NULL;
103
104   /* Free name if set */
105   if (ci->ci_name) {
106     free(ci->ci_name);
107   }
108   free(ci);
109 }
110
111 /*
112  * Set the size for fixed block allocations.
113  * This is only allowed for memory cookies.
114  */
115 void
116 olsr_cookie_set_memory_size(struct olsr_cookie_info *ci, size_t size)
117 {
118   if (!ci) {
119     return;
120   }
121
122   assert(ci->ci_type == OLSR_COOKIE_TYPE_MEMORY);
123   ci->ci_size = size;
124 }
125
126 /*
127  * Basic sanity checking for a passed-in cookie-id.
128  */
129 static olsr_bool
130 olsr_cookie_valid(olsr_cookie_t cookie_id)
131 {
132   if ((cookie_id < COOKIE_ID_MAX) && cookies[cookie_id]) {
133     return OLSR_TRUE;
134   }
135   return OLSR_FALSE;
136 }
137
138 /*
139  * Increment usage state for a given cookie.
140  */
141 void
142 olsr_cookie_usage_incr(olsr_cookie_t cookie_id)
143 {
144   if (olsr_cookie_valid(cookie_id)) {
145     cookies[cookie_id]->ci_usage++;
146     cookies[cookie_id]->ci_changes++;
147   }
148 }
149
150 /*
151  * Decrement usage state for a given cookie.
152  */
153 void
154 olsr_cookie_usage_decr(olsr_cookie_t cookie_id)
155 {
156   if (olsr_cookie_valid(cookie_id)) {
157     cookies[cookie_id]->ci_usage--;
158     cookies[cookie_id]->ci_changes++;
159   }
160 }
161
162 /*
163  * Return a cookie name.
164  * Mostly used for logging purposes.
165  */
166 char *
167 olsr_cookie_name(olsr_cookie_t cookie_id)
168 {
169   static char unknown[] = "unknown";
170
171   if (olsr_cookie_valid(cookie_id)) {
172     return (cookies[cookie_id])->ci_name;
173   }
174
175   return unknown;
176 }
177
178 /*
179  * Allocate a fixed amount of memory based on a passed in cookie type.
180  */
181 void *
182 olsr_cookie_malloc(struct olsr_cookie_info *ci)
183 {
184   void *ptr;
185   struct olsr_cookie_mem_brand *branding;
186
187   /*
188    * Not all the callers do a proper cleaning of memory.
189    * Clean it on behalf of those.
190    */
191   ptr = calloc(1, ci->ci_size + sizeof(struct olsr_cookie_mem_brand));
192
193   if (!ptr) {
194     const char *const err_msg = strerror(errno);
195     OLSR_PRINTF(1, "OUT OF MEMORY: %s\n", err_msg);
196     olsr_syslog(OLSR_LOG_ERR, "olsrd: out of memory!: %s\n", err_msg);
197     olsr_exit(ci->ci_name, EXIT_FAILURE);
198   }
199
200   /*
201    * Now brand mark the end of the memory block with a short signature
202    * indicating presence of a cookie. This will be checked against
203    * When the block is freed to detect corruption.
204    */
205   branding = (struct olsr_cookie_mem_brand *)
206     ((unsigned char *)ptr + ci->ci_size);
207   memcpy(&branding->cmb_sig, "cookie", 6);
208   branding->cmb_id = ci->ci_id;
209
210   /* Stats keeping */
211   olsr_cookie_usage_incr(ci->ci_id);
212
213 #if 1
214   olsr_printf(1, "MEMORY: alloc %s, %p, %u bytes\n",
215               ci->ci_name, ptr, ci->ci_size);
216 #endif
217
218   return ptr;
219 }
220
221 /*
222  * Free a memory block owned by a given cookie.
223  * Run some corruption checks.
224  */
225 void
226 olsr_cookie_free(struct olsr_cookie_info *ci, void *ptr)
227 {
228   struct olsr_cookie_mem_brand *branding;
229
230   branding = (struct olsr_cookie_mem_brand *)
231     ((unsigned char *)ptr + ci->ci_size);
232
233   /*
234    * Verify if there has been a memory overrun, or
235    * the wrong owner is trying to free this.
236    */
237   assert(!memcmp(&branding->cmb_sig, "cookie", 6) &&
238          branding->cmb_id == ci->ci_id);
239
240   /* Kill the brand */
241   memset(branding, 0, sizeof(*branding));
242
243   /* Stats keeping */
244   olsr_cookie_usage_decr(ci->ci_id);
245
246 #if 1
247   olsr_printf(1, "MEMORY: free %s, %p, %u bytes\n",
248               ci->ci_name, ptr, ci->ci_size);
249 #endif
250
251   free(ptr);
252 }
253
254 /*
255  * Local Variables:
256  * c-basic-offset: 2
257  * End:
258  */