Changeset 6210da7ee0e2ed143d71a8e00b709f16e71059f8

Show
Ignore:
Timestamp:
03/17/09 21:10:22 (6 years ago)
Author:
Theo Schlossnagle <jesus@omniti.com>
git-committer:
Theo Schlossnagle <jesus@omniti.com> 1237324222 +0000
git-parent:

[f99cf462c3bf905a727087a97e5c305a52256d5e]

git-author:
Theo Schlossnagle <jesus@omniti.com> 1237324222 +0000
Message:

various changes to avoid dereferencing type-punned pointers and breaking strict-aliasing rules, refs #34

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • src/eventer/eventer.c

    r928d57f r6210da7  
    3838} 
    3939eventer_func_t eventer_callback_for_name(const char *name) { 
    40   eventer_func_t f; 
    41   if(noit_hash_retrieve(&__name_to_func, name, strlen(name), (void **)&f)) 
    42     return f; 
     40  void *vf; 
     41  if(noit_hash_retrieve(&__name_to_func, name, strlen(name), &vf)) 
     42    return (eventer_func_t)vf; 
    4343  return (eventer_func_t)NULL; 
    4444} 
    4545const char *eventer_name_for_callback(eventer_func_t f) { 
    4646  const char *name; 
    47   if(noit_hash_retrieve(&__func_to_name, (char *)&f, sizeof(f), (void **)&name)) 
     47  if(noit_hash_retr_str(&__func_to_name, (char *)&f, sizeof(f), &name)) 
    4848    return name; 
    4949  return NULL; 
  • src/eventer/eventer_SSL_fd_opset.c

    r11f8bf8 r6210da7  
    100100  if(!x509ctx) return 0; 
    101101 
    102   if(!noit_hash_retrieve(options, "optional_no_ca", strlen("optional_no_ca"), 
    103                          (void **)&opt_no_ca)) 
     102  if(!noit_hash_retr_str(options, "optional_no_ca", strlen("optional_no_ca"), 
     103                         &opt_no_ca)) 
    104104    opt_no_ca = "false"; 
    105   if(!noit_hash_retrieve(options, "ignore_dates", strlen("ignore_dates"), 
    106                          (void **)&ignore_dates)) 
     105  if(!noit_hash_retr_str(options, "ignore_dates", strlen("ignore_dates"), 
     106                         &ignore_dates)) 
    107107    ignore_dates = "false"; 
    108108 
     
    374374eventer_SSL_read(int fd, void *buffer, size_t len, int *mask, void *closure) { 
    375375  int rv; 
    376   noitL(noit_debug, "SSL_read(%d) wants %ld bytes\n", fd, len); 
     376  noitL(noit_debug, "SSL_read(%d) wants %ld bytes\n", fd, (long int)len); 
    377377  rv = eventer_SSL_rw(SSL_OP_READ, fd, buffer, len, mask, closure); 
    378   noitL(noit_debug, "SSL_read(%d) wanted %ld bytes, got return value %d\n", fd, len, rv); 
     378  noitL(noit_debug, "SSL_read(%d) wanted %ld bytes, got return value %d\n", fd, (long int)len, rv); 
    379379  return rv; 
    380380} 
     
    383383                  void *closure) { 
    384384  int rv; 
    385   noitL(noit_debug, "SSL_write(%d) wants %ld bytes\n", fd, len); 
     385  noitL(noit_debug, "SSL_write(%d) wants %ld bytes\n", fd, (long int)len); 
    386386  rv = eventer_SSL_rw(SSL_OP_WRITE, fd, (void *)buffer, len, mask, closure); 
    387   noitL(noit_debug, "SSL_write(%d) wanted %ld bytes, got return value %d\n", fd, len, rv); 
     387  noitL(noit_debug, "SSL_write(%d) wanted %ld bytes, got return value %d\n", fd, (long int)len, rv); 
    388388  return rv; 
    389389} 
  • src/eventer/eventer_jobq.c

    r84d6f13 r6210da7  
    288288  const char *key; 
    289289  int klen; 
    290   eventer_jobq_t *jobq; 
     290  void *vjobq; 
    291291  noit_hash_iter iter = NOIT_HASH_ITER_ZERO; 
    292292 
    293293  pthread_mutex_lock(&all_queues_lock); 
    294   while(noit_hash_next(&all_queues, &iter, &key, &klen, (void **)&jobq)) { 
    295     func(jobq, closure); 
     294  while(noit_hash_next(&all_queues, &iter, &key, &klen, &vjobq)) { 
     295    func((eventer_jobq_t *)vjobq, closure); 
    296296  } 
    297297  pthread_mutex_unlock(&all_queues_lock); 
  • src/modules/dns.c

    rdb656f3 r6210da7  
    4848} 
    4949static dns_ctx_handle_t *dns_ctx_alloc(const char *ns) { 
     50  void *vh; 
    5051  dns_ctx_handle_t *h = NULL; 
    5152  pthread_mutex_lock(&dns_ctx_store_lock); 
     
    5758  } 
    5859  if(ns && 
    59      noit_hash_retrieve(&dns_ctx_store, ns, strlen(ns), (void **)&h)) { 
     60     noit_hash_retrieve(&dns_ctx_store, ns, strlen(ns), &vh)) { 
     61    h = (dns_ctx_handle_t *)vh; 
    6062    noit_atomic_inc32(&h->refcnt); 
    6163  } 
     
    130132 
    131133static int __isactive_ci(struct dns_check_info *ci) { 
    132   struct dns_check_info *u; 
     134  void *u; 
    133135  int exists = 0; 
    134136  pthread_mutex_lock(&active_events_lock); 
    135   if(noit_hash_retrieve(&active_events, (void *)&ci, sizeof(ci), (void **)&u)) 
     137  if(noit_hash_retrieve(&active_events, (void *)&ci, sizeof(ci), &u)) 
    136138    exists = 1; 
    137139  pthread_mutex_unlock(&active_events_lock); 
     
    498500 
    499501static int dns_check_send(noit_module_t *self, noit_check_t *check) { 
     502  void *vnv_pair = NULL; 
    500503  struct dns_nameval *nv_pair; 
    501504  eventer_t newe; 
     
    534537  } 
    535538#define CONFIG_OVERRIDE(a) \ 
    536   if(noit_hash_retrieve(check->config, #a, strlen(#a), \ 
    537                         (void **)&config_val) && \ 
     539  if(noit_hash_retr_str(check->config, #a, strlen(#a), \ 
     540                        &config_val) && \ 
    538541     strlen(config_val) > 0) \ 
    539542    a = config_val 
     
    586589  /* Lookup out class */ 
    587590  if(!noit_hash_retrieve(&dns_ctypes, ctype, strlen(ctype), 
    588                          (void **)&nv_pair)) { 
     591                         &vnv_pair)) { 
    589592    ci->error = strdup("bad class"); 
    590593  } 
    591   else 
     594  else { 
     595    nv_pair = (struct dns_nameval *)vnv_pair; 
    592596    ci->query_ctype = nv_pair->val; 
    593  
     597  } 
    594598  /* Lookup out rr type */ 
    595599  if(!noit_hash_retrieve(&dns_rtypes, rtype, strlen(rtype), 
    596                          (void **)&nv_pair)) { 
     600                         &vnv_pair)) { 
    597601    ci->error = strdup("bad rr type"); 
    598602  } 
    599   else 
     603  else { 
     604    nv_pair = (struct dns_nameval *)vnv_pair; 
    600605    ci->query_rtype = nv_pair->val; 
     606  } 
    601607 
    602608  if(!ci->error) { 
  • src/modules/external.c

    r876ca61 r6210da7  
    202202    noit_check_t *check; 
    203203    struct check_info *ci; 
     204    void *vci; 
    204205 
    205206    if(!data->cr) { 
     
    278279                          (const char *)&data->cr->check_no, 
    279280                          sizeof(data->cr->check_no), 
    280                           (void **)&ci) == 0) 
    281       ci = NULL; 
     281                          &vci) == 0) 
     282      vci = NULL; 
     283    ci = (struct check_info *)vci; 
    282284 
    283285    /* We've seen it, it ain't coming again... 
     
    370372    const char *user = NULL, *group = NULL; 
    371373    if(data->options) { 
    372       noit_hash_retrieve(data->options, "user", 4, (void **)&user); 
    373       noit_hash_retrieve(data->options, "group", 4, (void **)&group); 
     374      noit_hash_retr_str(data->options, "user", 4, &user); 
     375      noit_hash_retr_str(data->options, "group", 4, &group); 
    374376    } 
    375377    noit_security_usergroup(user, group); 
     
    454456  ci->check = check; 
    455457  /* We might want to extract metrics */ 
    456   if(noit_hash_retrieve(check->config, 
     458  if(noit_hash_retr_str(check->config, 
    457459                        "output_extract", strlen("output_extract"), 
    458                         (void **)&value) != 0) { 
     460                        &value) != 0) { 
    459461    const char *error; 
    460462    int erroffset; 
     
    473475    char argname[10]; 
    474476    snprintf(argname, sizeof(argname), "arg%d", i); 
    475     if(noit_hash_retrieve(check->config, argname, strlen(argname), 
    476                           (void **)&value) == 0) break; 
     477    if(noit_hash_retr_str(check->config, argname, strlen(argname), 
     478                          &value) == 0) break; 
    477479    i++; 
    478480  } 
     
    482484 
    483485  /* Make the command */ 
    484   if(noit_hash_retrieve(check->config, "command", strlen("command"), 
    485                         (void **)&value) == 0) { 
     486  if(noit_hash_retr_str(check->config, "command", strlen("command"), 
     487                        &value) == 0) { 
    486488    value = "/bin/true"; 
    487489  } 
     
    493495    char argname[10]; 
    494496    snprintf(argname, sizeof(argname), "arg%d", i); 
    495     if(noit_hash_retrieve(check->config, argname, strlen(argname), 
    496                           (void **)&value) == 0) { 
     497    if(noit_hash_retr_str(check->config, argname, strlen(argname), 
     498                          &value) == 0) { 
    497499      if(i == 0) { 
    498500        /* if we don't have arg0, make it last element of path */ 
     
    513515  memset(&iter, 0, sizeof(iter)); 
    514516  ci->envcnt = 0; 
    515   while(noit_hash_next(check->config, &iter, &name, &klen, (void **)&value)) 
     517  while(noit_hash_next_str(check->config, &iter, &name, &klen, &value)) 
    516518    if(!strncasecmp(name, "env_", 4)) 
    517519      ci->envcnt++; 
     
    520522  ci->envs = calloc(ci->envcnt, sizeof(*ci->envs)); 
    521523  ci->envcnt = 0; 
    522   while(noit_hash_next(check->config, &iter, &name, &klen, (void **)&value)) 
     524  while(noit_hash_next_str(check->config, &iter, &name, &klen, &value)) 
    523525    if(!strncasecmp(name, "env_", 4)) { 
    524526      snprintf(interp_fmt, sizeof(interp_fmt), "%s=%s", name+4, value); 
  • src/modules/http.c

    r4f91a9d r6210da7  
    557557 finish: 
    558558  gettimeofday(&ci->finish_time, NULL); 
    559   noitL(nldeb, "serf finished request (%s) [%d.%06d]\n", ctx->check->target, 
    560         ci->finish_time.tv_sec, ci->finish_time.tv_usec); 
     559  noitL(nldeb, "serf finished request (%s) [%ld.%06d]\n", ctx->check->target, 
     560        (long int)ci->finish_time.tv_sec, (int)ci->finish_time.tv_usec); 
    561561  if(ci->timeout_event) { 
    562562    eventer_remove(ci->timeout_event); 
  • src/modules/lua.c

    rdb656f3 r6210da7  
    3535} 
    3636static void 
    37 noit_lua_loader_set_directory(noit_module_loader_t *self, char *dir) { 
     37noit_lua_loader_set_directory(noit_module_loader_t *self, const char *dir) { 
    3838  struct loader_conf *c = __get_loader_conf(self); 
    3939  if(c->script_dir) free(c->script_dir); 
     
    5959noit_lua_check_info_t * 
    6060get_ci(lua_State *L) { 
    61   noit_lua_check_info_t *v = NULL; 
    62   if(noit_hash_retrieve(&noit_coros, (const char *)&L, sizeof(L), (void **)&v)) 
    63     return v; 
     61  void *v = NULL; 
     62  if(noit_hash_retrieve(&noit_coros, (const char *)&L, sizeof(L), &v)) 
     63    return (noit_lua_check_info_t *)v; 
    6464  return NULL; 
    6565} 
     
    136136  lua_createtable(L, 0, t ? t->size : 0); 
    137137  if(t) { 
    138     while(noit_hash_next(t, &iter, &key, &klen, (void **)&value)) { 
     138    while(noit_hash_next_str(t, &iter, &key, &klen, &value)) { 
    139139      lua_pushlstring(L, value, strlen(value)); 
    140140      lua_setfield(L, -2, key); 
     
    776776static int 
    777777noit_lua_loader_config(noit_module_loader_t *self, noit_hash_table *o) { 
    778   char *dir = "."; 
    779   noit_hash_retrieve(o, "directory", strlen("directory"), (void **)&dir); 
     778  const char *dir = "."; 
     779  noit_hash_retr_str(o, "directory", strlen("directory"), &dir); 
    780780  noit_lua_loader_set_directory(self, dir); 
    781781  return 0; 
  • src/modules/ping_icmp.c

    rec240f3 r6210da7  
    382382  int interval = PING_INTERVAL; 
    383383  int count = PING_COUNT; 
    384   if(noit_hash_retrieve(check->config, "interval", strlen("interval"), 
    385                         (void **)&config_val)) 
     384  if(noit_hash_retr_str(check->config, "interval", strlen("interval"), 
     385                        &config_val)) 
    386386    interval = atoi(config_val); 
    387   if(noit_hash_retrieve(check->config, "count", strlen("count"), 
    388                         (void **)&config_val)) 
     387  if(noit_hash_retr_str(check->config, "count", strlen("count"), 
     388                        &config_val)) 
    389389    count = atoi(config_val); 
    390390 
  • src/modules/postgres.c

    rdb656f3 r6210da7  
    154154 
    155155#define FETCH_CONFIG_OR(key, str) do { \ 
    156   if(!noit_hash_retrieve(check->config, #key, strlen(#key), (void **)&key)) \ 
     156  if(!noit_hash_retr_str(check->config, #key, strlen(#key), &key)) \ 
    157157    key = str; \ 
    158158} while(0) 
  • src/modules/selfcheck.c

    r84d6f13 r6210da7  
    8787 
    8888#define FETCH_CONFIG_OR(key, str) do { \ 
    89   if(!noit_hash_retrieve(check->config, #key, strlen(#key), (void **)&key)) \ 
     89  if(!noit_hash_retr_str(check->config, #key, strlen(#key), &key)) \ 
    9090    key = str; \ 
    9191} while(0) 
  • src/modules/snmp.c

    r374e7c3 r6210da7  
    135135} 
    136136static struct check_info *get_check(int reqid) { 
    137   struct check_info *c; 
    138   if(noit_hash_retrieve(&active_checks, (char *)&reqid, sizeof(reqid), 
    139                         (void **)&c)) 
    140     return c; 
     137  void *vc; 
     138  if(noit_hash_retrieve(&active_checks, (char *)&reqid, sizeof(reqid), &vc)) 
     139    return (struct check_info *)vc; 
    141140  return NULL; 
    142141} 
     
    148147struct target_session * 
    149148_get_target_session(noit_module_t *self, char *target) { 
     149  void *vts; 
    150150  struct target_session *ts; 
    151151  snmp_mod_config_t *conf; 
    152152  conf = noit_module_get_userdata(self); 
    153153  if(!noit_hash_retrieve(&conf->target_sessions, 
    154                          target, strlen(target), (void **)&ts)) { 
     154                         target, strlen(target), &vts)) { 
    155155    ts = calloc(1, sizeof(*ts)); 
    156156    ts->self = self; 
     
    160160    noit_hash_store(&conf->target_sessions, 
    161161                    strdup(target), strlen(target), ts); 
    162   } 
    163   return ts; 
     162    vts = ts; 
     163  } 
     164  return (struct target_session *)vts; 
    164165} 
    165166 
     
    687688    goto cleanup; 
    688689  } 
    689   if(!noit_hash_retrieve(check->config, "community", strlen("community"), 
    690                          (void **)&community) && 
    691      !noit_hash_retrieve(conf->options, "community", strlen("community"), 
    692                          (void **)&community)) { 
     690  if(!noit_hash_retr_str(check->config, "community", strlen("community"), 
     691                         &community) && 
     692     !noit_hash_retr_str(conf->options, "community", strlen("community"), 
     693                         &community)) { 
    693694    noitL(nlerr, "No community defined for check, dropping trap\n"); 
    694695    goto cleanup; 
     
    747748  sess.version = SNMP_VERSION_2c; 
    748749  sess.peername = check->target; 
    749   if(!noit_hash_retrieve(check->config, "community", strlen("community"), 
    750                          (void **)&community)) { 
     750  if(!noit_hash_retr_str(check->config, "community", strlen("community"), 
     751                         &community)) { 
    751752    community = "public"; 
    752753  } 
     
    777778 
    778779  /* Figure our how many. */ 
    779   while(noit_hash_next(check->config, &iter, &name, &klen, (void **)&value)) { 
     780  while(noit_hash_next_str(check->config, &iter, &name, &klen, &value)) { 
    780781    if(!strncasecmp(name, "oid_", 4)) { 
    781782      info->noids++; 
     
    792793  memset(&iter, 0, sizeof(iter)); 
    793794  i = 0; 
    794   while(noit_hash_next(check->config, &iter, &name, &klen, (void **)&value)) { 
     795  while(noit_hash_next_str(check->config, &iter, &name, &klen, &value)) { 
    795796    if(!strncasecmp(name, "oid_", 4)) { 
    796797      char oidbuff[128]; 
  • src/modules/ssh2.c

    rdb656f3 r6210da7  
    202202  socklen_t sockaddr_len; 
    203203  unsigned short ssh_port = DEFAULT_SSH_PORT; 
    204   const char *port_str
     204  const char *port_str = NULL
    205205  long on; 
    206206 
     
    230230  if(ioctl(fd, FIONBIO, &on)) goto fail; 
    231231 
    232   if(noit_hash_retrieve(check->config, "port", strlen("port"), 
    233                         (void **)&port_str)) { 
     232  if(noit_hash_retr_str(check->config, "port", strlen("port"), 
     233                        &port_str)) { 
    234234    ssh_port = (unsigned short)atoi(port_str); 
    235235  } 
  • src/noit_check.c

    r5b175f1 r6210da7  
    107107  sec = noit_conf_get_sections(NULL, xpath, &cnt); 
    108108  for(i=0; i<cnt; i++) { 
    109     noit_check_t *existing_check; 
     109    void *vcheck; 
    110110    char uuid_str[37]; 
    111111    char target[256]; 
     
    183183 
    184184    if(noit_hash_retrieve(&polls, (char *)uuid, UUID_SIZE, 
    185                           (void **)&existing_check)) { 
     185                          &vcheck)) { 
     186      noit_check_t *existing_check = (noit_check_t *)vcheck; 
    186187      /* Once set, we can never change it. */ 
    187188      assert(!existing_check->module || !existing_check->module[0] || 
     
    238239  uuid_t key_id; 
    239240  int klen; 
    240   noit_check_t *check; 
     241  void *vcheck; 
    241242  while(noit_hash_next(&polls, &iter, (const char **)key_id, &klen, 
    242                        (void **)&check)) { 
    243     noit_check_activate(check); 
     243                       &vcheck)) { 
     244    noit_check_activate((noit_check_t *)vcheck); 
    244245  } 
    245246} 
     
    250251  uuid_t key_id; 
    251252  int klen; 
    252   noit_check_t *check, *tofree = NULL; 
     253  noit_check_t *tofree = NULL; 
     254  void *vcheck; 
    253255 
    254256  /* Cleanup any previous causal map */ 
    255257  while(noit_hash_next(&polls, &iter, (const char **)key_id, &klen, 
    256                        (void **)&check)) { 
     258                       &vcheck)) { 
     259    noit_check_t *check = (noit_check_t *)vcheck; 
    257260    /* We don't free the one we're looking at... we free it on the next 
    258261     * pass.  This leaves out iterator in good shape.  We just need to 
     
    276279  uuid_t key_id; 
    277280  int klen; 
    278   noit_check_t *check, *parent
     281  void *vcheck
    279282 
    280283  /* Cleanup any previous causal map */ 
    281284  while(noit_hash_next(&polls, &iter, (const char **)key_id, &klen, 
    282                        (void **)&check)) { 
     285                       &vcheck)) { 
     286    noit_check_t *check = (noit_check_t *)vcheck; 
    283287    dep_list_t *dep; 
    284288    while((dep = check->causal_checks) != NULL) { 
     
    291295  /* Walk all checks and add check dependencies to their parents */ 
    292296  while(noit_hash_next(&polls, &iter, (const char **)key_id, &klen, 
    293                        (void **)&check)) { 
     297                       &vcheck)) { 
     298    noit_check_t *check = (noit_check_t *)vcheck, *parent; 
    294299    if(check->oncheck) { 
    295300      /* This service is causally triggered by another service */ 
     
    361366noit_check_clone(uuid_t in) { 
    362367  noit_check_t *checker, *new_check; 
     368  void *vcheck; 
    363369  if(noit_hash_retrieve(&polls, 
    364370                        (char *)in, UUID_SIZE, 
    365                         (void **)&checker) == 0) { 
     371                        &vcheck) == 0) { 
    366372    return NULL; 
    367373  } 
     374  checker = (noit_check_t *)vcheck; 
    368375  if(checker->oncheck) { 
    369376    return NULL; 
     
    562569int 
    563570noit_poller_deschedule(uuid_t in) { 
     571  void *vcheck; 
    564572  noit_check_t *checker; 
    565573  noit_module_t *mod; 
    566574  if(noit_hash_retrieve(&polls, 
    567575                        (char *)in, UUID_SIZE, 
    568                         (void **)&checker) == 0) { 
     576                        &vcheck) == 0) { 
    569577    return -1; 
    570578  } 
     579  checker = (noit_check_t *)vcheck; 
    571580  checker->flags |= (NP_DISABLED|NP_KILLED); 
    572581 
     
    601610noit_check_t * 
    602611noit_poller_lookup(uuid_t in) { 
    603   noit_check_t *check; 
    604   if(noit_hash_retrieve(&polls, 
    605                         (char *)in, UUID_SIZE, 
    606                         (void **)&check)) { 
    607     return check; 
    608   } 
     612  void *vcheck; 
     613  if(noit_hash_retrieve(&polls, (char *)in, UUID_SIZE, &vcheck)) 
     614    return (noit_check_t *)vcheck; 
    609615  return NULL; 
    610616} 
     
    869875  uuid_t key_id; 
    870876  int klen, i = 0; 
    871   noit_check_t *check; 
     877  void *vcheck; 
    872878 
    873879  if(argc == 1) { 
     
    877883    } 
    878884    while(noit_hash_next(&polls, &iter, (const char **)key_id, &klen, 
    879                          (void **)&check)) { 
     885                         &vcheck)) { 
     886      noit_check_t *check = (noit_check_t *)vcheck; 
    880887      char out[512]; 
    881888      char uuid_str[37]; 
     
    910917  uuid_t key_id; 
    911918  int klen, i = 0; 
    912   noit_check_t *check; 
    913919 
    914920  if(argc == 1) { 
     921    void *vcheck; 
    915922    while(noit_hash_next(&polls, &iter, (const char **)key_id, &klen, 
    916                          (void **)&check)) { 
     923                         &vcheck)) { 
    917924      char out[512]; 
    918925      char uuid_str[37]; 
     926      noit_check_t *check = (noit_check_t *)vcheck; 
    919927      snprintf(out, sizeof(out), "%s`%s", check->target, check->name); 
    920928      uuid_unparse_lower(check->checkid, uuid_str); 
     
    940948                         noit_console_state_t *dstate, 
    941949                         void *closure) { 
    942   struct timeval _now; 
    943950  noit_hash_iter iter = NOIT_HASH_ITER_ZERO; 
    944951  uuid_t key_id; 
    945952  int klen; 
    946   noit_check_t *check; 
    947  
    948   gettimeofday(&_now, NULL); 
     953  void *vcheck; 
     954 
    949955  while(noit_hash_next(&polls, &iter, (const char **)key_id, &klen, 
    950                        (void **)&check)) { 
    951     nc_printf_check_brief(ncct, check); 
     956                       &vcheck)) { 
     957    nc_printf_check_brief(ncct, (noit_check_t *)vcheck); 
    952958  } 
    953959  return 0; 
  • src/noit_check_log.c

    rb13e0b2 r6210da7  
    113113  const char *key; 
    114114  int klen; 
    115   metric_t *m; 
    116115  stats_t *c; 
     116  void *vm; 
    117117 
    118118  uuid_unparse_lower(check->checkid, uuid_str); 
    119119  c = &check->stats.current; 
    120   while(noit_hash_next(&c->metrics, &iter, &key, &klen, (void **)&m)) { 
     120  while(noit_hash_next(&c->metrics, &iter, &key, &klen, &vm)) { 
    121121    /* If we apply the filter set and it returns false, we don't log */ 
     122    metric_t *m = (metric_t *)vm; 
    122123    if(!noit_apply_filterset(check->filterset, check, m)) continue; 
    123124    if(!ls->enabled) continue; 
  • src/noit_check_tools.c

    r5a9b91b r6210da7  
    6565              if(*oper == ':' && 
    6666                 (nkey = strnstrn(":", 1, oper + 1, fmte - key - 1)) != NULL) { 
     67                void *voper; 
    6768                oper++; 
    6869                /* find oper, nkey-oper */ 
    6970                if(!noit_hash_retrieve(&interpolation_operators, 
    7071                                       oper, nkey - oper, 
    71                                        (void **)&oper_sprint)) { 
     72                                       &voper)) { 
    7273                  /* else oper <- copy */ 
    7374                  oper_sprint = interpolate_oper_copy; 
    7475                } 
     76                else 
     77                  oper_sprint = voper; 
    7578                nkey++; 
    7679              } 
     
    7982                nkey = key; 
    8083              } 
    81               if(!noit_hash_retrieve((closer == '}') ?  config : attrs, 
    82                                      nkey, fmte - nkey, (void **)&replacement)) 
     84              if(!noit_hash_retr_str((closer == '}') ?  config : attrs, 
     85                                     nkey, fmte - nkey, &replacement)) 
    8386                replacement = ""; 
    8487              fmt = fmte + 1; /* Format points just after the end of the key */ 
  • src/noit_conf.c

    rc8af4b3 r6210da7  
    313313int _noit_conf_get_string(noit_conf_section_t section, xmlNodePtr *vnode, 
    314314                          const char *path, char **value) { 
    315   char *str; 
     315  const char *str; 
    316316  int i, rv = 1; 
    317317  xmlXPathObjectPtr pobj = NULL; 
     
    341341  } 
    342342 fallback: 
    343   if(noit_hash_retrieve(&_compiled_fallback, 
    344                         path, strlen(path), (void **)&str)) { 
     343  if(noit_hash_retr_str(&_compiled_fallback, 
     344                        path, strlen(path), &str)) { 
    345345    *value = (char *)xmlStrdup((xmlChar *)str); 
    346346    goto found; 
  • src/noit_conf_checks.c

    r31eed12 r6210da7  
    163163 
    164164  for(i=0; i<argc; i+=2) { 
     165    void *vattrinfo; 
    165166    struct _valid_attr_t *attrinfo; 
    166167    char *attr = argv[i], *val = NULL; 
     
    168169    else val = argv[i+1]; 
    169170    if(!noit_hash_retrieve(&check_attrs, attr, strlen(attr), 
    170                            (void **)&attrinfo)) { 
     171                           &vattrinfo)) { 
    171172      error = 1; 
    172173      break; 
    173174    } 
     175    attrinfo = vattrinfo; 
    174176    /* The fixation stuff doesn't matter here, this check is brand-new */ 
    175177    xmlUnsetProp(node, (xmlChar *)attrinfo->name); 
  • src/noit_config.h.in

    r87de1cf r6210da7  
    5858#undef HAVE_DIRENT_H 
    5959#undef HAVE_PWD_H 
     60#undef HAVE_PTY_H 
    6061#undef HAVE_ERRNO_H 
    6162#undef HAVE_STRING_H 
  • src/noit_console.c

    r680ff24 r6210da7  
    2424#ifdef HAVE_TERMIOS_H 
    2525#include <termios.h> 
     26#endif 
     27#ifdef HAVE_PTY_H 
     28#include <pty.h> 
    2629#endif 
    2730#ifdef HAVE_UTIL_H 
     
    209212noit_console_userdata_get(struct __noit_console_closure *ncct, 
    210213                          const char *name) { 
    211   noit_console_userdata_t *item; 
     214  void *vitem; 
    212215  if(noit_hash_retrieve(&ncct->userdata, name, strlen(name), 
    213                         (void **)&item)) 
    214     return item->data; 
     216                        &vitem)) 
     217    return ((noit_console_userdata_t *)vitem)->data; 
    215218  return NULL; 
    216219} 
     
    361364      } 
    362365 
    363       if(!noit_hash_retrieve(ac->config, 
     366      if(!noit_hash_retr_str(ac->config, 
    364367                             "line_protocol", strlen("line_protocol"), 
    365                              (void **)&line_protocol)) { 
     368                             &line_protocol)) { 
    366369        line_protocol = NULL; 
    367370      } 
  • src/noit_filters.c

    r057e0c6 r6210da7  
    157157   * a filterset other than check->filterset.. You never know. 
    158158   */ 
    159   filterset_t *fs; 
     159  void *vfs; 
    160160  if(!filtersets || !filterset) return noit_true; 
    161161 
    162   if(noit_hash_retrieve(filtersets, filterset, strlen(filterset), 
    163                         (void **)&fs)) { 
     162  if(noit_hash_retrieve(filtersets, filterset, strlen(filterset), &vfs)) { 
     163    filterset_t *fs = (filterset_t *)vfs; 
    164164    filterrule_t *r; 
    165165#define MATCHES(rname, value) noit_apply_filterrule(r->rname, r->rname##_e, value) 
  • src/noit_http.c

    r26e5e98 r6210da7  
    298298          const char *prefix = NULL; 
    299299          int l1, l2; 
    300           noit_hash_retrieve(&req->headers, last_name, strlen(last_name), 
    301                              (void **)&prefix); 
     300          noit_hash_retr_str(&req->headers, last_name, strlen(last_name), 
     301                             &prefix); 
    302302          if(!prefix) FAIL; 
    303303          l1 = strlen(prefix); 
     
    583583  b->size += slen; \ 
    584584} while(0) 
    585   while(noit_hash_next(&ctx->res.headers, &iter, 
    586                        &key, &klen, (void **)&value)) { 
     585  while(noit_hash_next_str(&ctx->res.headers, &iter, 
     586                           &key, &klen, &value)) { 
    587587    int vlen = strlen(value); 
    588588    CTX_LEADER_APPEND(key, klen); 
  • src/noit_jlog_listener.c

    r6bb9ef8 r6210da7  
    186186    char path[PATH_MAX], *sub; 
    187187    jcl = ac->service_ctx = noit_jlog_closure_alloc(); 
    188     if(!noit_hash_retrieve(ac->config, 
     188    if(!noit_hash_retr_str(ac->config, 
    189189                           "log_transit_feed_name", 
    190190                           strlen("log_transit_feed_name"), 
    191                            (void **)&logname)) { 
     191                           &logname)) { 
    192192      noitL(noit_error, "No 'log_transit_feed_name' specified in log_transit.\n"); 
    193193      goto socket_error; 
  • src/noit_listener.c

    r50d9d44 r6210da7  
    102102 
    103103    if(listener_closure->sslconfig->size) { 
    104       char *cert, *key, *ca, *ciphers; 
     104      const char *cert, *key, *ca, *ciphers; 
    105105      eventer_ssl_ctx_t *ctx; 
    106106      /* We have an SSL configuration.  While our socket accept is 
     
    109109       */ 
    110110#define SSLCONFGET(var,name) do { \ 
    111   if(!noit_hash_retrieve(listener_closure->sslconfig, name, strlen(name), \ 
    112                          (void **)&var)) var = NULL; } while(0) 
     111  if(!noit_hash_retr_str(listener_closure->sslconfig, name, strlen(name), \ 
     112                         &var)) var = NULL; } while(0) 
    113113      SSLCONFGET(cert, "certificate_file"); 
    114114      SSLCONFGET(key, "key_file"); 
     
    345345  u_int32_t cmd; 
    346346  int len; 
    347   noit_hash_table *delegation_table; 
     347  void *vdelegation_table; 
     348  noit_hash_table *delegation_table = NULL; 
    348349  acceptor_closure_t *ac = closure; 
    349350 
     
    367368  if(noit_hash_retrieve(&listener_commands, 
    368369                        (char *)&ac->dispatch, sizeof(ac->dispatch), 
    369                         (void **)&delegation_table)) { 
    370     eventer_func_t *eventer_func; 
     370                        (void **)&vdelegation_table)) { 
     371    void *vfunc; 
     372    delegation_table = (noit_hash_table *)vdelegation_table; 
    371373    if(noit_hash_retrieve(delegation_table, 
    372                           (char *)&cmd, sizeof(cmd), 
    373                           (void **)&eventer_func)) { 
    374       e->callback = *eventer_func; 
     374                          (char *)&cmd, sizeof(cmd), &vfunc)) { 
     375      e->callback = *((eventer_func_t *)vfunc); 
    375376      return e->callback(e, mask, closure, now); 
    376377    } 
     
    396397  u_int32_t *cmd_copy; 
    397398  eventer_func_t *handler_copy; 
     399  void *vdelegation_table; 
    398400  noit_hash_table *delegation_table; 
    399401  if(!noit_hash_retrieve(&listener_commands, 
    400402                         (char *)&listener_dispatch, sizeof(listener_dispatch), 
    401                          (void **)&delegation_table)) { 
     403                         &vdelegation_table)) { 
    402404    delegation_table = calloc(1, sizeof(*delegation_table)); 
    403405    handler_copy = malloc(sizeof(*handler_copy)); 
     
    407409                    delegation_table); 
    408410  } 
     411  else 
     412    delegation_table = (noit_hash_table *)vdelegation_table; 
     413 
    409414  cmd_copy = malloc(sizeof(*cmd_copy)); 
    410415  *cmd_copy = cmd; 
  • src/noit_module.c

    r56c7e9d r6210da7  
    4444 
    4545noit_module_loader_t * noit_loader_lookup(const char *name) { 
    46   noit_module_loader_t *loader; 
    47  
    48   if(noit_hash_retrieve(&loaders, name, strlen(name), (void **)&loader)) { 
    49     return loader; 
    50   } 
     46  void *vloader; 
     47 
     48  if(noit_hash_retrieve(&loaders, name, strlen(name), &vloader)) 
     49    return (noit_module_loader_t *)vloader; 
    5150  return NULL; 
    5251} 
    5352 
    5453noit_module_t * noit_module_lookup(const char *name) { 
    55   noit_module_t *module; 
    56  
    57   if(noit_hash_retrieve(&modules, name, strlen(name), (void **)&module)) { 
    58     return module; 
    59   } 
     54  void *vmodule; 
     55 
     56  if(noit_hash_retrieve(&modules, name, strlen(name), &vmodule)) 
     57    return (noit_module_t *)vmodule; 
    6058  return NULL; 
    6159} 
     
    249247    const char *name; 
    250248    int klen, i = 0; 
    251     noit_image_t *hdr; 
     249    void *vhdr; 
    252250 
    253251    while(noit_hash_next(&loaders, &iter, (const char **)&name, &klen, 
    254                          (void **)&hdr)) { 
     252                         &vhdr)) { 
     253      noit_image_t *hdr = (noit_image_t *)vhdr; 
    255254      if(!strncmp(hdr->name, argv[0], strlen(argv[0]))) { 
    256255        if(idx == i) return strdup(hdr->name); 
     
    260259    memset(&iter, 0, sizeof(iter)); 
    261260    while(noit_hash_next(&modules, &iter, (const char **)&name, &klen, 
    262                          (void **)&hdr)) { 
     261                         &vhdr)) { 
     262      noit_image_t *hdr = (noit_image_t *)vhdr; 
    263263      if(!strncmp(hdr->name, argv[0], strlen(argv[0]))) { 
    264264        if(idx == i) return strdup(hdr->name); 
     
    283283    const char *name; 
    284284    int klen; 
    285     noit_image_t *hdr; 
     285    void *vhdr; 
    286286 
    287287    nc_printf(ncct, "= Loaders and Modules =\n"); 
    288288    while(noit_hash_next(&loaders, &iter, (const char **)&name, &klen, 
    289                          (void **)&hdr)) { 
     289                         &vhdr)) { 
     290      noit_image_t *hdr = (noit_image_t *)vhdr;; 
    290291      nc_printf(ncct, "  %s\n", hdr->name); 
    291292    } 
    292293    memset(&iter, 0, sizeof(iter)); 
    293294    while(noit_hash_next(&modules, &iter, (const char **)&name, &klen, 
    294                          (void **)&hdr)) { 
     295                         &vhdr)) { 
     296      noit_image_t *hdr = (noit_image_t *)vhdr;; 
    295297      nc_printf(ncct, "  %s\n", hdr->name); 
    296298    } 
  • src/noit_tokenizer.c

    r1d69a01 r6210da7  
    1 /* Generated by re2c 0.12.0 on Fri Feb  8 14:52:45 2008 */ 
     1/* Generated by re2c 0.13.2 on Tue Mar 17 15:37:18 2009 */ 
    22#line 1 "noit_tokenizer.re" 
     3#include "noit_defines.h" 
    34#include <stdlib.h> 
    45#include <string.h> 
     
    4748 mainpattern: 
    4849 
    49 #line 50 "noit_tokenizer.c" 
     50#line 51 "noit_tokenizer.c" 
    5051        { 
    5152                unsigned char yych; 
    5253 
    5354                yych = (unsigned char)*t->next; 
    54                 switch(yych) { 
     55                switch (yych) { 
    5556                case 0x00:      goto yy10; 
    5657                case 0x09: 
     
    6768                goto yy17; 
    6869yy3: 
    69 #line 53 "noit_tokenizer.re" 
     70#line 54 "noit_tokenizer.re" 
    7071                { t->token = NULL; 
    7172                      t->end = t->next; 
    7273                      t->type = NT_SPACE; 
    7374                      return 1; } 
    74 #line 75 "noit_tokenizer.c" 
     75#line 76 "noit_tokenizer.c" 
    7576yy4: 
    7677                ++t->next; 
    77 #line 57 "noit_tokenizer.re" 
     78#line 58 "noit_tokenizer.re" 
    7879                { t->type = NT_DQSTRING; 
    7980                      if(t->start != t->end) { 
     
    8889                        goto dqstring; 
    8990                    } 
    90 #line 91 "noit_tokenizer.c" 
     91#line 92 "noit_tokenizer.c" 
    9192yy6: 
    9293                ++t->next; 
    93 #line 69 "noit_tokenizer.re" 
     94#line 70 "noit_tokenizer.re" 
    9495                { t->type = NT_IDENT; 
    9596                      if(t->start != t->end) { 
     
    103104                        goto sqstring; 
    104105                    } 
    105 #line 106 "noit_tokenizer.c" 
     106#line 107 "noit_tokenizer.c" 
    106107yy8: 
    107108                ++t->next; 
     
    109110                goto yy13; 
    110111yy9: 
    111 #line 81 "noit_tokenizer.re" 
     112#line 82 "noit_tokenizer.re" 
    112113                { char only = ' '; 
    113114                      t->end = t->next; 
     
    118119                      return 1; 
    119120                    } 
    120 #line 121 "noit_tokenizer.c" 
     121#line 122 "noit_tokenizer.c" 
    121122yy10: 
    122123                ++t->next; 
    123 #line 89 "noit_tokenizer.re" 
     124#line 90 "noit_tokenizer.re" 
    124125                { t->token = NULL; 
    125126                      t->type = NT_EOF; 
    126127                      return 0; 
    127128                    } 
    128 #line 129 "noit_tokenizer.c" 
     129#line 130 "noit_tokenizer.c" 
    129130yy12: 
    130131                ++t->next; 
    131132                yych = (unsigned char)*t->next; 
    132133yy13: 
    133                 switch(yych) { 
     134                switch (yych) { 
    134135                case 0x00: 
    135136                case 0x09: 
     
    143144                ++t->next; 
    144145                yych = (unsigned char)*t->next; 
    145                 switch(yych) { 
     146                switch (yych) { 
    146147                case 0x00: 
    147148                case 0x09: 
     
    155156                yych = (unsigned char)*t->next; 
    156157yy17: 
    157                 switch(yych) { 
     158                switch (yych) { 
    158159                case 0x09: 
    159160                case 0x0A: 
     
    163164                } 
    164165        } 
    165 #line 94 "noit_tokenizer.re" 
     166#line 95 "noit_tokenizer.re" 
    166167 
    167168 
    168169 sqstring: 
    169170 
    170 #line 171 "noit_tokenizer.c" 
     171#line 172 "noit_tokenizer.c" 
    171172        { 
    172173                unsigned char yych; 
    173174                yych = (unsigned char)*t->next; 
    174                 switch(yych) { 
     175                switch (yych) { 
    175176                case 0x00:      goto yy23; 
    176177                case '\'':      goto yy20; 
     
    178179                } 
    179180yy20: 
    180 #line 98 "noit_tokenizer.re" 
     181#line 99 "noit_tokenizer.re" 
    181182                { t->end = t->next; 
    182183                      goto mainpattern; } 
    183 #line 184 "noit_tokenizer.c" 
     184#line 185 "noit_tokenizer.c" 
    184185yy21: 
    185186                ++t->next; 
    186187                yych = (unsigned char)*t->next; 
    187                 switch(yych) { 
     188                switch (yych) { 
    188189                case 0x00: 
    189190                case '\'':      goto yy20; 
     
    192193yy23: 
    193194                ++t->next; 
    194 #line 100 "noit_tokenizer.re" 
     195#line 101 "noit_tokenizer.re" 
    195196                { BAIL_UNKNOWN; } 
    196 #line 197 "noit_tokenizer.c" 
     197#line 198 "noit_tokenizer.c" 
    197198        } 
    198 #line 101 "noit_tokenizer.re" 
     199#line 102 "noit_tokenizer.re" 
    199200 
    200201 
    201202 dqstring: 
    202203 
    203 #line 204 "noit_tokenizer.c" 
     204#line 205 "noit_tokenizer.c" 
    204205        { 
    205206                unsigned char yych; 
    206207                yych = (unsigned char)*t->next; 
    207                 switch(yych) { 
     208                switch (yych) { 
    208209                case 0x00:      goto yy33; 
    209210                case '"':       goto yy29; 
     
    213214yy27: 
    214215                yych = (unsigned char)*++t->next; 
    215                 switch(yych) { 
     216                switch (yych) { 
    216217                case 0x00:      goto yy28; 
    217218                case '"': 
     
    230231yy29: 
    231232                ++t->next; 
    232 #line 109 "noit_tokenizer.re" 
     233#line 110 "noit_tokenizer.re" 
    233234                { t->end = t->next--; 
    234235                      goto mainpattern; 
    235236                    } 
    236 #line 237 "noit_tokenizer.c" 
     237#line 238 "noit_tokenizer.c" 
    237238yy31: 
    238239                ++t->next; 
    239 #line 112 "noit_tokenizer.re" 
     240#line 113 "noit_tokenizer.re" 
    240241                { goto dqstring; } 
    241 #line 242 "noit_tokenizer.c" 
     242#line 243 "noit_tokenizer.c" 
    242243yy33: 
    243244                ++t->next; 
    244 #line 113 "noit_tokenizer.re" 
     245#line 114 "noit_tokenizer.re" 
    245246                { BAIL_UNKNOWN; } 
    246 #line 247 "noit_tokenizer.c" 
     247#line 248 "noit_tokenizer.c" 
    247248yy35: 
    248249                ++t->next; 
    249 #line 108 "noit_tokenizer.re" 
     250#line 109 "noit_tokenizer.re" 
    250251                { goto dqstring; } 
    251 #line 252 "noit_tokenizer.c" 
     252#line 253 "noit_tokenizer.c" 
    252253yy37: 
    253254                ++t->next; 
    254 #line 106 "noit_tokenizer.re" 
     255#line 107 "noit_tokenizer.re" 
    255256                { goto dqstring; } 
    256 #line 257 "noit_tokenizer.c" 
     257#line 258 "noit_tokenizer.c" 
    257258        } 
    258 #line 114 "noit_tokenizer.re" 
     259#line 115 "noit_tokenizer.re" 
    259260 
    260261} 
  • src/noit_tokenizer.re

    r37cf7d8 r6210da7  
     1#include "noit_defines.h" 
    12#include <stdlib.h> 
    23#include <string.h> 
  • src/noitd.c

    r21b0c6c r6210da7  
    8787    const char *key, *value; 
    8888    int klen; 
    89     while(noit_hash_next(table, &iter, &key, &klen, (void **)&value)) { 
     89    while(noit_hash_next_str(table, &iter, &key, &klen, &value)) { 
    9090      int subrv; 
    9191      if((subrv = eventer_propset(key, value)) != 0) 
  • src/noitedit/common.c

    r6480ae1 r6210da7  
    776776 
    777777        if (!found) { 
    778 #ifdef SDEBUG} 
     778#ifdef SDEBUG 
    779779                (void) fprintf(el->el_errfile, "not found\n"); 
    780780#endif 
  • src/stratcon_datastore.c

    rdbaf64b r6210da7  
    107107conn_q * 
    108108__get_conn_q_for_remote(struct sockaddr *remote) { 
     109  void *vcq; 
    109110  conn_q *cq; 
    110111  char queue_name[128] = "datastore_"; 
     
    136137    len = 4; 
    137138  } 
    138   if(noit_hash_retrieve(&ds_conns, (const char *)remote, len, (void **)&cq)) 
    139     return cq; 
     139  if(noit_hash_retrieve(&ds_conns, (const char *)remote, len, &vcq)) 
     140    return vcq; 
    140141  cq = calloc(1, sizeof(*cq)); 
    141142  cq->remote = malloc(len); 
     
    435436  dsn[0] = '\0'; 
    436437  t = noit_conf_get_hash(NULL, "/stratcon/database/dbconfig"); 
    437   while(noit_hash_next(t, &iter, &k, &klen, (void **)&v)) { 
     438  while(noit_hash_next_str(t, &iter, &k, &klen, &v)) { 
    438439    if(dsn[0]) strlcat(dsn, " ", sizeof(dsn)); 
    439440    strlcat(dsn, k, sizeof(dsn)); 
  • src/stratcon_jlog_streamer.c

    r21b0c6c r6210da7  
    7777  const char *v; 
    7878  u_int32_t min_interval = 1000, max_interval = 60000; 
    79   if(noit_hash_retrieve(ctx->config, 
     79  if(noit_hash_retr_str(ctx->config, 
    8080                        "reconnect_initial_interval", 
    8181                        strlen("reconnect_initial_interval"), 
    82                         (void **)&v)) { 
     82                        &v)) { 
    8383    min_interval = MAX(atoi(v), 100); /* .1 second minimum */ 
    8484  } 
    85   if(noit_hash_retrieve(ctx->config, 
     85  if(noit_hash_retr_str(ctx->config, 
    8686                        "reconnect_maximum_interval", 
    8787                        strlen("reconnect_maximum_interval"), 
    88                         (void **)&v)) { 
     88                        &v)) { 
    8989    max_interval = MIN(atoi(v), 3600*1000); /* 1 hour maximum */ 
    9090  } 
     
    157157    ctx->buffer = malloc(size + 1); \ 
    158158    if(ctx->buffer == NULL) { \ 
    159       noitL(noit_error, "malloc(%lu) failed.\n", size + 1); \ 
     159      noitL(noit_error, "malloc(%lu) failed.\n", (long unsigned int)size + 1); \ 
    160160      goto socket_error; \ 
    161161    } \ 
     
    172172  if(len != size) { \ 
    173173    noitL(noit_error, "SSL short read [%d] (%d/%lu).  Reseting connection.\n", \ 
    174           ctx->state, len, size); \ 
     174          ctx->state, len, (long unsigned int)size); \ 
    175175    goto socket_error; \ 
    176176  } \ 
     
    324324                                 struct timeval *now) { 
    325325  noit_connection_ctx_t *nctx = closure; 
    326   char *cert, *key, *ca, *ciphers; 
     326  const char *cert, *key, *ca, *ciphers; 
    327327  eventer_ssl_ctx_t *sslctx; 
    328328 
     
    336336 
    337337#define SSLCONFGET(var,name) do { \ 
    338   if(!noit_hash_retrieve(nctx->sslconfig, name, strlen(name), \ 
    339                          (void **)&var)) var = NULL; } while(0) 
     338  if(!noit_hash_retr_str(nctx->sslconfig, name, strlen(name), \ 
     339                         &var)) var = NULL; } while(0) 
    340340  SSLCONFGET(cert, "certificate_file"); 
    341341  SSLCONFGET(key, "key_file"); 
  • src/stratcon_realtime_http.c

    r2cc7e9e r6210da7  
    371371    noitL(noit_error, "http: %s %s %s\n", 
    372372          req->method_str, req->uri_str, req->protocol_str); 
    373     while(noit_hash_next(&req->headers, &iter, &key, &klen, (void **)&value)) { 
     373    while(noit_hash_next_str(&req->headers, &iter, &key, &klen, &value)) { 
    374374      noitL(noit_error, "http: [%s: %s]\n", key, value); 
    375375    } 
  • src/stratcond.c

    r55168c7 r6210da7  
    8080    const char *key, *value; 
    8181    int klen; 
    82     while(noit_hash_next(table, &iter, &key, &klen, (void **)&value)) { 
     82    while(noit_hash_next_str(table, &iter, &key, &klen, &value)) { 
    8383      int subrv; 
    8484      if((subrv = eventer_propset(key, value)) != 0) 
  • src/utils/noit_hash.c

    rf99cf46 r6210da7  
    309309} 
    310310 
     311int noit_hash_next_str(noit_hash_table *h, noit_hash_iter *iter, 
     312                       const char **k, int *klen, const char **dstr) { 
     313  void *data = NULL; 
     314  int rv; 
     315  rv = noit_hash_next(h,iter,k,klen,&data); 
     316  *dstr = data; 
     317  return rv; 
     318} 
     319 
    311320int noit_hash_firstkey(noit_hash_table *h, const char **k, int *klen) { 
    312321  int i; 
  • src/utils/noit_hash.h

    rf99cf46 r6210da7  
    7676                      NoitHashFreeFunc keyfree, NoitHashFreeFunc datafree); 
    7777int noit_hash_retrieve(noit_hash_table *h, const char *k, int klen, void **data); 
    78 int noit_hash_retr_str(noit_hash_table *h, const char *k, int klen, const char **data); 
     78int noit_hash_retr_str(noit_hash_table *h, const char *k, int klen, const char **dstr); 
    7979int noit_hash_delete(noit_hash_table *h, const char *k, int klen, 
    8080                     NoitHashFreeFunc keyfree, NoitHashFreeFunc datafree); 
     
    106106int noit_hash_next(noit_hash_table *h, noit_hash_iter *iter, 
    107107                   const char **k, int *klen, void **data); 
     108int noit_hash_next_str(noit_hash_table *h, noit_hash_iter *iter, 
     109                       const char **k, int *klen, const char **dstr); 
    108110int noit_hash_firstkey(noit_hash_table *h, const char **k, int *klen); 
    109111int noit_hash_nextkey(noit_hash_table *h, const char **k, int *klen, const char *lk, int lklen);