MojErr testMultiEcho()
{
const MojChar* echoStr = _T("{\"hello\":\"world\"}");
MojObject expectedResponse;
MojErr err = formatEchoResponse(echoStr, expectedResponse);
MojTestErrCheck(err);
MojRefCountedPtr<MojServiceRequest> req;
err = m_service.createRequest(req);
MojTestErrCheck(err);
m_pendingResponseCount+= multiResponseCount;
MojRefCountedPtr<EchoMultiResponseHdlr> hdlr(new EchoMultiResponseHdlr(expectedResponse, m_pendingResponseCount, multiResponseCount));
MojAllocCheck(hdlr.get());
MojObject payload;
err = payload.fromJson(echoStr);
MojTestErrCheck(err);
err = req->send(hdlr->m_slot, ServiceName, _T("multiecho"), payload, MojServiceRequest::Unlimited);
MojTestErrCheck(err);
err = receiveResponses();
MojTestErrCheck(err);
return MojErrNone;
}
int diag_process_apps_masks(unsigned char *buf, int len)
{
int size = 0;
int sub_cmd = 0;
int (*hdlr)(unsigned char *src_buf, int src_len,
unsigned char *dest_buf, int dest_len) = NULL;
if (!buf || len <= 0)
return -EINVAL;
if (*buf == DIAG_CMD_LOG_CONFIG) {
sub_cmd = *(int *)(buf + sizeof(int));
switch (sub_cmd) {
case DIAG_CMD_OP_LOG_DISABLE:
hdlr = diag_cmd_disable_log_mask;
break;
case DIAG_CMD_OP_GET_LOG_RANGE:
hdlr = diag_cmd_get_log_range;
break;
case DIAG_CMD_OP_SET_LOG_MASK:
hdlr = diag_cmd_set_log_mask;
break;
case DIAG_CMD_OP_GET_LOG_MASK:
hdlr = diag_cmd_get_log_mask;
break;
}
} else if (*buf == DIAG_CMD_MSG_CONFIG) {
sub_cmd = *(uint8_t *)(buf + sizeof(uint8_t));
switch (sub_cmd) {
case DIAG_CMD_OP_GET_SSID_RANGE:
hdlr = diag_cmd_get_ssid_range;
break;
case DIAG_CMD_OP_GET_BUILD_MASK:
hdlr = diag_cmd_get_build_mask;
break;
case DIAG_CMD_OP_GET_MSG_MASK:
hdlr = diag_cmd_get_msg_mask;
break;
case DIAG_CMD_OP_SET_MSG_MASK:
hdlr = diag_cmd_set_msg_mask;
break;
case DIAG_CMD_OP_SET_ALL_MSG_MASK:
hdlr = diag_cmd_set_all_msg_mask;
break;
}
} else if (*buf == DIAG_CMD_GET_EVENT_MASK) {
hdlr = diag_cmd_get_event_mask;
} else if (*buf == DIAG_CMD_SET_EVENT_MASK) {
hdlr = diag_cmd_update_event_mask;
} else if (*buf == DIAG_CMD_EVENT_TOGGLE) {
hdlr = diag_cmd_toggle_events;
}
if (hdlr)
size = hdlr(buf, len, driver->apps_rsp_buf, APPS_BUF_SIZE);
return (size > 0) ? size : 0;
}
MojErr cancellableEcho(MojServiceMessage* msg, const MojObject& payload)
{
MojRefCountedPtr<EchoCancelHdlr> hdlr(new EchoCancelHdlr(m_cCancellableEchos));
MojAllocCheck(hdlr.get());
msg->notifyCancel(hdlr->m_slot);
m_cCancellableEchos++;
MojErr err = echo(msg, payload);
MojTestErrCheck(err);
return MojErrNone;
}
int
sendPDU(isess_t *sess, pdu_t *pp, handler_t *hdlr)
{
if(xmitpdu(sess, pp))
return 0;
if(hdlr) {
int res;
pp->ahs_size = 8 * 1024;
if((pp->ahs = malloc(pp->ahs_size)) == NULL) {
fprintf(stderr, "out of mem!");
return -1;
}
pp->ds_size = 0;
if((res = recvpdu(sess, pp)) != 0) {
fprintf(stderr, "recvpdu failed\n");
return res;
}
res = hdlr(sess, pp);
freePDU(pp);
return res;
}
return 1;
}
sm_rcs_t
sm_process_event (sm_table_t *tbl, sm_event_t *event)
{
static const char fname[] = "sm_process_event";
int state_id = event->state;
int event_id = event->event;
sm_rcs_t rc = SM_RC_ERROR;
fsm_fcb_t *fcb = (fsm_fcb_t *) event->data;
cc_feature_t *feat_msg = NULL;
line_t line_id;
fsm_types_t fsm_type;
callid_t call_id;
sm_function_t hdlr; /* cached handler in order to compute its addr once */
/*
* validate the state and event
* and that there is a valid function for this state-event pair.
*/
if ((state_id > tbl->min_state) &&
(state_id < tbl->max_state) &&
(event_id > tbl->min_event) &&
(event_id < tbl->max_event)) {
rc = SM_RC_DEF_CONT;
/*
* Save some paramters for debuging, the event handler may
* free the fcb once returned.
*/
fsm_type = fcb->fsm_type;
call_id = fcb->call_id;
if ((hdlr = tbl->table[tbl->max_event * state_id + event_id]) != NULL) {
FSM_DEBUG_SM(DEB_F_PREFIX"%s %-4d: 0x%08lx: sm entry: (%s:%s)\n",
DEB_F_PREFIX_ARGS(FSM, fname), fsm_type_name(fsm_type), call_id,
tbl->table[tbl->max_event * state_id + event_id],
fsm_state_name(fsm_type, state_id),
cc_msg_name((cc_msgs_t)(event_id)));
rc = hdlr(event);
}
if (rc != SM_RC_DEF_CONT) {
/* For event_id == CC_MSG_FEATURE then display the
* feature associated with it.
*/
if (event_id == CC_MSG_FEATURE) {
feat_msg = (cc_feature_t *) event->msg;
}
line_id = ((cc_feature_t *) event->msg)->line;
DEF_DEBUG(DEB_L_C_F_PREFIX"%-5s :(%s:%s%s)\n",
DEB_L_C_F_PREFIX_ARGS(GSM, line_id, call_id, fname),
fsm_type_name(fsm_type),
fsm_state_name(fsm_type, state_id),
cc_msg_name((cc_msgs_t)(event_id)),
feat_msg ? cc_feature_name(feat_msg->feature_id):" ");
}
}
/*
* Invalid state-event pair.
*/
else {
GSM_ERR_MSG(GSM_F_PREFIX"illegal state-event pair: (%d <-- %d)\n",
fname, state_id, event_id);
rc = SM_RC_ERROR;
}
return rc;
}
int a4l_do_insn(a4l_cxt_t * cxt, a4l_kinsn_t * dsc)
{
int ret;
a4l_subd_t *subd;
a4l_dev_t *dev = a4l_get_dev(cxt);
int (*hdlr) (a4l_subd_t *, a4l_kinsn_t *) = NULL;
/* Checks the subdevice index */
if (dsc->idx_subd >= dev->transfer.nb_subd) {
__a4l_err("a4l_do_insn: "
"subdevice index out of range (idx=%d)\n",
dsc->idx_subd);
return -EINVAL;
}
/* Recovers pointers on the proper subdevice */
subd = dev->transfer.subds[dsc->idx_subd];
/* Checks the subdevice's characteristics */
if ((subd->flags & A4L_SUBD_TYPES) == A4L_SUBD_UNUSED) {
__a4l_err("a4l_do_insn: wrong subdevice selected\n");
return -EINVAL;
}
/* Checks the channel descriptor */
ret = a4l_check_chanlist(dev->transfer.subds[dsc->idx_subd],
1, &dsc->chan_desc);
if (ret < 0)
return ret;
/* Choose the proper handler, we can check the pointer because
the subdevice was memset to 0 at allocation time */
switch (dsc->type) {
case A4L_INSN_READ:
hdlr = subd->insn_read;
break;
case A4L_INSN_WRITE:
hdlr = subd->insn_write;
break;
case A4L_INSN_BITS:
hdlr = subd->insn_bits;
break;
case A4L_INSN_CONFIG:
hdlr = subd->insn_config;
break;
default:
ret = -EINVAL;
}
/* We check the instruction type */
if (ret < 0)
return ret;
/* We check whether a handler is available */
if (hdlr == NULL)
return -ENOSYS;
/* Prevents the subdevice from being used during
the following operations */
ret = a4l_reserve_transfer(cxt, dsc->idx_subd);
if (ret < 0)
goto out_do_insn;
/* Let's the driver-specific code perform the instruction */
ret = hdlr(subd, dsc);
if (ret < 0)
__a4l_err("a4l_do_insn: "
"execution of the instruction failed (err=%d)\n",
ret);
out_do_insn:
/* Releases the subdevice from its reserved state */
a4l_cancel_transfer(cxt, dsc->idx_subd);
return ret;
}
