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; }