//./a.out filename
int main(int argc, const char *argv[])
{
int msg_id;
msg_t msg;
if(argc < 2){
fprintf(stderr,"Usage : %s <filename>\n",argv[0]);
exit(EXIT_FAILURE);
}
msg_id = msg_init(argv[1]);
while(1){
printf("Input > ");
fgets(msg.mtxt,sizeof(msg.mtxt),stdin);
msg.mtxt[strlen(msg.mtxt) - 1] = '\0';
msg.msg_type = MSG_TYPE;
send_msg(msg_id,&msg,sizeof(msg_t) - sizeof(long));
if(strncmp(msg.mtxt,"quit",4) == 0){
break;
}
}
msg_delete(msg_id);
return 0;
}
void MsgStorage::invoke(const string& method,
const AmArg& args, AmArg& ret) {
if(method == "msg_new"){
MessageDataFile* f =
dynamic_cast<MessageDataFile*>(args.get(3).asObject());
if (NULL == f) {
throw(string("message data is not a file ptr."));
}
ret.push(msg_new(args.get(0).asCStr(),
args.get(1).asCStr(),
args.get(2).asCStr(),
f->fp));
} else if(method == "msg_get"){
msg_get(args.get(0).asCStr(),
args.get(1).asCStr(),
args.get(2).asCStr(),
ret);
} else if(method == "msg_markread"){
ret.push(msg_markread(args.get(0).asCStr(),
args.get(1).asCStr(),
args.get(2).asCStr()));
} else if(method == "msg_delete"){
ret.push(msg_delete(args.get(0).asCStr(),
args.get(1).asCStr(),
args.get(2).asCStr()));
} else if(method == "userdir_open"){
userdir_open(args.get(0).asCStr(),
args.get(1).asCStr(),
ret);
} else if(method == "userdir_close"){
ret.push(userdir_close(args.get(0).asCStr(),
args.get(1).asCStr()));
} else if(method == "userdir_getcount"){
userdir_getcount(args.get(0).asCStr(),
args.get(1).asCStr(),
ret);
} else if(method == "events_subscribe"){
events_subscribe(args.get(0).asDynInv(),
args.get(1).asCStr());
} else if(method == "events_unsubscribe"){
events_unsubscribe(args.get(0).asDynInv());
} else if(method == "_list"){
ret.push("msg_new");
ret.push("msg_get");
ret.push("msg_markread");
ret.push("msg_delete");
ret.push("userdir_open");
ret.push("userdir_close");
ret.push("userdir_getcount");
ret.push("events_subscribe");
ret.push("events_unsubscribe");
}
else
throw AmDynInvoke::NotImplemented(method);
}
/*****************************************************************************
Prototype : vid_enc_thr
Description : image encode thread
Input : void *arg
Output : None
Return Value : void
Calls :
Called By :
History :
1.Date : 2012/3/8
Author : Sun
Modification : Created function
*****************************************************************************/
void *vid_enc_thr(void *arg)
{
VidEncThrEnv env;
CommonMsg msgBuf;
Int32 ret;
Int32 fdMsg, fdMax;
fd_set rdSet;
ret = vid_enc_thr_init((VidEncThrArg *)arg, (VidEncThrEnv *)&env);
assert(ret == E_NO);
if(ret)
goto exit;
fdMsg = msg_get_fd(env.hMsg);
fdMax = fdMsg + 1;
/* start main loop */
while(!env.exit) {
/* wait data ready */
FD_ZERO(&rdSet);
FD_SET(fdMsg, &rdSet);
ret = select(fdMax, &rdSet, NULL, NULL, NULL);
if(ret < 0 && errno != EINTR) {
ERRSTR("select err");
break;
}
/* no data ready */
if(!ret)
continue;
if(FD_ISSET(fdMsg, &rdSet)) {
/* process msg */
msg_process(&env, &msgBuf);
}
}
exit:
if(env.hH264Enc)
h264_enc_delete(env.hH264Enc);
if(env.hOsd)
osd_delete(env.hOsd);
if(env.hBufEnc)
buffer_free(env.hBufEnc);
if(env.hMsg)
msg_delete(env.hMsg);
INFO("vid encode thread exit...");
pthread_exit(0);
}
/*****************************************************************************
Prototype : encoder_delete
Description : delete encoder module
Input : EncoderHandle hEnc
Output : None
Return Value :
Calls :
Called By :
History :
1.Date : 2012/3/17
Author : Sun
Modification : Created function
*****************************************************************************/
Int32 encoder_delete(EncoderHandle hEnc, MsgHandle hCurMsg)
{
if(!hEnc)
return E_INVAL;
/* ask thread to exit */
if(hEnc->pid > 0) {
if(hCurMsg) {
MsgHeader msg;
/* send msg to our thread to exit */
msg.cmd = APPCMD_EXIT;
msg.index = 0;
msg.dataLen = 0;
msg.type = MSG_TYPE_REQU;
msg_send(hCurMsg, msg_get_name(hEnc->hMsg), &msg, 0);
}
/* set flag to exit */
hEnc->exit = TRUE;
pthread_join(hEnc->pid, NULL);
}
/* delete modules used */
if(hEnc->hEncode)
alg_delete(hEnc->hEncode);
if(hEnc->hBufEnc)
buffer_free(hEnc->hBufEnc);
if(hEnc->hOsd)
osd_delete(hEnc->hOsd);
if(hEnc->hPoolEnc)
buf_pool_delete(hEnc->hPoolEnc);
if(hEnc->hMsg)
msg_delete(hEnc->hMsg);
if(hEnc->hPoolIn)
buf_pool_free_all(hEnc->hPoolIn);
free(hEnc);
return E_NO;
}
/**
* send message with data to client
*
* @param [in] h client to inform
* @param [in] state state to provide
* @param [in] data data to send
*
* @return E_ERR_SUCCESS if successful
* @return E_ERR_FAILED otherwise
*/
e_mmgr_errors_t client_inform(const client_hdle_t *h, e_mmgr_events_t state,
void *data)
{
size_t size;
size_t write_size;
e_mmgr_errors_t ret = E_ERR_SUCCESS;
mmgr_cli_event_t event = { .id = state, .data = data };
msg_t msg = { .data = NULL };
client_t *client = (client_t *)h;
ASSERT(client != NULL);
ASSERT(client->set_data[state] != NULL);
/* do not check data because it can be NULL on purpose */
client->set_data[state] (&msg, &event);
size = SIZE_HEADER + msg.hdr.len;
write_size = size;
if ((0x01 << state) & client->subscription) {
if ((ret = cnx_write(client->fd, msg.data, &write_size)) ==
E_ERR_SUCCESS) {
if (size != write_size) {
LOG_ERROR("send failed for client (fd=%d name=%s) send=%d/%d",
client->fd, client->name, write_size, size);
ret = E_ERR_FAILED;
} else {
LOG_DEBUG("Client (fd=%d name=%s) informed of: %s", client->fd,
client->name, g_mmgr_events[state]);
}
}
} else {
LOG_DEBUG("Client (fd=%d name=%s) NOT informed of: %s",
client->fd, client->name, g_mmgr_events[state]);
}
msg_delete(&msg);
return ret;
}
static void *thr_msg(void *arg)
{
assert(arg);
TaskEnv *env = (TaskEnv *)arg;
MsgHandle hMsg;
MsgData msgData;
hMsg = msg_create(env->name, env->dest, 0);
if(!hMsg) {
ERR("create msg handle failed...");
goto exit;
}
DBG("create msg ok, our name: %s, dst name: %s.", env->name, env->dest);
sleep(1);
int cnt = 0, dataLen = sizeof(msgData.header);
int err;
memset(&msgData, 0, sizeof(msgData));
msgData.header.cmd = cnt;
msgData.header.index = cnt;
msgData.header.type = MSG_TYPE_REQU;
msgData.header.dataLen = sprintf(msgData.buf, "%s start", env->name);
dataLen = msgData.header.dataLen + sizeof(msgData.header);
//msgData.header.dataLen += 16;
if(env->id) {
DBG("send msg to %s", env->dest);
err = msg_send(hMsg, env->dest, &msgData.header, 0);
if(err < 0)
DBG("send msg returns %d", err);
}
DBG("%s, start recv msg", env->name);
struct timeval tmStart,tmEnd;
float timeUse;
err = msg_set_recv_timeout(hMsg, 1);
err |= msg_set_send_timeout(hMsg, 2);
assert(err == E_NO);
while(1) {
/* Do echo loop */
gettimeofday(&tmStart,NULL);
err = msg_recv(hMsg, &msgData.header, sizeof(MsgData), 0);
gettimeofday(&tmEnd,NULL);
if(err > 0) {
DBG("<%u> recv msg from %s, len: %d",
(unsigned int)pthread_self(), msg_get_recv_src(hMsg), err);
DBG(" cmd: %d, index: %d",
msgData.header.cmd, msgData.header.index);
if(msgData.header.dataLen > 0)
DBG(" append data: %s", msgData.buf);
timeUse = 1000000*(tmEnd.tv_sec-tmStart.tv_sec)+tmEnd.tv_usec-tmStart.tv_usec;
DBG(" recv cost: %.0f us", timeUse);
}
/* Send back data */
sprintf(msgData.buf, "<%d> %s send msg", cnt, env->name);
msgData.header.dataLen = sizeof(msgData.buf);
msgData.header.type = MSG_TYPE_RESP;
msgData.header.index = cnt;
dataLen = msgData.header.dataLen + sizeof(msgData.header);
gettimeofday(&tmStart,NULL);
err = msg_send(hMsg, NULL, &msgData.header, 0);
gettimeofday(&tmEnd,NULL);
if(err)
ERR("Send msg failed");
timeUse = 1000000*(tmEnd.tv_sec-tmStart.tv_sec)+tmEnd.tv_usec-tmStart.tv_usec;
DBG("<%u> send %d bytes msg to %s cost: %.0f us",
(unsigned int)pthread_self(), dataLen, msg_get_recv_src(hMsg), timeUse);
cnt++;
if( env->params->loopCnt > 0 &&
cnt > env->params->loopCnt)
break;
}
exit:
if(env)
free(env);
if(hMsg)
msg_delete(hMsg);
pthread_exit(0);
}
static Int32 raw_trans_test()
{
Int8 bufTx[1024], bufRx[1024];
MsgHandle hMsgTx = msg_create("/tmp/RawSend", "/tmp/RawRecv", 0);
MsgHandle hMsgRx = msg_create("/tmp/RawRecv", "/tmp/RawSend", 0);
assert(hMsgTx && hMsgRx);
int fdTx, fdRx;
fdTx = msg_get_fd(hMsgTx);
fdRx = msg_get_fd(hMsgRx);
Int32 i;
for(i = 0; i < sizeof(bufTx); i++) {
bufTx[i] = i;
}
struct sockaddr_un serverAddr;
memset(&serverAddr, 0, sizeof(serverAddr));
serverAddr.sun_family = AF_UNIX;
strncpy(serverAddr.sun_path, "/tmp/RawRecv", sizeof(serverAddr.sun_path));
if(sendto( fdTx, bufTx, 64, 0,
(struct sockaddr *)&serverAddr, sizeof(serverAddr)) != 64) {
ERRSTR("<0> sendto data err");
return E_IO;
}
if(sendto( fdTx, bufTx, 128, 0,
(struct sockaddr *)&serverAddr, sizeof(serverAddr)) != 128) {
ERRSTR("<1> sendto data err");
return E_IO;
}
if(sendto( fdTx, bufTx, 256, 0,
(struct sockaddr *)&serverAddr, sizeof(serverAddr)) != 256) {
ERRSTR("<2> sendto data err");
return E_IO;
}
Int32 rcv;
socklen_t len;
len = sizeof(serverAddr);
rcv = recvfrom(fdRx, bufRx, 512, 0, (struct sockaddr *)&serverAddr, &len);
DBG("recv len %d", rcv);
rcv = recvfrom(fdRx, bufRx, 512, 0, (struct sockaddr *)&serverAddr, &len);
DBG("recv len %d", rcv);
rcv = recvfrom(fdRx, bufRx, 512, 0, (struct sockaddr *)&serverAddr, &len);
DBG("recv len %d", rcv);
msg_delete(hMsgTx);
msg_delete(hMsgRx);
return E_NO;
}
/*
* ======== dev_destroy_device ========
* Purpose:
* Destroys the channel manager for this device, if any, calls
* bridge_dev_destroy(), and then attempts to unload the Bridge module.
*/
int dev_destroy_device(struct dev_object *hdev_obj)
{
int status = 0;
struct dev_object *dev_obj = hdev_obj;
DBC_REQUIRE(refs > 0);
if (hdev_obj) {
if (dev_obj->cod_mgr) {
cod_delete(dev_obj->cod_mgr);
dev_obj->cod_mgr = NULL;
}
if (dev_obj->hnode_mgr) {
node_delete_mgr(dev_obj->hnode_mgr);
dev_obj->hnode_mgr = NULL;
}
/* Free the io, channel, and message managers for this board: */
if (dev_obj->hio_mgr) {
io_destroy(dev_obj->hio_mgr);
dev_obj->hio_mgr = NULL;
}
if (dev_obj->hchnl_mgr) {
chnl_destroy(dev_obj->hchnl_mgr);
dev_obj->hchnl_mgr = NULL;
}
if (dev_obj->hmsg_mgr) {
msg_delete(dev_obj->hmsg_mgr);
dev_obj->hmsg_mgr = NULL;
}
if (dev_obj->hdeh_mgr) {
/* Uninitialize DEH module. */
bridge_deh_destroy(dev_obj->hdeh_mgr);
dev_obj->hdeh_mgr = NULL;
}
if (dev_obj->hcmm_mgr) {
cmm_destroy(dev_obj->hcmm_mgr, true);
dev_obj->hcmm_mgr = NULL;
}
if (dev_obj->dmm_mgr) {
dmm_destroy(dev_obj->dmm_mgr);
dev_obj->dmm_mgr = NULL;
}
/* Call the driver's bridge_dev_destroy() function: */
/* Require of DevDestroy */
if (dev_obj->hbridge_context) {
status = (*dev_obj->bridge_interface.pfn_dev_destroy)
(dev_obj->hbridge_context);
dev_obj->hbridge_context = NULL;
} else
status = -EPERM;
if (!status) {
kfree(dev_obj->proc_list);
dev_obj->proc_list = NULL;
/* Remove this DEV_Object from the global list: */
drv_remove_dev_object(dev_obj->hdrv_obj, dev_obj);
/* Free The library * LDR_FreeModule
* (dev_obj->module_obj); */
/* Free this dev object: */
kfree(dev_obj);
dev_obj = NULL;
}
} else {
status = -EFAULT;
}
return status;
}
