int main(int argc, char **argv)
{
hashmap_t * map;
if (argc != 2) {
fprintf(stderr, "Usage: %s string\n",argv[0]);
exit(EXIT_FAILURE);
}
map = (hashmap_t *)malloc(sizeof(hashmap_t));
hashmap_init(map);
decode(argv[1], map);
hashmap_iterate(map,print_hashmap);
hashmap_delete_all(map);
hashmap_free(map);
free(map);
exit(0);
}
int free_patch_ids(struct patch_ids *ids)
{
hashmap_free(&ids->patches, 1);
return 0;
}
static void manager_free(Manager *m) {
Session *session;
User *u;
Device *d;
Seat *s;
Inhibitor *i;
Button *b;
assert(m);
while ((session = hashmap_first(m->sessions)))
session_free(session);
while ((u = hashmap_first(m->users)))
user_free(u);
while ((d = hashmap_first(m->devices)))
device_free(d);
while ((s = hashmap_first(m->seats)))
seat_free(s);
while ((i = hashmap_first(m->inhibitors)))
inhibitor_free(i);
while ((b = hashmap_first(m->buttons)))
button_free(b);
hashmap_free(m->devices);
hashmap_free(m->seats);
hashmap_free(m->sessions);
hashmap_free(m->users);
hashmap_free(m->inhibitors);
hashmap_free(m->buttons);
hashmap_free(m->user_units);
hashmap_free(m->session_units);
sd_event_source_unref(m->idle_action_event_source);
sd_event_source_unref(m->inhibit_timeout_source);
sd_event_source_unref(m->scheduled_shutdown_timeout_source);
sd_event_source_unref(m->nologin_timeout_source);
sd_event_source_unref(m->wall_message_timeout_source);
sd_event_source_unref(m->console_active_event_source);
sd_event_source_unref(m->udev_seat_event_source);
sd_event_source_unref(m->udev_device_event_source);
sd_event_source_unref(m->udev_vcsa_event_source);
sd_event_source_unref(m->udev_button_event_source);
sd_event_source_unref(m->lid_switch_ignore_event_source);
safe_close(m->console_active_fd);
udev_monitor_unref(m->udev_seat_monitor);
udev_monitor_unref(m->udev_device_monitor);
udev_monitor_unref(m->udev_vcsa_monitor);
udev_monitor_unref(m->udev_button_monitor);
udev_unref(m->udev);
if (m->unlink_nologin)
(void) unlink("/run/nologin");
bus_verify_polkit_async_registry_free(m->polkit_registry);
sd_bus_unref(m->bus);
sd_event_unref(m->event);
safe_close(m->reserve_vt_fd);
strv_free(m->kill_only_users);
strv_free(m->kill_exclude_users);
free(m->scheduled_shutdown_type);
free(m->scheduled_shutdown_tty);
free(m->wall_message);
free(m->action_job);
free(m);
}
static void free_hashmap(void * h) {
hashmap_free(h);
free(h);
}
bool buxton_cache_smack_rules(void)
{
smack_check();
FILE *load_file = NULL;
char *rule_pair = NULL;
int ret = true;
bool have_rules = false;
struct stat buf;
if (_smackrules) {
hashmap_free(_smackrules);
}
_smackrules = hashmap_new(string_hash_func, string_compare_func);
if (!_smackrules) {
abort();
}
//FIXME: should check for a proper mount point instead
if ((stat(SMACK_MOUNT_DIR, &buf) == -1) || !S_ISDIR(buf.st_mode)) {
buxton_log("Smack filesystem not detected; disabling Smack checks\n");
have_smack = false;
goto end;
}
load_file = fopen(buxton_smack_load_file(), "r");
if (!load_file) {
switch (errno) {
case ENOENT:
buxton_log("Smackfs load2 file not found; disabling Smack checks\n");
have_smack = false;
goto end;
default:
buxton_log("fopen(): %m\n");
ret = false;
goto end;
}
}
do {
int r;
int chars;
BuxtonKeyAccessType *accesstype;
char subject[SMACK_LABEL_LEN+1] = { 0, };
char object[SMACK_LABEL_LEN+1] = { 0, };
char access[ACC_LEN] = { 0, };
/* read contents from load2 */
chars = fscanf(load_file, "%s %s %s\n", subject, object, access);
if (ferror(load_file)) {
buxton_log("fscanf(): %m\n");
ret = false;
goto end;
}
if (!have_rules && chars == EOF && feof(load_file)) {
buxton_debug("No loaded Smack rules found\n");
goto end;
}
if (chars != 3) {
buxton_log("Corrupt load file detected\n");
ret = false;
goto end;
}
have_rules = true;
r = asprintf(&rule_pair, "%s %s", subject, object);
if (r == -1) {
abort();
}
accesstype = malloc0(sizeof(BuxtonKeyAccessType));
if (!accesstype) {
abort();
}
*accesstype = ACCESS_NONE;
if (strchr(access, 'r')) {
*accesstype |= ACCESS_READ;
}
if (strchr(access, 'w')) {
*accesstype |= ACCESS_WRITE;
}
hashmap_put(_smackrules, rule_pair, accesstype);
} while (!feof(load_file));
end:
if (load_file) {
fclose(load_file);
}
return ret;
}
void fuser_userdict_destroy(hashmap *users)
{
hashmap_map(users, &user_delete, NULL);
hashmap_free(users);
}
int renderman_tear_down () {
hashmap_free ( mapSceneData );
hashmap_free ( staticShaders );
hashmap_free ( staticPrograms );
return 0;
}
void set_free(Set* s) {
hashmap_free(MAKE_HASHMAP(s));
}
int main(char* argv, int argc)
{
int index;
int error;
map_t mymap;
char key_string[KEY_MAX_LENGTH];
data_struct_t* value;
fprintf(stderr, "start...\n");
mymap = hashmap_new();
/* First, populate the hash map with ascending values */
for (index=0; index<KEY_COUNT; index+=1)
{
/* Store the key string along side the numerical value so we can free it later */
value = malloc(sizeof(data_struct_t));
//snprintf(value->key_string, KEY_MAX_LENGTH, "%s%d", KEY_PREFIX, index);
snprintf(value->key_string, KEY_MAX_LENGTH, "%s", strings[index]);
value->number = index;
//fprintf(stderr, "value->key_string=%s, value->number=%d\n",
// value->key_string, value->number);
error = hashmap_put(mymap, value->key_string, value);
assert(error==MAP_OK);
}
/* Now, check all of the expected values are there */
for (index=0; index<KEY_COUNT; index+=1)
{
//snprintf(key_string, KEY_MAX_LENGTH, "%s%d", KEY_PREFIX, index);
snprintf(key_string, KEY_MAX_LENGTH, "%s", strings[index]);
error = hashmap_get(mymap, key_string, (void**)(&value));
//fprintf(stderr, "error=%d, value->number=%d, index=(%d)\n", error, value->number, index);
/* Make sure the value was both found and the correct number */
assert(error==MAP_OK);
assert(value->number==index);
}
/* Make sure that a value that wasn't in the map can't be found */
snprintf(key_string, KEY_MAX_LENGTH, "%s%d", KEY_PREFIX, KEY_COUNT);
//snprintf(key_string, KEY_MAX_LENGTH, "%s", KEY_COUNT);
error = hashmap_get(mymap, key_string, (void**)(&value));
fprintf(stderr, "error=%d\n", error);
/* Make sure the value was not found */
assert(error==MAP_MISSING);
/* Free all of the values we allocated and remove them from the map */
for (index=0; index<KEY_COUNT; index+=1)
{
//snprintf(key_string, KEY_MAX_LENGTH, "%s%d", KEY_PREFIX, index);
snprintf(key_string, KEY_MAX_LENGTH, "%s", strings[index]);
error = hashmap_get(mymap, key_string, (void**)(&value));
assert(error==MAP_OK);
error = hashmap_remove(mymap, key_string);
assert(error==MAP_OK);
free(value);
}
/* Now, destroy the map */
hashmap_free(mymap);
return 1;
}
void oidmap_free(struct oidmap *map, int free_entries)
{
if (!map)
return;
hashmap_free(&map->map, free_entries);
}
/*
* Read stdin line by line and print result of commands to stdout:
*
* hash key -> strhash(key) memhash(key) strihash(key) memihash(key)
* put key value -> NULL / old value
* get key -> NULL / value
* remove key -> NULL / old value
* iterate -> key1 value1\nkey2 value2\n...
* size -> tablesize numentries
*
* perfhashmap method rounds -> test hashmap.[ch] performance
*/
int main(int argc, char *argv[])
{
char line[1024];
struct hashmap map;
int icase;
/* init hash map */
icase = argc > 1 && !strcmp("ignorecase", argv[1]);
hashmap_init(&map, (hashmap_cmp_fn) (icase ? test_entry_cmp_icase
: test_entry_cmp), 0);
/* process commands from stdin */
while (fgets(line, sizeof(line), stdin)) {
char *cmd, *p1 = NULL, *p2 = NULL;
int l1 = 0, l2 = 0, hash = 0;
struct test_entry *entry;
/* break line into command and up to two parameters */
cmd = strtok(line, DELIM);
/* ignore empty lines */
if (!cmd || *cmd == '#')
continue;
p1 = strtok(NULL, DELIM);
if (p1) {
l1 = strlen(p1);
hash = icase ? strihash(p1) : strhash(p1);
p2 = strtok(NULL, DELIM);
if (p2)
l2 = strlen(p2);
}
if (!strcmp("hash", cmd) && l1) {
/* print results of different hash functions */
printf("%u %u %u %u\n", strhash(p1), memhash(p1, l1),
strihash(p1), memihash(p1, l1));
} else if (!strcmp("add", cmd) && l1 && l2) {
/* create entry with key = p1, value = p2 */
entry = alloc_test_entry(hash, p1, l1, p2, l2);
/* add to hashmap */
hashmap_add(&map, entry);
} else if (!strcmp("put", cmd) && l1 && l2) {
/* create entry with key = p1, value = p2 */
entry = alloc_test_entry(hash, p1, l1, p2, l2);
/* add / replace entry */
entry = hashmap_put(&map, entry);
/* print and free replaced entry, if any */
puts(entry ? get_value(entry) : "NULL");
free(entry);
} else if (!strcmp("get", cmd) && l1) {
/* lookup entry in hashmap */
entry = hashmap_get_from_hash(&map, hash, p1);
/* print result */
if (!entry)
puts("NULL");
while (entry) {
puts(get_value(entry));
entry = hashmap_get_next(&map, entry);
}
} else if (!strcmp("remove", cmd) && l1) {
/* setup static key */
struct hashmap_entry key;
hashmap_entry_init(&key, hash);
/* remove entry from hashmap */
entry = hashmap_remove(&map, &key, p1);
/* print result and free entry*/
puts(entry ? get_value(entry) : "NULL");
free(entry);
} else if (!strcmp("iterate", cmd)) {
struct hashmap_iter iter;
hashmap_iter_init(&map, &iter);
while ((entry = hashmap_iter_next(&iter)))
printf("%s %s\n", entry->key, get_value(entry));
} else if (!strcmp("size", cmd)) {
/* print table sizes */
printf("%u %u\n", map.tablesize, map.size);
} else if (!strcmp("intern", cmd) && l1) {
/* test that strintern works */
const char *i1 = strintern(p1);
const char *i2 = strintern(p1);
if (strcmp(i1, p1))
printf("strintern(%s) returns %s\n", p1, i1);
else if (i1 == p1)
printf("strintern(%s) returns input pointer\n", p1);
else if (i1 != i2)
printf("strintern(%s) != strintern(%s)", i1, i2);
else
printf("%s\n", i1);
} else if (!strcmp("perfhashmap", cmd) && l1 && l2) {
perf_hashmap(atoi(p1), atoi(p2));
} else {
printf("Unknown command %s\n", cmd);
}
}
hashmap_free(&map, 1);
return 0;
}
void LXIntegerMapDestroy(LXIntegerMapPtr r)
{
if ( !r) return;
hashmap_free((map_t)r);
}
void manager_free(Manager *m) {
Session *session;
User *u;
Device *d;
Seat *s;
Inhibitor *i;
Button *b;
assert(m);
while ((session = hashmap_first(m->sessions)))
session_free(session);
while ((u = hashmap_first(m->users)))
user_free(u);
while ((d = hashmap_first(m->devices)))
device_free(d);
while ((s = hashmap_first(m->seats)))
seat_free(s);
while ((i = hashmap_first(m->inhibitors)))
inhibitor_free(i);
while ((b = hashmap_first(m->buttons)))
button_free(b);
hashmap_free(m->devices);
hashmap_free(m->seats);
hashmap_free(m->sessions);
hashmap_free(m->users);
hashmap_free(m->inhibitors);
hashmap_free(m->buttons);
hashmap_free(m->user_units);
hashmap_free(m->session_units);
set_free_free(m->busnames);
sd_event_source_unref(m->idle_action_event_source);
sd_event_source_unref(m->console_active_event_source);
sd_event_source_unref(m->udev_seat_event_source);
sd_event_source_unref(m->udev_device_event_source);
sd_event_source_unref(m->udev_vcsa_event_source);
sd_event_source_unref(m->udev_button_event_source);
sd_event_source_unref(m->lid_switch_ignore_event_source);
safe_close(m->console_active_fd);
if (m->udev_seat_monitor)
udev_monitor_unref(m->udev_seat_monitor);
if (m->udev_device_monitor)
udev_monitor_unref(m->udev_device_monitor);
if (m->udev_vcsa_monitor)
udev_monitor_unref(m->udev_vcsa_monitor);
if (m->udev_button_monitor)
udev_monitor_unref(m->udev_button_monitor);
if (m->udev)
udev_unref(m->udev);
bus_verify_polkit_async_registry_free(m->bus, m->polkit_registry);
sd_bus_unref(m->bus);
sd_event_unref(m->event);
safe_close(m->reserve_vt_fd);
strv_free(m->kill_only_users);
strv_free(m->kill_exclude_users);
free(m->action_job);
free(m);
}
void procedures_at_exit(void) {
struct source_file_name *f, *fn;
struct object_file *o;
struct reference *r;
struct section *s;
struct stack *sta;
struct label *l;
/* free all the dynamically allocated data structures */
while (obj_first != NULL) {
f = obj_first->source_file_names_list;
while (f != NULL) {
if (f->name != NULL)
free(f->name);
fn = f->next;
free(f);
f = fn;
}
if (obj_first->data != NULL)
free(obj_first->data);
if (obj_first->name != NULL)
free(obj_first->name);
o = obj_first;
obj_first = obj_first->next;
free(o);
}
if (global_unique_label_map != NULL)
hashmap_free(global_unique_label_map);
if (namespace_map != NULL) {
hashmap_free_all_elements(namespace_map);
hashmap_free(namespace_map);
}
while (labels_first != NULL) {
l = labels_first;
labels_first = labels_first->next;
free(l);
}
while (reference_first != NULL) {
r = reference_first;
reference_first = reference_first->next;
free(r);
}
while (stacks_first != NULL) {
sta = stacks_first->next;
free(stacks_first->stack);
free(stacks_first);
stacks_first = sta;
}
while (sec_first != NULL) {
s = sec_first->next;
if (sec_first->listfile_cmds != NULL)
free(sec_first->listfile_cmds);
if (sec_first->listfile_ints != NULL)
free(sec_first->listfile_ints);
hashmap_free(sec_first->label_map);
free(sec_first);
sec_first = s;
}
while (sec_hd_first != NULL) {
s = sec_hd_first->next;
free(sec_hd_first);
sec_hd_first = s;
}
if (banksizes != NULL)
free(banksizes);
if (bankaddress != NULL)
free(bankaddress);
}
/*
* Clears the cache.
*/
static void fscache_clear(void)
{
hashmap_free(&map, 1);
hashmap_init(&map, (hashmap_cmp_fn)fsentry_cmp, NULL, 0);
}
int main(void) {
entry *en;
char *key, *value;
int res;
hashmap *hm = hashmap_empty(20, string_hash_function, entry_free_func);
if (hm == NULL) {
return EXIT_FAILURE;
}
printf("Inserting test entries...\n");
en = create_entry("cat", "goes meow");
res = hashmap_put(en, hm);
if (res) {
fprintf(stderr, "FAIL: OOM (Insert1)\n");
return EXIT_FAILURE;
}
en = create_entry("dog", "goes woof");
res = hashmap_put(en, hm);
if (res) {
fprintf(stderr, "FAIL: OOM (Insert2)\n");
return EXIT_FAILURE;
}
en = create_entry("bird", "goes tweet");
res = hashmap_put(en, hm);
if (res) {
fprintf(stderr, "FAIL: OOM (Insert3)\n");
return EXIT_FAILURE;
}
en = create_entry("mouse", "goes sqeak");
res = hashmap_put(en, hm);
if (res) {
fprintf(stderr, "FAIL: OOM (Insert4)\n");
return EXIT_FAILURE;
}
if (hm->nr_entries == 4) {
printf("Success: 4 test entries inserted\n");
} else {
fprintf(stderr, "FAIL: Wrong number of entries! (insert5)\n");
return EXIT_FAILURE;
}
printf("\nTest Get...\n");
key = "dog";
value = (char *) hashmap_get(key, strlen(key) + 1, hm);
if (value) {
printf("Success: %s %s\n", key, value);
} else {
fprintf(stderr, "FAIL: No entry found! (Get1)\n");
return EXIT_FAILURE;
}
value = (char *) hashmap_get(key, strlen(key), hm);
if (value) {
fprintf(stderr, "FAIL: Entry found! (Get2)\n");
return EXIT_FAILURE;
} else {
printf("Success: No entry found for erroneous key length\n");
}
printf("\nTest Remove...\n");
res = hashmap_remove(key, strlen(key) + 1, hm);
if (res) {
printf("Success: Entry removed\n");
} else {
fprintf(stderr, "FAIL: Entry not removed! (Remove1)\n");
return EXIT_FAILURE;
}
value = (char *) hashmap_get(key, strlen(key), hm);
if (value) {
fprintf(stderr, "FAIL: Entry found! (Remove2)\n");
return EXIT_FAILURE;
} else {
printf("Success: No entry found after removal\n");
}
hashmap_free(hm);
return EXIT_SUCCESS;
}
void i18n_cleanup(void)
{
hashmap_free(&map, 1);
}
/*
* shm_network_stopall - Shared Memory Manager destructor
*/
static void shm_network_stopall() {
hashmap_free(shm_network);
free(shm_network);
syscall_shm_release(shm_cmd);
}
static void group_hashmap_free(Hashmap *h) {
group_hashmap_clear(h);
hashmap_free(h);
}
void free_eml_domains(map_t domains){
hashmap_iterate_keys(domains,&free_eml_domain_key,NULL);
hashmap_free(domains);
}
static void free_scene_data (Scene* scene) {
char sdkey[KEYSIZE];
snprintf (sdkey, KEYSIZE, "%p", scene);
SceneData* sceneData = hashmap_find (sdkey, mapSceneData);
if (sceneData) {
GLuint handle;
int k;
for (k = 0; k < list_size(sceneData->listBuffers); k++) {
handle = (GLuint)list_get(k, sceneData->listBuffers);
glDeleteBuffers (1, &handle);
}
for ( k = 0; k < list_size(sceneData->listPrograms); k++) {
handle = (GLuint)list_get(k, sceneData->listPrograms);
glDeleteProgram ( handle );
}
for ( k = 0; k < list_size(sceneData->listVShaders); k++) {
handle = (GLuint)list_get(k, sceneData->listVShaders);
glDeleteShader ( handle );
}
for ( k = 0; k < list_size(sceneData->listFShaders); k++) {
handle = (GLuint)list_get(k, sceneData->listFShaders);
glDeleteShader ( handle );
}
for ( k = 0; k < list_size(sceneData->listTextures); k++) {
handle = (GLuint)list_get(k, sceneData->listTextures);
glDeleteTextures ( 1, &handle );
}
list_free (sceneData->listPrograms);
list_free (sceneData->listVShaders);
list_free (sceneData->listFShaders);
list_free (sceneData->listBuffers);
list_free (sceneData->listTextures);
hashmap_free (sceneData->mapVShader2Handle);
hashmap_free (sceneData->mapFShader2Handle);
hashmap_free (sceneData->mapShaderShader2Handle);
hashmap_free (sceneData->mapBuffer2Handle);
hashmap_free (sceneData->mapTexture2Handle);
hashmap_free (sceneData->countBufferUsers);
hashmap_free (sceneData->countVShaderUsers);
hashmap_free (sceneData->countFShaderUsers);
hashmap_free (sceneData->countProgramUsers);
hashmap_free (sceneData->countTextureUsers);
hashmap_free (sceneData->mapSo2SoData);
list_free (sceneData->stageGbuffer);
list_free (sceneData->stageLight);
list_free (sceneData->stageGeometry);
list_free (sceneData->stageParticle);
list_free (sceneData->stageOverlay);
hashmap_delete (sdkey, mapSceneData);
}
}
/**
* Entry point into bt-daemon
* @param argc Number of arguments passed
* @param argv An array of string arguments
* @returns EXIT_SUCCESS if the operation succeeded, otherwise EXIT_FAILURE
*/
int main(int argc, char *argv[])
{
int fd;
int smackfd = -1;
socklen_t addr_len;
struct sockaddr_un remote;
int descriptors;
int ret;
bool manual_start = false;
struct sigaction sa;
if (!buxton_cache_smack_rules())
exit(EXIT_FAILURE);
smackfd = buxton_watch_smack_rules();
if (smackfd < 0 && errno)
exit(EXIT_FAILURE);
self.nfds_alloc = 0;
self.accepting_alloc = 0;
self.nfds = 0;
self.buxton.client.direct = true;
self.buxton.client.uid = geteuid();
if (!buxton_direct_open(&self.buxton))
exit(EXIT_FAILURE);
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
sa.sa_handler = my_handler;
ret = sigaction(SIGINT, &sa, NULL);
if (ret == -1)
exit(EXIT_FAILURE);
ret = sigaction(SIGTERM, &sa, NULL);
if (ret == -1)
exit(EXIT_FAILURE);
/* For client notifications */
self.notify_mapping = hashmap_new(string_hash_func, string_compare_func);
/* Store a list of connected clients */
LIST_HEAD_INIT(client_list_item, self.client_list);
descriptors = sd_listen_fds(0);
if (descriptors < 0) {
buxton_log("sd_listen_fds: %m\n");
exit(EXIT_FAILURE);
} else if (descriptors == 0) {
/* Manual invocation */
manual_start = true;
union {
struct sockaddr sa;
struct sockaddr_un un;
} sa;
fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (fd < 0) {
buxton_log("socket(): %m\n");
exit(EXIT_FAILURE);
}
memset(&sa, 0, sizeof(sa));
sa.un.sun_family = AF_UNIX;
strncpy(sa.un.sun_path, BUXTON_SOCKET, sizeof(sa.un.sun_path) - 1);
sa.un.sun_path[sizeof(sa.un.sun_path)-1] = 0;
ret = unlink(sa.un.sun_path);
if (ret == -1 && errno != ENOENT) {
exit(EXIT_FAILURE);
}
if (bind(fd, &sa.sa, sizeof(sa)) < 0) {
buxton_log("bind(): %m\n");
exit(EXIT_FAILURE);
}
chmod(sa.un.sun_path, 0666);
if (listen(fd, SOMAXCONN) < 0) {
buxton_log("listen(): %m\n");
exit(EXIT_FAILURE);
}
add_pollfd(&self, fd, POLLIN | POLLPRI, true);
} else {
/* systemd socket activation */
for (fd = SD_LISTEN_FDS_START + 0; fd < SD_LISTEN_FDS_START + descriptors; fd++) {
if (sd_is_fifo(fd, NULL)) {
add_pollfd(&self, fd, POLLIN, false);
buxton_debug("Added fd %d type FIFO\n", fd);
} else if (sd_is_socket_unix(fd, SOCK_STREAM, -1, BUXTON_SOCKET, 0)) {
add_pollfd(&self, fd, POLLIN | POLLPRI, true);
buxton_debug("Added fd %d type UNIX\n", fd);
} else if (sd_is_socket(fd, AF_UNSPEC, 0, -1)) {
add_pollfd(&self, fd, POLLIN | POLLPRI, true);
buxton_debug("Added fd %d type SOCKET\n", fd);
}
}
}
if (smackfd >= 0) {
/* add Smack rule fd to pollfds */
add_pollfd(&self, smackfd, POLLIN | POLLPRI, false);
}
buxton_log("%s: Started\n", argv[0]);
/* Enter loop to accept clients */
for (;;) {
ret = poll(self.pollfds, self.nfds, -1);
if (ret < 0) {
buxton_log("poll(): %m\n");
if (errno == EINTR) {
if (do_shutdown)
break;
else
continue;
}
break;
}
if (ret == 0)
continue;
for (nfds_t i=0; i<self.nfds; i++) {
client_list_item *cl = NULL;
char discard[256];
if (self.pollfds[i].revents == 0)
continue;
if (self.pollfds[i].fd == -1) {
/* TODO: Remove client from list */
buxton_debug("Removing / Closing client for fd %d\n", self.pollfds[i].fd);
del_pollfd(&self, i);
continue;
}
if (smackfd >= 0) {
if (self.pollfds[i].fd == smackfd) {
if (!buxton_cache_smack_rules())
exit(EXIT_FAILURE);
buxton_log("Reloaded Smack access rules\n");
/* discard inotify data itself */
while (read(smackfd, &discard, 256) == 256);
continue;
}
}
if (self.accepting[i] == true) {
struct timeval tv;
int fd;
int on = 1;
addr_len = sizeof(remote);
if ((fd = accept(self.pollfds[i].fd,
(struct sockaddr *)&remote, &addr_len)) == -1) {
buxton_log("accept(): %m\n");
break;
}
buxton_debug("New client fd %d connected through fd %d\n", fd, self.pollfds[i].fd);
cl = malloc0(sizeof(client_list_item));
if (!cl)
exit(EXIT_FAILURE);
LIST_INIT(client_list_item, item, cl);
cl->fd = fd;
cl->cred = (struct ucred) {0, 0, 0};
LIST_PREPEND(client_list_item, item, self.client_list, cl);
/* poll for data on this new client as well */
add_pollfd(&self, cl->fd, POLLIN | POLLPRI, false);
/* Mark our packets as high prio */
if (setsockopt(cl->fd, SOL_SOCKET, SO_PRIORITY, &on, sizeof(on)) == -1)
buxton_log("setsockopt(SO_PRIORITY): %m\n");
/* Set socket recv timeout */
tv.tv_sec = SOCKET_TIMEOUT;
tv.tv_usec = 0;
if (setsockopt(cl->fd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv,
sizeof(struct timeval)) == -1)
buxton_log("setsockopt(SO_RCVTIMEO): %m\n");
/* check if this is optimal or not */
break;
}
assert(self.accepting[i] == 0);
if (smackfd >= 0)
assert(self.pollfds[i].fd != smackfd);
/* handle data on any connection */
/* TODO: Replace with hash table lookup */
LIST_FOREACH(item, cl, self.client_list)
if (self.pollfds[i].fd == cl->fd)
break;
assert(cl);
handle_client(&self, cl, i);
}
}
buxton_log("%s: Closing all connections\n", argv[0]);
if (manual_start)
unlink(BUXTON_SOCKET);
for (int i = 0; i < self.nfds; i++) {
close(self.pollfds[i].fd);
}
for (client_list_item *i = self.client_list; i;) {
client_list_item *j = i->item_next;
free(i);
i = j;
}
hashmap_free(self.notify_mapping);
buxton_direct_close(&self.buxton);
return EXIT_SUCCESS;
}
