struct qb_ipcs_connection *
qb_ipcs_connection_alloc(struct qb_ipcs_service *s)
{
struct qb_ipcs_connection *c =
calloc(1, sizeof(struct qb_ipcs_connection));
if (c == NULL) {
return NULL;
}
c->refcount = 1;
c->service = s;
c->pid = 0;
c->euid = -1;
c->egid = -1;
qb_list_init(&c->list);
c->receive_buf = NULL;
c->context = NULL;
c->fc_enabled = QB_FALSE;
c->state = QB_IPCS_CONNECTION_INACTIVE;
c->poll_events = POLLIN | POLLPRI | POLLNVAL;
c->setup.type = s->type;
c->request.type = s->type;
c->response.type = s->type;
c->event.type = s->type;
return c;
}
/*
* Create a new level @level node with value @value. The node should eventually
* be destroyed with @skiplist_node_destroy.
*
* return: a new node on success and NULL otherwise.
*/
static struct skiplist_node *
skiplist_node_new(const int8_t level, const char *key, const void *value)
{
struct skiplist_node *new_node = (struct skiplist_node *)
(malloc(sizeof(struct skiplist_node)));
if (!new_node)
return NULL;
new_node->value = (void *)value;
new_node->key = key;
new_node->level = level;
new_node->refcount = 1;
qb_list_init(&new_node->notifier_head);
/* A level 0 node still needs to hold 1 forward pointer, etc. */
new_node->forward = (struct skiplist_node **)
(calloc(level + 1, sizeof(struct skiplist_node *)));
if (new_node->forward == NULL) {
free(new_node);
return NULL;
}
return new_node;
}
int
main(int argc, char *argv[])
{
qb_list_init (&msg_log_head);
qb_list_init (&config_chg_log_head);
if (NSS_NoDB_Init(".") != SECSuccess) {
qb_log(LOG_ERR, "Couldn't initialize nss");
exit (0);
}
if ((sha1_context = PK11_CreateDigestContext(SEC_OID_SHA1)) == NULL) {
qb_log(LOG_ERR, "Couldn't initialize nss");
exit (0);
}
return test_agent_run ("cpg_test_agent", 9034, do_command, my_pre_exit);
}
static void config_change_callback (
cpg_handle_t handle,
const struct cpg_name *groupName,
const struct cpg_address *member_list, size_t member_list_entries,
const struct cpg_address *left_list, size_t left_list_entries,
const struct cpg_address *joined_list, size_t joined_list_entries)
{
int i;
log_entry_t *log_pt;
/* group_name,ip,pid,join|leave */
if (record_config_events_g > 0) {
qb_log (LOG_INFO, "got cpg event[recording] for group %s", groupName->value);
} else {
qb_log (LOG_INFO, "got cpg event[ignoring] for group %s", groupName->value);
}
for (i = 0; i < left_list_entries; i++) {
if (record_config_events_g > 0) {
log_pt = malloc (sizeof(log_entry_t));
qb_list_init (&log_pt->list);
snprintf (log_pt->log, LOG_STR_SIZE, "%s,%u,%u,left",
groupName->value, left_list[i].nodeid,left_list[i].pid);
qb_list_add_tail(&log_pt->list, &config_chg_log_head);
qb_log (LOG_INFO, "cpg event %s", log_pt->log);
}
}
for (i = 0; i < joined_list_entries; i++) {
if (record_config_events_g > 0) {
log_pt = malloc (sizeof(log_entry_t));
qb_list_init (&log_pt->list);
snprintf (log_pt->log, LOG_STR_SIZE, "%s,%u,%u,join",
groupName->value, joined_list[i].nodeid,joined_list[i].pid);
qb_list_add_tail (&log_pt->list, &config_chg_log_head);
qb_log (LOG_INFO, "cpg event %s", log_pt->log);
}
}
if (pcmk_test == 1) {
in_cnchg = 1;
send_some_more_messages (NULL);
in_cnchg = 0;
}
}
qb_ipcs_service_t *
qb_ipcs_create(const char *name,
int32_t service_id,
enum qb_ipc_type type, struct qb_ipcs_service_handlers *handlers)
{
struct qb_ipcs_service *s;
s = calloc(1, sizeof(struct qb_ipcs_service));
if (s == NULL) {
return NULL;
}
if (type == QB_IPC_NATIVE) {
#if defined (HAVE_SEM_TIMEDWAIT) || defined(HAVE_SEMTIMEDOP)
s->type = QB_IPC_SHM;
#else
s->type = QB_IPC_SOCKET;
#endif /* HAVE_SEM_TIMEDWAIT */
} else {
s->type = type;
}
s->pid = getpid();
s->needs_sock_for_poll = QB_FALSE;
s->poll_priority = QB_LOOP_MED;
s->ref_count = 1;
s->service_id = service_id;
(void)strlcpy(s->name, name, NAME_MAX);
s->serv_fns.connection_accept = handlers->connection_accept;
s->serv_fns.connection_created = handlers->connection_created;
s->serv_fns.msg_process = handlers->msg_process;
s->serv_fns.connection_closed = handlers->connection_closed;
s->serv_fns.connection_destroyed = handlers->connection_destroyed;
qb_list_init(&s->connections);
qb_list_init(&s->list);
qb_list_add(&s->list, &qb_ipc_services);
return s;
}
static void delivery_callback (
cpg_handle_t handle,
const struct cpg_name *groupName,
uint32_t nodeid,
uint32_t pid,
void *msg,
size_t msg_len)
{
log_entry_t *log_pt;
msg_t *msg_pt = (msg_t*)msg;
msg_status_t status = MSG_OK;
char status_buf[20];
unsigned char sha1_compare[20];
unsigned int sha1_len;
if (record_messages_g == 0) {
return;
}
if (nodeid != msg_pt->nodeid) {
status = MSG_NODEID_ERR;
}
if (pid != msg_pt->pid) {
status = MSG_PID_ERR;
}
if (msg_len != msg_pt->size) {
status = MSG_SIZE_ERR;
}
PK11_DigestBegin(sha1_context);
PK11_DigestOp(sha1_context, msg_pt->payload, (msg_pt->size - sizeof (msg_t)));
PK11_DigestFinal(sha1_context, sha1_compare, &sha1_len, sizeof(sha1_compare));
if (memcmp (sha1_compare, msg_pt->sha1, 20) != 0) {
qb_log (LOG_ERR, "msg seq:%d; incorrect hash",
msg_pt->seq);
status = MSG_SHA1_ERR;
}
log_pt = malloc (sizeof(log_entry_t));
qb_list_init (&log_pt->list);
snprintf (log_pt->log, LOG_STR_SIZE, "%u:%d:%d:%s;",
msg_pt->nodeid, msg_pt->seq, my_seq,
err_status_string (status_buf, 20, status));
qb_list_add_tail (&log_pt->list, &msg_log_head);
total_stored_msgs++;
total_msgs_revd++;
my_seq++;
if ((total_msgs_revd % 1000) == 0) {
qb_log (LOG_INFO, "rx %d", total_msgs_revd);
}
}
static int32_t
skiplist_notify_add(qb_map_t * m, const char *key,
qb_map_notify_fn fn, int32_t events, void *user_data)
{
struct skiplist *t = (struct skiplist *)m;
struct qb_map_notifier *f;
struct skiplist_node *n;
struct qb_list_head *list;
int add_to_tail = QB_FALSE;
if (key) {
n = skiplist_lookup(t, key);
} else {
n = t->header;
}
if (events & QB_MAP_NOTIFY_FREE) {
add_to_tail = QB_TRUE;
}
if (n) {
for (list = n->notifier_head.next;
list != &n->notifier_head; list = list->next) {
f = qb_list_entry(list, struct qb_map_notifier, list);
if (events & QB_MAP_NOTIFY_FREE &&
f->events == events) {
/* only one free notifier */
return -EEXIST;
}
if (f->events == events &&
f->callback == fn &&
f->user_data == user_data) {
return -EEXIST;
}
}
f = malloc(sizeof(struct qb_map_notifier));
if (f == NULL) {
return -errno;
}
f->events = events;
f->user_data = user_data;
f->callback = fn;
qb_list_init(&f->list);
if (add_to_tail) {
qb_list_add_tail(&f->list, &n->notifier_head);
} else {
qb_list_add(&f->list, &n->notifier_head);
}
return 0;
}
return -EINVAL;
}
void
qb_log_thread_log_post(struct qb_log_callsite *cs,
time_t timestamp, const char *buffer)
{
struct qb_log_record *rec;
size_t buf_size;
size_t total_size;
rec = malloc(sizeof(struct qb_log_record));
if (rec == NULL) {
return;
}
buf_size = strlen(buffer) + 1;
total_size = sizeof(struct qb_log_record) + buf_size;
rec->cs = cs;
rec->buffer = malloc(buf_size);
if (rec->buffer == NULL) {
goto free_record;
}
memcpy(rec->buffer, buffer, buf_size);
rec->timestamp = timestamp;
qb_list_init(&rec->list);
(void)qb_thread_lock(logt_wthread_lock);
logt_memory_used += total_size;
if (logt_memory_used > 512000) {
free(rec->buffer);
free(rec);
logt_memory_used = logt_memory_used - total_size;
logt_dropped_messages += 1;
(void)qb_thread_unlock(logt_wthread_lock);
return;
} else {
qb_list_add_tail(&rec->list, &logt_print_finished_records);
}
(void)qb_thread_unlock(logt_wthread_lock);
sem_post(&logt_print_finished);
return;
free_record:
free(rec);
}
static void
qb_loop_run_level(struct qb_loop_level *level)
{
struct qb_loop_item *job;
int32_t processed = 0;
Ill_have_another:
if (!qb_list_empty(&level->job_head)) {
job = qb_list_first_entry(&level->job_head, struct qb_loop_item, list);
qb_list_del(&job->list);
qb_list_init(&job->list);
job->source->dispatch_and_take_back(job, level->priority);
level->todo--;
processed++;
if (level->l->stop_requested) {
return;
}
if (processed < level->to_process) {
goto Ill_have_another;
}
}