Ejemplo n.º 1
0
int PushThePainting(){
    send_messages("push", "$agent_name $agent_verb the painting on the wall.",
      this_player(), 0, environment(this_player()));
    if(hidden == 1) {
        OpenSesame();
    }
    return 1;
}
Ejemplo n.º 2
0
Archivo: close.c Proyecto: Elohim/FGmud
mixed eventClose(object who){
    if( !SetClosed(1) ){
        return 0;
    }
    send_messages("close", "$agent_name $agent_verb $target_name.",
            who, this_object(), environment(who));
    return 1;
}
Ejemplo n.º 3
0
int openDoor(object who) {
    object car;
    send_messages("press", "$agent_name $agent_verb the button.",
      who, 0, environment(who));
    car=load_object("/domains/town/room/elevator");
    car->SetDoor(1);
    car->CallMe(2);

}
Ejemplo n.º 4
0
void GDNetHost::thread_loop() {
	while (_running) {
		acquireMutex();

		send_messages();
		poll_events();

		releaseMutex();
	}
}
Ejemplo n.º 5
0
void datalink_module::loop(void)
{
    boost::posix_time::time_duration interval_10Hz(boost::posix_time::milliseconds(1000 / 10));
    boost::posix_time::ptime timer = boost::posix_time::microsec_clock::local_time() + interval_10Hz;

    while(thread_running)
    {
        send_messages();

        boost::this_thread::sleep(timer - boost::posix_time::microsec_clock::local_time());
        timer += interval_10Hz; // update timer
    }

}
Ejemplo n.º 6
0
Archivo: cold.c Proyecto: Elohim/FGmud
int eventSuffer(object who) {
    if( !random(100) ) {
        Destruct();
        return 1;
    }
    switch(random(3)) {
        case 0:
            send_messages("cough", "$agent_name $agent_verb miserably.",
                    who, 0, environment(who));
            break;

        case 1:
            send_messages("", "$agent_possessive_noun red nose runs all over "
                    "$agent_possessive face.", who, 0, environment(who));
            break;

        case 2:
            send_messages("look", "$agent_name $agent_verb miserable.",
                    who, 0, environment(who));
            break;
    }
    who->eventReceiveDamage(0, COLD, random(3) + 1, 1);
    return 1;
}
Ejemplo n.º 7
0
int execute_command(int sd, char* command, int* seq_no){
	FILE *fp;
	fp = popen(command,"r");
	printf("Executing command \n");
	if(fp == NULL){
		printf("Bad output \n");
		close(sd);
		exit(1);
	}
	if(command[0]=='c' && command[1] == 'd'){
		pclose(fp);
		return 0;
	}
	send_messages(sd, fp, seq_no);
	pclose(fp);
	return 0;
}
Ejemplo n.º 8
0
mixed eventFall(){
    string rvoid = ROOMS_D->GetVoid(this_object());
    object env = environment();
    mixed rumbo = 0;
    mixed tmprumbo = 0;
    string name = this_object()->GetName();

    if(!living(this_object())) name = this_object()->GetShort();

    if(!env || !(rumbo = env->GetExit("down"))){
        if(!sizeof((rumbo = env->GetSinkRoom()))){
            return 0;
        }
    }
    if(env == rumbo){
        return 0;
    }
    if(env->GetMedium() != MEDIUM_AIR){
        send_messages("crash", "$agent_name $agent_verb down!",
                this_object(), 0, env);
        if(living(this_object())) this_object()->SetPosition(POSITION_LYING);
        return 1;
    }
    else {
        mixed err;
        if(!rumbo){
            return 0;
        }
        tmprumbo = rumbo;
        if(stringp(rumbo)){
            if(grepp(rumbo, "#")) err = "Let's not load a clone.";
            else err = catch(rumbo = load_object(rumbo));
        }
        if(err || !rumbo){
            log_file("runtime","\n"+timestamp()+" "+identify(this_object())+
                    " could not load "+identify(rumbo)+" to fall into.\n");
            err = catch(rumbo = load_object(rvoid));
        }
        if(err || !rumbo){
            this_object()->eventMove(ROOM_START);
            return 0;
        }
        tell_object(this_object(),"You plummet downward!");
        if(err = this_object()->eventMove(rumbo)){
            tell_room(rumbo,capitalize(name)+" plummets in from above.",
                    ({ this_object() }));
Ejemplo n.º 9
0
int hitCallback(object who, object agent, int x, class MagicProtection cl) {
    string str;
    object Caster = cl->caster;

    if( (int)agent->GetUndead() ) return 0;
    str = (string)agent->GetName() || (string)agent->GetShort();
    if( who == Caster ) {
        who->eventTrainSkill("magic defense",cl->args,x,1);
    }
    else if( Caster && playerp(who) && Caster != who ) {
        Caster->eventTrainSkill("magic defense",cl->args,0,1);
    } 

    send_messages("", "The %^YELLOW%^magical shield%^RESET%^ around "
      "$agent_name wavers as $target_name strikes it.",
      who, agent, environment(who), 0);
    return x;
}
Ejemplo n.º 10
0
/*
* Receives requests and places the messages in a queue.
*/
static void run(int fd) {
	
	char buf[MAX_LENGTH], method[MAX_LENGTH], uri[MAX_LENGTH], version[MAX_LENGTH], error[MAX_LENGTH];
	char * args = NULL;

	//clear variables to prevent corruption
	memset(error, '\0', MAX_LENGTH);
	memset(uri, '\0', MAX_LENGTH);
	memset(buf, '\0', MAX_LENGTH);
	memset(version, '\0', MAX_LENGTH);
	memset(method, '\0', MAX_LENGTH);

	// Parse and perform requests if we haven't hit timeout and if the headers are still valid
	while (read(fd, buf, MAX_LENGTH) > 0) {

		sscanf(buf, "%s %s %s", method, uri, version);

		//Check for non GET method call
		if (strncasecmp(method, "GET", 3)) {

			snprintf(error, sizeof(error), "501 error: %s not supported The server does not support the method provided %s", method, version);
			write(fd, error, sizeof(error));
			Close(fd);
			return;
		}
		//check if version is HTTP 1.0, if so, break.
		if (strcmp(version, "HTTP/1.0") == 0) {
			fprintf(stderr, "NON HTTP 1.0 MESSAGE RECEIVED\n");
			break;
		}

		if ((args = strstr(uri, "/get_messages")))
			send_messages(fd, version);

		//clear variables to prevent corruption
		memset(error, '\0', MAX_LENGTH);
		memset(uri, '\0', MAX_LENGTH);
		memset(buf, '\0', MAX_LENGTH);
		memset(version, '\0', MAX_LENGTH);
		memset(method, '\0', MAX_LENGTH);
	}

	Close(fd);
}
Ejemplo n.º 11
0
void RedChannel::on_event()
{
    if (_outgoing_message) {
        RedPeer::OutMessage& peer_message = _outgoing_message->peer_message();

        _outgoing_pos += do_send(peer_message,  _outgoing_pos);
        if (_outgoing_pos == peer_message.message_size()) {
            _outgoing_message->release();
            _outgoing_message = NULL;
        }
    }
    send_messages();

    if (_incomming_header_pos) {
        _incomming_header_pos += RedPeer::recive(((uint8_t*)&_incomming_header) +
                                                 _incomming_header_pos,
                                                 sizeof(SpiceDataHeader) - _incomming_header_pos);
        if (_incomming_header_pos != sizeof(SpiceDataHeader)) {
            return;
        }
        _incomming_header_pos = 0;
        _incomming_message = new CompoundInMessage(_incomming_header.serial,
                                                   _incomming_header.type,
                                                   _incomming_header.size,
                                                   _incomming_header.sub_list);
        _incomming_message_pos = 0;
    }

    if (_incomming_message) {
        _incomming_message_pos += RedPeer::recive(_incomming_message->data() +
                                                  _incomming_message_pos,
                                                  _incomming_message->compound_size() -
                                                  _incomming_message_pos);
        if (_incomming_message_pos != _incomming_message->compound_size()) {
            return;
        }
        AutoRef<CompoundInMessage> message(_incomming_message);
        _incomming_message = NULL;
        on_message_recived();
        _message_handler->handle_message(*(*message));
        on_message_complition((*message)->serial());
    }
    recive_messages();
}
Ejemplo n.º 12
0
static GLOBAL_FUNC(cmd_messages)
{
    long mask = MESSAGE_RECIPIENT_AUTHED | MESSAGE_RECIPIENT_LUSERS | MESSAGE_RECIPIENT_CHANNELS | MESSAGE_RECIPIENT_RCHANNELS;
    unsigned int count;

    if(IsOper(user))
	mask |= MESSAGE_RECIPIENT_OPERS;

    if(IsHelper(user))
	mask |= MESSAGE_RECIPIENT_HELPERS;

    count = send_messages(user, mask, 0);
    if(count)
	global_notice(user, "GMSG_MESSAGE_COUNT", count);
    else
	global_notice(user, "GMSG_NO_MESSAGES");

    return 1;
}
Ejemplo n.º 13
0
int main(int argc, char * argv[]) {
  int socket_id, e;
  char *hostname, *username;
  int sending = 0;

  if (argc < 3) {
    printf("Usage: client <hostname> <username>\n");
    exit(1);
  } else {
    hostname = argv[1];
    username = argv[2];
    if (argc >= 4) {
      sending = 1;
    };
  }

  struct user me = new_user(username);

  setup_sig_handler();

  e = socket_id = connect_to_server(hostname, PORT);
  if (e < 0) check_errors("Error connecting to server", e);

  e = handshake(socket_id, me);
  if (e < 0) {
    printf("Username already taken\n");
    running = 0;
  } else {
    printf("Handshake succesfull!\n");
  }

  while (running) {
    if (sending) {
      e = send_messages(socket_id, me);
    } else {
      e = receive_messages(socket_id);
    }
    if (e < 0) running = 0;
  }

  cleanup(socket_id);
}
Ejemplo n.º 14
0
void
serverlist_query(unsigned short msg)
{
	int contactsock;

	if (!initial && explicit_host != NULL) {
		/* already did the work, no point doing it again */
		return;
	}

	contactsock = socket(SOCK_FAMILY, SOCK_DGRAM, 0);
	if (contactsock < 0) {
		leave(1, "socket system call failed");
	}

	send_messages(contactsock, msg);
	get_responses(contactsock);

	(void) close(contactsock);
}
Ejemplo n.º 15
0
Archivo: sender.hpp Proyecto: 7ev3n/hpx
 bool background_work()
 {
     connection_list connections;
     {
         std::unique_lock<mutex_type> l(connections_mtx_, std::try_to_lock);
         if(l && !connections_.empty())
         {
             connections.push_back(connections_.front());
             connections_.pop_front();
         }
     }
     bool has_work = false;
     if(!connections.empty())
     {
         send_messages(std::move(connections));
         has_work = true;
     }
     next_free_tag();
     return has_work;
 }
Ejemplo n.º 16
0
static int
global_process_user(struct userNode *user, UNUSED_ARG(void *extra))
{
    if(IsLocal(user) || self->uplink->burst || user->uplink->burst)
        return 0;
    send_messages(user, MESSAGE_RECIPIENT_LUSERS, 1);

    /* only alert on new usercount if the record was broken in the last
     * 30 seconds, and no alert had been sent in that time.
     */
    if((now - max_clients_time) <= 30 && (now - last_max_alert) > 30)
    {
	char *message;
	message = alloca(36);
	sprintf(message, "New user count record: %d", max_clients);
	global_message(MESSAGE_RECIPIENT_OPERS, message);
	last_max_alert = now;
    }

    return 0;
}
Ejemplo n.º 17
0
int main()
{

  static const unsigned int repeations = 10;
  distributor_type& inst = distributor_type::instance();
  observer_type* obs1 = new observer_type();
  inst.append_observer(obs1);

  time_vector.clear();
  for( unsigned int i=0; i < repeations; ++i  ) { send_messages();}
  print_time_vector("send_messages");


  time_vector.clear();
  for( unsigned int i=0; i < repeations; ++i  ) { send_messages_mt(); }
  print_time_vector("send_messages_mt");


  inst.remove_observer(obs1);
  delete obs1;

  return 0;
}
Ejemplo n.º 18
0
// Adds the message to the queue and sends the queued messages if
// the queue becomes full.
static void send_message(msgpack_sbuffer *buffer) {
  queue_message(buffer);
  if(queued_message_count() == MESSAGE_BATCH_SIZE)
    send_messages();
}
Ejemplo n.º 19
0
int cmd_cure(string str) {
    string whom, limb, clas;
    int amount, cost, healing, i;
    object tp, ob;
    string * limbs;
   if (!spell()) {
      notify_fail("What?\n");
      return 0;
   }
    if(!str) {
        notify_fail("Cure whom?\n");
        return 0;
    }
    tp = this_player();
    if(tp->query_disable()) {
        notify_fail("You are in the middle of something else.\n");
        return 0;
    }
    if(!alignment_ok(this_player())) {
        notify_fail("You have betrayed the source of your powers.\n");
        return 0;
    }
    healing = (int)tp->query_skill("healing");
    clas = (string)tp->query_subclass();
    if(str == "me" || str == "myself") ob = tp;
    else ob = present(str, environment(tp));
    if(!ob) {
        if(sscanf(str, "%s %s", whom, limb) != 2) {
            notify_fail("Correct syntax: <cure [who] [(limb)]\n");
            return 0;
        }
        if(whom == "me" || whom == "myself") ob = tp;
        else ob = present(whom, environment(tp));
    }
    if(!ob) {
        notify_fail("Cure whom?\n");
        return 0;
    }
    if(!limb) cost = healing*2/3;
    else if(limb == "all") cost = healing;
    else if(member_array(limb, (string *)ob->query_limbs()) == -1) {
        notify_fail("That limb is missing!\n");
        return 0;
    }
    else cost = healing/3;
    if(ob != tp) cost = random(cost);
    if((int)tp->query_mp() < cost) {
        notify_fail("Too low on magic power.\n");
        return 0;
    }
    tp->add_mp(-cost);
    amount = (healing*((int)ob->query_level()))/10;
    if(amount > 400) {
       log_file("hmmm", this_player()->query_name()+" healing "+ob->query_short()+" "+amount+"\n");
       amount = 400;
    }
    if(clas == "paladin"){
      amount = amount/2;
    }
    this_player()->set_magic_round(2);
    if(tp == ob) tp->add_skill_points("healing", amount/6);
    else {
        tp->add_skill_points("healing", amount/2);
        tp->add_alignment("healing", amount/5);
    }
    if(!limb) {
      if (tp->query_hp() < 1) {
        ob->set_hp(1);
        send_messages(tp, ob, clas, 0);}
      else{   
        ob->add_hp(amount);
        send_messages(tp, ob, clas, 0);}
    }
    else if(limb == "all") {
        limbs = (string *)ob->query_limbs();
        for(i=0; i<sizeof(limbs); i++) {
          ob->heal_limb(limbs[i], (amount/2));
        }
      if (tp->query_hp() < 1) {
        ob->set_hp(1);
        send_messages(tp, ob, clas, 0);}
      else{   
        ob->add_hp(amount);
        send_messages(tp, ob, clas, 0);}
    }
    else {
        ob->add_hp(amount/4);
      if (tp->query_hp() < 1) {
        ob->set_hp(1);
        send_messages(tp, ob, clas, 0);}
      else{   
        ob->add_hp(amount);
        send_messages(tp, ob, clas, 0);}
    }
    tp->set_disable();
    return 1;
}
Ejemplo n.º 20
0
int cmd_heal(string str) {
  string whom, limb, clas;
  int amount, cost, healing, i, wisdom;
  object tp, ob;
  string * limbs;
  if (!spell()) {
    return 0;
  }
  if(!str) {
    notify_fail("Heal whom?\n");
    return 0;
  }
  tp = this_player();
  if(tp->query_disable()) {
    notify_fail("You are in the middle of something else.\n");
    return 0;
  }
  if(!alignment_ok(this_player())) {
    notify_fail("You have betrayed the source of your powers.\n");
    return 0;
  }
  if(this_player()->query_ghost())
    return notify_fail("You cannot speak without a body.\n");
  healing = (int)tp->query_skill("healing")/2;
  healing += (int)tp->query_level()/3;
  healing += (int)tp->query_skill("faith")/4;
  healing += tp->query_skill("belief")/4;

  clas = (string)tp->query_subclass();
  if(str == "me" || str == "myself") ob = tp;
  else ob = present(str, environment(tp));
  if(!ob) {
    if(sscanf(str, "%s %s", whom, limb) != 2) {
      notify_fail("Heal whom?\n");
      return 0;
    }
    if(whom == "me" || whom == "myself") ob = tp;
    else ob = present(whom, environment(tp));
  }
  if(!ob) {
    notify_fail("Heal whom?\n");
    return 0;
  }
  if(!limb) cost = healing/2;
  else if(limb == "all") cost = healing*3/4;
  else if(member_array(limb, (string *)ob->query_limbs()) == -1) {
    notify_fail("That limb is missing!\n");
    return 0;
  }
  else cost = healing/3;
  if(ob != tp) cost = random(cost);
  if((int)tp->query_mp() < cost) {
    notify_fail("Too low on magic power.\n");
    return 0;
  }
  tp->add_mp(-cost);
  amount = (healing);
  if(amount > 800) {
    log_file("hmmm", this_player()->query_name()+" healing "+ob->query_short()+" "+amount+"\n");
    amount = 800;
  }
  this_player()->set_magic_round(2);
  if(tp == ob) tp->add_skill_points("healing", amount/3);
  else {
    tp->add_skill_points("healing", amount/2);
    tp->add_alignment(amount/5);
    tp->add_exp(amount/4);
  }
  if(!limb) {
    ob->add_hp(amount);
  }
  else if(limb == "all") {
    limbs = (string *)ob->query_limbs();
    for(i=0; i<sizeof(limbs); i++) {
      ob->heal_limb(limbs[i], (amount/2));
    }
    ob->add_hp(amount/2);
  }
  else {
    ob->heal_limb(limb, amount);  
    ob->add_hp(amount/3);
  }
  send_messages(tp, ob, clas, limb);
  return 1;
}
int main(int argc, char** argv)
{
    boost::program_options::options_description desc("options");
    desc.add_options()
        ("help", "produce help message")
        ("topic", boost::program_options::value<std::string>(), "topic")
        ("broker", boost::program_options::value<std::string>(), "broker")
        ("schema_registry", boost::program_options::value<std::string>(), "schema_registry")
        ("schema_registry_port", boost::program_options::value<int>()->default_value(8081), "schema_registry_port")
        ;

    boost::program_options::variables_map vm;
    boost::program_options::store(boost::program_options::parse_command_line(argc, argv, desc), vm);
    boost::program_options::notify(vm);

    boost::log::core::get()->set_filter(boost::log::trivial::severity >= boost::log::trivial::info);

    if (vm.count("help"))
    {
        std::cout << desc << std::endl;
        return 0;
    }

    std::string topic;
    if (vm.count("topic"))
    {
        topic = vm["topic"].as<std::string>();
    }
    else
    {
        std::cout << "--topic must be specified" << std::endl;
        return 0;
    }

    int32_t kafka_port = 9092;
    std::vector<csi::kafka::broker_address> kafka_brokers;
    if (vm.count("broker"))
    {
        std::string s = vm["broker"].as<std::string>();
        size_t last_colon = s.find_last_of(':');
        if (last_colon != std::string::npos)
            kafka_port = atoi(s.substr(last_colon + 1).c_str());
        s = s.substr(0, last_colon);

        // now find the brokers...
        size_t last_separator = s.find_last_of(',');
        while (last_separator != std::string::npos)
        {
            std::string host = s.substr(last_separator + 1);
            kafka_brokers.push_back(csi::kafka::broker_address(host, kafka_port));
            s = s.substr(0, last_separator);
            last_separator = s.find_last_of(',');
        }
        kafka_brokers.push_back(csi::kafka::broker_address(s, kafka_port));
    }
    else
    {
        std::cout << "--broker must be specified" << std::endl;
        return 0;
    }

    int32_t schema_registry_port = 8081;
    std::vector<csi::kafka::broker_address> schema_registrys;
    std::string used_schema_registry;

    if (vm.count("schema_registry_port"))
    {
        schema_registry_port = vm["schema_registry_port"].as<int>();
    }

    if (vm.count("schema_registry"))
    {
        std::string s = vm["schema_registry"].as<std::string>();
        size_t last_colon = s.find_last_of(':');
        if (last_colon != std::string::npos)
            schema_registry_port = atoi(s.substr(last_colon + 1).c_str());
        s = s.substr(0, last_colon);

        // now find the brokers...
        size_t last_separator = s.find_last_of(',');
        while (last_separator != std::string::npos)
        {
            std::string host = s.substr(last_separator + 1);
            schema_registrys.push_back(csi::kafka::broker_address(host, schema_registry_port));
            s = s.substr(0, last_separator);
            last_separator = s.find_last_of(',');
        }
        schema_registrys.push_back(csi::kafka::broker_address(s, schema_registry_port));
    }
    else
    {
        // default - assume registry is running on all kafka brokers
        for (std::vector<csi::kafka::broker_address>::const_iterator i = kafka_brokers.begin(); i != kafka_brokers.end(); ++i)
        {
            schema_registrys.push_back(csi::kafka::broker_address(i->host_name, schema_registry_port));
        }
    }

    // right now the schema registry class cannot handle severel hosts so just stick to the first one.
    used_schema_registry = schema_registrys[0].host_name + ":" + std::to_string(schema_registrys[0].port);


    std::string kafka_broker_str = "";
    for (std::vector<csi::kafka::broker_address>::const_iterator i = kafka_brokers.begin(); i != kafka_brokers.end(); ++i)
    {
        kafka_broker_str += i->host_name + ":" + std::to_string(i->port);
        if (i != kafka_brokers.end() - 1)
            kafka_broker_str += ", ";
    }

    BOOST_LOG_TRIVIAL(info) << "kafka broker(s): " << kafka_broker_str;
    BOOST_LOG_TRIVIAL(info) << "topic          : " << topic;

    std::string schema_registrys_info;
    for (std::vector<csi::kafka::broker_address>::const_iterator i = schema_registrys.begin(); i != schema_registrys.end(); ++i)
    {
        schema_registrys_info += i->host_name + ":" + std::to_string(i->port);
        if (i != schema_registrys.end() - 1)
            schema_registrys_info += ", ";
    }
    BOOST_LOG_TRIVIAL(info) << "schema_registry(s)  : " << schema_registrys_info;
    BOOST_LOG_TRIVIAL(info) << "used schema registry: " << used_schema_registry;


    int64_t total = 0;
	boost::asio::io_service fg_ios;
	std::auto_ptr<boost::asio::io_service::work> work(new boost::asio::io_service::work(fg_ios));
	boost::thread fg(boost::bind(&boost::asio::io_service::run, &fg_ios));

	csi::kafka::highlevel_producer producer(fg_ios, topic, -1, 200, 1000000);
    confluent::registry            registry(fg_ios, used_schema_registry);
	confluent::codec               avro_codec(registry);

    producer.connect(kafka_brokers);
    BOOST_LOG_TRIVIAL(info) << "connected to kafka";
    producer.connect_forever(kafka_brokers);

	boost::thread do_log([&producer]
	{
		while (true)
		{
			boost::this_thread::sleep(boost::posix_time::seconds(1));

			std::vector<csi::kafka::highlevel_producer::metrics>  metrics = producer.get_metrics();

			size_t total_queue = 0;
			uint32_t tx_msg_sec_total = 0;
			uint32_t tx_kb_sec_total = 0;
			for (std::vector<csi::kafka::highlevel_producer::metrics>::const_iterator i = metrics.begin(); i != metrics.end(); ++i)
			{
				total_queue += (*i).msg_in_queue;
				tx_msg_sec_total += (*i).tx_msg_sec;
				tx_kb_sec_total += (*i).tx_kb_sec;
			}
            BOOST_LOG_TRIVIAL(info) << "\t        \tqueue:" << total_queue << "\t" << tx_msg_sec_total << " msg/s \t" << (tx_kb_sec_total / 1024) << "MB/s";
		}
	});


	std::cerr << "registring schemas" << std::endl;
	auto key_res = avro_codec.put_schema("sample.contact_info_key", sample::contact_info_key::valid_schema());

	if (key_res.first!=0)
	{
        BOOST_LOG_TRIVIAL(error) << "registring sample.contact_info_key failed";
		return -1;
	}
	auto val_res = avro_codec.put_schema("sample.contact_info", sample::contact_info::valid_schema());
	if (val_res.first!=0)
	{
        BOOST_LOG_TRIVIAL(error) << "registring sample.contact_info failed";
		return -1;
	}
    BOOST_LOG_TRIVIAL(info) << "registring schemas done";
	
    //produce messages

	std::vector<boost::thread*> threads;
	
	for (int i = 0; i != 10; ++i)
	{
        threads.emplace_back(new boost::thread([&avro_codec, key_res, val_res, &producer, i]
		{
            send_messages(avro_codec, key_res.second, val_res.second, producer, i);
		}));
	}

	while (true)
	{
		boost::this_thread::sleep(boost::posix_time::seconds(1));
	}


    work.reset();
	fg_ios.stop();
    return EXIT_SUCCESS;
}
Ejemplo n.º 22
0
Archivo: _heal.c Proyecto: ehershey/pd
int cmd_heal(string str) {
    string whom, limb, clas;
    int amount, cost, healing, i, wisdom;
    object tp, ob;
    string * limbs;

   if (!spell()) {
      write("What?\n");
      return 1;
   }
    if(!str) {
        notify_fail("Heal whom?\n");
        return 0;
    }
    tp = this_player();
    if(tp->query_casting()) {
        notify_fail("You are in the middle of another spell!\n");
        return 0;
    }
    if(!alignment_ok(this_player())) {
        notify_fail("You have betrayed the source of your powers.\n");
        return 0;
    }
    healing = (int)tp->query_skill("healing");
    wisdom = (int)tp->query_stats("wisdom");
    clas = (string)tp->query_subclass();
    if(str == "me" || str == "myself") ob = tp;
    else ob = present(str, environment(tp));
    if(!ob) {
        if(sscanf(str, "%s %s", whom, limb) != 2) {
            notify_fail("Correct syntax: <heal [who] [(limb)]\n");
            return 0;
        }
        if(whom == "me" || whom == "myself") ob = tp;
        else ob = present(whom, environment(tp));
    }
    if(!ob) {
        notify_fail("Heal whom?\n");
        return 0;
    }
    if(!limb) cost = 22;
    else if(limb == "all") cost = 44;
    else if(member_array(limb, (string *)tp->query_limbs()) == -1) {
        notify_fail("You do not have a "+limb+".\n");
        return 0;
    }
    else cost = 14;
    if(ob != tp) cost = random(cost);
    if((int)tp->query_mp() < cost) {
        notify_fail("Too low on magic power.\n");
        tp->add_mp(-cost);
        return 0;
    }
    this_player()->set_magic_round(1);
    tp->add_mp(-cost);
    if(healing < 5) amount = 0;
    else amount = random(wisdom + (healing/10));
    if(!amount) {
        write("You do not have the skill to do that.");
        return 1;
    }
    if(tp == ob) tp->add_skill_points("healing", amount);
    else {
        tp->add_skill_points("healing", amount * 2);
        tp->add_alignment(amount);
        tp->add_exp(random((amount/2)+2));
    }
    if(!limb) {
        ob->add_hp(amount);
        send_messages(tp, ob, clas, 0);
    }
    else if(limb == "all") {
        limbs = (string *)ob->query_limbs();
        for(i=0; i<sizeof(limbs); i++) {
            ob->heal_limb(limbs[i], (amount / 2));
        }
        ob->add_hp(amount / 2);
        send_messages(tp, ob, clas, limb);
    }
    else {
        ob->heal_limb(limb, amount);
        send_messages(tp, ob, clas, limb);
    }
    return 1;
}
Ejemplo n.º 23
0
int main()
{
 int sfd, cfd;
 socklen_t len;
 struct sockaddr_in saddr, caddr;
 
 sfd= socket(AF_INET, SOCK_STREAM, 0);
 
 saddr.sin_family=AF_INET;
 saddr.sin_addr.s_addr=htonl(INADDR_ANY);
 saddr.sin_port=htons(SERVER_PORT);
 
 bind(sfd, (struct sockaddr *)&saddr, sizeof(saddr));
 
 listen(sfd, 5);  //listen upto 5 connections simultaneously
 signal(SIGCHLD, SIG_IGN);
 
 while(1) {
	 printf("Server waiting\n");
	 len=sizeof(caddr);
	 cfd=accept(sfd, (struct sockaddr *)&caddr, &len); //Returns descriptor
	 
	 if( fork() == 0) {
	 
		 close(sfd); // In the child process close this. Parent closes cfd
		 char msg[MAX_COMMAND_SIZE]; 
		 struct Message* buff = (struct Message*)malloc(sizeof(struct Message));
		 int started = 0;
		 int seq_no = 0;
		 int rc;
		 printf("Came into first connection");
		 while(1){
			 while((rc = recv(cfd, buff, sizeof(struct Message), MSG_DONTWAIT))<=0);
			 memcpy(msg, buff->content, buff->size);
			 if(msg[strlen(msg)-1]=='\n'){
			    msg[strlen(msg)-1]='\0';
			  }
			 printf("Received %s with rc = %d and started = %d\n",msg, rc, started);

			 if(!started){
			     if(strcmp(msg,"open") == 0){
				    if(chdir("/")==-1){
					    exit(1);
				    }else{
					    send_message(cfd, "HOME\0", 5, seq_no ++);
					    printf("Opened... ");
					    started = 1;
				    }
			    }
		    	  }
			    
			    //ls command
			    else if(msg[0] == 'l' && msg[1] == 's'){
				    execute_command(cfd, msg, &seq_no);
			    }else if(msg[0] == 'c' && msg[1] == 'd'){
				    if(msg[2] == '\0'){
					    //A simple cd.
					    if(chdir("/")==-1){
						    send_message(cfd, "Cannot move to home directory.\n\0", 32, seq_no ++);
					    }else{
						    execute_command(cfd, msg, &seq_no);
						    send_message(cfd, "Moved to home directory\n\0", 25, seq_no ++);
					    }
				    }
				    else{
					    int i;
					    int k = strlen(msg);
					    for(i = 0; i <= k - 3; i++){
						    msg[i] = msg[i+3];
					    }
					    msg[k - 3] = '\0';
					    if(chdir(msg)==-1){
						send_message(cfd, "Cannot move to specified location.\n\0", 32, seq_no ++);
					    }else{
						send_message(cfd, "Successfully moved to specified location.\n\0", 41, seq_no ++);
					    }
				    }
			    }else if(msg[0] == 'p' && msg[1] == 'w' && msg[2] == 'd'){
				    execute_command(cfd, "pwd", &seq_no);
			    }else if(msg[0] == 'g' && msg[1] == 'e' && msg[2] == 't'){
				    int i;
				    int k = strlen(msg);
				    for(i = 0; i <= k - 4; i++){
					    msg[i] = msg[i+4];
				    }
				    msg[k - 4] = '\0';
				    FILE *fp;
				    fp = fopen(msg, "rb");
				    if(fp == NULL){
					    printf("Unable to open file.\n");				   
				    } else{
					    printf("Beginning file transfer.\n");	
					    send_messages(cfd, fp, &seq_no);
					    fclose(fp);
				    }
			   }else{
				send_message(cfd, "Invalid command.\n\0", 19, seq_no ++);
			   }
		}
		
		 free(buff);
		 close(cfd);
		 return 0;

	 }

	 
 
	 close(cfd); // Parent has closed this.
	 // As there is a bound on the number of fd's you can have.
 }

 
}
Ejemplo n.º 24
0
static void
global_process_auth(struct userNode *user, UNUSED_ARG(struct handle_info *old_handle), UNUSED_ARG(void *extra))
{
    if(IsHelper(user))
	send_messages(user, MESSAGE_RECIPIENT_HELPERS, 0);
}
Ejemplo n.º 25
0
Archivo: bed.c Proyecto: Elohim/FGmud
int PushBed(){
    send_messages("move", "$agent_name $agent_verb the bed.",
            this_player(), 0, environment(this_player()));
    environment(this_object())->OpenPassage();
    return 1;
}
Ejemplo n.º 26
0
void RedChannel::on_send_trigger()
{
    send_messages();
}
Ejemplo n.º 27
0
int PushRug() {
    send_messages("move", "$agent_name $agent_verb the Persian rug.",
                  this_player(), 0, environment(this_player()));
    environment(this_object())->RevealDoor();
    return 1;
}
Ejemplo n.º 28
0
void endCallback(object who) {
    if( who ) {
        send_messages("", "The %^BOLD%^CYAN%^magical shield%^RESET%^ around "
          "$agent_name shatters into nothingness.", who, 0, environment(who), 0);
    }
}