int mrp_get_domain(struct mrp_listener_ctx *ctx, struct mrp_domain_attr *class_a, struct mrp_domain_attr *class_b)
{
	char *msgbuf;
	int ret;

	/* we may not get a notification if we are joining late,
	 * so query for what is already there ...
	 */
	msgbuf = malloc(1500);
	if (NULL == msgbuf)
		return -1;
	memset(msgbuf, 0, 1500);
	sprintf(msgbuf, "S??");
	ret = send_msg(msgbuf, 1500, ctx);
	free(msgbuf);
	if (ret != 1500)
		return -1;
	while (!ctx->halt_tx && (ctx->domain_a_valid == 0) && (ctx->domain_b_valid == 0))
		usleep(20000);
	class_a->id = 0;
	class_a->priority = 0;
	class_a->vid = 0;
	class_b->id = 0;
	class_b->priority = 0;
	class_b->vid = 0;
	if (ctx->domain_a_valid) {
		class_a->id = ctx->domain_class_a_id;
		class_a->priority = ctx->domain_class_a_priority;
		class_a->vid = ctx->domain_class_a_vid;
	}
	if (ctx->domain_b_valid) {
		class_b->id = ctx->domain_class_b_id;
		class_b->priority = ctx->domain_class_b_priority;
		class_b->vid = ctx->domain_class_b_vid;
	}
	return 0;
}

/* Send a request to get the slave ID of the device (only available in serial
   communication). */
int modbus_report_slave_id(modbus_t *ctx, uint8_t *dest)
{
    int rc;
    int req_length;
    uint8_t req[_MIN_REQ_LENGTH];

    req_length = ctx->backend->build_request_basis(ctx, _FC_REPORT_SLAVE_ID,
                                                   0, 0, req);

    /* HACKISH, addr and count are not used */
    req_length -= 4;

    rc = send_msg(ctx, req, req_length);
    if (rc > 0) {
        int i;
        int offset;
        uint8_t rsp[MAX_MESSAGE_LENGTH];

        rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION);
        if (rc == -1)
            return -1;

        rc = check_confirmation(ctx, req, rsp, rc);
        if (rc == -1)
            return -1;

        offset = ctx->backend->header_length + 2;

        /* Byte count, slave id, run indicator status,
           additional data */
        for (i=0; i < rc; i++) {
            dest[i] = rsp[offset + i];
        }
    }

    return rc;
}

static void test_ctx_send_cb(struct pomp_ctx *ctx,
		struct pomp_conn *conn,
		struct pomp_buffer *buf,
		uint32_t status,
		void *cookie,
		void *userdata)
{
	int res = 0;
	struct test_data *data = userdata;
	struct test_peer *src = NULL;
	struct test_peer *dst = NULL;
	CU_ASSERT_PTR_NOT_NULL(ctx);
	CU_ASSERT_PTR_NOT_NULL(conn);
	CU_ASSERT_PTR_NOT_NULL(buf);
	data->sendcount++;
	CU_ASSERT_PTR_NULL(cookie);

	/* Internal function invalid arguments checks */
	res = pomp_ctx_notify_send(NULL, conn, buf, 0);
	CU_ASSERT_EQUAL(res, -EINVAL);
	res = pomp_ctx_notify_send(ctx, NULL, buf, 0);
	CU_ASSERT_EQUAL(res, -EINVAL);
	res = pomp_ctx_notify_send(ctx, conn, NULL, 0);
	CU_ASSERT_EQUAL(res, -EINVAL);

	/* Get source and destination */
	src = (ctx == data->srv.ctx) ? &data->srv : &data->cli;
	dst = (ctx == data->srv.ctx) ? &data->cli : &data->srv;

	if (src->recurs_send_enabled) {
		/* Disable recursive send. */
		src->recurs_send_enabled = 0;

		/* Exchange some message */
		send_msg(data, src, dst, "recursive_msg");
	}
}

