Back to index

glibc  2.9
Classes | Defines | Functions | Variables
fmtmsg.c File Reference
#include <fmtmsg.h>
#include <bits/libc-lock.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/syslog.h>

Go to the source code of this file.

Classes

struct  severity_info

Defines

#define NKEYWORDS   (sizeof( keywords) / sizeof (keywords[0]))

Functions

 __libc_lock_define_initialized (static, lock)
static void init (void)
static int internal_addseverity (int severity, const char *string) internal_function
int fmtmsg (long int classification, const char *label, int severity, const char *text, const char *action, const char *tag)
int addseverity (int severity, const char *string)
 libc_freeres_fn (free_mem)

Variables

struct {
uint32_t len
const char name [12]
keywords []
static struct severity_info
static struct severity_infoseverity_list = (struct severity_info *) &infosev
static int print

Class Documentation

struct severity_info

Definition at line 61 of file fmtmsg.c.

Collaboration diagram for severity_info:
Class Members
struct severity_info * next
int severity
const char * string

Define Documentation

#define NKEYWORDS   (sizeof( keywords) / sizeof (keywords[0]))

Definition at line 58 of file fmtmsg.c.


Function Documentation

__libc_lock_define_initialized ( static  ,
lock   
)

Definition at line 32 of file fmtmsg.c.

{
  label_mask = 0x01,
  severity_mask = 0x02,
  text_mask = 0x04,
  action_mask = 0x08,
  tag_mask = 0x10,
  all_mask = label_mask | severity_mask | text_mask | action_mask | tag_mask
};
int addseverity ( int  severity,
const char *  string 
)

Definition at line 343 of file fmtmsg.c.

{
  int result;

  /* Prevent illegal SEVERITY values.  */
  if (severity <= MM_INFO)
    return MM_NOTOK;

  /* Protect the global data.  */
  __libc_lock_lock (lock);

  /* Do the real work.  */
  result = internal_addseverity (severity, string);

  /* Release the lock.  */
  __libc_lock_unlock (lock);

  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int fmtmsg ( long int  classification,
const char *  label,
int  severity,
const char *  text,
const char *  action,
const char *  tag 
)

Definition at line 104 of file fmtmsg.c.

{
  __libc_once_define (static, once);
  int result = MM_OK;
  struct severity_info *severity_rec;

  /* Make sure everything is initialized.  */
  __libc_once (once, init);

  /* Start the real work.  First check whether the input is ok.  */
  if (label != MM_NULLLBL)
    {
      /* Must be two fields, separated by a colon.  */
      const char *cp = strchr (label, ':');
      if (cp == NULL)
       return MM_NOTOK;

      /* The first field must not contain more then 10 bytes.  */
      if (cp - label > 10
         /* The second field must not have more then 14 bytes.  */
         || strlen (cp + 1) > 14)
       return MM_NOTOK;
    }

  for (severity_rec = severity_list; severity_rec != NULL;
       severity_rec = severity_rec->next)
    if (severity == severity_rec->severity)
      /* Bingo.  */
      break;

  /* If we don't know anything about the severity level return an error.  */
  if (severity_rec == NULL)
    return MM_NOTOK;


#ifdef __libc_ptf_call
  /* We do not want this call to be cut short by a thread
     cancellation.  Therefore disable cancellation for now.  */
  int state = PTHREAD_CANCEL_ENABLE;
  __libc_ptf_call (pthread_setcancelstate, (PTHREAD_CANCEL_DISABLE, &state),
                 0);
#endif

  /* Now we can print.  */
  if (classification & MM_PRINT)
    {
      int do_label = (print & label_mask) && label != MM_NULLLBL;
      int do_severity = (print & severity_mask) && severity != MM_NULLSEV;
      int do_text = (print & text_mask) && text != MM_NULLTXT;
      int do_action = (print & action_mask) && action != MM_NULLACT;
      int do_tag = (print & tag_mask) && tag != MM_NULLTAG;

      if (__fxprintf (stderr, "%s%s%s%s%s%s%s%s%s%s\n",
                    do_label ? label : "",
                    do_label && (do_severity | do_text | do_action | do_tag)
                    ? ": " : "",
                    do_severity ? severity_rec->string : "",
                    do_severity && (do_text | do_action | do_tag)
                    ? ": " : "",
                    do_text ? text : "",
                    do_text && (do_action | do_tag) ? "\n" : "",
                    do_action ? "TO FIX: " : "",
                    do_action ? action : "",
                    do_action && do_tag ? "  " : "",
                    do_tag ? tag : "") < 0)
       /* Oh, oh.  An error occurred during the output.  */
       result = MM_NOMSG;
    }

  if (classification & MM_CONSOLE)
    {
      int do_label = label != MM_NULLLBL;
      int do_severity = severity != MM_NULLSEV;
      int do_text = text != MM_NULLTXT;
      int do_action = action != MM_NULLACT;
      int do_tag = tag != MM_NULLTAG;

      syslog (LOG_ERR, "%s%s%s%s%s%s%s%s%s%s\n",
             do_label ? label : "",
             do_label && (do_severity | do_text | do_action | do_tag)
             ? ": " : "",
             do_severity ? severity_rec->string : "",
             do_severity && (do_text | do_action | do_tag) ? ": " : "",
             do_text ? text : "",
             do_text && (do_action | do_tag) ? "\n" : "",
             do_action ? "TO FIX: " : "",
             do_action ? action : "",
             do_action && do_tag ? "  " : "",
             do_tag ? tag : "");
    }

#ifdef __libc_ptf_call
  __libc_ptf_call (pthread_setcancelstate, (state, NULL), 0);
#endif

  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void init ( void  ) [static]
static int internal_function internal_addseverity ( int  severity,
const char *  string 
) [static]

Definition at line 292 of file fmtmsg.c.

{
  struct severity_info *runp, *lastp;
  int result = MM_OK;

  /* First see if there is already a record for the severity level.  */
  for (runp = severity_list, lastp = NULL; runp != NULL; runp = runp->next)
    if (runp->severity == severity)
      break;
    else
      lastp = runp;

  if (runp != NULL)
    {
      if (string != NULL)
       /* Change the string.  */
       runp->string = string;
      else
       {
         /* Remove the severity class.  */
         if (lastp == NULL)
           severity_list = runp->next;
         else
           lastp->next = runp->next;

         free (runp);
       }
    }
  else if (string != NULL)
    {
      runp = malloc (sizeof (*runp));
      if (runp == NULL)
       result = MM_NOTOK;
      else
       {
         runp->severity = severity;
         runp->next = severity_list;
         runp->string = string;
         severity_list = runp;
       }
    }
  else
    /* We tried to remove a non-existing severity class.  */
    result = MM_NOTOK;

  return result;
}

Here is the caller graph for this function:

libc_freeres_fn ( free_mem  )

Definition at line 364 of file fmtmsg.c.

{
  struct severity_info *runp = severity_list;

  while (runp != NULL)
    if (runp->severity > MM_INFO)
      {
       /* This is data we have to release.  */
       struct severity_info *here = runp;
       runp = runp->next;
       free (here);
      }
    else
      runp = runp->next;
}

Variable Documentation

struct { ... } keywords[] [static]
int print [static]

Definition at line 95 of file fmtmsg.c.

static struct severity_info [static]
Initial value:
{
  MM_NOSEV, "", NULL
}

Definition at line 70 of file fmtmsg.c.

struct severity_info* severity_list = (struct severity_info *) &infosev [static]

Definition at line 92 of file fmtmsg.c.