Changeset 33 for trunk/test


Ignore:
Timestamp:
07/17/05 15:03:02 (19 years ago)
Author:
tim
Message:

Fixed some bugs.

rewrote testing code to allow for a path filter expression.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/test/lib-regfio.c

    r32 r33  
    2424#include <stdio.h>
    2525#include <string.h>
     26#include <strings.h>
    2627#include "../include/regfio.h"
    2728#include "../include/void_stack.h"
    2829
    2930
    30 char* getStackPath(void_stack* nk_stack)
    31 {
    32   REGF_NK_REC* cur;
     31void_stack* path2Stack(const char* s)
     32{
     33  void_stack* ret_val = void_stack_new(1024);
     34  char* cur = strdup(s);
     35  char* next = NULL;
     36 
     37  while((next = strrchr(cur, '/')) != NULL)
     38  {
     39    next[0] = '\0';
     40    if(strlen(next+1) > 0)
     41      void_stack_push(ret_val, next+1);
     42  }
     43  if(strlen(cur) > 0)
     44    void_stack_push(ret_val, cur);
     45
     46  return ret_val;
     47}
     48
     49
     50char* stack2Path(void_stack* nk_stack)
     51{
     52  const REGF_NK_REC* cur;
    3353  unsigned int buf_left = 127;
    3454  unsigned int buf_len = buf_left+1;
     
    5171  }
    5272
     73  /* skip root element */
     74  cur = void_stack_iterator_next(iter);
     75
    5376  while((cur = void_stack_iterator_next(iter)) != NULL)
    5477  {
     78    buf[buf_len-buf_left-1] = '/';
     79    buf_left -= 1;
    5580    name_len = strlen(cur->keyname);
    5681    if(name_len+1 > buf_left)
    5782    {
    58       grow_amt = (unsigned int)(buf_len/3);
     83      grow_amt = (unsigned int)(buf_len/2);
    5984      buf_len += name_len+1+grow_amt-buf_left;
    6085      if((new_buf = realloc(buf, buf_len)) == NULL)
     
    6994    strncpy(buf+(buf_len-buf_left-1), cur->keyname, name_len);
    7095    buf_left -= name_len;
    71     buf[buf_len-buf_left-1] = '/';
    72     buf_left -= 1;
    7396    buf[buf_len-buf_left-1] = '\0';
    7497  }
    7598
    76   /* Cut trailing slash */ 
    77   if(buf[buf_len-buf_left-2] == '/')
    78     buf[buf_len-buf_left-2] = '\0';
    79 
    8099  return buf;
    81100}
    82101
    83102
    84 void printKeyList(REGF_NK_REC* nk, char* prefix)
     103void printValue(REGF_VK_REC* vk, char* prefix)
     104{
     105  const char* str_type;
     106 
     107  str_type = type_val2str(vk->type);
     108  printf("%s/%s:%s=\n", prefix, vk->valuename, str_type);
     109}
     110
     111
     112void printValueList(REGF_NK_REC* nk, char* prefix)
    85113{
    86114  unsigned int i;
    87   const char* str_type;
    88115 
    89116  for(i=0; i < nk->num_values; i++)
    90   {
    91     str_type = type_val2str(nk->values[i].type);
    92     printf("%s/%s:%s=\n", prefix, nk->values[i].valuename, str_type);
    93   }
    94 }
    95 
    96 
    97 void printKeyTree(REGF_FILE* f, void_stack* nk_stack)
     117    printValue(&nk->values[i], prefix);
     118}
     119
     120/* XXX: this function is god-awful.  Needs to be re-designed. */
     121void printKeyTree(REGF_FILE* f, void_stack* nk_stack, char* prefix)
    98122{
    99123  REGF_NK_REC* cur;
    100124  REGF_NK_REC* sub;
    101125  char* path;
     126  char* val_path;
    102127
    103128  if((cur = (REGF_NK_REC*)void_stack_cur(nk_stack)) != NULL)
    104129  {
    105     printf("%s:KEY\n", cur->keyname);
     130    cur->subkey_index = 0;
     131    path = stack2Path(nk_stack);
     132   
     133    if(strlen(path) > 0)
     134      printf("%s%s:KEY\n", prefix, path);
     135    printValueList(cur, path);
    106136    while((cur = (REGF_NK_REC*)void_stack_cur(nk_stack)) != NULL)
    107137    {
    108138      if((sub = regfio_fetch_subkey(f, cur)) != NULL)
    109139      {
     140        sub->subkey_index = 0;
    110141        void_stack_push(nk_stack, sub);
    111         path = getStackPath(nk_stack);
     142        path = stack2Path(nk_stack);
    112143        if(path != NULL)
    113144        {
    114           printKeyList(cur, path);
    115           printf("%s:KEY\n", path);
     145          val_path = (char*)malloc(strlen(prefix)+strlen(path)+1);
     146          sprintf(val_path, "%s%s", prefix, path);
     147          printf("%s:KEY\n", val_path);
     148          printValueList(sub, val_path);
     149          free(val_path);
    116150          free(path);
    117151        }
     
    123157         * routines to replace the Samba code for this.
    124158         */
    125         if(cur != NULL)
    126           free(cur);
    127       }
    128     }
    129   }
     159        /*      if(cur != NULL)
     160          free(cur);*/
     161      }
     162    }
     163  }
     164}
     165
     166
     167/*
     168 * Returns 0 if path was found.
     169 * Returns 1 if path was not found.
     170 * Returns less than 0 on other error.
     171 */
     172int retrievePath(REGF_FILE* f, void_stack* nk_stack,
     173                 void_stack* path_stack)
     174{
     175  REGF_NK_REC* sub;
     176  REGF_NK_REC* cur;
     177  void_stack* sub_nk_stack;
     178  char* prefix;
     179  char* cur_str = NULL;
     180  bool found_cur = true;
     181  unsigned int i;
     182  unsigned short path_depth;
     183  if(path_stack == NULL)
     184    return -1;
     185
     186  path_depth = void_stack_size(path_stack);
     187  if(path_depth < 1)
     188    return -2;
     189
     190  if(void_stack_size(nk_stack) < 1)
     191    return -3;
     192  cur = (REGF_NK_REC*)void_stack_cur(nk_stack);
     193
     194  while(void_stack_size(path_stack) > 1)
     195  {
     196    /* Search key records only */
     197    cur_str = (char*)void_stack_pop(path_stack);
     198
     199    found_cur = false;
     200    while(!found_cur &&
     201          (sub = regfio_fetch_subkey(f, cur)) != NULL)
     202    {
     203      if(strcasecmp(sub->keyname, cur_str) == 0)
     204      {
     205        cur = sub;
     206        void_stack_push(nk_stack, sub);
     207        found_cur = true;
     208      }
     209    }
     210
     211    if(!found_cur)
     212      return 0;
     213  }
     214
     215  /* Last round, search value and key records */
     216  cur_str = (char*)void_stack_pop(path_stack);
     217
     218  for(i=0; (i < cur->num_values); i++)
     219  {
     220    if(strcasecmp(sub->values[i].valuename, cur_str) == 0)
     221    {
     222      printValue(&sub->values[i], stack2Path(nk_stack));
     223      return 0;
     224    }
     225  }
     226
     227  while((sub = regfio_fetch_subkey(f, cur)) != NULL)
     228  {
     229    if(strcasecmp(sub->keyname, cur_str) == 0)
     230    {
     231      sub_nk_stack = void_stack_new(1024);
     232      void_stack_push(sub_nk_stack, sub);
     233      void_stack_push(nk_stack, sub);
     234      prefix = stack2Path(nk_stack);
     235      printKeyTree(f, sub_nk_stack, prefix);
     236      return 0;
     237    }
     238  }
     239
     240  return 1;
    130241}
    131242
     
    134245{
    135246  void_stack* nk_stack;
     247  void_stack* path_stack;
    136248  REGF_FILE* f;
    137249  REGF_NK_REC* root;
     250  int retr_path_ret;
     251  char* path = "/ControlSet002/Services/Eventlog/";
    138252
    139253  if(argc < 2)
     
    148262  nk_stack = void_stack_new(1024);
    149263  if(void_stack_push(nk_stack, root))
    150     printKeyTree(f, nk_stack);
     264  {
     265    path_stack = path2Stack(path);
     266    if(void_stack_size(path_stack) < 1)
     267      printKeyTree(f, nk_stack, "");
     268    else
     269    {
     270      retr_path_ret = retrievePath(f, nk_stack,
     271                                   path_stack);
     272      if(retr_path_ret == 1)
     273        printf("WARNING: specified path not found.\n");
     274      else if(retr_path_ret != 0)
     275        printf("ERROR\n");
     276    }
     277  }
    151278  void_stack_destroy(nk_stack);
    152279
    153280  regfio_close(f);
    154 /*
    155 REGF_NK_REC*  regfio_rootkey( REGF_FILE *file );
    156 REGF_NK_REC*  regfio_fetch_subkey( REGF_FILE *file, REGF_NK_REC *nk );
    157 */
    158281
    159282  return 0;
Note: See TracChangeset for help on using the changeset viewer.