int
main()
{
	uint16_t	num_trackers;
	in_addr_t	trackers[MAX_TRACKERS];
	uint16_t	maxpeers;
	uint16_t	num_pkg_servers;
	in_addr_t	pkg_servers[MAX_PKG_SERVERS];
	int		i;
	int		sockfd;
	char		trackers_url[256];
	char		pkg_servers_url[256];

	sprintf(trackers_url,"127.0.0.1");

	sprintf(pkg_servers_url,"127.0.0.1");

	fprintf(stderr, "main:trackers_url (%s)\n", trackers_url);
	fprintf(stderr, "main:pkg_servers_url (%s)\n", pkg_servers_url);
	
	if (init(&num_trackers, trackers_url, trackers, &maxpeers,
			pkg_servers_url, &num_pkg_servers, pkg_servers) != 0) {
		fprintf(stderr, "main:init failed\n");
		return(-1);
	}

	if ((sockfd = init_tracker_comm(0)) < 0) {
		fprintf(stderr, "main:init_tracker_comm failed\n");
		return(-1);
	}

	for (i = 0 ; i < num_trackers; ++i) {
		send_msg(sockfd, &trackers[i], DUMP_TABLES);
	}

	return(0);
}

static int on_host_init(VSCMsgHeader *mhHeader, VSCMsgInit *incoming)
{
    uint32_t *capabilities = (incoming->capabilities);
    int num_capabilities =
        1 + ((mhHeader->length - sizeof(VSCMsgInit)) / sizeof(uint32_t));
    int i;
    int rv;
    pthread_t thread_id;

    incoming->version = ntohl(incoming->version);
    if (incoming->version != VSCARD_VERSION) {
        if (verbose > 0) {
            printf("warning: host has version %d, we have %d\n",
                verbose, VSCARD_VERSION);
        }
    }
    if (incoming->magic != VSCARD_MAGIC) {
        printf("unexpected magic: got %d, expected %d\n",
            incoming->magic, VSCARD_MAGIC);
        return -1;
    }
    for (i = 0 ; i < num_capabilities; ++i) {
        capabilities[i] = ntohl(capabilities[i]);
    }
    /* Future: check capabilities */
    /* remove whatever reader might be left in qemu,
     * in case of an unclean previous exit. */
    send_msg(VSC_ReaderRemove, VSCARD_MINIMAL_READER_ID, NULL, 0);
    /* launch the event_thread. This will trigger reader adds for all the
     * existing readers */
    rv = pthread_create(&thread_id, NULL, event_thread, NULL);
    if (rv < 0) {
        perror("pthread_create");
        return rv;
    }
    return 0;
}

int
ACE_TMAIN (int, ACE_TCHAR *[])
{
  long pid = long (ACE_OS::getpid ());

  ACE_Typed_SV_Message_Queue<Message_Data> msgque (key_t (SRV_KEY));

  Message_Data msg_data (pid,
                         ACE_OS::cuserid (static_cast<char *> (0)),
                         "did you get this?");

  ACE_Typed_SV_Message<Message_Data> send_msg (msg_data,
					       SRV_ID,
					       msg_data.length ()),
					       recv_msg (pid);

  if (msgque.send (send_msg) < 0)
    ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"),
                       ACE_TEXT ("msgque.send")), 1);

  if (msgque.recv (recv_msg) < 0)
    ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"),
                       ACE_TEXT ("msgque.recv")), 1);

  Message_Data &recv_msg_data = recv_msg.data ();

  ACE_DEBUG ((LM_DEBUG,
              ACE_TEXT ("a message of length %d")
              ACE_TEXT (" received from server %d")
              ACE_TEXT (" (user %C): %C\n"),
              recv_msg_data.length (),
              recv_msg_data.pid (),
              recv_msg_data.user (),
              recv_msg_data.text ()));

  return 0;
}

int init_draw_graph_u(sym_environment *env)
{
   if (env->par.do_draw_graph){ /*start up the graphics window*/
      int s_bufid;
      if (env->par.dg_machine_set){
	 spawn(env->par.dg_exe, (char **)NULL, env->par.dg_debug | TaskHost,
	       env->par.dg_machine, 1, &env->dg_tid);
      }else{
	 spawn(env->par.dg_exe, (char **)NULL, env->par.dg_debug, (char *)NULL, 1,
	       &env->dg_tid);
      }
      s_bufid = init_send(DataInPlace);
      send_char_array((char *)&env->par.dg_par, sizeof(dg_params));
      send_msg(env->dg_tid, DG_DATA);
      freebuf(s_bufid);

#ifdef USE_SYM_APPLICATION
      if (env->dg_tid)
	 CALL_USER_FUNCTION( user_init_draw_graph(env->user, env->dg_tid) );
#endif
   }

   return(FUNCTION_TERMINATED_NORMALLY);
}

