Message Functions (msg_xxx)

Classes
struct	msg_buffer_entry

Functions
std::string	cm_get_error (INT code)
int	cm_msg_early_init (void)
int	cm_msg_open_buffer (void)
int	cm_msg_close_buffer (void)
INT EXPRT	cm_msg_facilities (STRING_LIST *list)
void	cm_msg_get_logfile (const char *fac, time_t t, std::string *filename, std::string *linkname, std::string *linktarget)
INT	cm_set_msg_print (INT system_mask, INT user_mask, int(*func)(const char *))
INT	cm_msg_log (INT message_type, const char *facility, const char *message)
static std::string	cm_msg_format (INT message_type, const char *filename, INT line, const char *routine, const char *format, va_list *argptr)
static INT	cm_msg_send_event (DWORD ts, INT message_type, const char *send_message)
INT	cm_msg_flush_buffer ()
INT	cm_msg (INT message_type, const char *filename, INT line, const char *routine, const char *format,...)
INT	cm_msg1 (INT message_type, const char *filename, INT line, const char *facility, const char *routine, const char *format,...)
INT	cm_msg_register (EVENT_HANDLER *func)
static void	add_message (char **messages, int *length, int *allocated, time_t tstamp, const char *new_message)
static int	cm_msg_retrieve1 (const char *filename, time_t t, INT n_messages, char **messages, int *length, int *allocated, int *num_messages)
INT	cm_msg_retrieve2 (const char *facility, time_t t, INT n_message, char **messages, int *num_messages)
INT	cm_msg_retrieve (INT n_message, char *message, INT buf_size)

Variables
static std::deque< msg_buffer_entry >	gMsgBuf
static std::mutex	gMsgBufMutex

Detailed Description

dox dox

Function Documentation

add_message()

static void add_message ( char **  messages, int *  length, int *  allocated, time_t  tstamp, const char *  new_message  )

static

Definition at line 1081 of file midas.cxx.

                                                                                                              {
   int new_message_length = strlen(new_message);
   int new_allocated = 1024 + 2 * ((*allocated) + new_message_length);
   char buf[100];
   int buf_length;
 
   //printf("add_message: new message %d, length %d, new end: %d, allocated: %d, maybe reallocate size %d\n", new_message_length, *length, *length + new_message_length, *allocated, new_allocated);
 
   if (*length + new_message_length + 100 > *allocated) {
      *messages = (char *) realloc(*messages, new_allocated);
      assert(*messages != NULL);
      *allocated = new_allocated;
   }
 
   if (*length > 0)
      if ((*messages)[(*length) - 1] != '\n') {
         (*messages)[*length] = '\n'; // separator between messages
         (*length) += 1;
      }
 
   sprintf(buf, "%ld ", tstamp);
   buf_length = strlen(buf);
   memcpy(&((*messages)[*length]), buf, buf_length);
   (*length) += buf_length;
 
   memcpy(&((*messages)[*length]), new_message, new_message_length);
   (*length) += new_message_length;
   (*messages)[*length] = 0; // make sure string is NUL terminated
}

Here is the caller graph for this function:

cm_get_error()

std::string cm_get_error

(

INT

code

)

Convert error code to string. Used after cm_connect_experiment to print error string in command line programs or windows programs.

Parameters

code	Error code as defined in midas.h
string	Error string

Returns

CM_SUCCESS

Definition at line 469 of file midas.cxx.

