s3-registry: use push_reg_sz().
[kai/samba.git] / source3 / registry / reg_eventlog.c
1
2 /* 
3  *  Unix SMB/CIFS implementation.
4  *  Virtual Windows Registry Layer
5  *  Copyright (C) Marcin Krzysztof Porwit    2005,
6  *  Copyright (C) Brian Moran                2005.
7  *  Copyright (C) Gerald (Jerry) Carter      2005.
8  *  
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License as published by
11  *  the Free Software Foundation; either version 3 of the License, or
12  *  (at your option) any later version.
13  *  
14  *  This program is distributed in the hope that it will be useful,
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *  GNU General Public License for more details.
18  *  
19  *  You should have received a copy of the GNU General Public License
20  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
21  */
22
23 #include "includes.h"
24
25 #undef DBGC_CLASS
26 #define DBGC_CLASS DBGC_REGISTRY
27
28 /**********************************************************************
29  for an eventlog, add in the default values
30 *********************************************************************/
31
32 bool eventlog_init_keys(void)
33 {
34         /* Find all of the eventlogs, add keys for each of them */
35         const char **elogs = lp_eventlog_list();
36         char *evtlogpath = NULL;
37         char *evtfilepath = NULL;
38         struct regsubkey_ctr *subkeys;
39         struct regval_ctr *values;
40         uint32 uiMaxSize;
41         uint32 uiRetention;
42         uint32 uiCategoryCount;
43         DATA_BLOB data;
44         TALLOC_CTX *ctx = talloc_tos();
45         WERROR werr;
46
47         while (elogs && *elogs) {
48                 werr = regsubkey_ctr_init(ctx, &subkeys);
49                 if (!W_ERROR_IS_OK(werr)) {
50                         DEBUG( 0, ( "talloc() failure!\n" ) );
51                         return False;
52                 }
53                 regdb_fetch_keys(KEY_EVENTLOG, subkeys);
54                 regsubkey_ctr_addkey( subkeys, *elogs );
55                 if ( !regdb_store_keys( KEY_EVENTLOG, subkeys ) ) {
56                         TALLOC_FREE(subkeys);
57                         return False;
58                 }
59                 TALLOC_FREE(subkeys);
60
61                 /* add in the key of form KEY_EVENTLOG/Application */
62                 DEBUG( 5,
63                        ( "Adding key of [%s] to path of [%s]\n", *elogs,
64                          KEY_EVENTLOG ) );
65
66                 evtlogpath = talloc_asprintf(ctx, "%s\\%s",
67                           KEY_EVENTLOG, *elogs);
68                 if (!evtlogpath) {
69                         return false;
70                 }
71                 /* add in the key of form KEY_EVENTLOG/Application/Application */
72                 DEBUG( 5,
73                        ( "Adding key of [%s] to path of [%s]\n", *elogs,
74                          evtlogpath ) );
75                 werr = regsubkey_ctr_init(ctx, &subkeys);
76                 if (!W_ERROR_IS_OK(werr)) {
77                         DEBUG( 0, ( "talloc() failure!\n" ) );
78                         return False;
79                 }
80                 regdb_fetch_keys( evtlogpath, subkeys );
81                 regsubkey_ctr_addkey( subkeys, *elogs );
82
83                 if ( !regdb_store_keys( evtlogpath, subkeys ) ) {
84                         TALLOC_FREE(subkeys);
85                         return False;
86                 }
87                 TALLOC_FREE( subkeys );
88
89                 /* now add the values to the KEY_EVENTLOG/Application form key */
90                 if (!(values = TALLOC_ZERO_P(ctx, struct regval_ctr))) {
91                         DEBUG( 0, ( "talloc() failure!\n" ) );
92                         return False;
93                 }
94                 DEBUG( 5,
95                        ( "Storing values to eventlog path of [%s]\n",
96                          evtlogpath ) );
97                 regdb_fetch_values( evtlogpath, values );
98
99
100                 if (!regval_ctr_key_exists(values, "MaxSize")) {
101
102                         /* assume we have none, add them all */
103
104                         /* hard code some initial values */
105
106                         /* uiDisplayNameId = 0x00000100; */
107                         uiMaxSize = 0x00080000;
108                         uiRetention = 0x93A80;
109
110                         regval_ctr_addvalue(values, "MaxSize", REG_DWORD,
111                                              (char *)&uiMaxSize,
112                                              sizeof(uint32));
113
114                         regval_ctr_addvalue(values, "Retention", REG_DWORD,
115                                              (char *)&uiRetention,
116                                              sizeof(uint32));
117                         push_reg_sz(talloc_tos(), &data, *elogs);
118
119                         regval_ctr_addvalue(values, "PrimaryModule", REG_SZ,
120                                              (char *)data.data,
121                                              data.length);
122                         push_reg_sz(talloc_tos(), &data, *elogs);
123
124                         regval_ctr_addvalue(values, "Sources", REG_MULTI_SZ,
125                                              (char *)data.data,
126                                              data.length);
127
128                         evtfilepath = talloc_asprintf(ctx,
129                                         "%%SystemRoot%%\\system32\\config\\%s.tdb",
130                                         *elogs);
131                         if (!evtfilepath) {
132                                 TALLOC_FREE(values);
133                         }
134                         push_reg_sz(talloc_tos(), &data, evtfilepath);
135                         regval_ctr_addvalue(values, "File", REG_EXPAND_SZ, (char *)data.data,
136                                              data.length);
137                         regdb_store_values(evtlogpath, values);
138
139                 }
140
141                 TALLOC_FREE(values);
142
143                 /* now do the values under KEY_EVENTLOG/Application/Application */
144                 TALLOC_FREE(evtlogpath);
145                 evtlogpath = talloc_asprintf(ctx, "%s\\%s\\%s",
146                           KEY_EVENTLOG, *elogs, *elogs);
147                 if (!evtlogpath) {
148                         return false;
149                 }
150                 if (!(values = TALLOC_ZERO_P(ctx, struct regval_ctr))) {
151                         DEBUG( 0, ( "talloc() failure!\n" ) );
152                         return False;
153                 }
154                 DEBUG( 5,
155                        ( "Storing values to eventlog path of [%s]\n",
156                          evtlogpath));
157                 regdb_fetch_values(evtlogpath, values);
158                 if (!regval_ctr_key_exists( values, "CategoryCount")) {
159
160                         /* hard code some initial values */
161
162                         uiCategoryCount = 0x00000007;
163                         regval_ctr_addvalue( values, "CategoryCount",
164                                              REG_DWORD,
165                                              ( char * ) &uiCategoryCount,
166                                              sizeof( uint32 ) );
167                         push_reg_sz(talloc_tos(), &data,
168                                       "%SystemRoot%\\system32\\eventlog.dll");
169
170                         regval_ctr_addvalue( values, "CategoryMessageFile",
171                                              REG_EXPAND_SZ,
172                                              ( char * ) data.data,
173                                              data.length);
174                         regdb_store_values( evtlogpath, values );
175                 }
176                 TALLOC_FREE(values);
177                 elogs++;
178         }
179
180         return true;
181 }
182
183 /*********************************************************************
184  for an eventlog, add in a source name. If the eventlog doesn't
185  exist (not in the list) do nothing.   If a source for the log
186  already exists, change the information (remove, replace)
187 *********************************************************************/
188
189 bool eventlog_add_source( const char *eventlog, const char *sourcename,
190                           const char *messagefile )
191 {
192         /* Find all of the eventlogs, add keys for each of them */
193         /* need to add to the value KEY_EVENTLOG/<eventlog>/Sources string (Creating if necessary)
194            need to add KEY of source to KEY_EVENTLOG/<eventlog>/<source> */
195
196         const char **elogs = lp_eventlog_list(  );
197         char **wrklist, **wp;
198         char *evtlogpath = NULL;
199         struct regsubkey_ctr *subkeys;
200         struct regval_ctr *values;
201         struct regval_blob *rval;
202         DATA_BLOB data;
203         uint16 *msz_wp;
204         int mbytes, ii;
205         bool already_in;
206         int i;
207         int numsources;
208         TALLOC_CTX *ctx = talloc_tos();
209         WERROR werr;
210
211         if (!elogs) {
212                 return False;
213         }
214
215         for ( i = 0; elogs[i]; i++ ) {
216                 if ( strequal( elogs[i], eventlog ) )
217                         break;
218         }
219
220         if ( !elogs[i] ) {
221                 DEBUG( 0,
222                        ( "Eventlog [%s] not found in list of valid event logs\n",
223                          eventlog ) );
224                 return false;   /* invalid named passed in */
225         }
226
227         /* have to assume that the evenlog key itself exists at this point */
228         /* add in a key of [sourcename] under the eventlog key */
229
230         /* todo add to Sources */
231
232         if (!( values = TALLOC_ZERO_P(ctx, struct regval_ctr))) {
233                 DEBUG( 0, ( "talloc() failure!\n" ));
234                 return false;
235         }
236
237         evtlogpath = talloc_asprintf(ctx, "%s\\%s", KEY_EVENTLOG, eventlog);
238         if (!evtlogpath) {
239                 TALLOC_FREE(values);
240                 return false;
241         }
242
243         regdb_fetch_values( evtlogpath, values );
244
245
246         if ( !( rval = regval_ctr_getvalue( values, "Sources" ) ) ) {
247                 DEBUG( 0, ( "No Sources value for [%s]!\n", eventlog ) );
248                 return False;
249         }
250         /* perhaps this adding a new string to a multi_sz should be a fn? */
251         /* check to see if it's there already */
252
253         if ( rval->type != REG_MULTI_SZ ) {
254                 DEBUG( 0,
255                        ( "Wrong type for Sources, should be REG_MULTI_SZ\n" ) );
256                 return False;
257         }
258         /* convert to a 'regulah' chars to do some comparisons */
259
260         already_in = False;
261         wrklist = NULL;
262         dump_data( 1, rval->data_p, rval->size );
263         if ( ( numsources =
264                regval_convert_multi_sz( ( uint16 * ) rval->data_p, rval->size,
265                                         &wrklist ) ) > 0 ) {
266
267                 ii = numsources;
268                 /* see if it's in there already */
269                 wp = wrklist;
270
271                 while ( ii && wp && *wp ) {
272                         if ( strequal( *wp, sourcename ) ) {
273                                 DEBUG( 5,
274                                        ( "Source name [%s] already in list for [%s] \n",
275                                          sourcename, eventlog ) );
276                                 already_in = True;
277                                 break;
278                         }
279                         wp++;
280                         ii--;
281                 }
282         } else {
283                 if ( numsources < 0 ) {
284                         DEBUG( 3, ( "problem in getting the sources\n" ) );
285                         return False;
286                 }
287                 DEBUG( 3,
288                        ( "Nothing in the sources list, this might be a problem\n" ) );
289         }
290
291         wp = wrklist;
292
293         if ( !already_in ) {
294                 /* make a new list with an additional entry; copy values, add another */
295                 wp = TALLOC_ARRAY(ctx, char *, numsources + 2 );
296
297                 if ( !wp ) {
298                         DEBUG( 0, ( "talloc() failed \n" ) );
299                         return False;
300                 }
301                 memcpy( wp, wrklist, sizeof( char * ) * numsources );
302                 *( wp + numsources ) = ( char * ) sourcename;
303                 *( wp + numsources + 1 ) = NULL;
304                 mbytes = regval_build_multi_sz( wp, &msz_wp );
305                 dump_data( 1, ( uint8 * ) msz_wp, mbytes );
306                 regval_ctr_addvalue( values, "Sources", REG_MULTI_SZ,
307                                      ( char * ) msz_wp, mbytes );
308                 regdb_store_values( evtlogpath, values );
309                 TALLOC_FREE(msz_wp);
310         } else {
311                 DEBUG( 3,
312                        ( "Source name [%s] found in existing list of sources\n",
313                          sourcename ) );
314         }
315         TALLOC_FREE(values);
316         TALLOC_FREE(wrklist);   /*  */
317
318         werr = regsubkey_ctr_init(ctx, &subkeys);
319         if (!W_ERROR_IS_OK(werr)) {
320                 DEBUG( 0, ( "talloc() failure!\n" ) );
321                 return False;
322         }
323         TALLOC_FREE(evtlogpath);
324         evtlogpath = talloc_asprintf(ctx, "%s\\%s", KEY_EVENTLOG, eventlog );
325         if (!evtlogpath) {
326                 TALLOC_FREE(subkeys);
327                 return false;
328         }
329
330         regdb_fetch_keys( evtlogpath, subkeys );
331
332         if ( !regsubkey_ctr_key_exists( subkeys, sourcename ) ) {
333                 DEBUG( 5,
334                        ( " Source name [%s] for eventlog [%s] didn't exist, adding \n",
335                          sourcename, eventlog ) );
336                 regsubkey_ctr_addkey( subkeys, sourcename );
337                 if ( !regdb_store_keys( evtlogpath, subkeys ) )
338                         return False;
339         }
340         TALLOC_FREE(subkeys);
341
342         /* at this point KEY_EVENTLOG/<eventlog>/<sourcename> key is in there. Now need to add EventMessageFile */
343
344         /* now allocate room for the source's subkeys */
345
346         werr = regsubkey_ctr_init(ctx, &subkeys);
347         if (!W_ERROR_IS_OK(werr)) {
348                 DEBUG( 0, ( "talloc() failure!\n" ) );
349                 return False;
350         }
351         TALLOC_FREE(evtlogpath);
352         evtlogpath = talloc_asprintf(ctx, "%s\\%s\\%s",
353                   KEY_EVENTLOG, eventlog, sourcename);
354         if (!evtlogpath) {
355                 TALLOC_FREE(subkeys);
356                 return false;
357         }
358
359         regdb_fetch_keys( evtlogpath, subkeys );
360
361         /* now add the values to the KEY_EVENTLOG/Application form key */
362         if ( !( values = TALLOC_ZERO_P(ctx, struct regval_ctr ) ) ) {
363                 DEBUG( 0, ( "talloc() failure!\n" ) );
364                 return False;
365         }
366         DEBUG( 5,
367                ( "Storing EventMessageFile [%s] to eventlog path of [%s]\n",
368                  messagefile, evtlogpath ) );
369
370         regdb_fetch_values( evtlogpath, values );
371
372         push_reg_sz(talloc_tos(), &data, messagefile);
373
374         regval_ctr_addvalue( values, "EventMessageFile", REG_SZ,
375                              ( char * ) data.data,
376                              data.length);
377         regdb_store_values( evtlogpath, values );
378
379         TALLOC_FREE(values);
380
381         return True;
382 }