bool gdbr_kill_pid(libgdbr_t *g, int pid) {
	char *cmd;
	int ret;
	size_t buffer_size;

	if (!g || !g->sock || !g->stub_features.multiprocess) {
		return false;
	}
	reg_cache.valid = false;
	g->stop_reason.is_valid = false;

	buffer_size = strlen (CMD_KILL_MP) + (sizeof (pid) * 2) + 1;
	cmd = calloc (buffer_size, sizeof (char));
	if (!cmd) {
		return false;
	}

	if ((snprintf (cmd, buffer_size, "%s%x", CMD_KILL_MP, g->pid)) < 0) {
		free(cmd);
		return false;
	}
	ret = send_msg (g, cmd);
	free(cmd);
	if (ret < 0) {
		return false;
	}

	read_packet (g, false);
	if ((ret = send_ack (g)) < 0) {
		return false;
	}
	if (strncmp (g->data, "OK", 2)) {
		return false;
	}
	return true;
}

/* Called from VM Monitor */
int NodeManager_notify_vm_started(
    char        *node_addr,
    char        *vmmon_addr,
    char        *theater )
{
    int retval = 0;
    NodeMessage *msg;

    Dbg_printf( NODE, INFO, "node_addr=%s, vmmon_addr=%s, theater=%s\n",
                node_addr, vmmon_addr, theater );

    msg = node_alloc_msg( NodeMessageID_NOTIFY_VM_STARTED );
    node_set_notify_vm_started_msg( msg, vmmon_addr, theater );

    if (send_msg( node_addr, NULL, msg ) < 0) {
        Dbg_printf( NODE, ERROR, "node_send_msg, node_addr=%s, msg=%s failed\n", 
                    node_addr, node_msgid2str( msg->msgid ) );
        retval = -1;
    }

    node_dealloc_msg( msg );

    return retval;
}

int UnixSocketAdapter::send(const AmSipRequest &req, string &src, string &dst)
{
  if (! isComplete(req)) {
    ERROR("can not send request: not complete.\n");
    return -1;
  }

  string rplAddr;
  string msg;
  int timeout;
  if (req.method == "CANCEL") {
    rplAddr = "/tmp/" + AmSession::getNewId();
    msg = serialize_cancel(req, rplAddr);
    timeout = 50000; /*TODO: WTF's with this value?!*/
  } else {
    rplAddr = src;//AmConfig::ReplySocketName;
    msg = serialize(req, rplAddr);
    /* timeout: don't wait for reply [comes through other, 
     * dedicated socket] */
    timeout = 0;
  }

  return send_msg(msg, rplAddr, dst, timeout);
}

int NodeManager_destroy_vm_req(
    char        *node_addr,
    char        *return_cos_addr,
    char        *vm_name )
{
    int retval = 0;
    NodeMessage *msg;

    Dbg_printf( NODE, INFO, "node_addr=%s, return_cos_addr=%s, vm_name=%s\n", 
                node_addr, return_cos_addr, vm_name );

    msg = node_alloc_msg( NodeMessageID_DESTROY_VM_REQ );
    node_set_destroy_vm_req_msg( msg, vm_name );

    if (send_msg( node_addr, return_cos_addr, msg ) < 0) {
        Dbg_printf( NODE, ERROR, "node_send_msg, node_addr=%s, return_cos_addr=%s, msg=%s failed\n", 
                    node_addr, return_cos_addr, node_msgid2str( msg->msgid ) );
        retval = -1;
    }

    node_dealloc_msg( msg );

    return retval;
}

/*
 *    Test2b
 *
 *    Sending thread of test2b
 */
