static void presence_process_request_event(void *op_base, const belle_sip_request_event_t *event) {
SalOp* op = (SalOp*)op_base;
belle_sip_server_transaction_t* server_transaction = belle_sip_provider_create_server_transaction(op->base.root->prov,belle_sip_request_event_get_request(event));
belle_sip_request_t* req = belle_sip_request_event_get_request(event);
belle_sip_dialog_state_t dialog_state;
belle_sip_header_expires_t* expires = belle_sip_message_get_header_by_type(req,belle_sip_header_expires_t);
belle_sip_response_t* resp;
const char *method=belle_sip_request_get_method(req);
belle_sip_object_ref(server_transaction);
if (op->pending_server_trans) belle_sip_object_unref(op->pending_server_trans);
op->pending_server_trans=server_transaction;
if (!op->dialog) {
if (strcmp(method,"SUBSCRIBE")==0){
op->dialog=belle_sip_provider_create_dialog(op->base.root->prov,BELLE_SIP_TRANSACTION(server_transaction));
belle_sip_dialog_set_application_data(op->dialog,op);
sal_op_ref(op);
ms_message("new incoming subscription from [%s] to [%s]",sal_op_get_from(op),sal_op_get_to(op));
}else{ /* this is a NOTIFY */
ms_message("Receiving out of dialog notify");
handle_notify(op,req);
return;
}
}
dialog_state=belle_sip_dialog_get_state(op->dialog);
switch(dialog_state) {
case BELLE_SIP_DIALOG_NULL: {
op->base.root->callbacks.subscribe_presence_received(op,sal_op_get_from(op));
break;
}
case BELLE_SIP_DIALOG_EARLY:
ms_error("unexpected method [%s] for dialog [%p] in state BELLE_SIP_DIALOG_EARLY ",method,op->dialog);
break;
case BELLE_SIP_DIALOG_CONFIRMED:
if (strcmp("NOTIFY",method)==0) {
handle_notify(op,req);
} else if (strcmp("SUBSCRIBE",method)==0) {
/*either a refresh or an unsubscribe*/
if (expires && belle_sip_header_expires_get_expires(expires)>0) {
op->base.root->callbacks.subscribe_presence_received(op,sal_op_get_from(op));
} else if(expires) {
ms_message("Unsubscribe received from [%s]",sal_op_get_from(op));
resp=sal_op_create_response_from_request(op,req,200);
belle_sip_server_transaction_send_response(server_transaction,resp);
}
}
break;
default:
ms_error("unexpected dialog state [%s]",belle_sip_dialog_state_to_string(dialog_state));
break;
}
}
/* dialog procedure for the "Identities" configuration node */
INT_PTR CALLBACK
khm_cfg_identities_proc(HWND hwnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam) {
HWND hw;
switch(uMsg) {
case WM_INITDIALOG:
set_window_node(hwnd, (khui_config_node) lParam);
add_subpanels(hwnd, (khui_config_node) lParam,
(khui_config_node) lParam);
hw = GetDlgItem(hwnd, IDC_CFG_TAB);
show_tab_panel(hwnd,
(khui_config_node) lParam,
hw,
TabCtrl_GetCurSel(hw),
TRUE);
return FALSE;
case WM_DESTROY:
return 0;
case KHUI_WM_CFG_NOTIFY:
return handle_cfg_notify(hwnd, wParam, lParam);
case WM_NOTIFY:
return handle_notify(hwnd, wParam, lParam);
}
return FALSE;
}
/*===========================================================================*
* chardriver_process *
*===========================================================================*/
void chardriver_process(struct chardriver *cdp, int driver_type,
message *m_ptr, int ipc_status)
{
/* Handle the given received message. */
int r;
/* Process the notification or request. */
if (is_ipc_notify(ipc_status)) {
handle_notify(cdp, m_ptr);
/* Do not reply to notifications. */
} else {
r = handle_request(cdp, m_ptr);
send_reply(driver_type, m_ptr, ipc_status, r);
}
}
/* dialog procedure for individual identity configuration nodes */
INT_PTR CALLBACK
khm_cfg_identity_proc(HWND hwnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam) {
HWND hw;
switch(uMsg) {
case WM_INITDIALOG:
{
khui_config_node refnode = NULL;
set_window_node(hwnd, (khui_config_node) lParam);
khui_cfg_open(NULL, L"KhmIdentities", &refnode);
#ifdef DEBUG
assert(refnode != NULL);
#endif
add_subpanels(hwnd,
(khui_config_node) lParam,
refnode);
hw = GetDlgItem(hwnd, IDC_CFG_TAB);
show_tab_panel(hwnd,
(khui_config_node) lParam,
hw,
TabCtrl_GetCurSel(hw),
TRUE);
khui_cfg_release(refnode);
}
return FALSE;
case WM_DESTROY:
return 0;
case KHUI_WM_CFG_NOTIFY:
return handle_cfg_notify(hwnd, wParam, lParam);
case WM_NOTIFY:
return handle_notify(hwnd, wParam, lParam);
}
return FALSE;
}
static bool can_read_data(struct io *io, void *user_data)
{
struct bt_att *att = user_data;
uint8_t opcode;
uint8_t *pdu;
ssize_t bytes_read;
bytes_read = read(att->fd, att->buf, att->mtu);
if (bytes_read < 0)
return false;
util_hexdump('>', att->buf, bytes_read,
att->debug_callback, att->debug_data);
if (bytes_read < ATT_MIN_PDU_LEN)
return true;
pdu = att->buf;
opcode = pdu[0];
/* Act on the received PDU based on the opcode type */
switch (get_op_type(opcode)) {
case ATT_OP_TYPE_RSP:
util_debug(att->debug_callback, att->debug_data,
"ATT response received: 0x%02x", opcode);
handle_rsp(att, opcode, pdu + 1, bytes_read - 1);
break;
case ATT_OP_TYPE_CONF:
util_debug(att->debug_callback, att->debug_data,
"ATT opcode cannot be handled: 0x%02x", opcode);
break;
default:
/* For all other opcodes notify the upper layer of the PDU and
* let them act on it.
*/
util_debug(att->debug_callback, att->debug_data,
"ATT PDU received: 0x%02x", opcode);
handle_notify(att, opcode, pdu + 1, bytes_read - 1);
break;
}
return true;
}
static void select_process_event(event_context_t *ec){
struct timeval tv={timeout,0};
fd_set read_set;
fd_set write_set;
intptr_t max=prepare_fd_set(ec,&read_set,&write_set);
intptr_t ret = select(max+1, &read_set, &write_set, NULL, &tv);
if(ret==-1){
my_log(ERROR,"select event error\n");
return;
}else if(ret==0){
return;
}
event_t *events=(event_t *)ec->events;
intptr_t i=0;
for(;i<max_event_count;i++){
intptr_t fd=events[i].fd;
if(fd==0){
continue;
}
if(FD_ISSET(fd,&read_set)){
if(fd==ec->listen_fd){
accept_connection();
}else if(fd==ec->worker_fd){
handle_notify(fd,ec);
}else{
handle_read(events[i].data);
}
}
if(FD_ISSET(fd,&write_set)){
intptr_t result=handle_write(events[i].data);
if(result==OK){
event_operation.del_event(fd,WRITE,ec);
}
}
}
}
static bool can_read_data(struct io *io, void *user_data)
{
struct bt_att *att = user_data;
uint8_t opcode;
uint8_t *pdu;
ssize_t bytes_read;
bytes_read = read(att->fd, att->buf, att->mtu);
if (bytes_read < 0)
return false;
util_hexdump('>', att->buf, bytes_read,
att->debug_callback, att->debug_data);
if (bytes_read < ATT_MIN_PDU_LEN)
return true;
pdu = att->buf;
opcode = pdu[0];
bt_att_ref(att);
/* Act on the received PDU based on the opcode type */
switch (get_op_type(opcode)) {
case ATT_OP_TYPE_RSP:
util_debug(att->debug_callback, att->debug_data,
"ATT response received: 0x%02x", opcode);
handle_rsp(att, opcode, pdu + 1, bytes_read - 1);
break;
case ATT_OP_TYPE_CONF:
util_debug(att->debug_callback, att->debug_data,
"ATT confirmation received: 0x%02x", opcode);
handle_conf(att, pdu + 1, bytes_read - 1);
break;
case ATT_OP_TYPE_REQ:
/*
* If a request is currently pending, then the sequential
* protocol was violated. Disconnect the bearer, which will
* promptly notify the upper layer via disconnect handlers.
*/
if (att->in_req) {
util_debug(att->debug_callback, att->debug_data,
"Received request while another is "
"pending: 0x%02x", opcode);
io_shutdown(att->io);
bt_att_unref(att);
return false;
}
att->in_req = true;
/* Fall through to the next case */
case ATT_OP_TYPE_CMD:
case ATT_OP_TYPE_NOT:
case ATT_OP_TYPE_UNKNOWN:
case ATT_OP_TYPE_IND:
default:
/* For all other opcodes notify the upper layer of the PDU and
* let them act on it.
*/
util_debug(att->debug_callback, att->debug_data,
"ATT PDU received: 0x%02x", opcode);
handle_notify(att, opcode, pdu + 1, bytes_read - 1);
break;
}
bt_att_unref(att);
return true;
}
