pnx/archived
Archived
1
0
Fork 0
Code Activity

Change indentation to follow the updated standard.

Browse source 
Alot of mixed indentation. use 4 chars wide soft tabs.
This commit is contained in:
Henrik Hautakoski 2011-03-19 12:28:48 +02:00
parent 9cc5420447
commit f46ae1970b
51 changed files with 634 additions and 639 deletions
Download patch file Download diff file Expand all files Collapse all files

46
src/archived.c
View file

@ -6,7 +6,7 @@
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
@ -52,36 +52,36 @@ static int load_config(const char *file) {
when in main loop is by signal */
static void clean_exit(int excode) {
time_t t = time(NULL);
time_t t = time(NULL);
notify_exit();
notify_exit();
database_close();
database_close();
iniparser_freedict(config);
printf("\nprocess exit at: %s", ctime(&t));
exit(excode);
printf("\nprocess exit at: %s", ctime(&t));
exit(excode);
}
/* Signal handler */
static void sighandl(int sig) {
switch(sig) {
/* normal exit signals */
case SIGTERM :
case SIGKILL :
case SIGINT :
clean_exit(EXIT_SUCCESS);
/* segmentation violation, let user now */
case SIGSEGV :
fprintf(stderr, "SEGFAULT: o no he didn't\n");
clean_exit(EXIT_FAILURE);
case SIGUSR1 :
case SIGUSR2 :
printf("notify stat:\n");
notify_stat();
}
switch(sig) {
/* normal exit signals */
case SIGTERM :
case SIGKILL :
case SIGINT :
clean_exit(EXIT_SUCCESS);
/* segmentation violation, let user now */
case SIGSEGV :
fprintf(stderr, "SEGFAULT: o no he didn't\n");
clean_exit(EXIT_FAILURE);
case SIGUSR1 :
case SIGUSR2 :
printf("notify stat:\n");
notify_stat();
}
}
/*
@ -97,7 +97,7 @@ static void main_loop() {
if (event == NULL)
continue;
logmsg(LOG_DEBUG, "%s: (%c) %s%s", notify_event_typetostr(event),
event->dir ? 'D' : 'F', event->path, event->filename);
@ -163,7 +163,7 @@ int main(int argc, char **argv) {
} else {
die("config (log:level): no levels defined\n");
}
init_log(level, path);
}

2
src/database.h
View file

@ -7,7 +7,7 @@
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*/
#ifndef __DATABASE_H
#define __DATABASE_H

12
src/database/mongo.c
View file

@ -55,7 +55,7 @@ int database_init(dictionary *conf) {
char *confdb = iniparser_getstring(conf, "mongo:database", NULL);
char *confcoll = iniparser_getstring(conf, "mongo:collection", NULL);
if (!confcoll) {
fprintf(stderr, "mongo: missing 'collection' in configuration\n");
return -1;
@ -67,13 +67,13 @@ int database_init(dictionary *conf) {
strncpy(db.opts.host, iniparser_getstring(conf, "mongo:host", "127.0.0.1"), sizeof(db.opts.host));
db.opts.port = iniparser_getint(conf, "mongo:port", 27017);
mongo_conn_return status = mongo_connect(&db.conn, &db.opts);
if (status != mongo_conn_success) {
char *err;
switch (status) {
case mongo_conn_bad_arg :
err = "Bad arguments";
@ -90,7 +90,7 @@ int database_init(dictionary *conf) {
default:
err = "Unkown error";
}
fprintf(stderr, "mongo: %s (%s:%i)\n", err, db.opts.host, db.opts.port);
return -1;
}
@ -115,7 +115,7 @@ int database_init(dictionary *conf) {
/* prepare collection */
coll_clear();
coll_create_index();
return 0;
}
@ -159,7 +159,7 @@ int database_delete(const char *path, const char *filename) {
bson_buffer_init(&buf);
bson_append_regex(&buf, "Path", fpath, "");
bson_from_buffer(&cond, &buf);
mongo_remove(&db.conn, db.ns, &cond);
bson_destroy(&cond);

8
src/database/mysql.c
View file

@ -30,9 +30,9 @@ static char* escape(const char *str) {
size_t len = strlen(str);
char *esc = xmalloc(len * 2 + 1);
mysql_real_escape_string(db.connection, esc, str, len);
return esc;
}
@ -158,13 +158,13 @@ int database_insert(const char *path, const char *filename, const int isdir) {
fprintf(stderr, "mysql: Lost connection to database. Could not reconnect\n");
return -1;
}
/* Escape the strings */
escaped_path = escape(path);
escaped_filename = escape(filename);
stmt = xmalloc(strlen(stmt_insert) + strlen(db.table) + strlen(escaped_path) + strlen(escaped_filename) - 6);
/* Create mysql query */
sprintf(stmt, stmt_insert, db.table, escaped_path, escaped_filename, isdir != 0);

126
src/event.c
View file

@ -1,5 +1,5 @@
/* event.c
*
*
* (C) Copyright 2010 Henrik Hautakoski <henrik@fiktivkod.org>
* (C) Copyright 2010 Fredric Nilsson <fredric@fiktivkod.org>
*
@ -14,29 +14,29 @@
#include "xalloc.h"
#define dealloc_data(ev) \
if (ev->path) \
xfree(ev->path); \
if (ev->filename) \
xfree(ev->filename)
if (ev->path) \
xfree(ev->path); \
if (ev->filename) \
xfree(ev->filename)
static void init_event(notify_event* ev) {
ev->filename = NULL;
ev->path = NULL;
ev->type = NOTIFY_UNKNOWN;
ev->dir = 0;
ev->filename = NULL;
ev->path = NULL;
ev->type = NOTIFY_UNKNOWN;
ev->dir = 0;
}
/*
* Create event
*/
notify_event* notify_event_new() {
notify_event *ev = xmalloc(sizeof(notify_event));
init_event(ev);
return ev;
notify_event *ev = xmalloc(sizeof(notify_event));
init_event(ev);
return ev;
}
/*
@ -44,11 +44,11 @@ notify_event* notify_event_new() {
*/
void notify_event_del(notify_event *event) {
if (event == NULL)
return;
dealloc_data(event);
xfree(event);
if (event == NULL)
return;
dealloc_data(event);
xfree(event);
}
/*
@ -56,74 +56,74 @@ void notify_event_del(notify_event *event) {
*/
void notify_event_clear(notify_event *event) {
if (event == NULL)
return;
if (event == NULL)
return;
dealloc_data(event);
init_event(event);
dealloc_data(event);
init_event(event);
}
/*
* Set event path
*/
void notify_event_set_path(notify_event *event, const char *path) {
if (event == NULL || path == NULL)
return;
event->path = xrealloc(event->path, strlen(path)+1);
memcpy(event->path, path, strlen(path)+1);
if (event == NULL || path == NULL)
return;
event->path = xrealloc(event->path, strlen(path)+1);
memcpy(event->path, path, strlen(path)+1);
}
/*
* Set event filename
*/
void notify_event_set_filename(notify_event *event, const char *filename) {
if (event == NULL || filename == NULL)
return;
event->filename = xrealloc(event->filename, strlen(filename)+1);
memcpy(event->filename, filename, strlen(filename)+1);
if (event == NULL || filename == NULL)
return;
event->filename = xrealloc(event->filename, strlen(filename)+1);
memcpy(event->filename, filename, strlen(filename)+1);
}
/* set directory */
void notify_event_set_dir(notify_event *event, uint8_t dir) {
if (event == NULL)
return;
if (event == NULL)
return;
event->dir = dir;
event->dir = dir;
}
void notify_event_set_type(notify_event *event, uint8_t type) {
if (event == NULL)
return;
event->type = type;
if (event == NULL)
return;
event->type = type;
}
const char* notify_event_typetostr(notify_event *event) {
if (!event)
return "(null)";
switch(event->type) {
case NOTIFY_CREATE :
return "CREATE";
case NOTIFY_DELETE :
return "DELETE";
break;
case NOTIFY_MOVE_FROM :
return "MOVE_FROM";
break;
case NOTIFY_MOVE_TO :
return "MOVE_TO";
break;
default:
return "UNKNOWN";
}
switch(event->type) {
case NOTIFY_CREATE :
return "CREATE";
case NOTIFY_DELETE :
return "DELETE";
break;
case NOTIFY_MOVE_FROM :
return "MOVE_FROM";
break;
case NOTIFY_MOVE_TO :
return "MOVE_TO";
break;
default:
return "UNKNOWN";
}
}

20
src/event.h
View file

@ -1,5 +1,5 @@
/* event.h - event data structure and operation's for notify API
*
*
* (C) Copyright 2010 Henrik Hautakoski <henrik@fiktivkod.org>
* (C) Copyright 2010 Fredric Nilsson <fredric@fiktivkod.org>
*
@ -15,17 +15,17 @@
#include <stdint.h>
/* event types */
#define NOTIFY_UNKNOWN (1 << 0)
#define NOTIFY_CREATE (1 << 1)
#define NOTIFY_DELETE (1 << 2)
#define NOTIFY_MOVE_FROM (1 << 3)
#define NOTIFY_MOVE_TO (1 << 4)
#define NOTIFY_UNKNOWN (1 << 0)
#define NOTIFY_CREATE (1 << 1)
#define NOTIFY_DELETE (1 << 2)
#define NOTIFY_MOVE_FROM (1 << 3)
#define NOTIFY_MOVE_TO (1 << 4)
typedef struct {
uint8_t type; /* type of event */
uint8_t dir; /* non zero if event is triggered on a directory */
char *path; /* path of the triggered event */
char *filename; /* the filename event was triggered on */
uint8_t type; /* type of event */
uint8_t dir; /* non zero if event is triggered on a directory */
char *path; /* path of the triggered event */
char *filename; /* the filename event was triggered on */
} notify_event;
notify_event* notify_event_new();

40
src/fscrawl.c
View file

@ -26,7 +26,7 @@
(x)->fts_info == FTS_SLNONE)
struct __fscrawl {
FTS *fts;
FTS *fts;
fs_entry ent;
};
@ -43,11 +43,11 @@ static fs_entry* ftsentcpy(fs_entry *dest, FTSENT *src) {
if (len > 0) {
char *newbase = realloc(dest->base, len + 1);
if (newbase) {
memcpy(newbase, src->fts_path, len);
newbase[len] = '\0';
dest->base = newbase;
dest->name = src->fts_name;
dest->dir = src->fts_info == FTS_D;
@ -59,13 +59,13 @@ static fs_entry* ftsentcpy(fs_entry *dest, FTSENT *src) {
}
fscrawl_t fsc_open(const char *path) {
struct __fscrawl *f;
struct __fscrawl *f;
char *npath;
f = malloc(sizeof(struct __fscrawl));
if (!f)
return NULL;
if (!f)
return NULL;
npath = path_normalize(path, NULL, 1);
if (!npath)
@ -82,7 +82,7 @@ fscrawl_t fsc_open(const char *path) {
f->ent.base = NULL;
f->ent.name = NULL;
f->ent.dir = 0;
return f;
return f;
free:
if (f)
free(f);
@ -101,23 +101,23 @@ void fsc_close(fscrawl_t f) {
}
fs_entry* fsc_cpy(fs_entry *ent) {
void *ptr = malloc(sizeof(fs_entry));
if (ptr == NULL)
return NULL;
memcpy(ptr, ent, sizeof(fs_entry));
return ptr;
void *ptr = malloc(sizeof(fs_entry));
if (ptr == NULL)
return NULL;
memcpy(ptr, ent, sizeof(fs_entry));
return ptr;
}
fs_entry* fsc_read(fscrawl_t f) {
FTSENT *ent;
FTSENT *ent;
if (!f)
return NULL;
if (!f)
return NULL;
for(;;) {
ent = fts_read(f->fts);

2
src/fscrawl.h
View file

@ -1,5 +1,5 @@
/* fscrawl.h - Filesystem traversal
*
*
* Copyright (C) 2010 Henrik Hautakoski <henrik@fiktivkod.org>
*
* This program is free software: you can redistribute it and/or modify

8
src/inotify-backend.c
View file

@ -84,12 +84,12 @@ void inotify_backend_exit(void) {
int inotify_backend_watch(const char *path) {
int wd = inotify_add_watch(fd, path, WATCH_MASK);
if (wd < 0) {
if (wd < 0) {
if (errno != EACCES && errno != ENOTDIR)
logerrno(LOG_CRIT, "inotify_watch", errno);
return -errno;
}
return -errno;
}
return wd;
}

50
src/inotify-backend.h
View file

@ -16,41 +16,41 @@
/* Structure describing an inotify event. */
struct inotify_event {
int wd; /* Watch descriptor. */
uint32_t mask; /* Watch mask. */
uint32_t cookie; /* Cookie to synchronize two events. */
uint32_t len; /* Length (including NULs) of name. */
char name __flexarr; /* Name. */
int wd; /* Watch descriptor. */
uint32_t mask; /* Watch mask. */
uint32_t cookie; /* Cookie to synchronize two events. */
uint32_t len; /* Length (including NULs) of name. */
char name __flexarr; /* Name. */
};
#define IN_EVENT_SIZE (sizeof(struct inotify_event) + 0x40)
/* Supported events suitable for MASK parameter of INOTIFY_ADD_WATCH. */
#define IN_ACCESS 0x00000001 /* File was accessed. */
#define IN_MODIFY 0x00000002 /* File was modified. */
#define IN_ATTRIB 0x00000004 /* Metadata changed. */
#define IN_CLOSE_WRITE 0x00000008 /* Writtable file was closed. */
#define IN_CLOSE_NOWRITE 0x00000010 /* Unwrittable file closed. */
#define IN_CLOSE (IN_CLOSE_WRITE | IN_CLOSE_NOWRITE) /* Close. */
#define IN_OPEN 0x00000020 /* File was opened. */
#define IN_MOVED_FROM 0x00000040 /* File was moved from X. */
#define IN_MOVED_TO 0x00000080 /* File was moved to Y. */
#define IN_MOVE (IN_MOVED_FROM | IN_MOVED_TO) /* Moves. */
#define IN_CREATE 0x00000100 /* Subfile was created. */
#define IN_DELETE 0x00000200 /* Subfile was deleted. */
#define IN_DELETE_SELF 0x00000400 /* Self was deleted. */
#define IN_MOVE_SELF 0x00000800 /* Self was moved. */
#define IN_ACCESS 0x00000001 /* File was accessed. */
#define IN_MODIFY 0x00000002 /* File was modified. */
#define IN_ATTRIB 0x00000004 /* Metadata changed. */
#define IN_CLOSE_WRITE 0x00000008 /* Writtable file was closed. */
#define IN_CLOSE_NOWRITE 0x00000010 /* Unwrittable file closed. */
#define IN_CLOSE (IN_CLOSE_WRITE | IN_CLOSE_NOWRITE) /* Close. */
#define IN_OPEN 0x00000020 /* File was opened. */
#define IN_MOVED_FROM 0x00000040 /* File was moved from X. */
#define IN_MOVED_TO 0x00000080 /* File was moved to Y. */
#define IN_MOVE (IN_MOVED_FROM | IN_MOVED_TO) /* Moves. */
#define IN_CREATE 0x00000100 /* Subfile was created. */
#define IN_DELETE 0x00000200 /* Subfile was deleted. */
#define IN_DELETE_SELF 0x00000400 /* Self was deleted. */
#define IN_MOVE_SELF 0x00000800 /* Self was moved. */
/* Events sent by the kernel. */
#define IN_UNMOUNT 0x00002000 /* Backing fs was unmounted. */
#define IN_Q_OVERFLOW 0x00004000 /* Event queued overflowed. */
#define IN_IGNORED 0x00008000 /* File was ignored. */
#define IN_UNMOUNT 0x00002000 /* Backing fs was unmounted. */
#define IN_Q_OVERFLOW 0x00004000 /* Event queued overflowed. */
#define IN_IGNORED 0x00008000 /* File was ignored. */
/* Helper events. */
#define IN_CLOSE (IN_CLOSE_WRITE | IN_CLOSE_NOWRITE) /* Close. */
#define IN_MOVE (IN_MOVED_FROM | IN_MOVED_TO) /* Moves. */
#define IN_CLOSE (IN_CLOSE_WRITE | IN_CLOSE_NOWRITE) /* Close. */
#define IN_MOVE (IN_MOVED_FROM | IN_MOVED_TO) /* Moves. */
#define IN_ISDIR 0x40000000 /* Event occurred against dir. */
#define IN_ISDIR 0x40000000 /* Event occurred against dir. */
int inotify_backend_init(void);

4
src/inotify-map.c
View file

@ -1,5 +1,5 @@
/* inotify-map.c
*
*
* (C) Copyright 2011 Henrik Hautakoski <henrik@fiktivkod.org>
*
* This program is free software: you can redistribute it and/or modify
@ -118,7 +118,7 @@ static int unmap_wd(struct watch *watch) {
int index;
struct list s = { (void**)&watch, 1 }, *list;
list = rbtree_search(&tree_wd_paths, &s);
list = rbtree_search(&tree_wd_paths, &s);
if (list) {
index = list_indexof(list, watch);

2
src/inotify-map.h
View file

@ -1,5 +1,5 @@
/* inotify-map.h
*
*
* (C) Copyright 2011 Henrik Hautakoski <henrik@fiktivkod.org>
*
* This program is free software: you can redistribute it and/or modify

28
src/inotify-syscalls.h
View file

@ -6,13 +6,13 @@
#include <unistd.h>
#if defined(__i386__)
# define __NR_inotify_init 291
# define __NR_inotify_add_watch 292
# define __NR_inotify_rm_watch 293
# define __NR_inotify_init 291
# define __NR_inotify_add_watch 292
# define __NR_inotify_rm_watch 293
#elif defined(__x86_64__)
# define __NR_inotify_init 253
# define __NR_inotify_add_watch 254
# define __NR_inotify_rm_watch 255
# define __NR_inotify_init 253
# define __NR_inotify_add_watch 254
# define __NR_inotify_rm_watch 255
#elif defined(__alpha__)
# define __NR_inotify_init 444
# define __NR_inotify_add_watch 445
@ -26,23 +26,23 @@
# define __NR_inotify_add_watch 152
# define __NR_inotify_rm_watch 156
#elif defined (__ia64__)
# define __NR_inotify_init 1277
# define __NR_inotify_init 1277
# define __NR_inotify_add_watch 1278
# define __NR_inotify_rm_watch 1279
#elif defined (__s390__) || defined (__s390x__)
# define __NR_inotify_init 284
# define __NR_inotify_init 284
# define __NR_inotify_add_watch 285
# define __NR_inotify_rm_watch 286
#elif defined (__arm__)
# define __NR_inotify_init 316
# define __NR_inotify_init 316
# define __NR_inotify_add_watch 317
# define __NR_inotify_rm_watch 318
#elif defined (__SH4__)
# define __NR_inotify_init 290
# define __NR_inotify_init 290
# define __NR_inotify_add_watch 291
# define __NR_inotify_rm_watch 292
#elif defined (__SH5__)
# define __NR_inotify_init 318
# define __NR_inotify_init 318
# define __NR_inotify_add_watch 319
# define __NR_inotify_rm_watch 320
#else
@ -56,12 +56,12 @@ static inline int inotify_init(void) {
static inline int inotify_add_watch(int fd, const char *name, __u32 mask) {
return syscall(__NR_inotify_add_watch, fd, name, mask);
return syscall(__NR_inotify_add_watch, fd, name, mask);
}
static inline int inotify_rm_watch(int fd, __u32 wd) {
return syscall(__NR_inotify_rm_watch, fd, wd);
return syscall(__NR_inotify_rm_watch, fd, wd);
}
#endif /* _LINUX_INOTIFY_SYSCALLS_H */

6
src/inotify-watch.c
View file

@ -11,7 +11,7 @@ struct watch* inotify_watch_new(int wd, const char *path) {
w->wd = wd;
w->path = path;
return w;
}
@ -28,7 +28,7 @@ void inotify_watch_destroy(struct watch *watch, void (*fn)(struct watch *)) {
if (watch) {
struct tree *tree = (struct tree*) watch;
if (!tree_is_root(tree))
tree_detach(tree);
@ -40,7 +40,7 @@ struct watch* inotify_watch_add(struct watch *parent, struct watch *watch) {
if (parent->tree.child) {
struct watch *it = (struct watch*)parent->tree.child;
/* move nodes that are children of this watch alongside watch */
while(it) {
if (path_isparent(it->path, watch->path)) {

28
src/inotify.c
View file

@ -25,8 +25,8 @@ void inotify_exit(void) {
if (event_queue) {
notify_event *e;
while((e = queue_dequeue(event_queue)))
notify_event_del(e);
queue_destroy(event_queue);
notify_event_del(e);
queue_destroy(event_queue);
event_queue = NULL;
}
}
@ -50,7 +50,7 @@ int inotify_ignore(const char *path) {
/* unmap and remove watch */
if (inotify_unmap_path(path) == 0) {
logmsg(LOG_DEBUG, "remove watch: %i %s", wd, path);
if (inotify_backend_ignore(wd) < 0)
return -1;
}
@ -61,24 +61,24 @@ static void proc_event(struct inotify_event *iev) {
int i;
struct list *watch_list;
logmsg(LOG_DEBUG, "RAW EVENT: %i, %x, %s", iev->wd, iev->mask, iev->name);
if (iev->mask & IN_IGNORED) {
inotify_unmap_wd(iev->wd);
return;
}
/* lookup watch descriptors */
watch_list = inotify_map_get_path(iev->wd);
if (!watch_list) {
logmsg(LOG_WARN, "-- IGNORING EVENT -- invalid watchdescriptor %i", iev->wd);
return;
}
/* lookup watch descriptors */
watch_list = inotify_map_get_path(iev->wd);
if (!watch_list) {
logmsg(LOG_WARN, "-- IGNORING EVENT -- invalid watchdescriptor %i", iev->wd);
return;
}
for(i=0; i < watch_list->nr; i++) {
struct watch *watch = watch_list->items[i];
notify_event *event = notify_event_new();
@ -101,7 +101,7 @@ static void proc_event(struct inotify_event *iev) {
* or some other file.
*/
if (iev->mask & IN_CREATE || iev->mask & IN_MOVED_TO) {
event->dir = (iev->mask & IN_ISDIR) ? 1 :
event->dir = (iev->mask & IN_ISDIR) ? 1 :
is_dir(mkpath("%s/%s", event->path, event->filename));
event->type = NOTIFY_CREATE;

60
src/list.c
View file

@ -24,10 +24,10 @@ static void resize(struct list *l) {
struct list* list_create(void) {
struct list *list = xmalloc(sizeof(struct list));
list->items = NULL;
list->nr = 0;
return list;
struct list *list = xmalloc(sizeof(struct list));
list->items = NULL;
list->nr = 0;
return list;
}
struct list* list_copy(struct list *list) {
@ -69,22 +69,22 @@ void list_clear_fn(struct list *list, clear_fn_t *fn) {
int list_insert(struct list *list, const void *item) {
if (!list)
return -1;
if (!list)
return -1;
list->items = xrealloc(list->items, sizeof(list->items) * (++list->nr));
list->items[list->nr - 1] = (void *) item;
return list->nr;
}
void* list_remove(struct list *list, unsigned index) {
void *item = NULL;
void *item = NULL;
if (list && index < list->nr) {
if (index < --list->nr) {
memmove(list->items + index, list->items + index + 1,
memmove(list->items + index, list->items + index + 1,
sizeof(list->items) * (list->nr - index));
}
resize(list);
@ -105,29 +105,29 @@ void* list_reduce(struct list *list) {
int list_indexof(struct list *list, const void *item) {
int i;
for(i=0; i < list->nr; i++) {
if (list->items[i] == item)
return i;
}
return -1;
int i;
for(i=0; i < list->nr; i++) {
if (list->items[i] == item)
return i;
}
return -1;
}
void* list_lookup(struct list *list, const void *item, cmp_fn_t *fn) {
int i;
if (fn) {
for(i=0; i < list->nr; i++) {
if (fn(list->items[i], item) == 0)
return list->items[i];
}
} else {
i = list_indexof(list, item);
if (i >= 0)
return list->items[i];
}
return NULL;
int i;
if (fn) {
for(i=0; i < list->nr; i++) {
if (fn(list->items[i], item) == 0)
return list->items[i];
}
} else {
i = list_indexof(list, item);
if (i >= 0)
return list->items[i];
}
return NULL;
}

10
src/log.c
View file

@ -136,7 +136,7 @@ unsigned logstrtolvl(const char *str) {
void logmsg(unsigned level, const char *fmt, ...) {
va_list vl;
va_list vl;
if (!validmask(level, 1))
die("log: invalid level: %x\n", level);
@ -155,9 +155,9 @@ void logmsg(unsigned level, const char *fmt, ...) {
void logerrno(unsigned level, const char *prefix, int err) {
char *str = strerror(err);
if (str && level & mask) {
char *str = strerror(err);
if (str && level & mask) {
if (!validmask(level, 1))
die("logerrno: invalid level: %x\n", level);
@ -169,5 +169,5 @@ void logerrno(unsigned level, const char *prefix, int err) {
fputs(str, logfd);
fputc('\n', logfd);
fflush(logfd);
}
}
}

2
src/log.h
View file

@ -14,7 +14,7 @@
#include <stddef.h>
#define LOG_INFO (1<<0)
#define LOG_WARN (1<<1)
#define LOG_WARN (1<<1)
#define LOG_CRIT (1<<2)
#define LOG_DEBUG (1<<3)
#define LOG_ALL (LOG_INFO | LOG_WARN | LOG_CRIT | LOG_DEBUG)

20
src/notify-inotify.c
View file

@ -93,13 +93,13 @@ static int rmwatch(const char *path, const char *name) {
int notify_init() {
if (!init) {
if (!init) {
if (inotify_init() < 0)
return -1;
init_ev_q = queue_init();
init = 1;
}
return 0;
return 0;
}
void notify_exit() {
@ -107,12 +107,12 @@ void notify_exit() {
if (init) {
notify_event *e;
while((e = queue_dequeue(init_ev_q)))
notify_event_del(e);
queue_destroy(init_ev_q);
notify_event_del(e);
queue_destroy(init_ev_q);
init_ev_q = NULL;
inotify_exit();
init = 0;
}
}
@ -128,10 +128,10 @@ int notify_add_watch(const char *path) {
}
int notify_rm_watch(const char *path) {
if (!init)
if (!init)
die("inotify is not instantiated.");
return rmwatch(path, NULL);
return rmwatch(path, NULL);
}
notify_event* notify_read() {
@ -140,10 +140,10 @@ notify_event* notify_read() {
if (!init)
die("inotify is not instantiated.");
if (!queue_isempty(init_ev_q))
return queue_dequeue(init_ev_q);
ev = inotify_read();
if (ev && ev->dir && ev->type == NOTIFY_CREATE)

2
src/notify.h
View file

@ -1,5 +1,5 @@
/* notify.h - filesystem notification API
*
*
* (C) Copyright 2010 Henrik Hautakoski <henrik@fiktivkod.org>
* (C) Copyright 2010 Fredric Nilsson <fredric@fiktivkod.org>
*

32
src/path.c
View file

@ -1,5 +1,5 @@
/* path.c - path handling routines
*
*
* Copyright (C) 2010-2011 Henrik Hautakoski <henrik.hautakoski@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
@ -7,7 +7,7 @@
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* The design goal here is to not use fixed size buffers because
* The design goal here is to not use fixed size buffers because
* path's can be extremely long (slightly overexaggerated but extreme cases are extreme).
* so we use funky heap memory based algorithms instead :)
*/
@ -24,17 +24,17 @@
static char path_null = '\0';
static inline int has_delim(const char *str) {
if (str == NULL)
return 0;
return strchr(str, '/') != NULL;
if (str == NULL)
return 0;
return strchr(str, '/') != NULL;
}
int is_abspath(const char *path) {
if (path == NULL || *path != '/')
return 0;
if (path == NULL || *path != '/')
return 0;
for(; *path; path++) {
@ -47,7 +47,7 @@ int is_abspath(const char *path) {
}
}
return 1;
return 1;
}
int is_file(const char *path) {
@ -62,7 +62,7 @@ int is_file(const char *path) {
int is_dir(const char *path) {
struct stat st;
if (path && stat(path, &st) >= 0)
return S_ISDIR(st.st_mode);
return 0;
@ -72,7 +72,7 @@ int path_isparent(const char *path, const char *parent) {
if (*path++ != '/' || *parent++ != '/')
return 0;
while(*path) {
if (*parent == '\0')
return *path == '/' || *(path-1) == '/';
@ -118,7 +118,7 @@ const char *mkpath(const char *fmt, ...) {
} else {
strbuf_expand(&sb, 1);
}
va_start(va, fmt);
len = strbuf_append_va(&sb, fmt, va);
va_end(va);
@ -146,8 +146,8 @@ char* path_normalize(const char *base, const char *name, unsigned dir) {
strbuf_t sb = STRBUF_INIT;
if (base == NULL || has_delim(name))
return NULL;
if (base == NULL || has_delim(name))
return NULL;
if (*base == '~') {
base++;
@ -163,7 +163,7 @@ char* path_normalize(const char *base, const char *name, unsigned dir) {
if (name) {
strbuf_append_str(&sb, name);
if (dir)
strbuf_append_ch(&sb, '/');
}

2
src/path.h
View file

@ -1,5 +1,5 @@
/* path.h - path handling routines
*
*
* Copyright (C) 2010-2011 Henrik Hautakoski <henrik@fiktivkod.org>
*
* This program is free software: you can redistribute it and/or modify

23
src/queue.c
View file

@ -19,7 +19,7 @@
/* linked list node holding a chunk of queue elements */
struct node {
void *block[BLOCK_SIZE];
struct node *next;
struct node *next;
};
struct ref {
@ -28,22 +28,22 @@ struct ref {
};
struct __queue {
struct ref tail;
struct ref head;
struct ref tail;
struct ref head;
};
static void alloc_node(struct ref *head) {
struct node *n = xmalloc(sizeof(struct node));
struct node *n = xmalloc(sizeof(struct node));
n->next = NULL;
head->n = head->n->next = n;
head->i = 0;
head->n = head->n->next = n;
head->i = 0;
}
static void dealloc_node(struct ref *tail) {
struct node *next = tail->n->next;
struct node *next = tail->n->next;
if (next) {
xfree(tail->n);
@ -58,7 +58,7 @@ queue_t queue_init() {
q->tail.n = q->head.n = xmalloc(sizeof(struct node));
q->tail.n->next = q->head.n->next = NULL;
q->tail.i = q->head.i = 0;
return q;
}
@ -81,10 +81,10 @@ void queue_enqueue(queue_t q, void *obj) {
return;
if (q->head.i >= BLOCK_SIZE) {
alloc_node(&q->head);
alloc_node(&q->head);
}
q->head.n->block[q->head.i++] = obj;
q->head.n->block[q->head.i++] = obj;
}
void* queue_dequeue(queue_t q) {
@ -101,7 +101,7 @@ void* queue_dequeue(queue_t q) {
} else if (q->tail.i >= BLOCK_SIZE) {
dealloc_node(&q->tail);
}
return obj;
}
@ -129,4 +129,3 @@ size_t queue_num_items(queue_t q) {
len += BLOCK_SIZE;
return len;
}

376
src/rbtree.c
View file

@ -1,5 +1,5 @@
/* rbtree.c - red black tree implementation
*
*
* Copyright (C) 2010-2011 Henrik Hautakoski <henrik@fiktivkod.org>
*
* This program is free software: you can redistribute it and/or modify
@ -24,84 +24,84 @@
/* node definition */
typedef struct _rbn {
const void *key;
struct _rbn *child[2];
unsigned char color;
struct _rbn *child[2];
unsigned char color;
} rbnode;
#define is_red(n) ((n) != NULL && (n)->color == RB_RED)
#define swap(n,d,q) ((n)->child[(n)->child[d] == (q)])
static rbnode* node_alloc(const void *key) {
rbnode *n = xmalloc(sizeof(rbnode));
n->key = key;
n->color = RB_RED;
n->child[0] = NULL;
n->child[1] = NULL;
return n;
rbnode *n = xmalloc(sizeof(rbnode));
n->key = key;
n->color = RB_RED;
n->child[0] = NULL;
n->child[1] = NULL;
return n;
}
/*
* Recursivly deallocate a tree.
*/
static void node_dealloc(rbnode *n, void (*dealloc)(void *)) {
if (!n)
return;
if (!n)
return;
if (dealloc)
dealloc((void *)n->key);
node_dealloc(n->child[0], dealloc);
node_dealloc(n->child[1], dealloc);
node_dealloc(n->child[0], dealloc);
node_dealloc(n->child[1], dealloc);
free(n);
free(n);
}
#ifdef __DEBUG__
#define rb_err(msg) fputs("rbtree error: " msg, stderr)
static int rb_assert_r(rbnode *node, int (*cmp)(const void *, const void *)) {
int rh, lh;
rbnode *ln, *rn;
if (node == NULL)
return 1;
ln = node->child[0];
rn = node->child[1];
if (is_red(node)) {
int rh, lh;
rbnode *ln, *rn;
if (node == NULL)
return 1;
ln = node->child[0];
rn = node->child[1];
if (is_red(node)) {
/* double red violation */
if (is_red(ln) || is_red(rn)) {
rb_err("Double red violation");
return 0;
}
}
lh = rb_assert_r(ln, cmp);
rh = rb_assert_r(rn, cmp);
if (is_red(ln) || is_red(rn)) {
rb_err("Double red violation");
return 0;
}
}
lh = rb_assert_r(ln, cmp);
rh = rb_assert_r(rn, cmp);
if ( (ln && cmp(ln->key, node->key) >= 0) &&
(rn && cmp(rn->key, node->key) <= 0) ) {
rb_err("Binary tree violation");
return 0;
}
if (rh != 0 && lh != 0) {
if (rh != lh) {
rb_err("Binary tree violation");
return 0;
}
if (rh != 0 && lh != 0) {
if (rh != lh) {
rb_err("Black height violation");
return 0;
}
return is_red(node) ? lh : lh+1;
}
return 0;
return 0;
}
return is_red(node) ? lh : lh+1;
}
return 0;
}
#undef rb_err
@ -118,67 +118,67 @@ static void rb_assert(rbtree *tree) {
* Recursivly walks a tree, applying action function on every node
*/
static void rbwalk(rbnode *n, void (*action)(const void *)) {
if (!n)
return;
rbwalk(n->child[0], action);
if (!n)
return;
rbwalk(n->child[0], action);
action(n->key);
rbwalk(n->child[1], action);
rbwalk(n->child[1], action);
}
static rbnode* rotate_single(rbnode *root, int dir) {
rbnode *save = root->child[!dir];
root->child[!dir] = save->child[dir];
save->child[dir] = root;
root->color = RB_RED;
save->color = RB_BLACK;
return save;
rbnode *save = root->child[!dir];
root->child[!dir] = save->child[dir];
save->child[dir] = root;
root->color = RB_RED;
save->color = RB_BLACK;
return save;
}
static rbnode* rotate_double(rbnode *root, int dir) {
root->child[!dir] = rotate_single(root->child[!dir], !dir);
return rotate_single(root, dir);
root->child[!dir] = rotate_single(root->child[!dir], !dir);
return rotate_single(root, dir);
}
int rbtree_is_empty(rbtree *tree) {
return tree == NULL || tree->root == NULL;
return tree == NULL || tree->root == NULL;
}
/*
* Searches a tree by key.
*/
void* rbtree_search(rbtree *tree, const void *key) {
rbnode *n;
if (!tree || !tree->cmp_fn)
return NULL;
n = tree->root;
while(n) {
rbnode *n;
if (!tree || !tree->cmp_fn)
return NULL;
n = tree->root;
while(n) {
int cmp = tree->cmp_fn(n->key, key);
if (cmp == 0)
return (void *) n->key;
if (cmp == 0)
return (void *) n->key;
n = n->child[cmp < 0];
}
return NULL;
}
return NULL;
}
void rbtree_walk(rbtree *tree, void (*action)(const void *)) {
if (!tree || !action)
return;
rbwalk(tree->root, action);
if (!tree || !action)
return;
rbwalk(tree->root, action);
#ifdef __DEBUG__
rb_assert(tree);
@ -186,12 +186,12 @@ void rbtree_walk(rbtree *tree, void (*action)(const void *)) {
}
void rbtree_free(rbtree *tree, void (*free_fn)(void *)) {
if (!tree)
return;
node_dealloc(tree->root, free_fn);
tree->root = NULL;
if (!tree)
return;
node_dealloc(tree->root, free_fn);
tree->root = NULL;
#ifdef __DEBUG__
rb_assert(tree);
@ -199,71 +199,71 @@ void rbtree_free(rbtree *tree, void (*free_fn)(void *)) {
}
int rbtree_insert(rbtree *tree, const void *key) {
rbnode head = {0};
/* grandparent and parent */
rbnode *g, *t;
/* iterator and parent */
rbnode *p, *q;
int dir = 0, last = 0;
rbnode head = {0};
/* grandparent and parent */
rbnode *g, *t;
/* iterator and parent */
rbnode *p, *q;
int dir = 0, last = 0;
if (!tree || !tree->cmp_fn)
return -1;
if (!tree->root) {
tree->root = q = node_alloc(key);
if (!tree->root) {
tree->root = q = node_alloc(key);
goto done;
}
t = &head;
g = p = NULL;
q = t->child[1] = tree->root;
}
t = &head;
g = p = NULL;
q = t->child[1] = tree->root;
/* somewhere in here, there should be dragons */
for(;;) {
for(;;) {
int cmp;
if (q == NULL) {
p->child[dir] = q = node_alloc(key);
} else if (is_red(q->child[0]) && is_red(q->child[1])) {
/* color flip case */
q->color = RB_RED;
q->child[0]->color = RB_BLACK;
q->child[1]->color = RB_BLACK;
}
/* fix red validation */
if (is_red(q) && is_red(p)) {
int dir2 = (t->child[1] == g);
if (q == p->child[last])
t->child[dir2] = rotate_single(g, !last);
else
t->child[dir2] = rotate_double(g, !last);
}
if (q == NULL) {
p->child[dir] = q = node_alloc(key);
} else if (is_red(q->child[0]) && is_red(q->child[1])) {
/* color flip case */
q->color = RB_RED;
q->child[0]->color = RB_BLACK;
q->child[1]->color = RB_BLACK;
}
/* fix red validation */
if (is_red(q) && is_red(p)) {
int dir2 = (t->child[1] == g);
if (q == p->child[last])
t->child[dir2] = rotate_single(g, !last);
else
t->child[dir2] = rotate_double(g, !last);
}
cmp = tree->cmp_fn(q->key, key);
if (cmp == 0)
break;
last = dir;
dir = cmp < 0;
if (g)
t = g;
g = p, p = q;
q = q->child[dir];
}
tree->root = head.child[1];
if (cmp == 0)
break;
last = dir;
dir = cmp < 0;
if (g)
t = g;
g = p, p = q;
q = q->child[dir];
}
tree->root = head.child[1];
done:
/* root should be black */
tree->root->color = RB_BLACK;
/* root should be black */
tree->root->color = RB_BLACK;
#ifdef __DEBUG__
rb_assert(tree);
@ -273,46 +273,46 @@ done:
}
void* rbtree_delete(rbtree *tree, const void *key) {
rbnode head = {0};
/* helpers*/
rbnode *q, *p, *g, *s;
/* found item */
rbnode *f = NULL, *ret = NULL;
int dir = 1, dir2, last;
if (rbtree_is_empty(tree) || !tree->cmp_fn)
return 0;
q = &head;
g = p = NULL;
q->child[1] = tree->root;
/* more dragons (killed some of them though) */
while(q->child[dir]) {
rbnode head = {0};
/* helpers*/
rbnode *q, *p, *g, *s;
/* found item */
rbnode *f = NULL, *ret = NULL;
int dir = 1, dir2, last;
if (rbtree_is_empty(tree) || !tree->cmp_fn)
return 0;
q = &head;
g = p = NULL;
q->child[1] = tree->root;
/* more dragons (killed some of them though) */
while(q->child[dir]) {
int cmp;
g = p, p = q;
g = p, p = q;
q = q->child[dir];
last = dir;
cmp = tree->cmp_fn(q->key, key);
dir = cmp < 0;
if (cmp == 0)
f = q;
if (is_red(q) || is_red(q->child[dir]))
dir = cmp < 0;
if (cmp == 0)
f = q;
if (is_red(q) || is_red(q->child[dir]))
continue;
if (is_red(q->child[!dir])) {
p = p->child[last] = rotate_single(q, dir);
} else {
s = p->child[!last];
if (s == NULL)
continue;
@ -321,35 +321,35 @@ void* rbtree_delete(rbtree *tree, const void *key) {
s->color = q->color = RB_RED;
} else {
dir2 = (g->child[1] == p);
if (is_red(s->child[last]))
g->child[dir2] = rotate_double(p, last);
else if (is_red(s->child[!last]))
g->child[dir2] = rotate_single(p, last);
q->color = g->child[dir2]->color = RB_RED;
g->child[dir2]->child[0]->color = RB_BLACK;
g->child[dir2]->child[1]->color = RB_BLACK;
}
}
}
}
}
/* remove if found */
if (f) {
/* remove if found */
if (f) {
ret = (void*)f->key;
if (f != q)
f->key = q->key;
swap(p, 1, q) = swap(q, 0, NULL);
xfree(q);
}
}
tree->root = head.child[1];
if (tree->root)
tree->root->color = RB_BLACK;
if (tree->root)
tree->root->color = RB_BLACK;
#ifdef __DEBUG__
rb_assert(tree);
#endif
return ret;
return ret;
}

4
src/rbtree.h
View file

@ -1,5 +1,5 @@
/* rbtree.h
*
*
* Copyright (C) 2010-2011 Henrik Hautakoski <henrik@fiktivkod.org>
*
* This program is free software: you can redistribute it and/or modify
@ -14,7 +14,7 @@
#include <stddef.h>
typedef struct {
struct _rbn *root;
struct _rbn *root;
/* user defined operations */
int (*cmp_fn)(const void *, const void *);
} rbtree;

12
src/str-list.c
View file

@ -95,13 +95,13 @@ int str_list_insert(struct str_list *list, const char *str) {
list->items = xrealloc(list->items, sizeof(list->items) * (list->nr + 1));
if (index < list->nr) {
memmove(list->items + index + 1, list->items + index,
memmove(list->items + index + 1, list->items + index,
sizeof(list->items) * (list->nr - index));
}
list->items[index] = (char *) str;
list->nr++;
return index;
}
@ -114,7 +114,7 @@ char* str_list_remove(struct str_list *list, const char *str) {
if (match && index < list->nr) {
item = list->items[index];
if (index < --list->nr) {
memmove(list->items + index, list->items + index + 1,
memmove(list->items + index, list->items + index + 1,
sizeof(list->items) * (list->nr - index));
}
resize(list);
@ -160,12 +160,10 @@ char** str_list_export(struct str_list *list) {
int i;
char **out = xmalloc(sizeof(char*) * (list->nr + 1));
for(i=0; i < list->nr; i++)
out[i] = list->items[i];
out[list->nr] = NULL;
return out;
}

70
src/strbuf.c
View file

@ -22,26 +22,26 @@ char strbuf_null = '\0';
void strbuf_init(strbuf_t *s) {
s->buf = &strbuf_null;
s->alloc_size = s->len = 0;
s->buf = &strbuf_null;
s->alloc_size = s->len = 0;
}
size_t strbuf_avail(strbuf_t *s) {
return s->alloc_size ? s->alloc_size - (s->len + 1) : 0;
}
void strbuf_expand(strbuf_t *s, size_t len) {
if (s->len + len + 1 < s->alloc_size)
return;
return;
if (!s->alloc_size)
s->buf = NULL;
do
s->alloc_size += CHNK_SIZE;
while(s->len + len + 1 > s->alloc_size);
do
s->alloc_size += CHNK_SIZE;
while(s->len + len + 1 > s->alloc_size);
s->buf = xrealloc(s->buf, s->alloc_size);
}
@ -66,25 +66,25 @@ void strbuf_setlen(strbuf_t *s, size_t len) {
char* strbuf_release(strbuf_t *s) {
char *ret;
if (!s->alloc_size)
char *ret;
if (!s->alloc_size)
ret = xmallocz(1);
else if (s->len + 1 != s->alloc_size)
ret = xrealloc(s->buf, s->len + 1);
else
ret = s->buf;
strbuf_init(s);
return ret;
ret = xrealloc(s->buf, s->len + 1);
else
ret = s->buf;
strbuf_init(s);
return ret;
}
void strbuf_free(strbuf_t *s) {
if (!s->alloc_size)
return;
xfree(s->buf);
strbuf_init(s);
}
@ -122,7 +122,7 @@ void strbuf_appendf(strbuf_t *s, const char *fmt, ...) {
va_list va;
int len;
if (!strbuf_avail(s))
strbuf_expand(s, CHNK_SIZE-1);
@ -131,10 +131,10 @@ void strbuf_appendf(strbuf_t *s, const char *fmt, ...) {
va_end(va);
if (len > 0) {
strbuf_expand(s, len);
va_start(va, fmt);
len = strbuf_append_va(s, fmt, va);
va_end(va);
strbuf_expand(s, len);
va_start(va, fmt);
len = strbuf_append_va(s, fmt, va);
va_end(va);
}
}
@ -186,8 +186,8 @@ void strbuf_term(strbuf_t *s, char ch) {
void strbuf_trim(strbuf_t *s) {
strbuf_rtrim(s);
strbuf_ltrim(s);
strbuf_rtrim(s);
strbuf_ltrim(s);
}
void strbuf_rtrim(strbuf_t *s) {
@ -200,15 +200,15 @@ void strbuf_rtrim(strbuf_t *s) {
void strbuf_ltrim(strbuf_t *s) {
size_t i, of = 0;
for(; of < s->len && isspace(s->buf[of]); of++);
if (of < 1)
return;
s->len -= of;
for(i=0; i <= s->len; i++)
s->buf[i] = s->buf[i + of];
for(; of < s->len && isspace(s->buf[of]); of++);
if (of < 1)
return;
s->len -= of;
for(i=0; i <= s->len; i++)
s->buf[i] = s->buf[i + of];
}
void strbuf_rev(strbuf_t *s) {
@ -251,7 +251,7 @@ strbuf_t** strbuf_explode(const strbuf_t *s, char sep) {
strbuf_t *tmp, **list;
list = xmallocz(sizeof(strbuf_t *) * count);
p = s->buf;
while(p < s->buf + s->len) {
char *d = memchr(p, sep, s->len - (p - s->buf));

2
src/tree.c
View file

@ -110,7 +110,7 @@ void tree_traverse(struct tree *tree, tree_traverse_fn fn, void *data) {
size_t tree_parent_count(struct tree *tree) {
size_t count = 0;
if (tree) {
for(; tree->parent; count++)
tree = tree->parent;

4
src/tree.h
View file

@ -7,7 +7,7 @@
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*/
#ifndef __TREE_H
#define __TREE_H
@ -37,7 +37,7 @@ struct tree* tree_link(struct tree *parent, struct tree *tree);
void tree_unlink(struct tree *tree);
void tree_move(struct tree *dest, struct tree *src);
void tree_move(struct tree *dest, struct tree *src);
void tree_detach(struct tree *tree);

2
src/xalloc.c
View file

@ -52,7 +52,7 @@ void* xrealloc(void *ptr, size_t size) {
void *new;
CHECK_INPUT(size, "xrealloc");
new = realloc(ptr, size);
if (!new)
die("xrealloc: Can't resize memory block (%s) on '%p' with size '%lu'",