?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dsdb-acl: introduce a 'msg' helper variable to acl_modify()
[Samba/gebeck_regimport.git] / source3 / registry / reg_perfcount.c
blobcfefb1fb95155dd84efa6e281740310cd55f52c5
1 /*
2 * Unix SMB/CIFS implementation.
3 * Virtual Windows Registry Layer
4 *
5 * Copyright (C) Marcin Krzysztof Porwit 2005,
6 * Copyright (C) Gerald (Jerry) Carter 2005.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "system/filesys.h"
24 #include "../librpc/gen_ndr/perfcount.h"
25 #include "registry.h"
26 #include "reg_perfcount.h"
27 #include "../libcli/registry/util_reg.h"
28 #include "util_tdb.h"
29
30 #undef DBGC_CLASS
31 #define DBGC_CLASS DBGC_REGISTRY
32
33 #define PERFCOUNT_MAX_LEN 256
34
35 #define PERFCOUNTDIR "perfmon"
36 #define NAMES_DB "names.tdb"
37 #define DATA_DB "data.tdb"
38
39 struct PERF_OBJECT_TYPE *_reg_perfcount_find_obj(struct PERF_DATA_BLOCK *block, int objind);
40
41 /*********************************************************************
42 *********************************************************************/
43
44 static char *counters_directory(const char *dbname)
45 {
46 char *path = NULL;
47 char *ret = NULL;
48 TALLOC_CTX *ctx = talloc_tos();
49
50 path = state_path(PERFCOUNTDIR);
51 if (!directory_create_or_exist(path, geteuid(), 0755)) {
52 return NULL;
53 }
54
55 path = talloc_asprintf(ctx, "%s/%s", PERFCOUNTDIR, dbname);
56 if (!path) {
57 return NULL;
58 }
59
60 ret = talloc_strdup(ctx, state_path(path));
61 TALLOC_FREE(path);
62 return ret;
63 }
64
65 /*********************************************************************
66 *********************************************************************/
67
68 uint32 reg_perfcount_get_base_index(void)
69 {
70 const char *fname = counters_directory( NAMES_DB );
71 TDB_CONTEXT *names;
72 TDB_DATA kbuf, dbuf;
73 char key[] = "1";
74 uint32 retval = 0;
75 char buf[PERFCOUNT_MAX_LEN];
76
77 names = tdb_open_log(fname, 0, TDB_DEFAULT, O_RDONLY, 0444);
78
79 if ( !names ) {
80 DEBUG(1, ("reg_perfcount_get_base_index: unable to open [%s].\n", fname));
81 return 0;
82 }
83 /* needs to read the value of key "1" from the counter_names.tdb file, as that is
84 where the total number of counters is stored. We're assuming no holes in the
85 enumeration.
86 The format for the counter_names.tdb file is:
87 key value
88 1 num_counters
89 2 perf_counter1
90 3 perf_counter1_help
91 4 perf_counter2
92 5 perf_counter2_help
93 even_num perf_counter<even_num>
94 even_num+1 perf_counter<even_num>_help
95 and so on.
96 So last_counter becomes num_counters*2, and last_help will be last_counter+1 */
97 kbuf = string_tdb_data(key);
98 dbuf = tdb_fetch_compat(names, kbuf);
99 if(dbuf.dptr == NULL)
100 {
101 DEBUG(1, ("reg_perfcount_get_base_index: failed to find key \'1\' in [%s].\n", fname));
102 tdb_close(names);
103 return 0;
104 }
105 else
106 {
107 tdb_close(names);
108 memset(buf, 0, PERFCOUNT_MAX_LEN);
109 memcpy(buf, dbuf.dptr, dbuf.dsize);
110 retval = (uint32)atoi(buf);
111 SAFE_FREE(dbuf.dptr);
112 return retval;
113 }
114 return 0;
115 }
116
117 /*********************************************************************
118 *********************************************************************/
119
120 uint32 reg_perfcount_get_last_counter(uint32 base_index)
121 {
122 uint32 retval;
123
124 if(base_index == 0)
125 retval = 0;
126 else
127 retval = base_index * 2;
128
129 return retval;
130 }
131
132 /*********************************************************************
133 *********************************************************************/
134
135 uint32 reg_perfcount_get_last_help(uint32 last_counter)
136 {
137 uint32 retval;
138
139 if(last_counter == 0)
140 retval = 0;
141 else
142 retval = last_counter + 1;
143
144 return retval;
145 }
146
147
148 /*********************************************************************
149 *********************************************************************/
150
151 static uint32 _reg_perfcount_multi_sz_from_tdb(TDB_CONTEXT *tdb,
152 int keyval,
153 char **retbuf,
154 uint32 buffer_size)
155 {
156 TDB_DATA kbuf, dbuf;
157 char temp[256];
158 char *buf1 = *retbuf;
159 uint32 working_size = 0;
160 DATA_BLOB name_index, name;
161 bool ok;
162
163 memset(temp, 0, sizeof(temp));
164 snprintf(temp, sizeof(temp), "%d", keyval);
165 kbuf = string_tdb_data(temp);
166 dbuf = tdb_fetch_compat(tdb, kbuf);
167 if(dbuf.dptr == NULL)
168 {
169 /* If a key isn't there, just bypass it -- this really shouldn't
170 happen unless someone's mucking around with the tdb */
171 DEBUG(3, ("_reg_perfcount_multi_sz_from_tdb: failed to find key [%s] in [%s].\n",
172 temp, tdb_name(tdb)));
173 return buffer_size;
174 }
175 /* First encode the name_index */
176 working_size = (kbuf.dsize + 1)*sizeof(uint16);
177 buf1 = (char *)SMB_REALLOC(buf1, buffer_size + working_size);
178 if(!buf1) {
179 buffer_size = 0;
180 return buffer_size;
181 }
182 ok = push_reg_sz(talloc_tos(), &name_index, (const char *)kbuf.dptr);
183 if (!ok) {
184 buffer_size = 0;
185 return buffer_size;
186 }
187 memcpy(buf1+buffer_size, (char *)name_index.data, working_size);
188 buffer_size += working_size;
189 /* Now encode the actual name */
190 working_size = (dbuf.dsize + 1)*sizeof(uint16);
191 buf1 = (char *)SMB_REALLOC(buf1, buffer_size + working_size);
192 if(!buf1) {
193 buffer_size = 0;
194 return buffer_size;
195 }
196 memset(temp, 0, sizeof(temp));
197 memcpy(temp, dbuf.dptr, dbuf.dsize);
198 SAFE_FREE(dbuf.dptr);
199 ok = push_reg_sz(talloc_tos(), &name, temp);
200 if (!ok) {
201 buffer_size = 0;
202 return buffer_size;
203 }
204 memcpy(buf1+buffer_size, (char *)name.data, working_size);
205 buffer_size += working_size;
206
207 *retbuf = buf1;
208
209 return buffer_size;
210 }
211
212 /*********************************************************************
213 *********************************************************************/
214
215 uint32 reg_perfcount_get_counter_help(uint32 base_index, char **retbuf)
216 {
217 char *buf1 = NULL;
218 uint32 buffer_size = 0;
219 TDB_CONTEXT *names;
220 const char *fname = counters_directory( NAMES_DB );
221 int i;
222
223 if(base_index == 0)
224 return 0;
225
226 names = tdb_open_log(fname, 0, TDB_DEFAULT, O_RDONLY, 0444);
227
228 if(names == NULL)
229 {
230 DEBUG(1, ("reg_perfcount_get_counter_help: unable to open [%s].\n", fname));
231 return 0;
232 }
233
234 for(i = 1; i <= base_index; i++)
235 {
236 buffer_size = _reg_perfcount_multi_sz_from_tdb(names, (i*2)+1, retbuf, buffer_size);
237 }
238 tdb_close(names);
239
240 /* Now terminate the MULTI_SZ with a double unicode NULL */
241 buf1 = *retbuf;
242 buf1 = (char *)SMB_REALLOC(buf1, buffer_size + 2);
243 if(!buf1) {
244 buffer_size = 0;
245 } else {
246 buf1[buffer_size++] = '\0';
247 buf1[buffer_size++] = '\0';
248 }
249
250 *retbuf = buf1;
251
252 return buffer_size;
253 }
254
255 /*********************************************************************
256 *********************************************************************/
257
258 uint32 reg_perfcount_get_counter_names(uint32 base_index, char **retbuf)
259 {
260 char *buf1 = NULL;
261 uint32 buffer_size = 0;
262 TDB_CONTEXT *names;
263 const char *fname = counters_directory( NAMES_DB );
264 int i;
265
266 if(base_index == 0)
267 return 0;
268
269 names = tdb_open_log(fname, 0, TDB_DEFAULT, O_RDONLY, 0444);
270
271 if(names == NULL)
272 {
273 DEBUG(1, ("reg_perfcount_get_counter_names: unable to open [%s].\n", fname));
274 return 0;
275 }
276
277 buffer_size = _reg_perfcount_multi_sz_from_tdb(names, 1, retbuf, buffer_size);
278
279 for(i = 1; i <= base_index; i++)
280 {
281 buffer_size = _reg_perfcount_multi_sz_from_tdb(names, i*2, retbuf, buffer_size);
282 }
283 tdb_close(names);
284
285 /* Now terminate the MULTI_SZ with a double unicode NULL */
286 buf1 = *retbuf;
287 buf1 = (char *)SMB_REALLOC(buf1, buffer_size + 2);
288 if(!buf1) {
289 buffer_size = 0;
290 } else {
291 buf1[buffer_size++] = '\0';
292 buf1[buffer_size++] = '\0';
293 }
294
295 *retbuf=buf1;
296
297 return buffer_size;
298 }
299
300 /*********************************************************************
301 *********************************************************************/
302
303 static void _reg_perfcount_make_key(TDB_DATA *key,
304 char *buf,
305 int buflen,
306 int key_part1,
307 const char *key_part2)
308 {
309 memset(buf, 0, buflen);
310 if(key_part2 != NULL)
311 snprintf(buf, buflen,"%d%s", key_part1, key_part2);
312 else
313 snprintf(buf, buflen, "%d", key_part1);
314
315 *key = string_tdb_data(buf);
316
317 return;
318 }
319
320 /*********************************************************************
321 *********************************************************************/
322
323 static bool _reg_perfcount_isparent(TDB_DATA data)
324 {
325 if(data.dsize > 0)
326 {
327 if(data.dptr[0] == 'p')
328 return True;
329 else
330 return False;
331 }
332 return False;
333 }
334
335 /*********************************************************************
336 *********************************************************************/
337
338 static bool _reg_perfcount_ischild(TDB_DATA data)
339 {
340 if(data.dsize > 0)
341 {
342 if(data.dptr[0] == 'c')
343 return True;
344 else
345 return False;
346 }
347 return False;
348 }
349
350 /*********************************************************************
351 *********************************************************************/
352
353 static uint32 _reg_perfcount_get_numinst(int objInd, TDB_CONTEXT *names)
354 {
355 TDB_DATA key, data;
356 char buf[PERFCOUNT_MAX_LEN];
357
358 _reg_perfcount_make_key(&key, buf, PERFCOUNT_MAX_LEN, objInd, "inst");
359 data = tdb_fetch_compat(names, key);
360
361 if(data.dptr == NULL)
362 return (uint32)PERF_NO_INSTANCES;
363
364 memset(buf, 0, PERFCOUNT_MAX_LEN);
365 memcpy(buf, data.dptr, data.dsize);
366 SAFE_FREE(data.dptr);
367 return (uint32)atoi(buf);
368 }
369
370 /*********************************************************************
371 *********************************************************************/
372
373 static bool _reg_perfcount_add_instance(struct PERF_OBJECT_TYPE *obj,
374 TALLOC_CTX *mem_ctx,
375 int instInd,
376 TDB_CONTEXT *names);
377
378 static bool _reg_perfcount_add_object(struct PERF_DATA_BLOCK *block,
379 TALLOC_CTX *mem_ctx,
380 int num,
381 TDB_DATA data,
382 TDB_CONTEXT *names)
383 {
384 int i;
385 bool success = True;
386 struct PERF_OBJECT_TYPE *obj;
387
388 block->objects = (struct PERF_OBJECT_TYPE *)talloc_realloc(mem_ctx,
389 block->objects,
390 struct PERF_OBJECT_TYPE,
391 block->NumObjectTypes+1);
392 if(block->objects == NULL)
393 return False;
394 obj = &(block->objects[block->NumObjectTypes]);
395 memset((void *)&(block->objects[block->NumObjectTypes]), 0, sizeof(struct PERF_OBJECT_TYPE));
396 block->objects[block->NumObjectTypes].ObjectNameTitleIndex = num;
397 block->objects[block->NumObjectTypes].ObjectNameTitlePointer = 0;
398 block->objects[block->NumObjectTypes].ObjectHelpTitleIndex = num+1;
399 block->objects[block->NumObjectTypes].ObjectHelpTitlePointer = 0;
400 block->objects[block->NumObjectTypes].NumCounters = 0;
401 block->objects[block->NumObjectTypes].DefaultCounter = 0;
402 block->objects[block->NumObjectTypes].NumInstances = _reg_perfcount_get_numinst(num, names);
403 block->objects[block->NumObjectTypes].counters = NULL;
404 block->objects[block->NumObjectTypes].instances = NULL;
405 block->objects[block->NumObjectTypes].counter_data.ByteLength = sizeof(uint32);
406 block->objects[block->NumObjectTypes].counter_data.data = NULL;
407 block->objects[block->NumObjectTypes].DetailLevel = PERF_DETAIL_NOVICE;
408 block->NumObjectTypes+=1;
409
410 for(i = 0; i < (int)obj->NumInstances; i++) {
411 success = _reg_perfcount_add_instance(obj, mem_ctx, i, names);
412 }
413
414 return success;
415 }
416
417 /*********************************************************************
418 *********************************************************************/
419
420 static bool _reg_perfcount_get_counter_data(TDB_DATA key, TDB_DATA *data)
421 {
422 TDB_CONTEXT *counters;
423 const char *fname = counters_directory( DATA_DB );
424
425 counters = tdb_open_log(fname, 0, TDB_DEFAULT, O_RDONLY, 0444);
426
427 if(counters == NULL)
428 {
429 DEBUG(1, ("reg_perfcount_get_counter_data: unable to open [%s].\n", fname));
430 return False;
431 }
432
433 *data = tdb_fetch_compat(counters, key);
434
435 tdb_close(counters);
436
437 return True;
438 }
439
440 /*********************************************************************
441 *********************************************************************/
442
443 static uint32 _reg_perfcount_get_size_field(uint32 CounterType)
444 {
445 uint32 retval;
446
447 retval = CounterType;
448
449 /* First mask out reserved lower 8 bits */
450 retval = retval & 0xFFFFFF00;
451 retval = retval << 22;
452 retval = retval >> 22;
453
454 return retval;
455 }
456
457 /*********************************************************************
458 *********************************************************************/
459
460 static uint32 _reg_perfcount_compute_scale(int64_t data)
461 {
462 int scale = 0;
463 if(data == 0)
464 return scale;
465 while(data > 100)
466 {
467 data /= 10;
468 scale--;
469 }
470 while(data < 10)
471 {
472 data *= 10;
473 scale++;
474 }
475
476 return (uint32)scale;
477 }
478
479 /*********************************************************************
480 *********************************************************************/
481
482 static bool _reg_perfcount_get_counter_info(struct PERF_DATA_BLOCK *block,
483 TALLOC_CTX *mem_ctx,
484 int CounterIndex,
485 struct PERF_OBJECT_TYPE *obj,
486 TDB_CONTEXT *names)
487 {
488 TDB_DATA key, data;
489 char buf[PERFCOUNT_MAX_LEN];
490 size_t dsize, padding;
491 long int data32, dbuf[2];
492 int64_t data64;
493 uint32 counter_size;
494
495 obj->counters[obj->NumCounters].DefaultScale = 0;
496 dbuf[0] = dbuf[1] = 0;
497 padding = 0;
498
499 _reg_perfcount_make_key(&key, buf, PERFCOUNT_MAX_LEN, CounterIndex, "type");
500 data = tdb_fetch_compat(names, key);
501 if(data.dptr == NULL)
502 {
503 DEBUG(3, ("_reg_perfcount_get_counter_info: No type data for counter [%d].\n", CounterIndex));
504 return False;
505 }
506 memset(buf, 0, PERFCOUNT_MAX_LEN);
507 memcpy(buf, data.dptr, data.dsize);
508 obj->counters[obj->NumCounters].CounterType = atoi(buf);
509 DEBUG(10, ("_reg_perfcount_get_counter_info: Got type [%d] for counter [%d].\n",
510 obj->counters[obj->NumCounters].CounterType, CounterIndex));
511 SAFE_FREE(data.dptr);
512
513 /* Fetch the actual data */
514 _reg_perfcount_make_key(&key, buf, PERFCOUNT_MAX_LEN, CounterIndex, "");
515 _reg_perfcount_get_counter_data(key, &data);
516 if(data.dptr == NULL)
517 {
518 DEBUG(3, ("_reg_perfcount_get_counter_info: No counter data for counter [%d].\n", CounterIndex));
519 return False;
520 }
521
522 counter_size = _reg_perfcount_get_size_field(obj->counters[obj->NumCounters].CounterType);
523
524 if(counter_size == PERF_SIZE_DWORD)
525 {
526 dsize = sizeof(data32);
527 memset(buf, 0, PERFCOUNT_MAX_LEN);
528 memcpy(buf, data.dptr, data.dsize);
529 data32 = strtol(buf, NULL, 0);
530 if((obj->counters[obj->NumCounters].CounterType & 0x00000F00) == PERF_TYPE_NUMBER)
531 obj->counters[obj->NumCounters].DefaultScale = _reg_perfcount_compute_scale((int64_t)data32);
532 else
533 obj->counters[obj->NumCounters].DefaultScale = 0;
534 dbuf[0] = data32;
535 padding = (dsize - (obj->counter_data.ByteLength%dsize)) % dsize;
536 }
537 else if(counter_size == PERF_SIZE_LARGE)
538 {
539 dsize = sizeof(data64);
540 memset(buf, 0, PERFCOUNT_MAX_LEN);
541 memcpy(buf, data.dptr, data.dsize);
542 data64 = atof(buf);
543 if((obj->counters[obj->NumCounters].CounterType & 0x00000F00) == PERF_TYPE_NUMBER)
544 obj->counters[obj->NumCounters].DefaultScale = _reg_perfcount_compute_scale(data64);
545 else
546 obj->counters[obj->NumCounters].DefaultScale = 0;
547 memcpy((void *)dbuf, (const void *)&data64, dsize);
548 padding = (dsize - (obj->counter_data.ByteLength%dsize)) % dsize;
549 }
550 else /* PERF_SIZE_VARIABLE_LEN */
551 {
552 dsize = data.dsize;
553 memset(buf, 0, PERFCOUNT_MAX_LEN);
554 memcpy(buf, data.dptr, data.dsize);
555 }
556 SAFE_FREE(data.dptr);
557
558 obj->counter_data.ByteLength += dsize + padding;
559 obj->counter_data.data = talloc_realloc(mem_ctx,
560 obj->counter_data.data,
561 uint8,
562 obj->counter_data.ByteLength - sizeof(uint32));
563 if(obj->counter_data.data == NULL)
564 return False;
565 if(dbuf[0] != 0 || dbuf[1] != 0)
566 {
567 memcpy((void *)(obj->counter_data.data +
568 (obj->counter_data.ByteLength - (sizeof(uint32) + dsize))),
569 (const void *)dbuf, dsize);
570 }
571 else
572 {
573 /* Handling PERF_SIZE_VARIABLE_LEN */
574 memcpy((void *)(obj->counter_data.data +
575 (obj->counter_data.ByteLength - (sizeof(uint32) + dsize))),
576 (const void *)buf, dsize);
577 }
578 obj->counters[obj->NumCounters].CounterOffset = obj->counter_data.ByteLength - dsize;
579 if(obj->counters[obj->NumCounters].CounterOffset % dsize != 0)
580 {
581 DEBUG(3,("Improperly aligned counter [%d]\n", obj->NumCounters));
582 }
583 obj->counters[obj->NumCounters].CounterSize = dsize;
584
585 return True;
586 }
587
588 /*********************************************************************
589 *********************************************************************/
590
591 struct PERF_OBJECT_TYPE *_reg_perfcount_find_obj(struct PERF_DATA_BLOCK *block, int objind)
592 {
593 int i;
594
595 struct PERF_OBJECT_TYPE *obj = NULL;
596
597 for(i = 0; i < block->NumObjectTypes; i++)
598 {
599 if(block->objects[i].ObjectNameTitleIndex == objind)
600 {
601 obj = &(block->objects[i]);
602 }
603 }
604
605 return obj;
606 }
607
608 /*********************************************************************
609 *********************************************************************/
610
611 static bool _reg_perfcount_add_counter(struct PERF_DATA_BLOCK *block,
612 TALLOC_CTX *mem_ctx,
613 int num,
614 TDB_DATA data,
615 TDB_CONTEXT *names)
616 {
617 char *begin, *end, *start, *stop;
618 int parent;
619 struct PERF_OBJECT_TYPE *obj;
620 bool success = True;
621 char buf[PERFCOUNT_MAX_LEN];
622
623 obj = NULL;
624 memset(buf, 0, PERFCOUNT_MAX_LEN);
625 memcpy(buf, data.dptr, data.dsize);
626 begin = strchr(buf, '[');
627 end = strchr(buf, ']');
628 if(begin == NULL || end == NULL)
629 return False;
630 start = begin+1;
631
632 while(start < end) {
633 stop = strchr(start, ',');
634 if(stop == NULL)
635 stop = end;
636 *stop = '\0';
637 parent = atoi(start);
638
639 obj = _reg_perfcount_find_obj(block, parent);
640 if(obj == NULL) {
641 /* At this point we require that the parent object exist.
642 This can probably be handled better at some later time */
643 DEBUG(3, ("_reg_perfcount_add_counter: Could not find parent object [%d] for counter [%d].\n",
644 parent, num));
645 return False;
646 }
647 obj->counters = (struct PERF_COUNTER_DEFINITION *)talloc_realloc(mem_ctx,
648 obj->counters,
649 struct PERF_COUNTER_DEFINITION,
650 obj->NumCounters+1);
651 if(obj->counters == NULL)
652 return False;
653 memset((void *)&(obj->counters[obj->NumCounters]), 0, sizeof(struct PERF_COUNTER_DEFINITION));
654 obj->counters[obj->NumCounters].CounterNameTitleIndex=num;
655 obj->counters[obj->NumCounters].CounterHelpTitleIndex=num+1;
656 obj->counters[obj->NumCounters].DetailLevel = PERF_DETAIL_NOVICE;
657 obj->counters[obj->NumCounters].ByteLength = sizeof(struct PERF_COUNTER_DEFINITION);
658 success = _reg_perfcount_get_counter_info(block, mem_ctx, num, obj, names);
659 obj->NumCounters += 1;
660 start = stop + 1;
661 }
662
663 /* Handle case of Objects/Counters without any counter data, which would suggest
664 that the required instances are not there yet, so change NumInstances from
665 PERF_NO_INSTANCES to 0 */
666
667 return success;
668 }
669
670 /*********************************************************************
671 *********************************************************************/
672
673 static bool _reg_perfcount_get_instance_info(struct PERF_INSTANCE_DEFINITION *inst,
674 TALLOC_CTX *mem_ctx,
675 int instId,
676 struct PERF_OBJECT_TYPE *obj,
677 TDB_CONTEXT *names)
678 {
679 TDB_DATA key, data;
680 char buf[PERFCOUNT_MAX_LEN], temp[PERFCOUNT_MAX_LEN];
681 smb_ucs2_t *name = NULL;
682 int pad;
683
684 /* First grab the instance data from the data file */
685 memset(temp, 0, PERFCOUNT_MAX_LEN);
686 snprintf(temp, PERFCOUNT_MAX_LEN, "i%d", instId);
687 _reg_perfcount_make_key(&key, buf, PERFCOUNT_MAX_LEN, obj->ObjectNameTitleIndex, temp);
688 if (!_reg_perfcount_get_counter_data(key, &data)) {
689 DEBUG(3, ("_reg_perfcount_get_counter_data failed\n"));
690 return false;
691 }
692 if(data.dptr == NULL)
693 {
694 DEBUG(3, ("_reg_perfcount_get_instance_info: No instance data for instance [%s].\n",
695 buf));
696 return False;
697 }
698 inst->counter_data.ByteLength = data.dsize + sizeof(inst->counter_data.ByteLength);
699 inst->counter_data.data = talloc_realloc(mem_ctx,
700 inst->counter_data.data,
701 uint8,
702 data.dsize);
703 if(inst->counter_data.data == NULL)
704 return False;
705 memset(inst->counter_data.data, 0, data.dsize);
706 memcpy(inst->counter_data.data, data.dptr, data.dsize);
707 SAFE_FREE(data.dptr);
708
709 /* Fetch instance name */
710 memset(temp, 0, PERFCOUNT_MAX_LEN);
711 snprintf(temp, PERFCOUNT_MAX_LEN, "i%dname", instId);
712 _reg_perfcount_make_key(&key, buf, PERFCOUNT_MAX_LEN, obj->ObjectNameTitleIndex, temp);
713 data = tdb_fetch_compat(names, key);
714 if(data.dptr == NULL)
715 {
716 /* Not actually an error, but possibly unintended? -- just logging FYI */
717 DEBUG(3, ("_reg_perfcount_get_instance_info: No instance name for instance [%s].\n",
718 buf));
719 inst->NameLength = 0;
720 }
721 else
722 {
723 memset(buf, 0, PERFCOUNT_MAX_LEN);
724 memcpy(buf, data.dptr, MIN(PERFCOUNT_MAX_LEN-1,data.dsize));
725 buf[PERFCOUNT_MAX_LEN-1] = '\0';
726 inst->NameLength = rpcstr_push_talloc(mem_ctx, &name, buf);
727 if (inst->NameLength == (uint32_t)-1 || !name) {
728 SAFE_FREE(data.dptr);
729 return False;
730 }
731 inst->data = talloc_realloc(mem_ctx,
732 inst->data,
733 uint8,
734 inst->NameLength);
735 if (inst->data == NULL) {
736 SAFE_FREE(data.dptr);
737 return False;
738 }
739 memcpy(inst->data, name, inst->NameLength);
740 SAFE_FREE(data.dptr);
741 }
742
743 inst->ParentObjectTitleIndex = 0;
744 inst->ParentObjectTitlePointer = 0;
745 inst->UniqueID = PERF_NO_UNIQUE_ID;
746 inst->NameOffset = 6 * sizeof(uint32);
747
748 inst->ByteLength = inst->NameOffset + inst->NameLength;
749 /* Need to be aligned on a 64-bit boundary here for counter_data */
750 if((pad = (inst->ByteLength % 8)))
751 {
752 pad = 8 - pad;
753 inst->data = talloc_realloc(mem_ctx,
754 inst->data,
755 uint8,
756 inst->NameLength + pad);
757 memset(inst->data + inst->NameLength, 0, pad);
758 inst->ByteLength += pad;
759 }
760
761 return True;
762 }
763
764 /*********************************************************************
765 *********************************************************************/
766
767 static bool _reg_perfcount_add_instance(struct PERF_OBJECT_TYPE *obj,
768 TALLOC_CTX *mem_ctx,
769 int instInd,
770 TDB_CONTEXT *names)
771 {
772 struct PERF_INSTANCE_DEFINITION *inst;
773
774 if(obj->instances == NULL) {
775 obj->instances = talloc_realloc(mem_ctx,
776 obj->instances,
777 struct PERF_INSTANCE_DEFINITION,
778 obj->NumInstances);
779 }
780 if(obj->instances == NULL)
781 return False;
782
783 memset(&(obj->instances[instInd]), 0, sizeof(struct PERF_INSTANCE_DEFINITION));
784 inst = &(obj->instances[instInd]);
785 return _reg_perfcount_get_instance_info(inst, mem_ctx, instInd, obj, names);
786 }
787
788 /*********************************************************************
789 *********************************************************************/
790
791 static int _reg_perfcount_assemble_global(struct PERF_DATA_BLOCK *block,
792 TALLOC_CTX *mem_ctx,
793 int base_index,
794 TDB_CONTEXT *names)
795 {
796 bool success;
797 int i, j, retval = 0;
798 char keybuf[PERFCOUNT_MAX_LEN];
799 TDB_DATA key, data;
800
801 for(i = 1; i <= base_index; i++)
802 {
803 j = i*2;
804 _reg_perfcount_make_key(&key, keybuf, PERFCOUNT_MAX_LEN, j, "rel");
805 data = tdb_fetch_compat(names, key);
806 if(data.dptr != NULL)
807 {
808 if(_reg_perfcount_isparent(data))
809 success = _reg_perfcount_add_object(block, mem_ctx, j, data, names);
810 else if(_reg_perfcount_ischild(data))
811 success = _reg_perfcount_add_counter(block, mem_ctx, j, data, names);
812 else
813 {
814 DEBUG(3, ("Bogus relationship [%s] for counter [%d].\n", data.dptr, j));
815 success = False;
816 }
817 if(success == False)
818 {
819 DEBUG(3, ("_reg_perfcount_assemble_global: Failed to add new relationship for counter [%d].\n", j));
820 retval = -1;
821 }
822 SAFE_FREE(data.dptr);
823 }
824 else
825 DEBUG(3, ("NULL relationship for counter [%d] using key [%s].\n", j, keybuf));
826 }
827 return retval;
828 }
829
830 /*********************************************************************
831 *********************************************************************/
832
833 static bool _reg_perfcount_get_64(uint64_t *retval,
834 TDB_CONTEXT *tdb,
835 int key_part1,
836 const char *key_part2)
837 {
838 TDB_DATA key, data;
839 char buf[PERFCOUNT_MAX_LEN];
840
841 _reg_perfcount_make_key(&key, buf, PERFCOUNT_MAX_LEN, key_part1, key_part2);
842
843 data = tdb_fetch_compat(tdb, key);
844 if(data.dptr == NULL)
845 {
846 DEBUG(3,("_reg_perfcount_get_64: No data found for key [%s].\n", key.dptr));
847 return False;
848 }
849
850 memset(buf, 0, PERFCOUNT_MAX_LEN);
851 memcpy(buf, data.dptr, data.dsize);
852 SAFE_FREE(data.dptr);
853
854 *retval = atof(buf);
855
856 return True;
857 }
858
859 /*********************************************************************
860 *********************************************************************/
861
862 static bool _reg_perfcount_init_data_block_perf(struct PERF_DATA_BLOCK *block,
863 TDB_CONTEXT *names)
864 {
865 uint64_t PerfFreq, PerfTime, PerfTime100nSec;
866 TDB_CONTEXT *counters;
867 bool status = False;
868 const char *fname = counters_directory( DATA_DB );
869
870 counters = tdb_open_log(fname, 0, TDB_DEFAULT, O_RDONLY, 0444);
871
872 if(counters == NULL)
873 {
874 DEBUG(1, ("reg_perfcount_init_data_block_perf: unable to open [%s].\n", fname));
875 return False;
876 }
877
878 status = _reg_perfcount_get_64(&PerfFreq, names, 0, "PerfFreq");
879 if(status == False)
880 {
881 tdb_close(counters);
882 return status;
883 }
884 memcpy((void *)&(block->PerfFreq), (const void *)&PerfFreq, sizeof(PerfFreq));
885
886 status = _reg_perfcount_get_64(&PerfTime, counters, 0, "PerfTime");
887 if(status == False)
888 {
889 tdb_close(counters);
890 return status;
891 }
892 memcpy((void *)&(block->PerfTime), (const void *)&PerfTime, sizeof(PerfTime));
893
894 status = _reg_perfcount_get_64(&PerfTime100nSec, counters, 0, "PerfTime100nSec");
895 if(status == False)
896 {
897 tdb_close(counters);
898 return status;
899 }
900 memcpy((void *)&(block->PerfTime100nSec), (const void *)&PerfTime100nSec, sizeof(PerfTime100nSec));
901
902 tdb_close(counters);
903 return True;
904 }
905
906 /*******************************************************************
907 ********************************************************************/
908
909 static bool make_systemtime(struct SYSTEMTIME *systime, struct tm *unixtime)
910 {
911 systime->year=unixtime->tm_year+1900;
912 systime->month=unixtime->tm_mon+1;
913 systime->dayofweek=unixtime->tm_wday;
914 systime->day=unixtime->tm_mday;
915 systime->hour=unixtime->tm_hour;
916 systime->minute=unixtime->tm_min;
917 systime->second=unixtime->tm_sec;
918 systime->milliseconds=0;
919
920 return True;
921 }
922
923 /*********************************************************************
924 *********************************************************************/
925
926 static bool _reg_perfcount_init_data_block(struct PERF_DATA_BLOCK *block,
927 TALLOC_CTX *mem_ctx, TDB_CONTEXT *names,
928 bool bigendian_data)
929 {
930 smb_ucs2_t *temp = NULL;
931 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
932 time_t tm;
933 size_t sz;
934
935 sz = rpcstr_push_talloc(tmp_ctx, &temp, "PERF");
936 if ((sz == -1) || (temp == NULL)) {
937 goto err_out;
938 }
939 memcpy(block->Signature, temp, strlen_w(temp) *2);
940
941 if(bigendian_data)
942 block->LittleEndian = 0;
943 else
944 block->LittleEndian = 1;
945 block->Version = 1;
946 block->Revision = 1;
947 block->TotalByteLength = 0;
948 block->NumObjectTypes = 0;
949 block->DefaultObject = -1;
950 block->objects = NULL;
951 tm = time(NULL);
952 make_systemtime(&(block->SystemTime), gmtime(&tm));
953 _reg_perfcount_init_data_block_perf(block, names);
954
955 sz = rpcstr_push_talloc(tmp_ctx, &temp, lp_netbios_name());
956 if ((sz == -1) || (temp == NULL)) {
957 goto err_out;
958 }
959 block->SystemNameLength = (strlen_w(temp) * 2) + 2;
960 block->data = talloc_zero_array(mem_ctx, uint8, block->SystemNameLength + (8 - (block->SystemNameLength % 8)));
961 if (block->data == NULL) {
962 goto err_out;
963 }
964 memcpy(block->data, temp, block->SystemNameLength);
965 block->SystemNameOffset = sizeof(struct PERF_DATA_BLOCK) - sizeof(block->objects) - sizeof(block->data);
966 block->HeaderLength = block->SystemNameOffset + block->SystemNameLength;
967 /* Make sure to adjust for 64-bit alignment for when we finish writing the system name,
968 so that the PERF_OBJECT_TYPE struct comes out 64-bit aligned */
969 block->HeaderLength += 8 - (block->HeaderLength % 8);
970 talloc_free(tmp_ctx);
971
972 return true;
973
974 err_out:
975 talloc_free(tmp_ctx);
976 return false;
977 }
978
979 /*********************************************************************
980 *********************************************************************/
981
982 static uint32 _reg_perfcount_perf_data_block_fixup(struct PERF_DATA_BLOCK *block, TALLOC_CTX *mem_ctx)
983 {
984 int obj, cnt, inst, pad, i;
985 struct PERF_OBJECT_TYPE *object;
986 struct PERF_INSTANCE_DEFINITION *instance;
987 struct PERF_COUNTER_DEFINITION *counter;
988 struct PERF_COUNTER_BLOCK *counter_data;
989 char *temp = NULL, *src_addr, *dst_addr;
990
991 block->TotalByteLength = 0;
992 object = block->objects;
993 for(obj = 0; obj < block->NumObjectTypes; obj++)
994 {
995 object[obj].TotalByteLength = 0;
996 object[obj].DefinitionLength = 0;
997 instance = object[obj].instances;
998 counter = object[obj].counters;
999 for(cnt = 0; cnt < object[obj].NumCounters; cnt++)
1000 {
1001 object[obj].TotalByteLength += counter[cnt].ByteLength;
1002 object[obj].DefinitionLength += counter[cnt].ByteLength;
1003 }
1004 if(object[obj].NumInstances != PERF_NO_INSTANCES)
1005 {
1006 for(inst = 0; inst < object[obj].NumInstances; inst++)
1007 {
1008 instance = &(object[obj].instances[inst]);
1009 object[obj].TotalByteLength += instance->ByteLength;
1010 counter_data = &(instance->counter_data);
1011 counter = &(object[obj].counters[object[obj].NumCounters - 1]);
1012 counter_data->ByteLength = counter->CounterOffset + counter->CounterSize + sizeof(counter_data->ByteLength);
1013 temp = talloc_realloc(mem_ctx,
1014 temp,
1015 char,
1016 counter_data->ByteLength- sizeof(counter_data->ByteLength));
1017 if (temp == NULL) {
1018 return 0;
1019 }
1020 memset(temp, 0, counter_data->ByteLength - sizeof(counter_data->ByteLength));
1021 src_addr = (char *)counter_data->data;
1022 for(i = 0; i < object[obj].NumCounters; i++)
1023 {
1024 counter = &(object[obj].counters[i]);
1025 dst_addr = temp + counter->CounterOffset - sizeof(counter_data->ByteLength);
1026 memcpy(dst_addr, src_addr, counter->CounterSize);
1027 src_addr += counter->CounterSize;
1028 }
1029 /* Make sure to be 64-bit aligned */
1030 if((pad = (counter_data->ByteLength % 8)))
1031 {
1032 pad = 8 - pad;
1033 }
1034 counter_data->data = talloc_realloc(mem_ctx,
1035 counter_data->data,
1036 uint8,
1037 counter_data->ByteLength - sizeof(counter_data->ByteLength) + pad);
1038 if (counter_data->data == NULL) {
1039 return 0;
1040 }
1041 memset(counter_data->data, 0, counter_data->ByteLength - sizeof(counter_data->ByteLength) + pad);
1042 memcpy(counter_data->data, temp, counter_data->ByteLength - sizeof(counter_data->ByteLength));
1043 counter_data->ByteLength += pad;
1044 object[obj].TotalByteLength += counter_data->ByteLength;
1045 }
1046 }
1047 else
1048 {
1049 /* Need to be 64-bit aligned at the end of the counter_data block, so pad counter_data to a 64-bit boundary,
1050 so that the next PERF_OBJECT_TYPE can start on a 64-bit alignment */
1051 if((pad = (object[obj].counter_data.ByteLength % 8)))
1052 {
1053 pad = 8 - pad;
1054 object[obj].counter_data.data = talloc_realloc(mem_ctx,
1055 object[obj].counter_data.data,
1056 uint8,
1057 object[obj].counter_data.ByteLength + pad);
1058 memset((void *)(object[obj].counter_data.data + object[obj].counter_data.ByteLength), 0, pad);
1059 object[obj].counter_data.ByteLength += pad;
1060 }
1061 object[obj].TotalByteLength += object[obj].counter_data.ByteLength;
1062 }
1063 object[obj].HeaderLength = sizeof(*object) - (sizeof(counter) + sizeof(instance) + sizeof(struct PERF_COUNTER_BLOCK));
1064 object[obj].TotalByteLength += object[obj].HeaderLength;
1065 object[obj].DefinitionLength += object[obj].HeaderLength;
1066
1067 block->TotalByteLength += object[obj].TotalByteLength;
1068 }
1069
1070 return block->TotalByteLength;
1071 }
1072
1073 /*********************************************************************
1074 *********************************************************************/
1075
1076 static uint32 reg_perfcount_get_perf_data_block(uint32 base_index,
1077 TALLOC_CTX *mem_ctx,
1078 struct PERF_DATA_BLOCK *block,
1079 const char *object_ids,
1080 bool bigendian_data)
1081 {
1082 uint32 buffer_size = 0;
1083 const char *fname = counters_directory( NAMES_DB );
1084 TDB_CONTEXT *names;
1085 int retval = 0;
1086
1087 names = tdb_open_log(fname, 0, TDB_DEFAULT, O_RDONLY, 0444);
1088
1089 if(names == NULL)
1090 {
1091 DEBUG(1, ("reg_perfcount_get_perf_data_block: unable to open [%s].\n", fname));
1092 return 0;
1093 }
1094
1095 if (!_reg_perfcount_init_data_block(block, mem_ctx, names, bigendian_data)) {
1096 DEBUG(0, ("_reg_perfcount_init_data_block failed\n"));
1097 tdb_close(names);
1098 return 0;
1099 }
1100
1101 reg_perfcount_get_last_counter(base_index);
1102
1103 if(object_ids == NULL)
1104 {
1105 /* we're getting a request for "Global" here */
1106 retval = _reg_perfcount_assemble_global(block, mem_ctx, base_index, names);
1107 }
1108 else
1109 {
1110 /* we're getting a request for a specific set of PERF_OBJECT_TYPES */
1111 retval = _reg_perfcount_assemble_global(block, mem_ctx, base_index, names);
1112 }
1113 buffer_size = _reg_perfcount_perf_data_block_fixup(block, mem_ctx);
1114
1115 tdb_close(names);
1116
1117 if (retval == -1) {
1118 return 0;
1119 }
1120
1121 return buffer_size + block->HeaderLength;
1122 }
1123
1124 /*******************************************************************
1125 ********************************************************************/
1126
1127 static bool smb_io_system_time(const char *desc, prs_struct *ps, int depth, struct SYSTEMTIME *systime)
1128 {
1129 if(!prs_uint16("year", ps, depth, &systime->year))
1130 return False;
1131 if(!prs_uint16("month", ps, depth, &systime->month))
1132 return False;
1133 if(!prs_uint16("dayofweek", ps, depth, &systime->dayofweek))
1134 return False;
1135 if(!prs_uint16("day", ps, depth, &systime->day))
1136 return False;
1137 if(!prs_uint16("hour", ps, depth, &systime->hour))
1138 return False;
1139 if(!prs_uint16("minute", ps, depth, &systime->minute))
1140 return False;
1141 if(!prs_uint16("second", ps, depth, &systime->second))
1142 return False;
1143 if(!prs_uint16("milliseconds", ps, depth, &systime->milliseconds))
1144 return False;
1145
1146 return True;
1147 }
1148
1149 /*********************************************************************
1150 *********************************************************************/
1151
1152 static bool _reg_perfcount_marshall_perf_data_block(prs_struct *ps, struct PERF_DATA_BLOCK block, int depth)
1153 {
1154 int i;
1155 prs_debug(ps, depth, "", "_reg_perfcount_marshall_perf_data_block");
1156 depth++;
1157
1158 if(!prs_align(ps))
1159 return False;
1160 for(i = 0; i < 4; i++)
1161 {
1162 if(!prs_uint16("Signature", ps, depth, &block.Signature[i]))
1163 return False;
1164 }
1165 if(!prs_uint32("Little Endian", ps, depth, &block.LittleEndian))
1166 return False;
1167 if(!prs_uint32("Version", ps, depth, &block.Version))
1168 return False;
1169 if(!prs_uint32("Revision", ps, depth, &block.Revision))
1170 return False;
1171 if(!prs_uint32("TotalByteLength", ps, depth, &block.TotalByteLength))
1172 return False;
1173 if(!prs_uint32("HeaderLength", ps, depth, &block.HeaderLength))
1174 return False;
1175 if(!prs_uint32("NumObjectTypes", ps, depth, &block.NumObjectTypes))
1176 return False;
1177 if(!prs_uint32("DefaultObject", ps, depth, &block.DefaultObject))
1178 return False;
1179 if(!smb_io_system_time("SystemTime", ps, depth, &block.SystemTime))
1180 return False;
1181 if(!prs_uint32("Padding", ps, depth, &block.Padding))
1182 return False;
1183 if(!prs_align_uint64(ps))
1184 return False;
1185 if(!prs_uint64("PerfTime", ps, depth, &block.PerfTime))
1186 return False;
1187 if(!prs_uint64("PerfFreq", ps, depth, &block.PerfFreq))
1188 return False;
1189 if(!prs_uint64("PerfTime100nSec", ps, depth, &block.PerfTime100nSec))
1190 return False;
1191 if(!prs_uint32("SystemNameLength", ps, depth, &block.SystemNameLength))
1192 return False;
1193 if(!prs_uint32("SystemNameOffset", ps, depth, &block.SystemNameOffset))
1194 return False;
1195 /* hack to make sure we're 64-bit aligned at the end of this whole mess */
1196 if(!prs_uint8s(False, "SystemName", ps, depth, block.data,
1197 block.HeaderLength - block.SystemNameOffset))
1198 return False;
1199
1200 return True;
1201 }
1202
1203 /*********************************************************************
1204 *********************************************************************/
1205
1206 static bool _reg_perfcount_marshall_perf_counters(prs_struct *ps,
1207 struct PERF_OBJECT_TYPE object,
1208 int depth)
1209 {
1210 int cnt;
1211 struct PERF_COUNTER_DEFINITION counter;
1212
1213 prs_debug(ps, depth, "", "_reg_perfcount_marshall_perf_counters");
1214 depth++;
1215
1216 for(cnt = 0; cnt < object.NumCounters; cnt++)
1217 {
1218 counter = object.counters[cnt];
1219
1220 if(!prs_align(ps))
1221 return False;
1222 if(!prs_uint32("ByteLength", ps, depth, &counter.ByteLength))
1223 return False;
1224 if(!prs_uint32("CounterNameTitleIndex", ps, depth, &counter.CounterNameTitleIndex))
1225 return False;
1226 if(!prs_uint32("CounterNameTitlePointer", ps, depth, &counter.CounterNameTitlePointer))
1227 return False;
1228 if(!prs_uint32("CounterHelpTitleIndex", ps, depth, &counter.CounterHelpTitleIndex))
1229 return False;
1230 if(!prs_uint32("CounterHelpTitlePointer", ps, depth, &counter.CounterHelpTitlePointer))
1231 return False;
1232 if(!prs_uint32("DefaultScale", ps, depth, &counter.DefaultScale))
1233 return False;
1234 if(!prs_uint32("DetailLevel", ps, depth, &counter.DetailLevel))
1235 return False;
1236 if(!prs_uint32("CounterType", ps, depth, &counter.CounterType))
1237 return False;
1238 if(!prs_uint32("CounterSize", ps, depth, &counter.CounterSize))
1239 return False;
1240 if(!prs_uint32("CounterOffset", ps, depth, &counter.CounterOffset))
1241 return False;
1242 }
1243
1244 return True;
1245 }
1246
1247 /*********************************************************************
1248 *********************************************************************/
1249
1250 static bool _reg_perfcount_marshall_perf_counter_data(prs_struct *ps,
1251 struct PERF_COUNTER_BLOCK counter_data,
1252 int depth)
1253 {
1254 prs_debug(ps, depth, "", "_reg_perfcount_marshall_perf_counter_data");
1255 depth++;
1256
1257 if(!prs_align_uint64(ps))
1258 return False;
1259
1260 if(!prs_uint32("ByteLength", ps, depth, &counter_data.ByteLength))
1261 return False;
1262 if(!prs_uint8s(False, "CounterData", ps, depth, counter_data.data, counter_data.ByteLength - sizeof(uint32)))
1263 return False;
1264 if(!prs_align_uint64(ps))
1265 return False;
1266
1267 return True;
1268 }
1269
1270 /*********************************************************************
1271 *********************************************************************/
1272
1273 static bool _reg_perfcount_marshall_perf_instances(prs_struct *ps,
1274 struct PERF_OBJECT_TYPE object,
1275 int depth)
1276 {
1277 struct PERF_INSTANCE_DEFINITION instance;
1278 int inst;
1279
1280 prs_debug(ps, depth, "", "_reg_perfcount_marshall_perf_instances");
1281 depth++;
1282
1283 for(inst = 0; inst < object.NumInstances; inst++)
1284 {
1285 instance = object.instances[inst];
1286
1287 if(!prs_align(ps))
1288 return False;
1289 if(!prs_uint32("ByteLength", ps, depth, &instance.ByteLength))
1290 return False;
1291 if(!prs_uint32("ParentObjectTitleIndex", ps, depth, &instance.ParentObjectTitleIndex))
1292 return False;
1293 if(!prs_uint32("ParentObjectTitlePointer", ps, depth, &instance.ParentObjectTitlePointer))
1294 return False;
1295 if(!prs_uint32("UniqueID", ps, depth, &instance.UniqueID))
1296 return False;
1297 if(!prs_uint32("NameOffset", ps, depth, &instance.NameOffset))
1298 return False;
1299 if(!prs_uint32("NameLength", ps, depth, &instance.NameLength))
1300 return False;
1301 if(!prs_uint8s(False, "InstanceName", ps, depth, instance.data,
1302 instance.ByteLength - instance.NameOffset))
1303 return False;
1304 if(_reg_perfcount_marshall_perf_counter_data(ps, instance.counter_data, depth) == False)
1305 return False;
1306 }
1307
1308 return True;
1309 }
1310
1311 /*********************************************************************
1312 *********************************************************************/
1313
1314 static bool _reg_perfcount_marshall_perf_objects(prs_struct *ps, struct PERF_DATA_BLOCK block, int depth)
1315 {
1316 int obj;
1317
1318 struct PERF_OBJECT_TYPE object;
1319
1320 prs_debug(ps, depth, "", "_reg_perfcount_marshall_perf_objects");
1321 depth++;
1322
1323 for(obj = 0; obj < block.NumObjectTypes; obj++)
1324 {
1325 object = block.objects[obj];
1326
1327 if(!prs_align(ps))
1328 return False;
1329
1330 if(!prs_uint32("TotalByteLength", ps, depth, &object.TotalByteLength))
1331 return False;
1332 if(!prs_uint32("DefinitionLength", ps, depth, &object.DefinitionLength))
1333 return False;
1334 if(!prs_uint32("HeaderLength", ps, depth, &object.HeaderLength))
1335 return False;
1336 if(!prs_uint32("ObjectNameTitleIndex", ps, depth, &object.ObjectNameTitleIndex))
1337 return False;
1338 if(!prs_uint32("ObjectNameTitlePointer", ps, depth, &object.ObjectNameTitlePointer))
1339 return False;
1340 if(!prs_uint32("ObjectHelpTitleIndex", ps, depth, &object.ObjectHelpTitleIndex))
1341 return False;
1342 if(!prs_uint32("ObjectHelpTitlePointer", ps, depth, &object.ObjectHelpTitlePointer))
1343 return False;
1344 if(!prs_uint32("DetailLevel", ps, depth, &object.DetailLevel))
1345 return False;
1346 if(!prs_uint32("NumCounters", ps, depth, &object.NumCounters))
1347 return False;
1348 if(!prs_uint32("DefaultCounter", ps, depth, &object.DefaultCounter))
1349 return False;
1350 if(!prs_uint32("NumInstances", ps, depth, &object.NumInstances))
1351 return False;
1352 if(!prs_uint32("CodePage", ps, depth, &object.CodePage))
1353 return False;
1354 if(!prs_align_uint64(ps))
1355 return False;
1356 if(!prs_uint64("PerfTime", ps, depth, &object.PerfTime))
1357 return False;
1358 if(!prs_uint64("PerfFreq", ps, depth, &object.PerfFreq))
1359 return False;
1360
1361 /* Now do the counters */
1362 /* If no instances, encode counter_data */
1363 /* If instances, encode instace plus counter data for each instance */
1364 if(_reg_perfcount_marshall_perf_counters(ps, object, depth) == False)
1365 return False;
1366 if(object.NumInstances == PERF_NO_INSTANCES)
1367 {
1368 if(_reg_perfcount_marshall_perf_counter_data(ps, object.counter_data, depth) == False)
1369 return False;
1370 }
1371 else
1372 {
1373 if(_reg_perfcount_marshall_perf_instances(ps, object, depth) == False)
1374 return False;
1375 }
1376 }
1377
1378 return True;
1379 }
1380
1381 /*********************************************************************
1382 *********************************************************************/
1383
1384 WERROR reg_perfcount_get_hkpd(prs_struct *ps, uint32 max_buf_size, uint32 *outbuf_len, const char *object_ids)
1385 {
1386 /*
1387 * For a detailed description of the layout of this structure,
1388 * see http://msdn.microsoft.com/library/default.asp?url=/library/en-us/perfmon/base/performance_data_format.asp
1389 *
1390 * By 2006-11-23 this link did not work anymore, I found something
1391 * promising under
1392 * http://msdn2.microsoft.com/en-us/library/aa373105.aspx -- vl
1393 */
1394 struct PERF_DATA_BLOCK block;
1395 uint32 buffer_size, base_index;
1396
1397 buffer_size = 0;
1398 base_index = reg_perfcount_get_base_index();
1399 ZERO_STRUCT(block);
1400
1401 buffer_size = reg_perfcount_get_perf_data_block(base_index, ps->mem_ctx, &block, object_ids, ps->bigendian_data);
1402
1403 if(buffer_size < max_buf_size)
1404 {
1405 *outbuf_len = buffer_size;
1406
1407 if (!_reg_perfcount_marshall_perf_data_block(ps, block, 0))
1408 return WERR_NOMEM;
1409
1410 if (!_reg_perfcount_marshall_perf_objects(ps, block, 0))
1411 return WERR_NOMEM;
1412
1413 return WERR_OK;
1414 }
1415 else
1416 {
1417 *outbuf_len = max_buf_size;
1418 if (!_reg_perfcount_marshall_perf_data_block(ps, block, 0))
1419 return WERR_NOMEM;
1420
1421 return WERR_INSUFFICIENT_BUFFER;
1422 }
1423 }
reg import