static void Test2b( void ) {

	pthread_t t1;
	char * msg = "Test2b Burst Send Non-Blocking / Receive Blocking";
	int recv_count = 0;
	int send_count = 0;

	TEST_INTRO( "Send Blocking Test" );

	if (pthread_create ( &t1, NULL, &test2b_thread, NULL ) != 0) {
		printf("Failed to create test2b_thread t1!\n");
		FAILURE_EXIT();
	}

	usleep(100000);

	burst_send( msg, MAX_QUEUE_SIZE, MBX_NON_BLOCKING, NOISY, ON_FAILURE_EXIT );
	send_count += MAX_QUEUE_SIZE;

	usleep(10000);

	send_msg( msg, MBX_BLOCK, NOISY, ON_FAILURE_EXIT );
	send_count += 1;

	pthread_join( t1, (void*)&recv_count );

	printf("Thread 0 sent %d messages\n",send_count);
	printf("Thread 1 received %d messages\n",recv_count);

	if (recv_count != send_count) {
		FAILURE_EXIT();
	}

	TEST_CLOSING();

}

bool campareGameMoney(Hero *hero,long _gameMoney)		//判断游戏币是否够用
{
	Money *money=hero->getMoney();
	if (money==NULL)								//money类为空 返回false;
	{
		return false;
	}
	if (_gameMoney<0)								//使用的游戏币为负数,返回false
	{
		cout<<"jolly:you can increase a negative number money_operator 228"<<endl;
		return false;
	}
	
	if ((money->money_getGameMoney()-_gameMoney)<0)
	{
		msg_error(g_out_buf,1);
		send_msg(hero->getFd(),g_out_buf);
		return false;
	}
	else
	{
		return true;
	}
}

bool increaseGameMoney(Hero *hero,long _gameMoney)	//增加游戏币
{	
	Money *money=hero->getMoney();
	if (money==NULL)								//money类为空 返回false;
	{
		return false;
	}
	if (_gameMoney<0)								//增加的游戏币为负数,返回false
	{
		cout<<"jolly:you can increase a negative number money_operator 210"<<endl;
		return false;
	}
	
	money->money_increaseGameMoney(_gameMoney);
	money->money_inform(g_out_buf,sizeof(g_out_buf));
	send_msg(hero->getFd(),g_out_buf);				//发送增加游戏币之后的金币状态	
	
	// 增加获得货币写日志功能,jolly 2012 12 17 start
	char account_msg[1024]={'\0'};
	sprintf(account_msg,"%d,%d,%s,%d,%s,%s,%ld,%ld",3,0,server_name,(int)myTime.tv_sec,hero->getIdentity(),hero->getNickName(),money->money_getGameMoney(),_gameMoney);
	write_log(account_msg);	
	// 增加获得货币写日志功能,jolly 2012 12 17 end
	return true;
}

bool campareGold(Hero *hero,long _gold)		//判定元宝是否够用
{
	Money *money=hero->getMoney();
	if (money==NULL)							//money类为空 返回false;
	{
		return false;
	}
	if (_gold<0)								//比较的元宝为负数,返回false
	{
		cout<<"jolly:you can increase a negative number money_operator 177"<<endl;
		return false;
	}	

	if (_gold>money->money_getGold())				//比较的元宝大于了自身的元宝,则提示充值
	{
		snprintf(g_out_buf,sizeof(g_out_buf),"%d,%d,%ld",9,MONEY_NOT_ENOUGH,_gold-money->money_getGold());
		send_msg(hero->getFd(),g_out_buf);
		return false;
	}
	else
	{
		return true;
	}	
}

int client_init(void)
{
/*
    if(argc<2)
    {
    
         printf("\n");
         printf("sorry,your type is wrong\n");    
         printf("usage: %s x.x.x.x(server ip)\n",argv[0]);
         exit(EXIT_FAILURE);
    }
*/
    if((client_sock = socket(AF_INET, SOCK_DGRAM, 0))< 0)
    {
       fprintf(stderr,"%s\n",strerror(errno)) ;
       exit(EXIT_FAILURE);
    
    }
    else
    {
         printf("create socket ok !\n");
    }



    bzero(&server, sizeof(server));

    server.sin_family = AF_INET;
    server.sin_port = htons(SERVER_PORD);
    server.sin_addr.s_addr = inet_addr("10.1.14.39");

    server_len = sizeof(server);
    send_msg(0,0);
    return 0;

}

