src/registry.c

   1 #include "common.h"
   2
   3 #include "registry_internals.h"
   4
   5 #define REGISTRY_STATUS_OK "ok"
   6 #define REGISTRY_STATUS_FAILED "failed"
   7 #define REGISTRY_STATUS_DISABLED "disabled"
   8
   9 // ----------------------------------------------------------------------------
  10 // REGISTRY concurrency locking
  11
  12 static inline void registry_lock(void) {
  13     pthread_mutex_lock(&registry.lock);
  14 }
  15
  16 static inline void registry_unlock(void) {
  17     pthread_mutex_unlock(&registry.lock);
  18 }
  19
  20
  21 // ----------------------------------------------------------------------------
  22 // COOKIES
  23
  24 static void registry_set_cookie(struct web_client *w, const char *guid) {
  25     char edate[100];
  26     time_t et = now_realtime_sec() + registry.persons_expiration;
  27     struct tm etmbuf, *etm = gmtime_r(&et, &etmbuf);
  28     strftime(edate, sizeof(edate), "%a, %d %b %Y %H:%M:%S %Z", etm);
  29
  30     snprintfz(w->cookie1, COOKIE_MAX, NETDATA_REGISTRY_COOKIE_NAME "=%s; Expires=%s", guid, edate);
  31
  32     if(registry.registry_domain && registry.registry_domain[0])
  33         snprintfz(w->cookie2, COOKIE_MAX, NETDATA_REGISTRY_COOKIE_NAME "=%s; Domain=%s; Expires=%s", guid, registry.registry_domain, edate);
  34 }
  35
  36 static inline void registry_set_person_cookie(struct web_client *w, REGISTRY_PERSON *p) {
  37     registry_set_cookie(w, p->guid);
  38 }
  39
  40
  41 // ----------------------------------------------------------------------------
  42 // JSON GENERATION
  43
  44 static inline void registry_json_header(RRDHOST *host, struct web_client *w, const char *action, const char *status) {
  45     buffer_flush(w->response.data);
  46     w->response.data->contenttype = CT_APPLICATION_JSON;
  47     buffer_sprintf(w->response.data, "{\n\t\"action\": \"%s\",\n\t\"status\": \"%s\",\n\t\"hostname\": \"%s\",\n\t\"machine_guid\": \"%s\"",
  48             action, status, (host == localhost)?registry.hostname:host->hostname, host->machine_guid);
  49 }
  50
  51 static inline void registry_json_footer(struct web_client *w) {
  52     buffer_strcat(w->response.data, "\n}\n");
  53 }
  54
  55 static inline int registry_json_disabled(RRDHOST *host, struct web_client *w, const char *action) {
  56     registry_json_header(host, w, action, REGISTRY_STATUS_DISABLED);
  57
  58     buffer_sprintf(w->response.data, ",\n\t\"registry\": \"%s\"",
  59             registry.registry_to_announce);
  60
  61     registry_json_footer(w);
  62     return 200;
  63 }
  64
  65
  66 // ----------------------------------------------------------------------------
  67 // CALLBACKS FOR WALKING THROUGH REGISTRY OBJECTS
  68
  69 // structure used be the callbacks below
  70 struct registry_json_walk_person_urls_callback {
  71     REGISTRY_PERSON *p;
  72     REGISTRY_MACHINE *m;
  73     struct web_client *w;
  74     int count;
  75 };
  76
  77 // callback for rendering PERSON_URLs
  78 static int registry_json_person_url_callback(void *entry, void *data) {
  79     REGISTRY_PERSON_URL *pu = (REGISTRY_PERSON_URL *)entry;
  80     struct registry_json_walk_person_urls_callback *c = (struct registry_json_walk_person_urls_callback *)data;
  81     struct web_client *w = c->w;
  82
  83     if(unlikely(c->count++))
  84         buffer_strcat(w->response.data, ",");
  85
  86     buffer_sprintf(w->response.data, "\n\t\t[ \"%s\", \"%s\", %u000, %u, \"%s\" ]",
  87             pu->machine->guid, pu->url->url, pu->last_t, pu->usages, pu->machine_name);
  88
  89     return 0;
  90 }
  91
  92 // callback for rendering MACHINE_URLs
  93 static int registry_json_machine_url_callback(void *entry, void *data) {
  94     REGISTRY_MACHINE_URL *mu = (REGISTRY_MACHINE_URL *)entry;
  95     struct registry_json_walk_person_urls_callback *c = (struct registry_json_walk_person_urls_callback *)data;
  96     struct web_client *w = c->w;
  97     REGISTRY_MACHINE *m = c->m;
  98
  99     if(unlikely(c->count++))
 100         buffer_strcat(w->response.data, ",");
 101
 102     buffer_sprintf(w->response.data, "\n\t\t[ \"%s\", \"%s\", %u000, %u ]",
 103             m->guid, mu->url->url, mu->last_t, mu->usages);
 104
 105     return 1;
 106 }
 107
 108 // ----------------------------------------------------------------------------
 109
 110 // structure used be the callbacks below
 111 struct registry_person_url_callback_verify_machine_exists_data {
 112     REGISTRY_MACHINE *m;
 113     int count;
 114 };
 115
 116 static inline int registry_person_url_callback_verify_machine_exists(void *entry, void *data) {
 117     struct registry_person_url_callback_verify_machine_exists_data *d = (struct registry_person_url_callback_verify_machine_exists_data *)data;
 118     REGISTRY_PERSON_URL *pu = (REGISTRY_PERSON_URL *)entry;
 119     REGISTRY_MACHINE *m = d->m;
 120
 121     if(pu->machine == m)
 122         d->count++;
 123
 124     return 0;
 125 }
 126
 127 // ----------------------------------------------------------------------------
 128 // public HELLO request
 129
 130 int registry_request_hello_json(RRDHOST *host, struct web_client *w) {
 131     registry_json_header(host, w, "hello", REGISTRY_STATUS_OK);
 132
 133     buffer_sprintf(w->response.data, ",\n\t\"registry\": \"%s\"",
 134             registry.registry_to_announce);
 135
 136     registry_json_footer(w);
 137     return 200;
 138 }
 139
 140 // ----------------------------------------------------------------------------
 141 //public ACCESS request
 142
 143 #define REGISTRY_VERIFY_COOKIES_GUID "give-me-back-this-cookie-now--please"
 144
 145 // the main method for registering an access
 146 int registry_request_access_json(RRDHOST *host, struct web_client *w, char *person_guid, char *machine_guid, char *url, char *name, time_t when) {
 147     if(unlikely(!registry.enabled))
 148         return registry_json_disabled(host, w, "access");
 149
 150     // ------------------------------------------------------------------------
 151     // verify the browser supports cookies
 152
 153     if(registry.verify_cookies_redirects > 0 && !person_guid[0]) {
 154         buffer_flush(w->response.data);
 155         registry_set_cookie(w, REGISTRY_VERIFY_COOKIES_GUID);
 156         w->response.data->contenttype = CT_APPLICATION_JSON;
 157         buffer_sprintf(w->response.data, "{ \"status\": \"redirect\", \"registry\": \"%s\" }", registry.registry_to_announce);
 158         return 200;
 159     }
 160
 161     if(unlikely(person_guid[0] && !strcmp(person_guid, REGISTRY_VERIFY_COOKIES_GUID)))
 162         person_guid[0] = '\0';
 163
 164     // ------------------------------------------------------------------------
 165
 166     registry_lock();
 167
 168     REGISTRY_PERSON *p = registry_request_access(person_guid, machine_guid, url, name, when);
 169     if(!p) {
 170         registry_json_header(host, w, "access", REGISTRY_STATUS_FAILED);
 171         registry_json_footer(w);
 172         registry_unlock();
 173         return 412;
 174     }
 175
 176     // set the cookie
 177     registry_set_person_cookie(w, p);
 178
 179     // generate the response
 180     registry_json_header(host, w, "access", REGISTRY_STATUS_OK);
 181
 182     buffer_sprintf(w->response.data, ",\n\t\"person_guid\": \"%s\",\n\t\"urls\": [", p->guid);
 183     struct registry_json_walk_person_urls_callback c = { p, NULL, w, 0 };
 184     avl_traverse(&p->person_urls, registry_json_person_url_callback, &c);
 185     buffer_strcat(w->response.data, "\n\t]\n");
 186
 187     registry_json_footer(w);
 188     registry_unlock();
 189     return 200;
 190 }
 191
 192 // ----------------------------------------------------------------------------
 193 // public DELETE request
 194
 195 // the main method for deleting a URL from a person
 196 int registry_request_delete_json(RRDHOST *host, struct web_client *w, char *person_guid, char *machine_guid, char *url, char *delete_url, time_t when) {
 197     if(!registry.enabled)
 198         return registry_json_disabled(host, w, "delete");
 199
 200     registry_lock();
 201
 202     REGISTRY_PERSON *p = registry_request_delete(person_guid, machine_guid, url, delete_url, when);
 203     if(!p) {
 204         registry_json_header(host, w, "delete", REGISTRY_STATUS_FAILED);
 205         registry_json_footer(w);
 206         registry_unlock();
 207         return 412;
 208     }
 209
 210     // generate the response
 211     registry_json_header(host, w, "delete", REGISTRY_STATUS_OK);
 212     registry_json_footer(w);
 213     registry_unlock();
 214     return 200;
 215 }
 216
 217 // ----------------------------------------------------------------------------
 218 // public SEARCH request
 219
 220 // the main method for searching the URLs of a netdata
 221 int registry_request_search_json(RRDHOST *host, struct web_client *w, char *person_guid, char *machine_guid, char *url, char *request_machine, time_t when) {
 222     if(!registry.enabled)
 223         return registry_json_disabled(host, w, "search");
 224
 225     registry_lock();
 226
 227     REGISTRY_MACHINE *m = registry_request_machine(person_guid, machine_guid, url, request_machine, when);
 228     if(!m) {
 229         registry_json_header(host, w, "search", REGISTRY_STATUS_FAILED);
 230         registry_json_footer(w);
 231         registry_unlock();
 232         return 404;
 233     }
 234
 235     registry_json_header(host, w, "search", REGISTRY_STATUS_OK);
 236
 237     buffer_strcat(w->response.data, ",\n\t\"urls\": [");
 238     struct registry_json_walk_person_urls_callback c = { NULL, m, w, 0 };
 239     dictionary_get_all(m->machine_urls, registry_json_machine_url_callback, &c);
 240     buffer_strcat(w->response.data, "\n\t]\n");
 241
 242     registry_json_footer(w);
 243     registry_unlock();
 244     return 200;
 245 }
 246
 247 // ----------------------------------------------------------------------------
 248 // SWITCH REQUEST
 249
 250 // the main method for switching user identity
 251 int registry_request_switch_json(RRDHOST *host, struct web_client *w, char *person_guid, char *machine_guid, char *url, char *new_person_guid, time_t when) {
 252     if(!registry.enabled)
 253         return registry_json_disabled(host, w, "switch");
 254
 255     (void)url;
 256     (void)when;
 257
 258     registry_lock();
 259
 260     REGISTRY_PERSON *op = registry_person_find(person_guid);
 261     if(!op) {
 262         registry_json_header(host, w, "switch", REGISTRY_STATUS_FAILED);
 263         registry_json_footer(w);
 264         registry_unlock();
 265         return 430;
 266     }
 267
 268     REGISTRY_PERSON *np = registry_person_find(new_person_guid);
 269     if(!np) {
 270         registry_json_header(host, w, "switch", REGISTRY_STATUS_FAILED);
 271         registry_json_footer(w);
 272         registry_unlock();
 273         return 431;
 274     }
 275
 276     REGISTRY_MACHINE *m = registry_machine_find(machine_guid);
 277     if(!m) {
 278         registry_json_header(host, w, "switch", REGISTRY_STATUS_FAILED);
 279         registry_json_footer(w);
 280         registry_unlock();
 281         return 432;
 282     }
 283
 284     struct registry_person_url_callback_verify_machine_exists_data data = { m, 0 };
 285
 286     // verify the old person has access to this machine
 287     avl_traverse(&op->person_urls, registry_person_url_callback_verify_machine_exists, &data);
 288     if(!data.count) {
 289         registry_json_header(host, w, "switch", REGISTRY_STATUS_FAILED);
 290         registry_json_footer(w);
 291         registry_unlock();
 292         return 433;
 293     }
 294
 295     // verify the new person has access to this machine
 296     data.count = 0;
 297     avl_traverse(&np->person_urls, registry_person_url_callback_verify_machine_exists, &data);
 298     if(!data.count) {
 299         registry_json_header(host, w, "switch", REGISTRY_STATUS_FAILED);
 300         registry_json_footer(w);
 301         registry_unlock();
 302         return 434;
 303     }
 304
 305     // set the cookie of the new person
 306     // the user just switched identity
 307     registry_set_person_cookie(w, np);
 308
 309     // generate the response
 310     registry_json_header(host, w, "switch", REGISTRY_STATUS_OK);
 311     buffer_sprintf(w->response.data, ",\n\t\"person_guid\": \"%s\"", np->guid);
 312     registry_json_footer(w);
 313
 314     registry_unlock();
 315     return 200;
 316 }
 317
 318 // ----------------------------------------------------------------------------
 319 // STATISTICS
 320
 321 void registry_statistics(void) {
 322     if(!registry.enabled) return;
 323
 324     static RRDSET *sts = NULL, *stc = NULL, *stm = NULL;
 325
 326     if(!sts) sts = rrdset_find_localhost("netdata.registry_sessions");
 327     if(!sts) {
 328         sts = rrdset_create_localhost("netdata", "registry_sessions", NULL, "registry", NULL
 329                                       , "NetData Registry Sessions", "session", 131000, localhost->rrd_update_every
 330                                       , RRDSET_TYPE_LINE);
 331
 332         rrddim_add(sts, "sessions",  NULL,  1, 1, RRD_ALGORITHM_ABSOLUTE);
 333     }
 334     else rrdset_next(sts);
 335
 336     rrddim_set(sts, "sessions", registry.usages_count);
 337     rrdset_done(sts);
 338
 339     // ------------------------------------------------------------------------
 340
 341     if(!stc) stc = rrdset_find_localhost("netdata.registry_entries");
 342     if(!stc) {
 343         stc = rrdset_create_localhost("netdata", "registry_entries", NULL, "registry", NULL, "NetData Registry Entries"
 344                                       , "entries", 131100, localhost->rrd_update_every, RRDSET_TYPE_LINE);
 345
 346         rrddim_add(stc, "persons",        NULL,  1, 1, RRD_ALGORITHM_ABSOLUTE);
 347         rrddim_add(stc, "machines",       NULL,  1, 1, RRD_ALGORITHM_ABSOLUTE);
 348         rrddim_add(stc, "urls",           NULL,  1, 1, RRD_ALGORITHM_ABSOLUTE);
 349         rrddim_add(stc, "persons_urls",   NULL,  1, 1, RRD_ALGORITHM_ABSOLUTE);
 350         rrddim_add(stc, "machines_urls",  NULL,  1, 1, RRD_ALGORITHM_ABSOLUTE);
 351     }
 352     else rrdset_next(stc);
 353
 354     rrddim_set(stc, "persons",       registry.persons_count);
 355     rrddim_set(stc, "machines",      registry.machines_count);
 356     rrddim_set(stc, "urls",          registry.urls_count);
 357     rrddim_set(stc, "persons_urls",  registry.persons_urls_count);
 358     rrddim_set(stc, "machines_urls", registry.machines_urls_count);
 359     rrdset_done(stc);
 360
 361     // ------------------------------------------------------------------------
 362
 363     if(!stm) stm = rrdset_find_localhost("netdata.registry_mem");
 364     if(!stm) {
 365         stm = rrdset_create_localhost("netdata", "registry_mem", NULL, "registry", NULL, "NetData Registry Memory", "KB"
 366                                       , 131300, localhost->rrd_update_every, RRDSET_TYPE_STACKED);
 367
 368         rrddim_add(stm, "persons",        NULL,  1, 1024, RRD_ALGORITHM_ABSOLUTE);
 369         rrddim_add(stm, "machines",       NULL,  1, 1024, RRD_ALGORITHM_ABSOLUTE);
 370         rrddim_add(stm, "urls",           NULL,  1, 1024, RRD_ALGORITHM_ABSOLUTE);
 371         rrddim_add(stm, "persons_urls",   NULL,  1, 1024, RRD_ALGORITHM_ABSOLUTE);
 372         rrddim_add(stm, "machines_urls",  NULL,  1, 1024, RRD_ALGORITHM_ABSOLUTE);
 373     }
 374     else rrdset_next(stm);
 375
 376     rrddim_set(stm, "persons",       registry.persons_memory + registry.persons_count * sizeof(NAME_VALUE) + sizeof(DICTIONARY));
 377     rrddim_set(stm, "machines",      registry.machines_memory + registry.machines_count * sizeof(NAME_VALUE) + sizeof(DICTIONARY));
 378     rrddim_set(stm, "urls",          registry.urls_memory);
 379     rrddim_set(stm, "persons_urls",  registry.persons_urls_memory);
 380     rrddim_set(stm, "machines_urls", registry.machines_urls_memory + registry.machines_count * sizeof(DICTIONARY) + registry.machines_urls_count * sizeof(NAME_VALUE));
 381     rrdset_done(stm);
 382 }