converted tabs for C, JS, BASH to 4 spaces

1 files changed, 1267 insertions, 1267 deletions

diff --git a/src/registry.c b/src/registry.c
index 988ed78d67..e43c16b1b7 100644
--- a/src/registry.c
+++ b/src/registry.c
@@ -39,60 +39,60 @@
 // COMMON structures
 
 struct registry {
-	int enabled;
-
-	char machine_guid[36 + 1];
-
-	// entries counters / statistics
-	unsigned long long persons_count;
-	unsigned long long machines_count;
-	unsigned long long usages_count;
-	unsigned long long urls_count;
-	unsigned long long persons_urls_count;
-	unsigned long long machines_urls_count;
-	unsigned long long log_count;
-
-	// memory counters / statistics
-	unsigned long long persons_memory;
-	unsigned long long machines_memory;
-	unsigned long long urls_memory;
-	unsigned long long persons_urls_memory;
-	unsigned long long machines_urls_memory;
-
-	// configuration
-	unsigned long long save_registry_every_entries;
-	char *registry_domain;
-	char *hostname;
-	char *registry_to_announce;
-	time_t persons_expiration; // seconds to expire idle persons
-	int verify_cookies_redirects;
-
-	size_t max_url_length;
-	size_t max_name_length;
-
-	// file/path names
-	char *pathname;
-	char *db_filename;
-	char *log_filename;
-	char *machine_guid_filename;
-
-	// open files
-	FILE *log_fp;
-
-	// the database
-	DICTIONARY *persons; 	// dictionary of PERSON *, with key the PERSON.guid
-	DICTIONARY *machines; 	// dictionary of MACHINE *, with key the MACHINE.guid
-	DICTIONARY *urls; 		// dictionary of URL *, with key the URL.url
-
-	// concurrency locking
-	// we keep different locks for different things
-	// so that many tasks can be completed in parallel
-	pthread_mutex_t persons_lock;
-	pthread_mutex_t machines_lock;
-	pthread_mutex_t urls_lock;
-	pthread_mutex_t person_urls_lock;
-	pthread_mutex_t machine_urls_lock;
-	pthread_mutex_t log_lock;
+    int enabled;
+
+    char machine_guid[36 + 1];
+
+    // entries counters / statistics
+    unsigned long long persons_count;
+    unsigned long long machines_count;
+    unsigned long long usages_count;
+    unsigned long long urls_count;
+    unsigned long long persons_urls_count;
+    unsigned long long machines_urls_count;
+    unsigned long long log_count;
+
+    // memory counters / statistics
+    unsigned long long persons_memory;
+    unsigned long long machines_memory;
+    unsigned long long urls_memory;
+    unsigned long long persons_urls_memory;
+    unsigned long long machines_urls_memory;
+
+    // configuration
+    unsigned long long save_registry_every_entries;
+    char *registry_domain;
+    char *hostname;
+    char *registry_to_announce;
+    time_t persons_expiration; // seconds to expire idle persons
+    int verify_cookies_redirects;
+
+    size_t max_url_length;
+    size_t max_name_length;
+
+    // file/path names
+    char *pathname;
+    char *db_filename;
+    char *log_filename;
+    char *machine_guid_filename;
+
+    // open files
+    FILE *log_fp;
+
+    // the database
+    DICTIONARY *persons;    // dictionary of PERSON *, with key the PERSON.guid
+    DICTIONARY *machines;   // dictionary of MACHINE *, with key the MACHINE.guid
+    DICTIONARY *urls;       // dictionary of URL *, with key the URL.url
+
+    // concurrency locking
+    // we keep different locks for different things
+    // so that many tasks can be completed in parallel
+    pthread_mutex_t persons_lock;
+    pthread_mutex_t machines_lock;
+    pthread_mutex_t urls_lock;
+    pthread_mutex_t person_urls_lock;
+    pthread_mutex_t machine_urls_lock;
+    pthread_mutex_t log_lock;
 } registry;
 
 