void ctrl_g_defence_original()
{
	char buf[200];
	if (RINFO.turn==mypos&& (PINFO(mypos).flag & PEOPLE_ALIVE))
	{
		if (PINFO(mypos).flag & PEOPLE_BAD)
		{
			if (RINFO.voted[mypos]!=-2)
			{
				sprintf (buf, "\33[31m你想崩溃了\33[m");
				RINFO.voted[mypos]=-2;
			}
			else
			{
				sprintf(buf,"\33[31m你不想崩溃了\33[m");
				RINFO.voted[mypos]=-1;
			}
		}
		else
			sprintf(buf,"不能崩溃");
		send_msg(mypos,buf);
		kill_msg(mypos);
	}
}

void mu_signal_process(char *command, int signal)
{
	unsigned short	slen;
	int		len, toprocess_id, save_errno;
	char		buff[256];
	error_def(ERR_MUPCLIERR);
	error_def(ERR_MUPIPSIG);

	slen = sizeof(buff);
	if (!cli_get_str("ID", buff, &slen))
		mupip_exit(ERR_MUPCLIERR);
	len = slen;
	toprocess_id = asc2i((uchar_ptr_t)buff, len);
	if (toprocess_id < 0)
	{
		util_out_print("Error converting !AD to a number", FLUSH, len, buff);
		mupip_exit(ERR_MUPCLIERR);
	} else
	{
		if (-1 == kill(toprocess_id, signal))
		{
			save_errno = errno;
			util_out_print("Error issuing !AD to process !UL: !AZ", FLUSH,
				       LEN_AND_STR(command), toprocess_id, STRERROR(errno));
		} else
		{
			util_out_print("!AD issued to process !UL", FLUSH, LEN_AND_STR(command), toprocess_id);
			if (!MEMCMP_LIT(command, STOP_STR))
			{
				send_msg(VARLSTCNT(9) ERR_MUPIPSIG, 7, LEN_AND_STR(command), signal, process_id, process_id,
					 toprocess_id, toprocess_id);
			}
		}
	}
	return;
}

void		soon(int cs)
{
	char				buf[1024];
	int					r;
	char				*home;

	home = get_pwd();
	while ((r = read(cs, buf, 1023)) > 0)
	{
		buf[r - 1] = '\0';
		ft_printf("received %d bytes: [%s]\n", r, buf);
		if (!ft_strcmp(buf, "ls"))
			ft_ls(cs);
		else if (!ft_strcmp(buf, "pwd"))
			send_msg(cs, get_pwd(), 0);
		else if (!ft_strncmp(buf, "cd ", 3) || !ft_strcmp(buf, "cd"))
			ft_cd(cs, buf, home);
		else if (!ft_strcmp(buf, "quit"))
			break ;
		else
			send_error(cs, "invalid_cmd");
		ft_bzero(buf, 1024);
	}
}

int NodeManager_notify_low_cpu_usage(
    char        *node_addr,
    char        *vmmon_addr,
    double      cpu_usage_history[CPU_USAGE_HISTORY_LEN] )
{
    int retval = 0;
    NodeMessage *msg;

    Dbg_printf( NODE, INFO, "vmmon_addr=%s, cpu_usage_history[0]=%lf\n",
                vmmon_addr, cpu_usage_history[0] );

    msg = node_alloc_msg( NodeMessageID_NOTIFY_LOW_CPU_USAGE );
    node_set_notify_cpu_usage_msg( msg, vmmon_addr, cpu_usage_history );

    if (send_msg( node_addr, vmmon_addr, msg ) < 0) {
        Dbg_printf( NODE, ERROR, "send_msg, node_addr=%s, msg=%s failed\n", 
                    node_addr, node_msgid2str( msg->msgid ) );
        retval = -1;
    }

    node_dealloc_msg( msg );

    return retval;
}