Beispiel #1
0
/*
 * Thread routine to monitor messages.
 */
void *
rc_monitor_msg(
	void *vun)
{
	sigset_t signal_set;
	dev_ent_t *un = (dev_ent_t *)vun;
	message_request_t *message;

	(void) sigfillset(&signal_set);	/* Block all signals */
	(void) thr_sigsetmask(SIG_SETMASK, &signal_set, (sigset_t *)NULL);
	(void) sigemptyset(&signal_set);
	(void) sigaddset(&signal_set, SIGEMT);	/* Allow SIGEMT */
	(void) thr_sigsetmask(SIG_UNBLOCK, &signal_set, NULL);
	message = (message_request_t *)SHM_REF_ADDR(un->dt.sc.message);
	Trace(TR_PROC, "Monitor messages thread started");

	/* Main loop */
	mutex_lock(&message->mutex);
	for (;;) {
		while (message->mtype == MESS_MT_VOID) {
			(void) cond_wait(&message->cond_r, &message->mutex);
		}

		process_client_message(un, message);
		message->mtype = MESS_MT_VOID;
		message->message.exit_id.pid = 0;
		/* wake up anyone waiting */
		(void) cond_signal(&message->cond_i);
	}
	/* LINTED Function has no return statement */
}
Beispiel #2
0
wxInt32 CViewMessages::FormatMessage(wxInt32 item, wxString& strBuffer) const {
    MESSAGE*   message = wxGetApp().GetDocument()->message(item);

    if (message) {
        strBuffer = process_client_message(message->body.c_str());
    }
    return 0;
}
Beispiel #3
0
int get_stuff_from_client()
{
  int client_len, i, j, activity;
  struct sockaddr_in client_address;
  struct timeval tv;
  char result[MESSAGE_LENGTH], message[MESSAGE_LENGTH];
  strcpy(result, "not done");

  while(strcmp(result, "done") != 0)
  {
    tv.tv_usec = 50000;
    tv.tv_sec = 0;
    readers = master;
    if(select(maxfd+1, &readers, NULL, NULL, &tv) < 0)
    {
      perror("select failed: ");
    }
//printf("well I'm here\n");
    activity = 0;
    if(FD_ISSET(server_socket, &readers))
    {
//      printf("and I'm trying\n");
      activity = 1;
      client_len = sizeof(client_address);
      fdlist[num_clients] = accept(server_socket, (struct sockaddr *)&client_address, (socklen_t *)&client_len);
      FD_SET(fdlist[num_clients], &master);
      if(fdlist[num_clients] > maxfd) maxfd = fdlist[num_clients];
      send_visible_world(fdlist[num_clients]);
      createPlayer(num_clients,50,70,50,0);
      num_clients++;
    }
//    printf("oh I left\n");
    for(i = 1; i < num_clients; i++)
    {
      if(FD_ISSET(fdlist[i], &readers))
      {
        activity = 1;
        if((client_len = get_all(fdlist[i], message, MESSAGE_LENGTH)) <= 0)
        {
          if(client_len < 0) perror("failure during read: ");
          else
          {
            FD_CLR(fdlist[i], &master);
            close(fdlist[i]);
            fdlist[i] = fdlist[num_clients-1];
            hidePlayer(num_clients);
            num_clients--;
            maxfd = 0;
            for(j = 0; j < num_clients; j++)
            {
              if(fdlist[j] > maxfd) maxfd = fdlist[j];
            }
          }
        }
        else
        {
          process_client_message(message);
        }
      }
    }
    if(activity == 0)
    {
      strcpy(result, "done");
    }
  }

  return 0;
}
Beispiel #4
0
int32_t parse_mile_message(struct mile_packet *packet, void **bl_reader,
		int16_t exceed_cpu_used, MEM_POOL_PTR session_mem) {
	int32_t result_code = MILE_RETURN_SUCCESS;
	//读buffer和写buffer
	struct data_buffer* rbuf = packet->rbuf;
	struct data_buffer* sbuf = packet->sbuf;
	//读取消息头
	struct mile_message_header msg_head;
	//当前时间与超时时间
	uint64_t now_time;
	uint64_t deadline_time;

	if (rbuf == NULL) {
		log_error("严重错误, 读buffer为空!");
		return ERROR_PACKET_FORMAT;
	}

	msg_head.version_major = read_int8(rbuf);
	msg_head.version_minor = read_int8(rbuf);
	msg_head.message_type = read_int16(rbuf);
	msg_head.message_id = read_int32(rbuf);
	packet->timeout = read_int32(rbuf);

	log_debug(
			"数据包包头信息 -- 主版本号: %d, 小版本号: %d, 消息类型: 0x%x, 消息id: %d, 超时: %d", msg_head.version_major, msg_head.version_minor, msg_head.message_type, msg_head.message_id, packet->timeout);

	now_time = get_time_msec();
	if (packet->timeout != 0
			&& now_time - packet->launch_time / 1000 > packet->timeout) {
		log_warn(
				"执行sql超时, 收到sql命令时的时间 %llu, 当前时间 %llu, 超时时间 %u", packet->launch_time / 1000, now_time, packet->timeout);
		return ERROR_TIMEOUT;
	} else {
		deadline_time = now_time + packet->timeout;
	}

	uint16_t msg_head_type = (msg_head.message_type & 0xFF00);

	if (msg_head_type == MT_VG_MD) {
		result_code = process_mergeserver_message(&msg_head, rbuf, sbuf,
				exceed_cpu_used, deadline_time);
	} else if (msg_head_type == MT_VG_SC) {
		result_code = StorageEngine::storage->Command(&msg_head, rbuf, sbuf);
		if (MILE_RETURN_SUCCESS != result_code)
			gen_docserver_client_error_packet(result_code, &msg_head, sbuf);
	} else if (msg_head_type == MT_VG_CD) {
		result_code = process_client_message(&msg_head, rbuf, sbuf);
	} else if (msg_head_type == MT_VG_SM) {
		result_code = process_master_message(&msg_head, rbuf, sbuf, bl_reader,
				session_mem);
	} else if (msg_head_type == MT_VG_TEST_REQ) {
		result_code = process_test_message(&msg_head, rbuf, sbuf);
	} else {
		result_code = -1;
	}

	if (result_code != MILE_RETURN_SUCCESS) {
		log_error(
				"执行过程中出错, 错误码 %d, 错误原因 %s", result_code, error_msg(result_code));
	}

	return result_code;
}