{
   for (int i = 0; _error_table[i].code; i++) {
      if (_error_table[i].code == code) {
         return _error_table[i].string;
      }
   }
 
   return msprintf("unlisted status code %d", code);
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_msg()

INT cm_msg	(	INT	message_type,
		const char *	filename,
		INT	line,
		const char *	routine,
		const char *	format,
			...
	)

This routine can be called whenever an internal error occurs or an informative message is produced. Different message types can be enabled or disabled by setting the type bits via cm_set_msg_print().

Attention

Do not add the "\n" escape carriage control at the end of the formated line as it is already added by the client on the receiving side.

...
cm_msg(MINFO, "my program", "This is a information message only);
cm_msg(MERROR, "my program", "This is an error message with status:%d", my_status);
cm_msg(MTALK, "my_program", My program is Done!");
...

Parameters

message_type	(See midas_macro).
filename	Name of source file where error occured
line	Line number where error occured
routine	Routine name.
format	message to printout, ... Parameters like for printf()

Returns

CM_SUCCESS

Definition at line 931 of file midas.cxx.

{
   DWORD ts = ss_time();
 
   /* print argument list into message */
   std::string message;
   va_list argptr;
   va_start(argptr, format);
   message = cm_msg_format(message_type, filename, line, routine, format, &argptr);
   va_end(argptr);
 
   //printf("message [%s]\n", message.c_str());
 
   /* call user function if set via cm_set_msg_print */
   MessagePrintCallback f = _message_print.load();
   if (f != NULL && (message_type & _message_mask_user) != 0) {
      if (message_type != MT_LOG) { // do not print MLOG messages
         (*f)(message.c_str());
      }
   }
 
   /* return if system mask is not set */
   if ((message_type & _message_mask_system) == 0) {
      return CM_SUCCESS;
   }
 
   gMsgBufMutex.lock();
   gMsgBuf.push_back(msg_buffer_entry{ts, message_type, message});
   gMsgBufMutex.unlock();
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

cm_msg1()

INT cm_msg1	(	INT	message_type,
		const char *	filename,
		INT	line,
		const char *	facility,
		const char *	routine,
		const char *	format,
			...
	)

This routine is similar to cm_msg(). It differs from cm_msg() only by the logging destination being a file given through the argument list i.e:facility

Attention

Do not add the "\n" escape carriage control at the end of the formated line as it is already added by the client on the receiving side. The first arg in the following example uses the predefined macro MINFO which handles automatically the first 3 arguments of the function (see midas_macro).

 ...
   cm_msg1(MINFO, "my_log_file", "my_program"," My message status:%d", status);
   ...
//----- File my_log_file.log
Thu Nov  8 17:59:28 2001 [my_program] My message status:1

Parameters

message_type	See midas_macro.
filename	Name of source file where error occured
line	Line number where error occured
facility	Logging file name
routine	Routine name
format	message to printout, ... Parameters like for printf()

Returns

CM_SUCCESS

Definition at line 989 of file midas.cxx.

                                                                                {
   va_list argptr;
   std::string message;
   static BOOL in_routine = FALSE;
 
   /* avoid recursive calles */
   if (in_routine)
      return 0;
 
   in_routine = TRUE;
 
   /* print argument list into message */
   va_start(argptr, format);
   message = cm_msg_format(message_type, filename, line, routine, format, &argptr);
   va_end(argptr);
 
   /* call user function if set via cm_set_msg_print */
   MessagePrintCallback f = _message_print.load();
   if (f != NULL && (message_type & _message_mask_user) != 0)
      (*f)(message.c_str());
 
   /* return if system mask is not set */
   if ((message_type & _message_mask_system) == 0) {
      in_routine = FALSE;
      return CM_SUCCESS;
   }
 
   /* send message to SYSMSG */
   cm_msg_send_event(0, message_type, message.c_str());
 
   /* log message */
   cm_msg_log(message_type, facility, message.c_str());
 
   in_routine = FALSE;
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_msg_close_buffer()

int cm_msg_close_buffer

(

void

)

Definition at line 501 of file midas.cxx.

                              {
   //printf("cm_msg_close_buffer!\n");
   if (_msg_buffer) {
      bm_close_buffer(_msg_buffer);
      _msg_buffer = 0;
   }
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_msg_early_init()

int cm_msg_early_init

(

void

)

Definition at line 481 of file midas.cxx.

                            {
 
   return CM_SUCCESS;
}

Here is the caller graph for this function:

cm_msg_facilities()

INT EXPRT cm_msg_facilities

(

STRING_LIST *

list

)

Retrieve list of message facilities by searching logfiles on disk

Parameters

list	List of facilities

Returns

status SUCCESS

Definition at line 518 of file midas.cxx.

                                               {
   std::string path;
 
   cm_msg_get_logfile("midas", 0, &path, NULL, NULL);
 
   /* extract directory name from full path name of midas.log */
   size_t pos = path.rfind(DIR_SEPARATOR);
   if (pos != std::string::npos) {
      path.resize(pos);
   } else {
      path = "";
   }
 
   //printf("cm_msg_facilities: path [%s]\n", path.c_str());
 
   STRING_LIST flist;
   
   ss_file_find(path.c_str(), "*.log", &flist);
 
   for (size_t i = 0; i < flist.size(); i++) {
      const char *p = flist[i].c_str();
      if (strchr(p, '_') == NULL && !(p[0] >= '0' && p[0] <= '9')) {
         size_t pos = flist[i].rfind('.');
         if (pos != std::string::npos) {
            flist[i].resize(pos);
         }
         list->push_back(flist[i]);
      }
   }
 
   return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_msg_flush_buffer()

INT cm_msg_flush_buffer

(

void

)

This routine can be called to process messages buffered by cm_msg(). Normally it is called from cm_yield() and cm_disconnect_experiment() to make sure all accumulated messages are processed.

Definition at line 881 of file midas.cxx.

                          {
   int i;
 
   //printf("cm_msg_flush_buffer!\n");
 
   for (i = 0; i < 100; i++) {
      msg_buffer_entry e;
      {
         std::lock_guard<std::mutex> lock(gMsgBufMutex);
         if (gMsgBuf.empty())
            break;
         e = gMsgBuf.front();
         gMsgBuf.pop_front();
         // implicit unlock
      }
 
      /* log message */
      cm_msg_log(e.message_type, "midas", e.message.c_str());
 
      /* send message to SYSMSG */
      int status = cm_msg_send_event(e.ts, e.message_type, e.message.c_str());
      if (status != CM_SUCCESS)
         return status;
   }
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_msg_format()

static std::string cm_msg_format ( INT  message_type, const char *  filename, INT  line, const char *  routine, const char *  format, va_list *  argptr  )

static

Definition at line 765 of file midas.cxx.

{
   /* strip path */
   const char* pc = filename + strlen(filename);
   while (*pc != '\\' && *pc != '/' && pc != filename)
      pc--;
   if (pc != filename)
      pc++;
 
   /* convert type to string */
   std::string type_str;
   if (message_type & MT_ERROR)
      type_str += MT_ERROR_STR;
   if (message_type & MT_INFO)
      type_str += MT_INFO_STR;
   if (message_type & MT_DEBUG)
      type_str += MT_DEBUG_STR;
   if (message_type & MT_USER)
      type_str += MT_USER_STR;
   if (message_type & MT_LOG)
      type_str += MT_LOG_STR;
   if (message_type & MT_TALK)
      type_str += MT_TALK_STR;
 
   std::string message;
 
   /* print client name into string */
   if (message_type == MT_USER)
      message = msprintf("[%s] ", routine);
   else {
      std::string name = rpc_get_name();
      if (name.length() > 0)
         message = msprintf("[%s,%s] ", name.c_str(), type_str.c_str());
      else
         message = "";
   }
 
   /* preceed error messages with file and line info */
   if (message_type == MT_ERROR) {
      message += msprintf("[%s:%d:%s,%s] ", pc, line, routine, type_str.c_str());
   } else if (message_type == MT_USER) {
      message = msprintf("[%s,%s] ", routine, type_str.c_str());
   }
 
   int bufsize = 1024;
   char* buf = (char*)malloc(bufsize);
   assert(buf);
 
   for (int i=0; i<10; i++) {
      va_list ap;
      va_copy(ap, *argptr);
      
      /* print argument list into message */
      int n = vsnprintf(buf, bufsize-1, format, ap);
 
      //printf("vsnprintf [%s] %d %d\n", format, bufsize, n);
 
      va_end(ap);
 
      if (n < bufsize) {
         break;
      }
 
      bufsize += 100;
      bufsize *= 2;
      buf = (char*)realloc(buf, bufsize);
      assert(buf);
   }
 
   message += buf;
   free(buf);
 
   return message;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_msg_get_logfile()

void cm_msg_get_logfile	(	const char *	fac,
		time_t	t,
		std::string *	filename,
		std::string *	linkname,
		std::string *	linktarget
	)

Definition at line 553 of file midas.cxx.

                                                                                                                    {
   HNDLE hDB;
   int status;
 
   status = cm_get_experiment_database(&hDB, NULL);
 
   // check for call to cm_msg() before MIDAS is fully initialized
   // or after MIDAS is partially shutdown.
   if (status != CM_SUCCESS) {
      if (filename)
         *filename = std::string(fac) + ".log";
      if (linkname)
         *linkname = "";
      if (linktarget)
         *linktarget = "";
      return;
   }
 
   if (filename)
      *filename = "";
   if (linkname)
      *linkname = "";
   if (linktarget)
      *linktarget = "";
 
   std::string facility;
   if (fac && fac[0])
      facility = fac;
   else
      facility = "midas";
 
   std::string message_format;
   db_get_value_string(hDB, 0, "/Logger/Message file date format", 0, &message_format, TRUE);
   if (message_format.find('%') != std::string::npos) {
      /* replace stings such as %y%m%d with current date */
      struct tm tms;
 
      ss_tzset();
      if (t == 0)
         time(&t);
      localtime_r(&t, &tms);
 
      char de[256];
      de[0] = '_';
      strftime(de + 1, sizeof(de)-1, strchr(message_format.c_str(), '%'), &tms);
      message_format = de;
   }
 
   std::string message_dir;
   db_get_value_string(hDB, 0, "/Logger/Message dir", 0, &message_dir, TRUE);
   if (message_dir.empty()) {
      db_get_value_string(hDB, 0, "/Logger/Data dir", 0, &message_dir, FALSE);
      if (message_dir.empty()) {
         message_dir = cm_get_path();
         if (message_dir.empty()) {
            message_dir = ss_getcwd();
         }
      }
   }
 
   // prepend experiment directory
   if (message_dir[0] != DIR_SEPARATOR)
      message_dir = cm_get_path() + message_dir;
 
   if (message_dir.back() != DIR_SEPARATOR)
      message_dir.push_back(DIR_SEPARATOR);
 
   if (filename)
      *filename = message_dir + facility + message_format + ".log";
   if (!message_format.empty()) {
      if (linkname)
         *linkname = message_dir + facility  + ".log";
      if (linktarget)
         *linktarget = facility  + message_format + ".log";
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_msg_log()

INT cm_msg_log	(	INT	message_type,
		const char *	facility,
		const char *	message
	)

Write message to logging file. Called by cm_msg.

Attention

May burn your fingers

Parameters

message_type	Message type
message	Message string
facility	Message facility, filename in which messages will be written

Returns

CM_SUCCESS

Definition at line 678 of file midas.cxx.

                                                                            {
   INT status;
 
   if (rpc_is_remote()) {
      if (rpc_is_connected()) {
         status = rpc_call(RPC_CM_MSG_LOG, message_type, facility, message);
         if (status != RPC_SUCCESS) {
            fprintf(stderr, "cm_msg_log: Message \"%s\" not written to midas.log because rpc_call(RPC_CM_MSG_LOG) failed with status %d\n", message, status);
         }
         return status;
      } else {
         fprintf(stderr, "cm_msg_log: Message \"%s\" not written to midas.log, no connection to mserver\n", message);
         return RPC_NET_ERROR;
      }
   }
 
   if (message_type != MT_DEBUG) {
      std::string filename, linkname, linktarget;
 
      cm_msg_get_logfile(facility, 0, &filename, &linkname, &linktarget);
 
#ifdef OS_LINUX
      if (!linkname.empty()) {
         //printf("cm_msg_log: filename [%s] linkname [%s] linktarget [%s]\n", filename.c_str(), linkname.c_str(), linktarget.c_str());
         // If filename does not exist, user just switched from non-date format to date format.
         // In that case we must copy linkname to filename, otherwise messages might get lost.
         if (ss_file_exist(linkname.c_str()) && !ss_file_link_exist(linkname.c_str())) {
            ss_file_copy(linkname.c_str(), filename.c_str(), true);
         }
 
         unlink(linkname.c_str());
         status = symlink(linktarget.c_str(), linkname.c_str());
         if (status != 0) {
            fprintf(stderr,
                    "cm_msg_log: Error: Cannot symlink message log file \'%s' to \'%s\', symlink() errno: %d (%s)\n",
                    linktarget.c_str(), linkname.c_str(), errno, strerror(errno));
         }
      }
#endif
 
      int fh = open(filename.c_str(), O_WRONLY | O_CREAT | O_APPEND | O_LARGEFILE, 0644);
      if (fh < 0) {
         fprintf(stderr,
                 "cm_msg_log: Message \"%s\" not written to midas.log because open(%s) failed with errno %d (%s)\n",
                 message, filename.c_str(), errno, strerror(errno));
      } else {
 
         struct timeval tv;
         struct tm tms;
 
         ss_tzset();
         gettimeofday(&tv, NULL);
         localtime_r(&tv.tv_sec, &tms);
 
         char str[256];
         strftime(str, sizeof(str), "%H:%M:%S", &tms);
         sprintf(str + strlen(str), ".%03d ", (int) (tv.tv_usec / 1000));
         strftime(str + strlen(str), sizeof(str), "%G/%m/%d", &tms);
 
         std::string msg;
         msg += str;
         msg += " ";
         msg += message;
         msg += "\n";
 
         /* avoid c++ complaint about comparison between
            unsigned size_t returned by msg.length() and
            signed ssize_t returned by write() */
         ssize_t len = msg.length();
 
         /* atomic write, no need to take a semaphore */
         ssize_t wr = write(fh, msg.c_str(), len);
 
         if (wr < 0) {
            fprintf(stderr, "cm_msg_log: Message \"%s\" not written to \"%s\", write() error, errno %d (%s)\n", message, filename.c_str(), errno, strerror(errno));
         } else if (wr != len) {
            fprintf(stderr, "cm_msg_log: Message \"%s\" not written to \"%s\", short write() wrote %d instead of %d bytes\n", message, filename.c_str(), (int)wr, (int)len);
         }
 
         close(fh);
      }
   }
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_msg_open_buffer()

int cm_msg_open_buffer

(

void

)

Definition at line 488 of file midas.cxx.

                             {
   //printf("cm_msg_open_buffer!\n");
   if (_msg_buffer == 0) {
      int status = bm_open_buffer(MESSAGE_BUFFER_NAME, MESSAGE_BUFFER_SIZE, &_msg_buffer);
      if (status != BM_SUCCESS && status != BM_CREATED) {
         return status;
      }
   }
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_msg_register()

INT cm_msg_register

(

EVENT_HANDLER *

func

)

Register a dispatch function for receiving system messages.

• example code from mlxspeaker.c

  void receive_message(HNDLE hBuf, HNDLE id, EVENT_HEADER *header, void *message)
  {
    char str[256], *pc, *sp;
    // print message
    printf("%s\n", (char *)(message));
   
    printf("evID:%x Mask:%x Serial:%i Size:%d\n"
                   ,header->event_id
                   ,header->trigger_mask
                   ,header->serial_number
                   ,header->data_size);
    pc = strchr((char *)(message),']')+2;
    ...
    // skip none talking message
    if (header->trigger_mask == MT_TALK ||
        header->trigger_mask == MT_USER)
     ...
  }
   
  int main(int argc, char *argv[])
  {
    ...
    // now connect to server
    status = cm_connect_experiment(host_name, exp_name, "Speaker", NULL);
    if (status != CM_SUCCESS)
      return 1;
    // Register callback for messages
    cm_msg_register(receive_message);
    ...
  }

  Parameters

  func	Dispatch function.

  Returns

  CM_SUCCESS or bm_open_buffer and bm_request_event return status

Definition at line 1067 of file midas.cxx.

                                         {
   INT status, id;
 
   // we should only come here after the message buffer
   // was opened by cm_connect_experiment()
   assert(_msg_buffer);
 
   _msg_dispatch = func;
 
   status = bm_request_event(_msg_buffer, EVENTID_ALL, TRIGGER_ALL, GET_NONBLOCKING, &id, func);
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_msg_retrieve()

INT cm_msg_retrieve	(	INT	n_message,
		char *	message,
		INT	buf_size
	)

Retrieve newest messages from "midas" facility log file

Parameters

n_message	Number of messages to retrieve
message	buf_size bytes of messages, separated by characters. The returned number of bytes is normally smaller than the initial buf_size, since only full lines are returned.
*buf_size	Size of message buffer to fill

Returns

CM_SUCCESS, CM_TRUNCATED

Definition at line 1350 of file midas.cxx.

                                                                {
   int status;
   char *messages = NULL;
   int num_messages = 0;
 
   if (rpc_is_remote())
      return rpc_call(RPC_CM_MSG_RETRIEVE, n_message, message, buf_size);
 
   status = cm_msg_retrieve2("midas", 0, n_message, &messages, &num_messages);
 
   if (messages) {
      mstrlcpy(message, messages, buf_size);
      int len = strlen(messages);
      if (len > buf_size)
         status = CM_TRUNCATED;
      free(messages);
   }
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_msg_retrieve1()

static int cm_msg_retrieve1 ( const char *  filename, time_t  t, INT  n_messages, char **  messages, int *  length, int *  allocated, int *  num_messages  )

static

Definition at line 1112 of file midas.cxx.

                                               {
   BOOL stop;
   int fh;
   char *p, str[1000];
   struct stat stat_buf;
   time_t tstamp, tstamp_valid, tstamp_last;
 
   ss_tzset(); // required by localtime_r()
 
   *num_messages = 0;
 
   fh = open(filename, O_RDONLY | O_TEXT, 0644);
   if (fh < 0) {
      cm_msg(MERROR, "cm_msg_retrieve1", "Cannot open log file \"%s\", errno %d (%s)", filename, errno,
             strerror(errno));
      return SS_FILE_ERROR;
   }
 
   /* read whole file into memory */
   fstat(fh, &stat_buf);
   ssize_t size = stat_buf.st_size;
 
   /* if file is too big, only read tail of file */
   ssize_t maxsize = 10 * 1024 * 1024;
   if (size > maxsize) {
      lseek(fh, -maxsize, SEEK_END);
      //printf("lseek status %d, errno %d (%s)\n", status, errno, strerror(errno));
      size = maxsize;
   }
 
   char *buffer = (char *) malloc(size + 1);
 
   if (buffer == NULL) {
      cm_msg(MERROR, "cm_msg_retrieve1", "Cannot malloc %d bytes to read log file \"%s\", errno %d (%s)", (int) size,
             filename, errno, strerror(errno));
      close(fh);
      return SS_FILE_ERROR;
   }
 
   ssize_t rd = read(fh, buffer, size);
 
   if (rd != size) {
      cm_msg(MERROR, "cm_msg_retrieve1", "Cannot read %d bytes from log file \"%s\", read() returned %d, errno %d (%s)",
             (int) size, filename, (int) rd, errno, strerror(errno));
      close(fh);
      return SS_FILE_ERROR;
   }
 
   buffer[size] = 0;
   close(fh);
 
   p = buffer + size - 1;
   tstamp_last = tstamp_valid = 0;
   stop = FALSE;
 
   while (*p == '\n' || *p == '\r')
      p--;
 
   int n;
   for (n = 0; !stop && p > buffer;) {
 
      /* go to beginning of line */
      int i;
      for (i = 0; p != buffer && (*p != '\n' && *p != '\r'); i++)
         p--;
 
      /* limit line length to sizeof(str) */
      if (i >= (int) sizeof(str))
         i = sizeof(str) - 1;
 
      if (p == buffer) {
         i++;
         memcpy(str, p, i);
      } else
         memcpy(str, p + 1, i);
      str[i] = 0;
      if (strchr(str, '\n'))
         *strchr(str, '\n') = 0;
      if (strchr(str, '\r'))
         *strchr(str, '\r') = 0;
      mstrlcat(str, "\n", sizeof(str));
 
      // extract time tag
      time_t now;
      time(&now);
 
      struct tm tms;
      localtime_r(&now, &tms); // must call tzset() beforehand!
 
      if (str[0] >= '0' && str[0] <= '9') {
         // new format
         tms.tm_hour = atoi(str);
         tms.tm_min = atoi(str + 3);
         tms.tm_sec = atoi(str + 6);
         tms.tm_year = atoi(str + 13) - 1900;
         tms.tm_mon = atoi(str + 18) - 1;
         tms.tm_mday = atoi(str + 21);
      } else {
         // old format
         tms.tm_hour = atoi(str + 11);
         tms.tm_min = atoi(str + 14);
         tms.tm_sec = atoi(str + 17);
         tms.tm_year = atoi(str + 20) - 1900;
         for (i = 0; i < 12; i++)
            if (strncmp(str + 4, mname[i], 3) == 0)
               break;
         tms.tm_mon = i;
         tms.tm_mday = atoi(str + 8);
      }
      tstamp = ss_mktime(&tms);
      if (tstamp != -1)
         tstamp_valid = tstamp;
 
      // for new messages (n=0!), stop when t reached
      if (n_messages == 0) {
         if (tstamp_valid < t)
            break;
      }
 
      // for old messages, stop when all messages belonging to tstamp_last are sent
      if (n_messages != 0) {
         if (tstamp_last > 0 && tstamp_valid < tstamp_last)
            break;
      }
 
      if (t == 0 || tstamp == -1 ||
          (n_messages > 0 && tstamp <= t) ||
          (n_messages == 0 && tstamp >= t)) {
 
         n++;
 
         add_message(messages, length, allocated, tstamp, str);
      }
 
      while (*p == '\n' || *p == '\r')
         p--;
 
      if (n_messages == 1)
         stop = TRUE;
      else if (n_messages > 1) {
         // continue collecting messages until time stamp differs from current one
         if (n == n_messages)
            tstamp_last = tstamp_valid;
 
         // if all messages without time tags, just return after n
         if (n == n_messages && tstamp_valid == 0)
            break;
      }
   }
 
   free(buffer);
 
   *num_messages = n;
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_msg_retrieve2()

INT cm_msg_retrieve2	(	const char *	facility,
		time_t	t,
		INT	n_message,
		char **	messages,
		int *	num_messages
	)

Retrieve old messages from log file

Parameters

facility	Logging facility ("midas", "chat", "lazy", ...)
t	Return messages logged before and including time t, value 0 means start with newest messages
min_messages	Minimum number of messages to return
messages	messages, newest first, separated by characters. caller should free() this buffer at the end.
num_messages	Number of messages returned

Returns

CM_SUCCESS

Definition at line 1280 of file midas.cxx.

                                                                                                        {
   std::string filename, linkname;
   INT n, i;
   time_t filedate;
   int length = 0;
   int allocated = 0;
 
   time(&filedate);
   cm_msg_get_logfile(facility, filedate, &filename, &linkname, NULL);
 
   //printf("facility %s, filename \"%s\" \"%s\"\n", facility, filename, linkname);
 
   // see if file exists, use linkname if not
   if (!linkname.empty()) {
      if (!ss_file_exist(filename.c_str()))
         filename = linkname;
   }
 
   if (ss_file_exist(filename.c_str())) {
      cm_msg_retrieve1(filename.c_str(), t, n_message, messages, &length, &allocated, &n);
   } else {
      n = 0;
   }
 
   /* if there is no symlink, then there is no additional log files to read */
   if (linkname.empty()) {
      *num_messages = n;
      return CM_SUCCESS;
   }
 
   //printf("read more messages %d %d!\n", n, n_message);
 
   int missing = 0;
   while (n < n_message) {
      filedate -= 3600 * 24;         // go one day back
 
      cm_msg_get_logfile(facility, filedate, &filename, NULL, NULL);
 
      //printf("read [%s] for time %d!\n", filename.c_str(), filedate);
 
      if (ss_file_exist(filename.c_str())) {
         cm_msg_retrieve1(filename.c_str(), t, n_message - n, messages, &length, &allocated, &i);
         n += i;
         missing = 0;
      } else {
         missing++;
      }
 
      // stop if ten consecutive files are not found
      if (missing > 10)
         break;
   }
 
   *num_messages = n;
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_msg_send_event()

static INT cm_msg_send_event ( DWORD  ts, INT  message_type, const char *  send_message  )

static

Definition at line 840 of file midas.cxx.

                                                                                   {
   //printf("cm_msg_send: ts %d, type %d, message [%s]\n", ts, message_type, send_message);
 
   /* send event if not of type MLOG */
   if (message_type != MT_LOG) {
      if (_msg_buffer) {
         /* copy message to event */
         size_t len = strlen(send_message);
         int event_length = sizeof(EVENT_HEADER) + len + 1;
         char event[event_length];
         EVENT_HEADER *pevent = (EVENT_HEADER *) event;
 
         memcpy(event + sizeof(EVENT_HEADER), send_message, len + 1);
 
         /* setup the event header and send the message */
         bm_compose_event(pevent, EVENTID_MESSAGE, (WORD) message_type, len + 1, 0);
         if (ts)
            pevent->time_stamp = ts;
         //printf("cm_msg_send_event: len %d, header %d, allocated %d, data_size %d, bm_send_event %p+%d\n", (int)len, (int)sizeof(EVENT_HEADER), event_length, pevent->data_size, pevent, (int)(pevent->data_size + sizeof(EVENT_HEADER)));
         bm_send_event(_msg_buffer, pevent, 0, BM_WAIT);
      }
   }
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_set_msg_print()

INT cm_set_msg_print	(	INT	system_mask,
		INT	user_mask,
		int(*)(const char *)	func
	)

Set message masks. When a message is generated by calling cm_msg(), it can got to two destinatinons. First a user defined callback routine and second to the "SYSMSG" buffer.

A user defined callback receives all messages which satisfy the user_mask.

int message_print(const char *msg)
{
  char str[160];
 
  memset(str, ' ', 159);
  str[159] = 0;
  if (msg[0] == '[')
    msg = strchr(msg, ']')+2;
  memcpy(str, msg, strlen(msg));
  ss_printf(0, 20, str);
  return 0;
}
...
  cm_set_msg_print(MT_ALL, MT_ALL, message_print);
...

Parameters

system_mask	Bit masks for MERROR, MINFO etc. to send system messages.
user_mask	Bit masks for MERROR, MINFO etc. to send messages to the user callback.
func	Function which receives all printout. By setting "puts", messages are just printed to the screen.

Returns

CM_SUCCESS

Definition at line 661 of file midas.cxx.

                                                                                {
   _message_mask_system = system_mask;
   _message_mask_user = user_mask;
   _message_print = func;
 
   return BM_SUCCESS;
}

Here is the caller graph for this function:

Variable Documentation

gMsgBuf

std::deque<msg_buffer_entry> gMsgBuf

static

Definition at line 872 of file midas.cxx.

gMsgBufMutex

std::mutex gMsgBufMutex

static

Definition at line 873 of file midas.cxx.