static gboolean
pe_msg_callback(IPC_Channel * client, gpointer user_data)
{
xmlNode *msg = NULL;
gboolean stay_connected = TRUE;
while (IPC_ISRCONN(client)) {
if (client->ops->is_message_pending(client) == 0) {
break;
}
msg = xmlfromIPC(client, MAX_IPC_DELAY);
if (msg != NULL) {
xmlNode *data = get_message_xml(msg, F_CRM_DATA);
process_pe_message(msg, data, client);
free_xml(msg);
}
}
if (client->ch_status != IPC_CONNECT) {
stay_connected = FALSE;
}
return stay_connected;
}
static gboolean
stonith_client_callback(IPC_Channel *channel, gpointer user_data)
{
int lpc = 0;
const char *value = NULL;
xmlNode *request = NULL;
gboolean keep_channel = TRUE;
stonith_client_t *stonith_client = user_data;
CRM_CHECK(stonith_client != NULL, crm_err("Invalid client"); return FALSE);
CRM_CHECK(stonith_client->id != NULL,
crm_err("Invalid client: %p", stonith_client); return FALSE);
if(IPC_ISRCONN(channel) && channel->ops->is_message_pending(channel)) {
lpc++;
request = xmlfromIPC(channel, MAX_IPC_DELAY);
if (request == NULL) {
goto bail;
}
if(stonith_client->name == NULL) {
value = crm_element_value(request, F_STONITH_CLIENTNAME);
if(value == NULL) {
stonith_client->name = crm_itoa(channel->farside_pid);
} else {
stonith_client->name = crm_strdup(value);
}
}
crm_xml_add(request, F_STONITH_CLIENTID, stonith_client->id);
crm_xml_add(request, F_STONITH_CLIENTNAME, stonith_client->name);
if(stonith_client->callback_id == NULL) {
value = crm_element_value(request, F_STONITH_CALLBACK_TOKEN);
if(value != NULL) {
stonith_client->callback_id = crm_strdup(value);
} else {
stonith_client->callback_id = crm_strdup(stonith_client->id);
}
}
crm_log_xml_trace(request, "Client[inbound]");
stonith_command(stonith_client, request, NULL);
free_xml(request);
}
bail:
if(channel->ch_status != IPC_CONNECT) {
crm_trace("Client disconnected");
keep_channel = stonith_client_disconnect(channel, stonith_client);
}
return keep_channel;
}
static gboolean
on_receive_cmd (IPC_Channel* ch, gpointer user_data)
{
IPC_Message* ipcmsg;
ha_logd_client_t* client = (ha_logd_client_t*)user_data;
IPC_Channel* logchan= client->logchan;
if (!ch->ops->is_message_pending(ch)) {
goto getout;
}
ipcmsg = getIPCmsg(ch);
if (ipcmsg == NULL){
if (IPC_ISRCONN(ch)) {
cl_log(LOG_ERR, "%s: read error on connected channel [%s:%d]"
, __FUNCTION__, client->app_name, client->pid);
}
return FALSE;
}
if( ipcmsg->msg_body && ipcmsg->msg_len > 0 ){
if (client->app_name[0] == '\0'){
LogDaemonMsgHdr* logmsghdr;
logmsghdr = (LogDaemonMsgHdr*) ipcmsg->msg_body;
strncpy(client->app_name, logmsghdr->entity, MAXENTITY);
}
if (!IPC_ISWCONN(logchan)){
cl_log(LOG_ERR
, "%s: channel to write process disconnected"
, __FUNCTION__);
return FALSE;
}
if (logchan->ops->send(logchan, ipcmsg) != IPC_OK){
cl_log(LOG_ERR
, "%s: forwarding msg from [%s:%d] to"
" write process failed"
, __FUNCTION__
, client->app_name, client->pid);
cl_log(LOG_ERR, "queue too small? (max=%ld, current len =%ld)",
(long)logchan->send_queue->max_qlen,
(long)logchan->send_queue->current_qlen);
return TRUE;
}
}else {
cl_log(LOG_ERR, "on_receive_cmd:"
" invalid ipcmsg\n");
}
getout:
return TRUE;
}
/*
* Apparently returning TRUE means "stay connected, keep doing stuff".
* Returning FALSE means "we're all done, close the connection"
*/
gboolean
crmd_ipc_msg_callback(IPC_Channel * client, gpointer user_data)
{
int lpc = 0;
xmlNode *msg = NULL;
crmd_client_t *curr_client = (crmd_client_t *) user_data;
gboolean stay_connected = TRUE;
crm_trace("Invoked: %s", curr_client->table_key);
while (IPC_ISRCONN(client)) {
if (client->ops->is_message_pending(client) == 0) {
break;
}
msg = xmlfromIPC(client, MAX_IPC_DELAY);
if (msg == NULL) {
break;
}
#if ENABLE_ACL
determine_request_user(&curr_client->user, client, msg, F_CRM_USER);
#endif
lpc++;
crm_trace("Processing msg from %s", curr_client->table_key);
crm_log_xml_trace(msg, "CRMd[inbound]");
if (crmd_authorize_message(msg, curr_client)) {
route_message(C_IPC_MESSAGE, msg);
}
free_xml(msg);
msg = NULL;
if (client->ch_status != IPC_CONNECT) {
break;
}
}
crm_trace("Processed %d messages", lpc);
if (client->ch_status != IPC_CONNECT) {
stay_connected = FALSE;
process_client_disconnect(curr_client);
}
trigger_fsa(fsa_source);
return stay_connected;
}
static gboolean
attrd_ipc_callback(IPC_Channel * client, gpointer user_data)
{
int lpc = 0;
xmlNode *msg = NULL;
attrd_client_t *curr_client = (attrd_client_t *) user_data;
gboolean stay_connected = TRUE;
crm_trace("Invoked: %s", curr_client->id);
while (IPC_ISRCONN(client)) {
if (client->ops->is_message_pending(client) == 0) {
break;
}
msg = xmlfromIPC(client, MAX_IPC_DELAY);
if (msg == NULL) {
break;
}
lpc++;
#if ENABLE_ACL
determine_request_user(&curr_client->user, client, msg, F_ATTRD_USER);
#endif
crm_trace("Processing msg from %s", curr_client->id);
crm_log_xml_trace(msg, __PRETTY_FUNCTION__);
attrd_local_callback(msg);
free_xml(msg);
msg = NULL;
if (client->ch_status != IPC_CONNECT) {
break;
}
}
crm_trace("Processed %d messages", lpc);
if (client->ch_status != IPC_CONNECT) {
stay_connected = FALSE;
}
return stay_connected;
}
static gboolean
resource_ipc_callback(IPC_Channel * server, void *private_data)
{
int lpc = 0;
xmlNode *msg = NULL;
gboolean stay_connected = TRUE;
while(IPC_ISRCONN(server)) {
if(server->ops->is_message_pending(server) == 0) {
break;
}
msg = xmlfromIPC(server, MAX_IPC_DELAY);
if (msg == NULL) {
break;
}
lpc++;
fprintf(stderr, ".");
crm_log_xml(LOG_DEBUG_2, "[inbound]", msg);
crmd_replies_needed--;
if(crmd_replies_needed == 0) {
fprintf(stderr, "\n");
crm_debug("Got all the replies we expected");
exit(0);
}
free_xml(msg);
msg = NULL;
if(server->ch_status != IPC_CONNECT) {
break;
}
}
crm_debug_2("Processed %d messages (%d)", lpc, server->ch_status);
if (server->ch_status != IPC_CONNECT) {
stay_connected = FALSE;
}
return stay_connected;
}
static gboolean
attrd_ipc_callback(IPC_Channel *client, gpointer user_data)
{
int lpc = 0;
xmlNode *msg = NULL;
attrd_client_t *curr_client = (attrd_client_t*)user_data;
gboolean stay_connected = TRUE;
crm_debug_2("Invoked: %s", curr_client->id);
while(IPC_ISRCONN(client)) {
if(client->ops->is_message_pending(client) == 0) {
break;
}
msg = xmlfromIPC(client, MAX_IPC_DELAY);
if (msg == NULL) {
break;
}
lpc++;
crm_debug_2("Processing msg from %s", curr_client->id);
crm_log_xml(LOG_DEBUG_3, __PRETTY_FUNCTION__, msg);
attrd_local_callback(msg);
free_xml(msg);
msg = NULL;
if(client->ch_status != IPC_CONNECT) {
break;
}
}
crm_debug_2("Processed %d messages", lpc);
if (client->ch_status != IPC_CONNECT) {
stay_connected = FALSE;
}
return stay_connected;
}
gboolean
subsystem_msg_dispatch(IPC_Channel *sender, void *user_data)
{
int lpc = 0;
xmlNode *msg = NULL;
xmlNode *data = NULL;
gboolean all_is_well = TRUE;
const char *sys_to;
const char *task;
gboolean (*process_function)
(xmlNode *msg, xmlNode *data, IPC_Channel *sender) = NULL;
while(IPC_ISRCONN(sender)) {
gboolean process = FALSE;
if(sender->ops->is_message_pending(sender) == 0) {
break;
}
msg = xmlfromIPC(sender, MAX_IPC_DELAY);
if (msg == NULL) {
break;
}
lpc++;
crm_log_xml(LOG_MSG, __FUNCTION__, msg);
sys_to = crm_element_value(msg, F_CRM_SYS_TO);
task = crm_element_value(msg, F_CRM_TASK);
if(safe_str_eq(task, CRM_OP_HELLO)) {
process = TRUE;
} else if(sys_to == NULL) {
crm_err("Value of %s was NULL!!", F_CRM_SYS_TO);
} else if(task == NULL) {
crm_err("Value of %s was NULL!!", F_CRM_TASK);
} else {
process = TRUE;
}
if(process == FALSE) {
free_xml(msg); msg = NULL;
continue;
}
data = get_message_xml(msg, F_CRM_DATA);
process_function = user_data;
if(FALSE == process_function(msg, data, sender)) {
crm_warn("Received a message destined for %s"
" by mistake", sys_to);
}
free_xml(msg); msg = NULL;
if(sender->ch_status == IPC_CONNECT) {
break;
}
}
crm_debug_2("Processed %d messages", lpc);
if (sender->ch_status != IPC_CONNECT) {
crm_err("The server %d has left us: Shutting down...NOW",
sender->farside_pid);
exit(1); /* shutdown properly later */
return !all_is_well;
}
return all_is_well;
}