@@ -103,9 +103,9 @@ struct registry {
 // we store them here and we keep pointers elsewhere
 
 struct url {
-	uint32_t links;	// the number of links to this URL - when none is left, we free it
-	uint16_t len;	// the length of the URL in bytes
-	char url[1];	// the URL - dynamically allocated to more size
+    uint32_t links; // the number of links to this URL - when none is left, we free it
+    uint16_t len;   // the length of the URL in bytes
+    char url[1];    // the URL - dynamically allocated to more size
 };
 typedef struct url URL;
 
@@ -115,27 +115,27 @@ typedef struct url URL;
 
 // For each MACHINE-URL pair we keep this
 struct machine_url {
-	URL *url;					// de-duplicated URL
-//	DICTIONARY *persons;		// dictionary of PERSON *
+    URL *url;                   // de-duplicated URL
+//  DICTIONARY *persons;        // dictionary of PERSON *
 
-	uint8_t flags;
-	uint32_t first_t;			// the first time we saw this
-	uint32_t last_t;			// the last time we saw this
-	uint32_t usages;			// how many times this has been accessed
+    uint8_t flags;
+    uint32_t first_t;           // the first time we saw this
+    uint32_t last_t;            // the last time we saw this
+    uint32_t usages;            // how many times this has been accessed
 };
 typedef struct machine_url MACHINE_URL;
 
 // A machine
 struct machine {
-	char guid[36 + 1];			// the GUID
+    char guid[36 + 1];          // the GUID
 
-	uint32_t links;				// the number of PERSON_URLs linked to this machine
+    uint32_t links;             // the number of PERSON_URLs linked to this machine
 
-	DICTIONARY *urls; 			// MACHINE_URL *
+    DICTIONARY *urls;           // MACHINE_URL *
 
-	uint32_t first_t;			// the first time we saw this
-	uint32_t last_t;			// the last time we saw this
-	uint32_t usages;			// how many times this has been accessed
+    uint32_t first_t;           // the first time we saw this
+    uint32_t last_t;            // the last time we saw this
+    uint32_t usages;            // how many times this has been accessed
 };
 typedef struct machine MACHINE;
 
@@ -145,28 +145,28 @@ typedef struct machine MACHINE;
 
 // for each PERSON-URL pair we keep this
 struct person_url {
-	URL *url;					// de-duplicated URL
-	MACHINE *machine;			// link the MACHINE of this URL
+    URL *url;                   // de-duplicated URL
+    MACHINE *machine;           // link the MACHINE of this URL
 
-	uint8_t flags;
-	uint32_t first_t;			// the first time we saw this
-	uint32_t last_t;			// the last time we saw this
-	uint32_t usages;			// how many times this has been accessed
+    uint8_t flags;
+    uint32_t first_t;           // the first time we saw this
+    uint32_t last_t;            // the last time we saw this
+    uint32_t usages;            // how many times this has been accessed
 
-	char name[1];				// the name of the URL, as known by the user
-								// dynamically allocated to fit properly
+    char name[1];               // the name of the URL, as known by the user
+                                // dynamically allocated to fit properly
 };
 typedef struct person_url PERSON_URL;
 
 // A person
 struct person {
-	char guid[36 + 1];			// the person GUID
+    char guid[36 + 1];          // the person GUID
 
-	DICTIONARY *urls;			// dictionary of PERSON_URL *
+    DICTIONARY *urls;           // dictionary of PERSON_URL *
 
-	uint32_t first_t;			// the first time we saw this
-	uint32_t last_t;			// the last time we saw this
-	uint32_t usages;			// how many times this has been accessed
+    uint32_t first_t;           // the first time we saw this
+    uint32_t last_t;            // the last time we saw this
+    uint32_t usages;            // how many times this has been accessed
 };
 typedef struct person PERSON;
 
@@ -175,27 +175,27 @@ typedef struct person PERSON;
 // REGISTRY concurrency locking
 
 static inline void registry_persons_lock(void) {
-	pthread_mutex_lock(&registry.persons_lock);
+    pthread_mutex_lock(&registry.persons_lock);
 }
 
 static inline void registry_persons_unlock(void) {
-	pthread_mutex_unlock(&registry.persons_lock);
+    pthread_mutex_unlock(&registry.persons_lock);
 }
 
 static inline void registry_machines_lock(void) {
-	pthread_mutex_lock(&registry.machines_lock);
+    pthread_mutex_lock(&registry.machines_lock);
 }
 
 static inline void registry_machines_unlock(void) {
-	pthread_mutex_unlock(&registry.machines_lock);
+    pthread_mutex_unlock(&registry.machines_lock);
 }
 
 static inline void registry_urls_lock(void) {
-	pthread_mutex_lock(&registry.urls_lock);
+    pthread_mutex_lock(&registry.urls_lock);
 }
 
 static inline void registry_urls_unlock(void) {
-	pthread_mutex_unlock(&registry.urls_lock);
+    pthread_mutex_unlock(&registry.urls_lock);
 }
 
 // ideally, we should not lock the whole registry for
@@ -203,13 +203,13 @@ static inline void registry_urls_unlock(void) {
 // however, to save the memory required for keeping a
 // mutex (40 bytes) per person, we do...
 static inline void registry_person_urls_lock(PERSON *p) {
-	(void)p;
-	pthread_mutex_lock(&registry.person_urls_lock);
+    (void)p;
+    pthread_mutex_lock(&registry.person_urls_lock);
 }
 
 static inline void registry_person_urls_unlock(PERSON *p) {
-	(void)p;
-	pthread_mutex_unlock(&registry.person_urls_lock);
+    (void)p;
+    pthread_mutex_unlock(&registry.person_urls_lock);
 }
 
 // ideally, we should not lock the whole registry for
@@ -217,21 +217,21 @@ static inline void registry_person_urls_unlock(PERSON *p) {
 // however, to save the memory required for keeping a
 // mutex (40 bytes) per machine, we do...
 static inline void registry_machine_urls_lock(MACHINE *m) {
-	(void)m;
-	pthread_mutex_lock(&registry.machine_urls_lock);
+    (void)m;
+    pthread_mutex_lock(&registry.machine_urls_lock);
 }
 
 static inline void registry_machine_urls_unlock(MACHINE *m) {
-	(void)m;
-	pthread_mutex_unlock(&registry.machine_urls_lock);
+    (void)m;
+    pthread_mutex_unlock(&registry.machine_urls_lock);
 }
 
 static inline void registry_log_lock(void) {
-	pthread_mutex_lock(&registry.log_lock);
+    pthread_mutex_lock(&registry.log_lock);
 }
 
 static inline void registry_log_unlock(void) {
-	pthread_mutex_unlock(&registry.log_lock);
+    pthread_mutex_unlock(&registry.log_lock);
 }
 
 
@@ -241,58 +241,58 @@ static inline void registry_log_unlock(void) {
 // parse a GUID and re-generated to be always lower case
 // this is used as a protection against the variations of GUIDs
 static inline int registry_regenerate_guid(const char *guid, char *result) {
-	uuid_t uuid;
-	if(unlikely(uuid_parse(guid, uuid) == -1)) {
-		info("Registry: GUID '%s' is not a valid GUID.", guid);
-		return -1;
-	}
-	else {
-		uuid_unparse_lower(uuid, result);
+    uuid_t uuid;
+    if(unlikely(uuid_parse(guid, uuid) == -1)) {
+        info("Registry: GUID '%s' is not a valid GUID.", guid);
+        return -1;
+    }
+    else {
+        uuid_unparse_lower(uuid, result);
 
 #ifdef NETDATA_INTERNAL_CHECKS
-		if(strcmp(guid, result))
-			info("Registry: source GUID '%s' and re-generated GUID '%s' differ!", guid, result);
+        if(strcmp(guid, result))
+            info("Registry: source GUID '%s' and re-generated GUID '%s' differ!", guid, result);
 #endif /* NETDATA_INTERNAL_CHECKS */
-	}
+    }
 
-	return 0;
+    return 0;
 }
 
 // make sure the names of the machines / URLs do not contain any tabs
 // (which are used as our separator in the database files)
 // and are properly trimmed (before and after)
 static inline char *registry_fix_machine_name(char *name, size_t *len) {
-	char *s = name?name:"";
+    char *s = name?name:"";
 
-	// skip leading spaces
-	while(*s && isspace(*s)) s++;
+    // skip leading spaces
+    while(*s && isspace(*s)) s++;
 
-	// make sure all spaces are a SPACE
-	char *t = s;
-	while(*t) {
-		if(unlikely(isspace(*t)))
-			*t = ' ';
+    // make sure all spaces are a SPACE
+    char *t = s;
+    while(*t) {
+        if(unlikely(isspace(*t)))
+            *t = ' ';
 
-		t++;
-	}
+        t++;
+    }
 
-	// remove trailing spaces
-	while(--t >= s) {
-		if(*t == ' ')
-			*t = '\0';
-		else
-			break;
-	}
-	t++;
+    // remove trailing spaces
+    while(--t >= s) {
+        if(*t == ' ')
+            *t = '\0';
+        else
+            break;
+    }
+    t++;
 
-	if(likely(len))
-		*len = (t - s);
+    if(likely(len))
+        *len = (t - s);
 
-	return s;
+    return s;
 }
 
 static inline char *registry_fix_url(char *url, size_t *len) {
-	return registry_fix_machine_name(url, len);
+    return registry_fix_machine_name(url, len);
 }
 
 
@@ -307,57 +307,57 @@ extern PERSON *registry_request_delete(char *person_guid, char *machine_guid, ch
 // URL
 
 static inline URL *registry_url_allocate_nolock(const char *url, size_t urllen) {
-	// protection from too big URLs
-	if(urllen > registry.max_url_length)
-		urllen = registry.max_url_length;
+    // protection from too big URLs
+    if(urllen > registry.max_url_length)
+        urllen = registry.max_url_length;
 
-	debug(D_REGISTRY, "Registry: registry_url_allocate_nolock('%s'): allocating %zu bytes", url, sizeof(URL) + urllen);
-	URL *u = mallocz(sizeof(URL) + urllen);
+    debug(D_REGISTRY, "Registry: registry_url_allocate_nolock('%s'): allocating %zu bytes", url, sizeof(URL) + urllen);
+    URL *u = mallocz(sizeof(URL) + urllen);
 
-	// a simple strcpy() should do the job
-	// but I prefer to be safe, since the caller specified urllen
-	u->len = (uint16_t)urllen;
-	strncpyz(u->url, url, u->len);
-	u->links = 0;
+    // a simple strcpy() should do the job
+    // but I prefer to be safe, since the caller specified urllen
+    u->len = (uint16_t)urllen;
+    strncpyz(u->url, url, u->len);
+    u->links = 0;
 
-	registry.urls_memory += sizeof(URL) + urllen;
+    registry.urls_memory += sizeof(URL) + urllen;
 
-	debug(D_REGISTRY, "Registry: registry_url_allocate_nolock('%s'): indexing it", url);
-	dictionary_set(registry.urls, u->url, u, sizeof(URL));
+    debug(D_REGISTRY, "Registry: registry_url_allocate_nolock('%s'): indexing it", url);
+    dictionary_set(registry.urls, u->url, u, sizeof(URL));
 
-	return u;
+    return u;
 }
 
 static inline URL *registry_url_get(const char *url, size_t urllen) {
-	debug(D_REGISTRY, "Registry: registry_url_get('%s')", url);
+    debug(D_REGISTRY, "Registry: registry_url_get('%s')", url);
 
-	registry_urls_lock();
+    registry_urls_lock();
 
-	URL *u = dictionary_get(registry.urls, url);
-	if(!u) {
-		u = registry_url_allocate_nolock(url, urllen);
-		registry.urls_count++;
-	}
+    URL *u = dictionary_get(registry.urls, url);
+    if(!u) {
+        u = registry_url_allocate_nolock(url, urllen);
+        registry.urls_count++;
+    }
 
-	registry_urls_unlock();
+    registry_urls_unlock();
 
-	return u;
+    return u;
 }
 
 static inline void registry_url_link_nolock(URL *u) {
-	u->links++;
-	debug(D_REGISTRY, "Registry: registry_url_link_nolock('%s'): URL has now %u links", u->url, u->links);
+    u->links++;
+    debug(D_REGISTRY, "Registry: registry_url_link_nolock('%s'): URL has now %u links", u->url, u->links);
 }
 
 static inline void registry_url_unlink_nolock(URL *u) {
-	u->links--;
-	if(!u->links) {
-		debug(D_REGISTRY, "Registry: registry_url_unlink_nolock('%s'): No more links for this URL", u->url);
-		dictionary_del(registry.urls, u->url);
-		freez(u);
-	}
-	else
-		debug(D_REGISTRY, "Registry: registry_url_unlink_nolock('%s'): URL has %u links left", u->url, u->links);
+    u->links--;
+    if(!u->links) {
+        debug(D_REGISTRY, "Registry: registry_url_unlink_nolock('%s'): No more links for this URL", u->url);
+        dictionary_del(registry.urls, u->url);
+        freez(u);
+    }
+    else
+        debug(D_REGISTRY, "Registry: registry_url_unlink_nolock('%s'): URL has %u links left", u->url, u->links);
 }
 
 
@@ -365,76 +365,76 @@ static inline void registry_url_unlink_nolock(URL *u) {
 // MACHINE
 
 static inline MACHINE *registry_machine_find(const char *machine_guid) {
-	debug(D_REGISTRY, "Registry: registry_machine_find('%s')", machine_guid);
-	return dictionary_get(registry.machines, machine_guid);
+    debug(D_REGISTRY, "Registry: registry_machine_find('%s')", machine_guid);
+    return dictionary_get(registry.machines, machine_guid);
 }
 
 static inline MACHINE_URL *registry_machine_url_allocate(MACHINE *m, URL *u, time_t when) {
-	debug(D_REGISTRY, "registry_machine_link_to_url('%s', '%s'): allocating %zu bytes", m->guid, u->url, sizeof(MACHINE_URL));
+    debug(D_REGISTRY, "registry_machine_link_to_url('%s', '%s'): allocating %zu bytes", m->guid, u->url, sizeof(MACHINE_URL));
 
-	MACHINE_URL *mu = mallocz(sizeof(MACHINE_URL));
+    MACHINE_URL *mu = mallocz(sizeof(MACHINE_URL));
 
-	// mu->persons = dictionary_create(DICTIONARY_FLAGS);
-	// dictionary_set(mu->persons, p->guid, p, sizeof(PERSON));
+    // mu->persons = dictionary_create(DICTIONARY_FLAGS);
+    // dictionary_set(mu->persons, p->guid, p, sizeof(PERSON));
 
-	mu->first_t = mu->last_t = (uint32_t)when;
-	mu->usages = 1;
-	mu->url = u;
-	mu->flags = REGISTRY_URL_FLAGS_DEFAULT;
+    mu->first_t = mu->last_t = (uint32_t)when;
+    mu->usages = 1;
+    mu->url = u;
+    mu->flags = REGISTRY_URL_FLAGS_DEFAULT;
 
-	registry.machines_urls_memory += sizeof(MACHINE_URL);
+    registry.machines_urls_memory += sizeof(MACHINE_URL);
 
-	debug(D_REGISTRY, "registry_machine_link_to_url('%s', '%s'): indexing URL in machine", m->guid, u->url);
-	dictionary_set(m->urls, u->url, mu, sizeof(MACHINE_URL));
-	registry_url_link_nolock(u);
+    debug(D_REGISTRY, "registry_machine_link_to_url('%s', '%s'): indexing URL in machine", m->guid, u->url);
+    dictionary_set(m->urls, u->url, mu, sizeof(MACHINE_URL));
+    registry_url_link_nolock(u);
 
-	return mu;
+    return mu;
 }
 
 static inline MACHINE *registry_machine_allocate(const char *machine_guid, time_t when) {
-	debug(D_REGISTRY, "Registry: registry_machine_allocate('%s'): creating new machine, sizeof(MACHINE)=%zu", machine_guid, sizeof(MACHINE));
+    debug(D_REGISTRY, "Registry: registry_machine_allocate('%s'): creating new machine, sizeof(MACHINE)=%zu", machine_guid, sizeof(MACHINE));
 
-	MACHINE *m = mallocz(sizeof(MACHINE));
+    MACHINE *m = mallocz(sizeof(MACHINE));
 
-	strncpyz(m->guid, machine_guid, 36);
+    strncpyz(m->guid, machine_guid, 36);
 
-	debug(D_REGISTRY, "Registry: registry_machine_allocate('%s'): creating dictionary of urls", machine_guid);
-	m->urls = dictionary_create(DICTIONARY_FLAGS);
+    debug(D_REGISTRY, "Registry: registry_machine_allocate('%s'): creating dictionary of urls", machine_guid);
+    m->urls = dictionary_create(DICTIONARY_FLAGS);
 
-	m->first_t = m->last_t = (uint32_t)when;
-	m->usages = 0;
+    m->first_t = m->last_t = (uint32_t)when;
+    m->usages = 0;
 
-	registry.machines_memory += sizeof(MACHINE);
+    registry.machines_memory += sizeof(MACHINE);
 
-	registry.machines_count++;
-	dictionary_set(registry.machines, m->guid, m, sizeof(MACHINE));
+    registry.machines_count++;
+    dictionary_set(registry.machines, m->guid, m, sizeof(MACHINE));
 
-	return m;
+    return m;
 }
 
 // 1. validate machine GUID
 // 2. if it is valid, find it or create it and return it
 // 3. if it is not valid, return NULL
 static inline MACHINE *registry_machine_get(const char *machine_guid, time_t when) {
-	MACHINE *m = NULL;
+    MACHINE *m = NULL;
 
-	registry_machines_lock();
+    registry_machines_lock();
 
-	if(likely(machine_guid && *machine_guid)) {
-		// validate it is a GUID
-		char buf[36 + 1];
-		if(unlikely(registry_regenerate_guid(machine_guid, buf) == -1))
-			info("Registry: machine guid '%s' is not a valid guid. Ignoring it.", machine_guid);
-		else {
-			machine_guid = buf;
-			m = registry_machine_find(machine_guid);
-			if(!m) m = registry_machine_allocate(machine_guid, when);
-		}
-	}
+    if(likely(machine_guid && *machine_guid)) {
+        // validate it is a GUID
+        char buf[36 + 1];
+        if(unlikely(registry_regenerate_guid(machine_guid, buf) == -1))
+            info("Registry: machine guid '%s' is not a valid guid. Ignoring it.", machine_guid);
+        else {
+            machine_guid = buf;
+            m = registry_machine_find(machine_guid);
+            if(!m) m = registry_machine_allocate(machine_guid, when);
+        }
+    }
 
-	registry_machines_unlock();
+    registry_machines_unlock();
 
-	return m;
+    return m;
 }
 
 
@@ -442,99 +442,99 @@ static inline MACHINE *registry_machine_get(const char *machine_guid, time_t whe
 // PERSON
 
 static inline PERSON *registry_person_find(const char *person_guid) {
-	debug(D_REGISTRY, "Registry: registry_person_find('%s')", person_guid);
-	return dictionary_get(registry.persons, person_guid);
+    debug(D_REGISTRY, "Registry: registry_person_find('%s')", person_guid);
+    return dictionary_get(registry.persons, person_guid);
 }
 
 static inline PERSON_URL *registry_person_url_allocate(PERSON *p, MACHINE *m, URL *u, char *name, size_t namelen, time_t when) {
-	// protection from too big names
-	if(namelen > registry.max_name_length)
-		namelen = registry.max_name_length;
+    // protection from too big names
+    if(namelen > registry.max_name_length)
+        namelen = registry.max_name_length;
 
-	debug(D_REGISTRY, "registry_person_url_allocate('%s', '%s', '%s'): allocating %zu bytes", p->guid, m->guid, u->url,
-		  sizeof(PERSON_URL) + namelen);
+    debug(D_REGISTRY, "registry_person_url_allocate('%s', '%s', '%s'): allocating %zu bytes", p->guid, m->guid, u->url,
+          sizeof(PERSON_URL) + namelen);
 
-	PERSON_URL *pu = mallocz(sizeof(PERSON_URL) + namelen);
+    PERSON_URL *pu = mallocz(sizeof(PERSON_URL) + namelen);
 
-	// a simple strcpy() should do the job
-	// but I prefer to be safe, since the caller specified urllen
-	strncpyz(pu->name, name, namelen);
+    // a simple strcpy() should do the job
+    // but I prefer to be safe, since the caller specified urllen
+    strncpyz(pu->name, name, namelen);
 
-	pu->machine = m;
-	pu->first_t = pu->last_t = when;
-	pu->usages = 1;
-	pu->url = u;
-	pu->flags = REGISTRY_URL_FLAGS_DEFAULT;
-	m->links++;
+    pu->machine = m;
+    pu->first_t = pu->last_t = when;
+    pu->usages = 1;
+    pu->url = u;
+    pu->flags = REGISTRY_URL_FLAGS_DEFAULT;
+    m->links++;
 
-	registry.persons_urls_memory += sizeof(PERSON_URL) + namelen;
+    registry.persons_urls_memory += sizeof(PERSON_URL) + namelen;
 
-	debug(D_REGISTRY, "registry_person_url_allocate('%s', '%s', '%s'): indexing URL in person", p->guid, m->guid, u->url);
-	dictionary_set(p->urls, u->url, pu, sizeof(PERSON_URL));
-	registry_url_link_nolock(u);
+    debug(D_REGISTRY, "registry_person_url_allocate('%s', '%s', '%s'): indexing URL in person", p->guid, m->guid, u->url);
+    dictionary_set(p->urls, u->url, pu, sizeof(PERSON_URL));
+    registry_url_link_nolock(u);
 
-	return pu;
+    return pu;
 }
 
 static inline PERSON_URL *registry_person_url_reallocate(PERSON *p, MACHINE *m, URL *u, char *name, size_t namelen, time_t when, PERSON_URL *pu) {
-	// this function is needed to change the name of a PERSON_URL
+    // this function is needed to change the name of a PERSON_URL
 
-	debug(D_REGISTRY, "registry_person_url_reallocate('%s', '%s', '%s'): allocating %zu bytes", p->guid, m->guid, u->url,
-		  sizeof(PERSON_URL) + namelen);
+    debug(D_REGISTRY, "registry_person_url_reallocate('%s', '%s', '%s'): allocating %zu bytes", p->guid, m->guid, u->url,
+          sizeof(PERSON_URL) + namelen);
 
-	PERSON_URL *tpu = registry_person_url_allocate(p, m, u, name, namelen, when);
-	tpu->first_t = pu->first_t;
-	tpu->last_t = pu->last_t;
-	tpu->usages = pu->usages;
+    PERSON_URL *tpu = registry_person_url_allocate(p, m, u, name, namelen, when);
+    tpu->first_t = pu->first_t;
+    tpu->last_t = pu->last_t;
+    tpu->usages = pu->usages;
 
-	// ok, these are a hack - since the registry_person_url_allocate() is
-	// adding these, we have to subtract them
-	tpu->machine->links--;
-	registry.persons_urls_memory -= sizeof(PERSON_URL) + strlen(pu->name);
-	registry_url_unlink_nolock(u);
+    // ok, these are a hack - since the registry_person_url_allocate() is
+    // adding these, we have to subtract them
+    tpu->machine->links--;
+    registry.persons_urls_memory -= sizeof(PERSON_URL) + strlen(pu->name);
+    registry_url_unlink_nolock(u);
 
-	freez(pu);
+    freez(pu);
 
-	return tpu;
+    return tpu;
 }
 
 static inline PERSON *registry_person_allocate(const char *person_guid, time_t when) {
-	PERSON *p = NULL;
+    PERSON *p = NULL;
 
-	debug(D_REGISTRY, "Registry: registry_person_allocate('%s'): allocating new person, sizeof(PERSON)=%zu", (person_guid)?person_guid:"", sizeof(PERSON));
+    debug(D_REGISTRY, "Registry: registry_person_allocate('%s'): allocating new person, sizeof(PERSON)=%zu", (person_guid)?person_guid:"", sizeof(PERSON));
 
-	p = mallocz(sizeof(PERSON));
+    p = mallocz(sizeof(PERSON));
 
-	if(!person_guid) {
-		for (; ;) {
-			uuid_t uuid;
-			uuid_generate(uuid);
-			uuid_unparse_lower(uuid, p->guid);
+    if(!person_guid) {
+        for (; ;) {
+            uuid_t uuid;
+            uuid_generate(uuid);
+            uuid_unparse_lower(uuid, p->guid);
 
-			debug(D_REGISTRY, "Registry: Checking if the generated person guid '%s' is unique", p->guid);
-			if (!dictionary_get(registry.persons, p->guid)) {
-				debug(D_REGISTRY, "Registry: generated person guid '%s' is unique", p->guid);
-				break;
-			}
-			else
-				info("Registry: generated person guid '%s' found in the registry. Retrying...", p->guid);
-		}
-	}
-	else
-		strncpyz(p->guid, person_guid, 36);
+            debug(D_REGISTRY, "Registry: Checking if the generated person guid '%s' is unique", p->guid);
+            if (!dictionary_get(registry.persons, p->guid)) {
+                debug(D_REGISTRY, "Registry: generated person guid '%s' is unique", p->guid);
+                break;
+            }
+            else
+                info("Registry: generated person guid '%s' found in the registry. Retrying...", p->guid);
+        }
+    }
+    else
+        strncpyz(p->guid, person_guid, 36);
 
-	debug(D_REGISTRY, "Registry: registry_person_allocate('%s'): creating dictionary of urls", p->guid);
-	p->urls = dictionary_create(DICTIONARY_FLAGS);
+    debug(D_REGISTRY, "Registry: registry_person_allocate('%s'): creating dictionary of urls", p->guid);
+    p->urls = dictionary_create(DICTIONARY_FLAGS);
 
-	p->first_t = p->last_t = when;
-	p->usages = 0;
+    p->first_t = p->last_t = when;
+    p->usages = 0;
 
-	registry.persons_memory += sizeof(PERSON);
+    registry.persons_memory += sizeof(PERSON);
 
-	registry.persons_count++;
-	dictionary_set(registry.persons, p->guid, p, sizeof(PERSON));
+    registry.persons_count++;
+    dictionary_set(registry.persons, p->guid, p, sizeof(PERSON));
 
-	return p;
+    return p;
 }
 
 
@@ -543,260 +543,260 @@ static inline PERSON *registry_person_allocate(const char *person_guid, time_t w
 // 3. if it is not valid, create a new one
 // 4. return it
 static inline PERSON *registry_person_get(const char *person_guid, time_t when) {
-	PERSON *p = NULL;
+    PERSON *p = NULL;
 
-	registry_persons_lock();
+    registry_persons_lock();
 
-	if(person_guid && *person_guid) {
-		char buf[36 + 1];
-		// validate it is a GUID
-		if(unlikely(registry_regenerate_guid(person_guid, buf) == -1))
-			info("Registry: person guid '%s' is not a valid guid. Ignoring it.", person_guid);
-		else {
-			person_guid = buf;
-			p = registry_person_find(person_guid);
-			if(!p) person_guid = NULL;
-		}
-	}
+    if(person_guid && *person_guid) {
+        char buf[36 + 1];
+        // validate it is a GUID
+        if(unlikely(registry_regenerate_guid(person_guid, buf) == -1))
+            info("Registry: person guid '%s' is not a valid guid. Ignoring it.", person_guid);
+        else {
+            person_guid = buf;
+            p = registry_person_find(person_guid);
+            if(!p) person_guid = NULL;
+        }
+    }
 
-	if(!p) p = registry_person_allocate(NULL, when);
+    if(!p) p = registry_person_allocate(NULL, when);
 
-	registry_persons_unlock();
+    registry_persons_unlock();
 
-	return p;
+    return p;
 }
 
 // ----------------------------------------------------------------------------
 // LINKING OF OBJECTS
 
 static inline PERSON_URL *registry_person_link_to_url(PERSON *p, MACHINE *m, URL *u, char *name, size_t namelen, time_t when) {
-	debug(D_REGISTRY, "registry_person_link_to_url('%s', '%s', '%s'): searching for URL in person", p->guid, m->guid, u->url);
-
-	registry_person_urls_lock(p);
-
-	PERSON_URL *pu = dictionary_get(p->urls, u->url);
-	if(!pu) {
-		debug(D_REGISTRY, "registry_person_link_to_url('%s', '%s', '%s'): not found", p->guid, m->guid, u->url);
-		pu = registry_person_url_allocate(p, m, u, name, namelen, when);
-		registry.persons_urls_count++;
-	}
-	else {
-		debug(D_REGISTRY, "registry_person_link_to_url('%s', '%s', '%s'): found", p->guid, m->guid, u->url);
-		pu->usages++;
-		if(likely(pu->last_t < (uint32_t)when)) pu->last_t = when;
-
-		if(pu->machine != m) {
-			MACHINE_URL *mu = dictionary_get(pu->machine->urls, u->url);
-			if(mu) {
-				info("registry_person_link_to_url('%s', '%s', '%s'): URL switched machines (old was '%s') - expiring it from previous machine.",
-					 p->guid, m->guid, u->url, pu->machine->guid);
-				mu->flags |= REGISTRY_URL_FLAGS_EXPIRED;
-			}
-			else {
-				info("registry_person_link_to_url('%s', '%s', '%s'): URL switched machines (old was '%s') - but the URL is not linked to the old machine.",
-					 p->guid, m->guid, u->url, pu->machine->guid);
-			}
-
-			pu->machine->links--;
-			pu->machine = m;
-		}
-
-		if(strcmp(pu->name, name)) {
-			// the name of the PERSON_URL has changed !
-			pu = registry_person_url_reallocate(p, m, u, name, namelen, when, pu);
-		}
-	}
-
-	p->usages++;
-	if(likely(p->last_t < (uint32_t)when)) p->last_t = when;
-
-	if(pu->flags & REGISTRY_URL_FLAGS_EXPIRED) {
-		info("registry_person_link_to_url('%s', '%s', '%s'): accessing an expired URL. Re-enabling URL.", p->guid, m->guid, u->url);
-		pu->flags &= ~REGISTRY_URL_FLAGS_EXPIRED;
-	}
-
-	registry_person_urls_unlock(p);
-
-	return pu;
+    debug(D_REGISTRY, "registry_person_link_to_url('%s', '%s', '%s'): searching for URL in person", p->guid, m->guid, u->url);
+
+    registry_person_urls_lock(p);
+
+    PERSON_URL *pu = dictionary_get(p->urls, u->url);
+    if(!pu) {
+        debug(D_REGISTRY, "registry_person_link_to_url('%s', '%s', '%s'): not found", p->guid, m->guid, u->url);
+        pu = registry_person_url_allocate(p, m, u, name, namelen, when);
+        registry.persons_urls_count++;
+    }
+    else {
+        debug(D_REGISTRY, "registry_person_link_to_url('%s', '%s', '%s'): found", p->guid, m->guid, u->url);
+        pu->usages++;
+        if(likely(pu->last_t < (uint32_t)when)) pu->last_t = when;
+
+        if(pu->machine != m) {
+            MACHINE_URL *mu = dictionary_get(pu->machine->urls, u->url);
+            if(mu) {
+                info("registry_person_link_to_url('%s', '%s', '%s'): URL switched machines (old was '%s') - expiring it from previous machine.",
+                     p->guid, m->guid, u->url, pu->machine->guid);
+                mu->flags |= REGISTRY_URL_FLAGS_EXPIRED;
+            }
+            else {
+                info("registry_person_link_to_url('%s', '%s', '%s'): URL switched machines (old was '%s') - but the URL is not linked to the old machine.",
+                     p->guid, m->guid, u->url, pu->machine->guid);
+            }
+
+            pu->machine->links--;
+            pu->machine = m;
+        }
+
+        if(strcmp(pu->name, name)) {
+            // the name of the PERSON_URL has changed !
+            pu = registry_person_url_reallocate(p, m, u, name, namelen, when, pu);
+        }
+    }
+
+    p->usages++;
+    if(likely(p->last_t < (uint32_t)when)) p->last_t = when;
+
+    if(pu->flags & REGISTRY_URL_FLAGS_EXPIRED) {
+        info("registry_person_link_to_url('%s', '%s', '%s'): accessing an expired URL. Re-enabling URL.", p->guid, m->guid, u->url);
+        pu->flags &= ~REGISTRY_URL_FLAGS_EXPIRED;
+    }
+
+    registry_person_urls_unlock(p);
+
+    return pu;
 }
 
 static inline MACHINE_URL *registry_machine_link_to_url(PERSON *p, MACHINE *m, URL *u, time_t when) {
-	debug(D_REGISTRY, "registry_machine_link_to_url('%s', '%s', '%s'): searching for URL in machine", p->guid, m->guid, u->url);
+    debug(D_REGISTRY, "registry_machine_link_to_url('%s', '%s', '%s'): searching for URL in machine", p->guid, m->guid, u->url);
 
-	registry_machine_urls_lock(m);
+    registry_machine_urls_lock(m);
 
-	MACHINE_URL *mu = dictionary_get(m->urls, u->url);
-	if(!mu) {
-		debug(D_REGISTRY, "registry_machine_link_to_url('%s', '%s', '%s'): not found", p->guid, m->guid, u->url);
-		mu = registry_machine_url_allocate(m, u, when);
-		registry.machines_urls_count++;
-	}
-	else {
-		debug(D_REGISTRY, "registry_machine_link_to_url('%s', '%s', '%s'): found", p->guid, m->guid, u->url);
-		mu->usages++;
-		if(likely(mu->last_t < (uint32_t)when)) mu->last_t = when;
-	}
+    MACHINE_URL *mu = dictionary_get(m->urls, u->url);
+    if(!mu) {
+        debug(D_REGISTRY, "registry_machine_link_to_url('%s', '%s', '%s'): not found", p->guid, m->guid, u->url);
+        mu = registry_machine_url_allocate(m, u, when);
+        registry.machines_urls_count++;
+    }
+    else {
+        debug(D_REGISTRY, "registry_machine_link_to_url('%s', '%s', '%s'): found", p->guid, m->guid, u->url);
+        mu->usages++;
+        if(likely(mu->last_t < (uint32_t)when)) mu->last_t = when;
+    }
 
-	//debug(D_REGISTRY, "registry_machine_link_to_url('%s', '%s', '%s'): indexing person in machine", p->guid, m->guid, u->url);
-	//dictionary_set(mu->persons, p->guid, p, sizeof(PERSON));
+    //debug(D_REGISTRY, "registry_machine_link_to_url('%s', '%s', '%s'): indexing person in machine", p->guid, m->guid, u->url);
+    //dictionary_set(mu->persons, p->guid, p, sizeof(PERSON));
 
-	m->usages++;
-	if(likely(m->last_t < (uint32_t)when)) m->last_t = when;
+    m->usages++;
+    if(likely(m->last_t < (uint32_t)when)) m->last_t = when;
 
-	if(mu->flags & REGISTRY_URL_FLAGS_EXPIRED) {
-		info("registry_machine_link_to_url('%s', '%s', '%s'): accessing an expired URL.", p->guid, m->guid, u->url);
-		mu->flags &= ~REGISTRY_URL_FLAGS_EXPIRED;
-	}
+    if(mu->flags & REGISTRY_URL_FLAGS_EXPIRED) {
+        info("registry_machine_link_to_url('%s', '%s', '%s'): accessing an expired URL.", p->guid, m->guid, u->url);
+        mu->flags &=