Show
Ignore:
Timestamp:
01/26/08 20:48:28 (6 years ago)
Author:
Theo Schlossnagle <jesus@omniti.com>
git-committer:
Theo Schlossnagle <jesus@omniti.com> 1201380508 +0000
git-parent:

[2c65def60e6630d515d47a2135e89e7961c4c5b9]

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

glue up some actual XML

Files:

Legend:

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

    r919b09a rcaa7b86  
    22#include "eventer/eventer_impl.h" 
    33#include "eventer/eventer_POSIX_fd_opset.h" 
     4#include "utils/noit_hash.h" 
    45 
    56eventer_t eventer_alloc() { 
     
    2728} 
    2829 
     30static noit_hash_table __name_to_func = NOIT_HASH_EMPTY; 
     31static noit_hash_table __func_to_name = NOIT_HASH_EMPTY; 
     32int eventer_name_callback(const char *name, eventer_func_t f) { 
     33  noit_hash_replace(&__name_to_func, strdup(name), strlen(name), f, free, NULL); 
     34  noit_hash_replace(&__func_to_name, (char *)f, sizeof(f), strdup(name), 
     35                    NULL, free); 
     36  return 0; 
     37} 
     38eventer_func_t eventer_callback_for_name(const char *name) { 
     39  eventer_func_t f; 
     40  if(noit_hash_retrieve(&__name_to_func, name, strlen(name), (void **)&f)) 
     41    return f; 
     42  return (eventer_func_t)NULL; 
     43} 
     44const char *eventer_name_for_callback(eventer_func_t f) { 
     45  const char *name; 
     46  if(noit_hash_retrieve(&__func_to_name, (char *)f, sizeof(f), (void **)&name)) 
     47    return name; 
     48  return NULL; 
     49} 
     50 
    2951int eventer_choose(const char *name) { 
    3052  eventer_impl_t choice; 
  • src/eventer/eventer.h

    rb62cf2b rcaa7b86  
    5353API_EXPORT(void)      eventer_free(eventer_t); 
    5454API_EXPORT(int)       eventer_timecompare(void *a, void *b); 
     55API_EXPORT(int)       eventer_name_callback(const char *name, eventer_func_t f); 
     56API_EXPORT(const char *) 
     57                      eventer_name_for_callback(eventer_func_t f); 
     58API_EXPORT(eventer_func_t) 
     59                      eventer_callback_for_name(const char *name); 
    5560 
    5661typedef struct _eventer_impl { 
  • src/noit_conf.c

    r0268e62 rcaa7b86  
    55 
    66#include "noit_defines.h" 
     7 
    78#include <stdio.h> 
     9#include <assert.h> 
     10#include <libxml/parser.h> 
     11#include <libxml/tree.h> 
     12#include <libxml/xpath.h> 
     13 
    814#include "noit_conf.h" 
    915#include "utils/noit_hash.h" 
     
    1117/* tmp hash impl, replace this with something nice */ 
    1218static noit_hash_table _tmp_config = NOIT_HASH_EMPTY; 
    13  
     19static xmlDocPtr master_config = NULL; 
     20static xmlXPathContextPtr xpath_ctxt = NULL; 
    1421 
    1522static noit_hash_table _compiled_fallback = NOIT_HASH_EMPTY; 
     
    3845                    (void *)strdup(config_info[i].val)); 
    3946  } 
     47  xmlInitParser(); 
     48  xmlXPathInit(); 
    4049} 
    4150 
    4251int noit_conf_load(const char *path) { 
     52  xmlDocPtr new_config; 
     53  new_config = xmlParseFile(path); 
     54  if(new_config) { 
     55    if(master_config) xmlFreeDoc(master_config); 
     56    if(xpath_ctxt) xmlXPathFreeContext(xpath_ctxt); 
     57 
     58    master_config = new_config; 
     59    xpath_ctxt = xmlXPathNewContext(master_config); 
     60    return 0; 
     61  } 
    4362  return -1; 
    4463} 
     
    4766} 
    4867 
    49 int noit_conf_get_string(const char *path, char **value) { 
    50   char *str; 
    51   if(noit_hash_retrieve(&_tmp_config, 
    52                         path, strlen(path), (void **)&str)) { 
    53     *value = strdup(str); 
     68noit_conf_section_t noit_conf_get_section(noit_conf_section_t section, 
     69                                          const char *path) { 
     70  noit_conf_section_t subsection = NULL; 
     71  xmlXPathObjectPtr pobj; 
     72  xmlXPathContextPtr current_ctxt; 
     73  xmlNodePtr current_node = (xmlNodePtr)section; 
     74 
     75  current_ctxt = xpath_ctxt; 
     76  if(current_node) { 
     77    current_ctxt = xmlXPathNewContext(master_config); 
     78    current_ctxt->node = current_node; 
     79  } 
     80  pobj = xmlXPathEval((xmlChar *)path, current_ctxt); 
     81  if(!pobj) goto out; 
     82  if(pobj->type != XPATH_NODESET) goto out; 
     83  if(xmlXPathNodeSetIsEmpty(pobj->nodesetval)) goto out; 
     84  subsection = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, 0); 
     85 out: 
     86  if(current_ctxt && current_ctxt != xpath_ctxt) 
     87    xmlXPathFreeContext(current_ctxt); 
     88  return subsection; 
     89
     90noit_conf_section_t *noit_conf_get_sections(noit_conf_section_t section, 
     91                                            const char *path, 
     92                                            int *cnt) { 
     93  int i; 
     94  noit_conf_section_t *sections; 
     95  xmlXPathObjectPtr pobj; 
     96  xmlXPathContextPtr current_ctxt; 
     97  xmlNodePtr current_node = (xmlNodePtr)section; 
     98 
     99  *cnt = 0; 
     100  current_ctxt = xpath_ctxt; 
     101  if(current_node) { 
     102    current_ctxt = xmlXPathNewContext(master_config); 
     103    current_ctxt->node = current_node; 
     104  } 
     105  pobj = xmlXPathEval((xmlChar *)path, current_ctxt); 
     106  if(!pobj) goto out; 
     107  if(pobj->type != XPATH_NODESET) goto out; 
     108  if(xmlXPathNodeSetIsEmpty(pobj->nodesetval)) goto out; 
     109  *cnt = xmlXPathNodeSetGetLength(pobj->nodesetval); 
     110  sections = calloc(*cnt, sizeof(*sections)); 
     111  for(i=0; i<*cnt; i++) 
     112    sections[i] = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, i); 
     113 out: 
     114  if(current_ctxt && current_ctxt != xpath_ctxt) 
     115    xmlXPathFreeContext(current_ctxt); 
     116  return sections; 
     117
     118int _noit_conf_get_string(noit_conf_section_t section, 
     119                          const char *path, char **value) { 
     120  char *str; 
     121  int i; 
     122  xmlXPathObjectPtr pobj; 
     123  xmlXPathContextPtr current_ctxt; 
     124  xmlNodePtr current_node = (xmlNodePtr)section; 
     125 
     126  current_ctxt = xpath_ctxt; 
     127  if(current_node) { 
     128    current_ctxt = xmlXPathNewContext(master_config); 
     129    current_ctxt->node = current_node; 
     130  } 
     131  pobj = xmlXPathEval((xmlChar *)path, current_ctxt); 
     132  if(pobj) { 
     133    switch(pobj->type) { 
     134      case XPATH_NODESET: 
     135        if(xmlXPathNodeSetIsEmpty(pobj->nodesetval)) return 0; 
     136        i = xmlXPathNodeSetGetLength(pobj->nodesetval); 
     137        assert(i == 1); 
     138        *value = (char *)xmlXPathCastNodeSetToString(pobj->nodesetval); 
     139        break; 
     140      default: 
     141        *value = (char *)xmlXPathCastToString(pobj); 
     142    } 
     143    goto found; 
    54144  } 
    55145  if(noit_hash_retrieve(&_compiled_fallback, 
    56146                        path, strlen(path), (void **)&str)) { 
     147    *value = str; 
     148    goto found; 
     149  } 
     150  return 0; 
     151 found: 
     152  if(current_ctxt && current_ctxt != xpath_ctxt) 
     153    xmlXPathFreeContext(current_ctxt); 
     154  return 1; 
     155} 
     156int noit_conf_get_string(noit_conf_section_t section, 
     157                         const char *path, char **value) { 
     158  char *str; 
     159  if(_noit_conf_get_string(section,path,&str)) { 
    57160    *value = strdup(str); 
    58   } 
    59   return 0; 
    60 
    61 int noit_conf_set_string(const char *path, const char *value) { 
     161    return 1; 
     162  } 
     163  return 0; 
     164
     165int noit_conf_get_stringbuf(noit_conf_section_t section, 
     166                            const char *path, char *buf, int len) { 
     167  char *str; 
     168  if(_noit_conf_get_string(section,path,&str)) { 
     169    strlcpy(buf, str, len); 
     170    return 1; 
     171  } 
     172  return 0; 
     173
     174int noit_conf_set_string(noit_conf_section_t section, 
     175                         const char *path, const char *value) { 
    62176  noit_hash_replace(&_tmp_config, 
    63177                    strdup(path), strlen(path), (void *)strdup(value), 
     
    65179  return 1; 
    66180} 
    67 int noit_conf_get_int(const char *path, int *value) { 
     181int noit_conf_get_int(noit_conf_section_t section, 
     182                      const char *path, int *value) { 
    68183  char *str; 
    69184  long longval; 
    70   if(noit_conf_get_string(path, &str)) { 
     185  if(noit_conf_get_string(section,path,&str)) { 
    71186    int base = 10; 
    72187    if(str[0] == '0') { 
     
    81196  return 0; 
    82197} 
    83 int noit_conf_set_int(const char *path, int value) { 
     198int noit_conf_set_int(noit_conf_section_t section, 
     199                      const char *path, int value) { 
    84200  char buffer[32]; 
    85201  snprintf(buffer, 32, "%d", value); 
    86   return noit_conf_set_string(path, buffer); 
    87 
    88 int noit_conf_get_float(const char *path, float *value) { 
    89   char *str; 
    90   if(noit_conf_get_string(path, &str)) { 
     202  return noit_conf_set_string(section,path,buffer); 
     203
     204int noit_conf_get_float(noit_conf_section_t section, 
     205                        const char *path, float *value) { 
     206  char *str; 
     207  if(noit_conf_get_string(section,path,&str)) { 
    91208    *value = atof(str); 
    92209    free(str); 
     
    95212  return 0; 
    96213} 
    97 int noit_conf_set_float(const char *path, float value) { 
     214int noit_conf_set_float(noit_conf_section_t section, 
     215                        const char *path, float value) { 
    98216  char buffer[32]; 
    99217  snprintf(buffer, 32, "%f", value); 
    100   return noit_conf_set_string(path, buffer); 
    101 
    102 int noit_conf_get_boolean(const char *path, noit_conf_boolean *value) { 
    103   char *str; 
    104   if(noit_conf_get_string(path, &str)) { 
    105     if(!strcasecmp(str, "true")) *value = true; 
    106     else *value = false; 
     218  return noit_conf_set_string(section,path,buffer); 
     219
     220int noit_conf_get_boolean(noit_conf_section_t section, 
     221                          const char *path, noit_conf_boolean *value) { 
     222  char *str; 
     223  if(noit_conf_get_string(section,path,&str)) { 
     224    if(!strcasecmp(str, "true")) *value = noit_true; 
     225    else *value = noit_false; 
    107226    free(str); 
    108227    return 1; 
     
    110229  return 0; 
    111230} 
    112 int noit_conf_set_boolean(const char *path, noit_conf_boolean value) { 
    113   if(value == true) 
    114     return noit_conf_set_string(path, "true"); 
    115   return noit_conf_set_string(path, "false"); 
    116 
    117  
     231int noit_conf_set_boolean(noit_conf_section_t section, 
     232                          const char *path, noit_conf_boolean value) { 
     233  if(value == noit_true) 
     234    return noit_conf_set_string(section,path,"true"); 
     235  return noit_conf_set_string(section,path,"false"); 
     236
     237 
  • src/noit_conf.h

    r0268e62 rcaa7b86  
    99#include "noit_defines.h" 
    1010 
    11 typedef enum { true, false } noit_conf_boolean; 
     11typedef enum { noit_true, noit_false } noit_conf_boolean; 
     12typedef void * noit_conf_section_t; 
    1213 
    1314API_EXPORT(void) noit_conf_init(); 
     
    1516API_EXPORT(int) noit_conf_save(const char *path); 
    1617 
    17 API_EXPORT(int) noit_conf_get_string(const char *path, char **value); 
    18 API_EXPORT(int) noit_conf_get_int(const char *path, int *value); 
    19 API_EXPORT(int) noit_conf_get_float(const char *path, float *value); 
    20 API_EXPORT(int) noit_conf_get_boolean(const char *path, noit_conf_boolean *value); 
     18API_EXPORT(noit_conf_section_t) 
     19  noit_conf_get_section(noit_conf_section_t section, const char *path); 
     20API_EXPORT(noit_conf_section_t *) 
     21  noit_conf_get_sections(noit_conf_section_t section, const char *path, 
     22                         int *cnt); 
    2123 
    22 API_EXPORT(int) noit_conf_set_string(const char *path, const char *value); 
    23 API_EXPORT(int) noit_conf_set_int(const char *path, int value); 
    24 API_EXPORT(int) noit_conf_set_float(const char *path, float value); 
    25 API_EXPORT(int) noit_conf_set_boolean(const char *path, noit_conf_boolean value); 
     24API_EXPORT(int) noit_conf_get_string(noit_conf_section_t section, 
     25                                     const char *path, char **value); 
     26API_EXPORT(int) noit_conf_get_stringbuf(noit_conf_section_t section, 
     27                                        const char *path, char *value, int len); 
     28API_EXPORT(int) noit_conf_get_int(noit_conf_section_t section, 
     29                                  const char *path, int *value); 
     30API_EXPORT(int) noit_conf_get_float(noit_conf_section_t section, 
     31                                    const char *path, float *value); 
     32API_EXPORT(int) noit_conf_get_boolean(noit_conf_section_t section, 
     33                                      const char *path, noit_conf_boolean *value); 
     34 
     35API_EXPORT(int) noit_conf_set_string(noit_conf_section_t section, 
     36                                     const char *path, const char *value); 
     37API_EXPORT(int) noit_conf_set_int(noit_conf_section_t section, 
     38                                  const char *path, int value); 
     39API_EXPORT(int) noit_conf_set_float(noit_conf_section_t section, 
     40                                    const char *path, float value); 
     41API_EXPORT(int) noit_conf_set_boolean(noit_conf_section_t section, 
     42                                      const char *path, noit_conf_boolean value); 
    2643 
    2744#endif 
  • src/noit_console.c

    r7629c91 rcaa7b86  
    99#include <unistd.h> 
    1010 
     11#include "eventer/eventer.h" 
    1112#include "utils/noit_log.h" 
    1213#include "noit_listener.h" 
    1314#include "noit_poller.h" 
     15#include "noit_console.h" 
     16 
     17void 
     18noit_console_init() { 
     19  eventer_name_callback("noit_console", noit_console_handler); 
     20} 
    1421 
    1522int 
  • src/noit_console.h

    rf41090d rcaa7b86  
    1010#include "eventer/eventer.h" 
    1111 
    12 int 
    13 noit_console_handler(eventer_t e, int mask, void *closure, 
    14                      struct timeval *now); 
     12API_EXPORT(void) noit_console_init(); 
     13 
     14API_EXPORT(int) 
     15  noit_console_handler(eventer_t e, int mask, void *closure, 
     16                       struct timeval *now); 
    1517 
    1618#endif 
  • src/noit_listener.c

    r7212f9d rcaa7b86  
    1717#include "utils/noit_log.h" 
    1818#include "noit_listener.h" 
     19#include "noit_conf.h" 
    1920 
    2021static int 
     
    7172    struct sockaddr_in6 addr6; 
    7273  } s; 
     74  const char *event_name; 
    7375 
     76  noit_log(noit_debug, NULL, "noit_listener(%s, %d, %d, %d, %s, %p)\n", 
     77           host, port, type, backlog, 
     78           (event_name = eventer_name_for_callback(handler))?event_name:"??", 
     79           closure); 
    7480  family = AF_INET; 
    7581  rv = inet_pton(family, host, &a); 
     
    7884    rv = inet_pton(family, host, &a); 
    7985    if(rv != 1) { 
    80       noit_log(noit_stderr, NULL, "Cannot translate '%s' to IP\n", host); 
    81       return -1; 
     86      if(!strcmp(host, "*")) { 
     87        family = AF_INET; 
     88        a.addr4.s_addr = INADDR_ANY; 
     89      } else { 
     90        noit_log(noit_stderr, NULL, "Cannot translate '%s' to IP\n", host); 
     91        return -1; 
     92      } 
    8293    } 
    8394  } 
     
    133144  return 0; 
    134145} 
     146 
     147void 
     148noit_listener_init() { 
     149  int i, cnt = 0; 
     150  noit_conf_section_t *listener_configs; 
     151 
     152  listener_configs = noit_conf_get_sections(NULL, "/global/listeners/listener", 
     153                                            &cnt); 
     154  noit_log(noit_stderr, NULL, "Found %d /global/listeners/listener stanzas\n", 
     155           cnt); 
     156  for(i=0; i<cnt; i++) { 
     157    char address[256]; 
     158    char type[256]; 
     159    unsigned short port; 
     160    int portint; 
     161    int backlog; 
     162    eventer_func_t f; 
     163 
     164    if(!noit_conf_get_stringbuf(listener_configs[i], 
     165                                "type", type, sizeof(type))) { 
     166      noit_log(noit_stderr, NULL, 
     167               "No type specified in listener stanza %d\n", i+1); 
     168      continue; 
     169    } 
     170    f = eventer_callback_for_name(type); 
     171    if(!f) { 
     172      noit_log(noit_stderr, NULL, 
     173               "Cannot find handler for listener type: '%s'\n", type); 
     174      continue; 
     175    } 
     176    if(!noit_conf_get_int(listener_configs[i], "port", &portint)) 
     177      portint = 0; 
     178    port = (unsigned short) portint; 
     179    if(portint == 0 || (port != portint)) { 
     180      noit_log(noit_stderr, NULL, 
     181               "Invalid port [%d] specified in stanza %d\n", port, i+1); 
     182      continue; 
     183    } 
     184    if(!noit_conf_get_stringbuf(listener_configs[i], 
     185                                "address", address, sizeof(address))) { 
     186      address[0] = '*'; 
     187      address[1] = '\0'; 
     188    } 
     189    if(!noit_conf_get_int(listener_configs[i], "backlog", &backlog)) 
     190      backlog = 5; 
     191 
     192    noit_listener(address, port, SOCK_STREAM, backlog, f, NULL); 
     193  } 
     194} 
  • src/noit_listener.h

    rf41090d rcaa7b86  
    1717} * listener_closure_t; 
    1818 
    19 int 
     19API_EXPORT(void) noit_listener_init(); 
     20 
     21API_EXPORT(int) 
    2022noit_listener(char *host, unsigned short port, int type, 
    2123              int backlog, eventer_func_t handler, void *closure); 
  • src/noit_module.c

    r0268e62 rcaa7b86  
    55 
    66#include "noit_defines.h" 
     7 
     8#include <stdio.h> 
     9#include <dlfcn.h> 
     10 
    711#include "noit_module.h" 
     12#include "noit_conf.h" 
    813#include "utils/noit_hash.h" 
     14#include "utils/noit_log.h" 
    915 
    1016static noit_hash_table modules = NOIT_HASH_EMPTY; 
    1117 
    1218int noit_module_load(const char *file, const char *name) { 
     19  char module_file[PATH_MAX]; 
     20  char *base; 
     21  void *dlhandle; 
     22  void *dlsymbol; 
     23  noit_module_t *module; 
     24 
     25  if(!noit_conf_get_string("/global/modules/directory", &base)) 
     26    base = strdup(""); 
     27 
     28  if(file[0] == '/') 
     29    strlcpy(module_file, file, sizeof(module_file)); 
     30  else 
     31    snprintf(module_file, sizeof(module_file), "%s/%s.%s", 
     32             base, name, MODULEEXT); 
     33  free(base); 
     34 
     35  dlhandle = dlopen(module_file, RTLD_LAZY | RTLD_GLOBAL); 
     36  if(!dlhandle) { 
     37    noit_log(noit_stderr, NULL, "Cannot open image '%s': %s\n", 
     38             module_file, dlerror()); 
     39    return -1; 
     40  } 
     41 
     42  dlsymbol = dlsym(dlhandle, name); 
     43  if(!dlsymbol) { 
     44    noit_log(noit_stderr, NULL, "Cannot find '%s' in image '%s': %s\n", 
     45             name, module_file, dlerror()); 
     46    dlclose(dlhandle); 
     47    return -1; 
     48  } 
     49 
     50  module = (noit_module_t *)dlsymbol; 
     51  if(noit_module_validate_magic(module) == -1) { 
     52    noit_log(noit_stderr, NULL, "I can't understand module %s\n", name); 
     53    dlclose(dlhandle); 
     54    return -1; 
     55  } 
     56 
     57  noit_hash_store(&modules, module->name, strlen(module->name), module); 
     58  return 0; 
    1359} 
     60 
    1461noit_module_t * noit_module_lookup(const char *name) { 
    1562  noit_module_t *module; 
  • src/noit_module.h

    r0268e62 rcaa7b86  
    1111#include "noit_poller.h" 
    1212 
     13#define NOIT_MODULE_MAGIC 0x4017DA7A 
     14 
    1315typedef struct { 
     16  uint32_t magic; 
     17  uint32_t version; 
    1418  char *name; 
    1519  char *description; 
     
    2024} noit_module_t; 
    2125 
     26#define MODULE_MAGIC(a)          ((a)->magic) 
     27#define MODULE_VERSION(a)        ((a)->version) 
     28 
     29#define noit_module_validate_magic(a) \ 
     30  ((MODULE_MAGIC(a) == NOIT_MODULE_MAGIC)?0:-1) 
     31 
    2232API_EXPORT(int) 
    2333  noit_module_load(const char *file, const char *name); 
  • src/noitd.c

    r2c65def rcaa7b86  
    88#include <fcntl.h> 
    99 
    10 #include "getopt_long.h" 
    1110#include "eventer/eventer.h" 
    1211#include "utils/noit_log.h" 
     
    3534 
    3635int main(int argc, char **argv) { 
     36  char conf_str[1024]; 
    3737  parse_clargs(argc, argv); 
    3838 
     39  /* First initialize logging, so we can log errors */ 
    3940  noit_log_init(); 
    4041  if(debug) 
     
    4243  noit_log_stream_add_stream(noit_error, noit_stderr); 
    4344 
     45  /* Next load the configs */ 
    4446  noit_conf_init(); 
    4547  if(noit_conf_load(config_file) == -1) { 
    4648    fprintf(stderr, "Cannot load config: '%s'\n", config_file); 
    4749  } 
    48   if(eventer_choose("kqueue") == -1) { 
    49     fprintf(stderr, "Cannot choose kqueue\n"); 
     50 
     51  /* Lastly, run through all other system inits */ 
     52  if(!noit_conf_get_stringbuf(NULL, "/global/eventer/implementation", 
     53                              conf_str, sizeof(conf_str))) { 
     54    noit_log(noit_stderr, NULL, "Cannot find '%s' in configuration\n", 
     55             "/global/eventer/implementation"); 
     56    exit(-1); 
     57  } 
     58  if(eventer_choose(conf_str) == -1) { 
     59    noit_log(noit_stderr, NULL, "Cannot choose eventer %s\n", conf_str); 
    5060    exit(-1); 
    5161  } 
    5262  if(eventer_init() == -1) { 
    53     fprintf(stderr, "Cannot init kqueue\n"); 
     63    noit_log(noit_stderr, NULL, "Cannot init eventer %s\n", conf_str); 
    5464    exit(-1); 
    5565  } 
     66  noit_console_init(); 
    5667 
    57   noit_listener("127.0.0.1", 23123, SOCK_STREAM, 5, noit_console_handler, NULL); 
     68  noit_listener_init(); 
     69 
    5870  eventer_loop(); 
    5971  return 0;