libiso_msgs.c File Reference

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/time.h>
#include "libiso_msgs.h"

Include dependency graph for libiso_msgs.c:

Go to the source code of this file.

Macros
#define	LIBISO_MSGS_H_INTERNAL   1

Functions
static int	libiso_msgs_item_new (struct libiso_msgs_item **item, struct libiso_msgs_item *link, int flag)
int	libiso_msgs_item_unlink (struct libiso_msgs_item *o, struct libiso_msgs_item **chain_start, struct libiso_msgs_item **chain_end, int flag)
	Detaches item from its queue and eventually readjusts start, end pointers of the queue. More...
int	libiso_msgs_item_destroy (struct libiso_msgs_item **item, int flag)
int	libiso_msgs_item_get_msg (struct libiso_msgs_item *item, int *error_code, char **msg_text, int *os_errno, int flag)
	Obtain from a message item the three application oriented components as submitted with the originating call of libiso_msgs_submit(). More...
int	libiso_msgs_item_get_origin (struct libiso_msgs_item *item, double *timestamp, pid_t *process_id, int *origin, int flag)
	Obtain from a message item the submitter identification submitted with the originating call of libiso_msgs_submit(). More...
int	libiso_msgs_item_get_rank (struct libiso_msgs_item *item, int *severity, int *priority, int flag)
	Obtain from a message item severity and priority as submitted with the originating call of libiso_msgs_submit(). More...
int	libiso_msgs_new (struct libiso_msgs **m, int flag)
	Create new empty message handling facility with queue and issue a first official reference to it. More...
static int	libiso_msgs_lock (struct libiso_msgs *m, int flag)
static int	libiso_msgs_unlock (struct libiso_msgs *m, int flag)
int	libiso_msgs_destroy (struct libiso_msgs **m, int flag)
	Destroy a message handling facility and all its eventual messages. More...
int	libiso_msgs_refer (struct libiso_msgs **pt, struct libiso_msgs *m, int flag)
	Create an official reference to an existing libiso_msgs object. More...
int	libiso_msgs_set_severities (struct libiso_msgs *m, int queue_severity, int print_severity, char *print_id, int flag)
	Set minimum severity for messages to be queued (default LIBISO_MSGS_SEV_ALL) and for messages to be printed directly to stderr (default LIBISO_MSGS_SEV_NEVER). More...
int	libiso_msgs__text_to_sev (char *severity_name, int *severity, int flag)
	Convert a severity name into a severity number,. More...
int	libiso_msgs__sev_to_text (int severity, char **severity_name, int flag)
	Convert a registered severity number into a severity name. More...
int	libiso_msgs_submit (struct libiso_msgs *m, int origin, int error_code, int severity, int priority, char *msg_text, int os_errno, int flag)
	Submit a message to a message handling facility. More...
int	libiso_msgs_obtain (struct libiso_msgs *m, struct libiso_msgs_item **item, int severity, int priority, int flag)
	Obtain a message item that has at least the given severity and priority. More...
int	libiso_msgs_destroy_item (struct libiso_msgs *m, struct libiso_msgs_item **item, int flag)
	Destroy a message item obtained by libiso_msgs_obtain(). More...

Macro Definition Documentation

LIBISO_MSGS_H_INTERNAL

#define LIBISO_MSGS_H_INTERNAL   1

Definition at line 21 of file libiso_msgs.c.

Function Documentation

libiso_msgs__sev_to_text()

int libiso_msgs__sev_to_text	(	int	severity,
		char **	severity_name,
		int	flag
	)

Convert a registered severity number into a severity name.

Parameters

flag	Bitfield for control purposes: bit0= list all severity names in a blank separated string

Returns

>0 success, <=0 failure

Definition at line 286 of file libiso_msgs.c.

{
 if(flag&1) {
   *severity_name= "ALL ERRFILE DEBUG UPDATE NOTE HINT WARNING SORRY MISHAP FAILURE FATAL ABORT NEVER";
   return(1);
 }
 *severity_name= "";
 if(severity>=LIBISO_MSGS_SEV_NEVER)
   *severity_name= "NEVER";
 else if(severity>=LIBISO_MSGS_SEV_ABORT)
   *severity_name= "ABORT";
 else if(severity>=LIBISO_MSGS_SEV_FATAL)
   *severity_name= "FATAL";
 else if(severity>=LIBISO_MSGS_SEV_FAILURE)
   *severity_name= "FAILURE";
 else if(severity>=LIBISO_MSGS_SEV_MISHAP)
   *severity_name= "MISHAP";
 else if(severity>=LIBISO_MSGS_SEV_SORRY)
   *severity_name= "SORRY";
 else if(severity>=LIBISO_MSGS_SEV_WARNING)
   *severity_name= "WARNING";
 else if(severity>=LIBISO_MSGS_SEV_HINT)
   *severity_name= "HINT";
 else if(severity>=LIBISO_MSGS_SEV_NOTE)
   *severity_name= "NOTE";
 else if(severity>=LIBISO_MSGS_SEV_UPDATE)
   *severity_name= "UPDATE";
 else if(severity>=LIBISO_MSGS_SEV_DEBUG)
   *severity_name= "DEBUG";
 else if(severity>=LIBISO_MSGS_SEV_ERRFILE)
   *severity_name= "ERRFILE";
 else if(severity>=LIBISO_MSGS_SEV_ALL)
   *severity_name= "ALL";
 else {
   *severity_name= "";
   return(0);
 }
 return(1);
}

References LIBISO_MSGS_SEV_ABORT, LIBISO_MSGS_SEV_ALL, LIBISO_MSGS_SEV_DEBUG, LIBISO_MSGS_SEV_ERRFILE, LIBISO_MSGS_SEV_FAILURE, LIBISO_MSGS_SEV_FATAL, LIBISO_MSGS_SEV_HINT, LIBISO_MSGS_SEV_MISHAP, LIBISO_MSGS_SEV_NEVER, LIBISO_MSGS_SEV_NOTE, LIBISO_MSGS_SEV_SORRY, LIBISO_MSGS_SEV_UPDATE, and LIBISO_MSGS_SEV_WARNING.

Referenced by iso_obtain_msgs(), iso_sev_to_text(), and libiso_msgs_submit().

libiso_msgs__text_to_sev()

int libiso_msgs__text_to_sev	(	char *	severity_name,
		int *	severity,
		int	flag
	)

Convert a severity name into a severity number,.

Parameters

flag	Bitfield for control purposes (unused yet, submit 0)

Returns

>0 success, <=0 failure

Definition at line 249 of file libiso_msgs.c.

{
 if(strncmp(severity_name,"NEVER",5)==0)
   *severity= LIBISO_MSGS_SEV_NEVER;
 else if(strncmp(severity_name,"ABORT",5)==0)
   *severity= LIBISO_MSGS_SEV_ABORT;
 else if(strncmp(severity_name,"FATAL",5)==0)
   *severity= LIBISO_MSGS_SEV_FATAL;
 else if(strncmp(severity_name,"FAILURE",7)==0)
   *severity= LIBISO_MSGS_SEV_FAILURE;
 else if(strncmp(severity_name,"MISHAP",6)==0)
   *severity= LIBISO_MSGS_SEV_MISHAP;
 else if(strncmp(severity_name,"SORRY",5)==0)
   *severity= LIBISO_MSGS_SEV_SORRY;
 else if(strncmp(severity_name,"WARNING",7)==0)
   *severity= LIBISO_MSGS_SEV_WARNING;
 else if(strncmp(severity_name,"HINT",4)==0)
   *severity= LIBISO_MSGS_SEV_HINT;
 else if(strncmp(severity_name,"NOTE",4)==0)
   *severity= LIBISO_MSGS_SEV_NOTE;
 else if(strncmp(severity_name,"UPDATE",6)==0)
   *severity= LIBISO_MSGS_SEV_UPDATE;
 else if(strncmp(severity_name,"DEBUG",5)==0)
   *severity= LIBISO_MSGS_SEV_DEBUG;
 else if(strncmp(severity_name,"ERRFILE",7)==0)
   *severity= LIBISO_MSGS_SEV_ERRFILE;
 else if(strncmp(severity_name,"ALL",3)==0)
   *severity= LIBISO_MSGS_SEV_ALL;
 else {
   *severity= LIBISO_MSGS_SEV_ALL;
   return(0);
 }
 return(1);
}

References LIBISO_MSGS_SEV_ABORT, LIBISO_MSGS_SEV_ALL, LIBISO_MSGS_SEV_DEBUG, LIBISO_MSGS_SEV_ERRFILE, LIBISO_MSGS_SEV_FAILURE, LIBISO_MSGS_SEV_FATAL, LIBISO_MSGS_SEV_HINT, LIBISO_MSGS_SEV_MISHAP, LIBISO_MSGS_SEV_NEVER, LIBISO_MSGS_SEV_NOTE, LIBISO_MSGS_SEV_SORRY, LIBISO_MSGS_SEV_UPDATE, and LIBISO_MSGS_SEV_WARNING.

Referenced by iso_msgs_submit(), iso_obtain_msgs(), iso_set_abort_severity(), iso_set_msgs_severities(), and iso_text_to_sev().

libiso_msgs_destroy()

int libiso_msgs_destroy	(	struct libiso_msgs **	m,
		int	flag
	)

Destroy a message handling facility and all its eventual messages.

The submitted pointer gets set to NULL. Actually only the last destroy call of all official references to the object will really dispose it. All others just decrement the reference counter. Call this function only with official reference pointers obtained by libiso_msgs_new() or libiso_msgs_refer(), and only once per such pointer.

Parameters

flag	Bitfield for control purposes (unused yet, submit 0)

Returns

1 for success, 0 for pointer to NULL, -1 for fatal error

Definition at line 190 of file libiso_msgs.c.

{
 struct libiso_msgs *o;
 struct libiso_msgs_item *item, *next_item;
 
 o= *m;
 if(o==NULL)
   return(0);
 if(o->refcount > 1) {
   if(libiso_msgs_lock(*m,0)<=0)
     return(-1);
   o->refcount--;
   libiso_msgs_unlock(*m,0);
   *m= NULL;
   return(1);
 }
 
#ifndef LIBISO_MSGS_SINGLE_THREADED
 if(pthread_mutex_destroy(&(o->lock_mutex))!=0) {
   pthread_mutex_unlock(&(o->lock_mutex));
   pthread_mutex_destroy(&(o->lock_mutex));
 }
#endif
 
 for(item= o->oldest; item!=NULL; item= next_item) {
   next_item= item->next;
   libiso_msgs_item_destroy(&item,0);
 }
 free((char *) o);
 *m= NULL;
 return(1);
}

References libiso_msgs_item_destroy(), libiso_msgs_lock(), and libiso_msgs_unlock().

Referenced by iso_finish().

libiso_msgs_destroy_item()

int libiso_msgs_destroy_item	(	struct libiso_msgs *	m,
		struct libiso_msgs_item **	item,
		int	flag
	)

Destroy a message item obtained by libiso_msgs_obtain().

The submitted pointer gets set to NULL. Caution: Copy eventually obtained msg_text before destroying the item, if you want to use it further.

Parameters

flag	Bitfield for control purposes (unused yet, submit 0)

Returns

1 for success, 0 for pointer to NULL, <0 for severe errors

Definition at line 430 of file libiso_msgs.c.

{
 int ret;
 
 ret= libiso_msgs_lock(m,0);
 if(ret<=0)
   return(-1);
 ret= libiso_msgs_item_destroy(item,0);
 libiso_msgs_unlock(m,0);
 return(ret);
}

References libiso_msgs_item_destroy(), libiso_msgs_lock(), and libiso_msgs_unlock().

Referenced by iso_obtain_msgs().

libiso_msgs_item_destroy()

int libiso_msgs_item_destroy	(	struct libiso_msgs_item **	item,
		int	flag
	)

Definition at line 86 of file libiso_msgs.c.

{
 struct libiso_msgs_item *o;
 
 o= *item;
 if(o==NULL)
   return(0);
 libiso_msgs_item_unlink(o,NULL,NULL,0); 
 if(o->msg_text!=NULL)
   free((char *) o->msg_text);
 free((char *) o);
 *item= NULL;
 return(1);
}

References libiso_msgs_item_unlink().

Referenced by libiso_msgs_destroy(), libiso_msgs_destroy_item(), libiso_msgs_obtain(), and libiso_msgs_submit().

libiso_msgs_item_get_msg()

int libiso_msgs_item_get_msg	(	struct libiso_msgs_item *	item,
		int *	error_code,
		char **	msg_text,
		int *	os_errno,
		int	flag
	)

Obtain from a message item the three application oriented components as submitted with the originating call of libiso_msgs_submit().

Caution: msg_text becomes a pointer into item, not a copy.

Parameters

flag	Bitfield for control purposes (unused yet, submit 0)

Returns

1 on success, 0 on invalid item, <0 for servere errors

Definition at line 103 of file libiso_msgs.c.

{
 *error_code= item->error_code;
 *msg_text= item->msg_text;
 *os_errno= item->os_errno;
 return(1);
}

Referenced by iso_obtain_msgs().

libiso_msgs_item_get_origin()

int libiso_msgs_item_get_origin	(	struct libiso_msgs_item *	item,
		double *	timestamp,
		pid_t *	process_id,
		int *	origin,
		int	flag
	)

Obtain from a message item the submitter identification submitted with the originating call of libiso_msgs_submit().

Parameters

flag	Bitfield for control purposes (unused yet, submit 0)

Returns

1 on success, 0 on invalid item, <0 for servere errors

Definition at line 114 of file libiso_msgs.c.

{
 *timestamp= item->timestamp;
 *process_id= item->process_id;
 *origin= item->origin;
 return(1);
}

Referenced by iso_obtain_msgs().

libiso_msgs_item_get_rank()

int libiso_msgs_item_get_rank	(	struct libiso_msgs_item *	item,
		int *	severity,
		int *	priority,
		int	flag
	)

Obtain from a message item severity and priority as submitted with the originating call of libiso_msgs_submit().

Parameters

flag	Bitfield for control purposes (unused yet, submit 0)

Returns

1 on success, 0 on invalid item, <0 for servere errors

Definition at line 125 of file libiso_msgs.c.

{
 *severity= item->severity;
 *priority= item->priority;
 return(1);
}

Referenced by iso_obtain_msgs().

libiso_msgs_item_new()

static int libiso_msgs_item_new ( struct libiso_msgs_item **  item, struct libiso_msgs_item *  link, int  flag  )

static

Definition at line 30 of file libiso_msgs.c.

{
 int ret;
 struct libiso_msgs_item *o;
 struct timeval tv;
 
 (*item)= o= 
           (struct libiso_msgs_item *) malloc(sizeof(struct libiso_msgs_item));
 if(o==NULL)
   return(-1);
 o->timestamp= 0.0;
 ret= gettimeofday(&tv, NULL);
 if(ret==0)
   o->timestamp= tv.tv_sec+0.000001*tv.tv_usec;
 o->process_id= getpid();
 o->origin= -1;
 o->severity= LIBISO_MSGS_SEV_ALL;
 o->priority= LIBISO_MSGS_PRIO_ZERO;
 o->error_code= 0;
 o->msg_text= NULL;
 o->os_errno= 0;
 o->prev= link;
 o->next= NULL;
 if(link!=NULL) {
   if(link->next!=NULL) {
     link->next->prev= o;
     o->next= link->next;
   }
   link->next= o;
 }
 return(1);
}

References LIBISO_MSGS_PRIO_ZERO, and LIBISO_MSGS_SEV_ALL.

Referenced by libiso_msgs_submit().

libiso_msgs_item_unlink()

int libiso_msgs_item_unlink	(	struct libiso_msgs_item *	o,
		struct libiso_msgs_item **	chain_start,
		struct libiso_msgs_item **	chain_end,
		int	flag
	)

Detaches item from its queue and eventually readjusts start, end pointers of the queue.

Definition at line 67 of file libiso_msgs.c.

{
 if(o->prev!=NULL)
   o->prev->next= o->next;
 if(o->next!=NULL)
   o->next->prev= o->prev;
 if(chain_start!=NULL)
   if(*chain_start == o)
     *chain_start= o->next;
 if(chain_end!=NULL)
   if(*chain_end == o)
     *chain_end= o->prev;
 o->next= o->prev= NULL;
 return(1);
}

Referenced by libiso_msgs_item_destroy(), and libiso_msgs_obtain().

libiso_msgs_lock()

static int libiso_msgs_lock ( struct libiso_msgs *  m, int  flag  )

static

Definition at line 160 of file libiso_msgs.c.

{
 
#ifndef LIBISO_MSGS_SINGLE_THREADED
 int ret;
 
 ret= pthread_mutex_lock(&(m->lock_mutex));
 if(ret!=0)
   return(0);
#endif
 
 return(1);
}

Referenced by libiso_msgs_destroy(), libiso_msgs_destroy_item(), libiso_msgs_obtain(), libiso_msgs_refer(), libiso_msgs_set_severities(), and libiso_msgs_submit().

libiso_msgs_new()

int libiso_msgs_new	(	struct libiso_msgs **	m,
		int	flag
	)

Create new empty message handling facility with queue and issue a first official reference to it.

Parameters

flag	Bitfield for control purposes (unused yet, submit 0)

Returns

>0 success, <=0 failure

Definition at line 137 of file libiso_msgs.c.

{
 struct libiso_msgs *o;
 
 (*m)= o= (struct libiso_msgs *) malloc(sizeof(struct libiso_msgs));
 if(o==NULL)
   return(-1);
 o->refcount= 1;
 o->oldest= NULL;
 o->youngest= NULL;
 o->count= 0;
 o->queue_severity= LIBISO_MSGS_SEV_ALL;
 o->print_severity= LIBISO_MSGS_SEV_NEVER;
 strcpy(o->print_id,"libiso: ");
 
#ifndef LIBISO_MSGS_SINGLE_THREADED
 pthread_mutex_init(&(o->lock_mutex),NULL);
#endif
 
 return(1);
}

References LIBISO_MSGS_SEV_ALL, and LIBISO_MSGS_SEV_NEVER.

Referenced by iso_init_with_flag().

libiso_msgs_obtain()

int libiso_msgs_obtain	(	struct libiso_msgs *	m,
		struct libiso_msgs_item **	item,
		int	severity,
		int	priority,
		int	flag
	)

Obtain a message item that has at least the given severity and priority.

Usually all older messages of lower severity are discarded then. If no item of sufficient severity was found, all others are discarded from the queue.

Parameters

flag	Bitfield for control purposes (unused yet, submit 0)

Returns

1 if a matching item was found, 0 if not, <0 for severe errors

Definition at line 396 of file libiso_msgs.c.

{
 int ret;
 struct libiso_msgs_item *im, *next_im= NULL;
 
 *item= NULL;
 ret= libiso_msgs_lock(m,0);
 if(ret<=0)
   return(-1);
 for(im= m->oldest; im!=NULL; im= next_im) {
   for(; im!=NULL; im= next_im) {
     next_im= im->next;
     if(im->severity>=severity)
   break;
     libiso_msgs_item_unlink(im,&(m->oldest),&(m->youngest),0);
     libiso_msgs_item_destroy(&im,0); /* severity too low: delete */
   }
   if(im==NULL)
 break;
   if(im->priority>=priority)
 break;
 }
 if(im==NULL)
   {ret= 0; goto ex;}
 libiso_msgs_item_unlink(im,&(m->oldest),&(m->youngest),0);
 *item= im;
 ret= 1;
ex:;
 libiso_msgs_unlock(m,0);
 return(ret);
}

References libiso_msgs_item_destroy(), libiso_msgs_item_unlink(), libiso_msgs_lock(), and libiso_msgs_unlock().

Referenced by iso_obtain_msgs().

libiso_msgs_refer()

int libiso_msgs_refer	(	struct libiso_msgs **	pt,
		struct libiso_msgs *	o,
		int	flag
	)

Create an official reference to an existing libiso_msgs object.

The references keep the object alive at least until it is released by a matching number of destroy calls. So each reference MUST be revoked by exactly one call to libiso_msgs_destroy().

Parameters

pt	The pointer to be set and registered
m	A pointer to the existing object
flag	Bitfield for control purposes (unused yet, submit 0)

Returns

1 for success, 0 for failure

Definition at line 224 of file libiso_msgs.c.

{
 if(libiso_msgs_lock(m,0)<=0)
   return(0);
 m->refcount++;
 *pt= m;
 libiso_msgs_unlock(m,0);
 return(1);
}

References libiso_msgs_lock(), and libiso_msgs_unlock().

libiso_msgs_set_severities()

int libiso_msgs_set_severities	(	struct libiso_msgs *	m,
		int	queue_severity,
		int	print_severity,
		char *	print_id,
		int	flag
	)

Set minimum severity for messages to be queued (default LIBISO_MSGS_SEV_ALL) and for messages to be printed directly to stderr (default LIBISO_MSGS_SEV_NEVER).

Parameters

print_id	A text of at most 80 characters to be printed before any eventually printed message (default is "libiso: ").
flag	Bitfield for control purposes (unused yet, submit 0)

Returns

always 1 for now

Definition at line 235 of file libiso_msgs.c.

{
 if(libiso_msgs_lock(m,0)<=0)
   return(0);
 m->queue_severity= queue_severity;
 m->print_severity= print_severity;
 strncpy(m->print_id,print_id,80);
 m->print_id[80]= 0;
 libiso_msgs_unlock(m,0);
 return(1);
}

References libiso_msgs_lock(), and libiso_msgs_unlock().

Referenced by iso_init_with_flag(), and iso_set_msgs_severities().

libiso_msgs_submit()

int libiso_msgs_submit	(	struct libiso_msgs *	m,
		int	origin,
		int	error_code,
		int	severity,
		int	priority,
		char *	msg_text,
		int	os_errno,
		int	flag
	)

Submit a message to a message handling facility.

Parameters

origin	program specific identification number of the originator of a message. E.g. drive number. Programs should have an own range of origin numbers. See above LIBISO_MSGS_ORIGIN_*_BASE Use -1 if no number is known.
error_code	Unique error code. Use only registered codes. See below. The same unique error_code may be issued at different occasions but those should be equivalent out of the view of a libiso_msgs application. (E.g. "cannot open ATA drive" versus "cannot open SCSI drive" would be equivalent.)
severity	The LIBISO_MSGS_SEV_* of the event.
priority	The LIBISO_MSGS_PRIO_* number of the event.
msg_text	Printable and human readable message text.
os_errno	Eventual error code from operating system (0 if none)
flag	Bitfield for control purposes (unused yet, submit 0)

Returns

1 on success, 0 on rejection, <0 for severe errors

Definition at line 328 of file libiso_msgs.c.

{
 int ret;
 char *textpt,*sev_name,sev_text[81];
 struct libiso_msgs_item *item= NULL;
 
 if(severity >= m->print_severity) {
   if(msg_text==NULL)
     textpt= "";
   else
     textpt= msg_text;
   sev_text[0]= 0;
   ret= libiso_msgs__sev_to_text(severity,&sev_name,0);
   if(ret>0)
     sprintf(sev_text,"%s : ",sev_name);
 
   fprintf(stderr,"%s%s%s\n",m->print_id,sev_text,textpt);
   if(os_errno!=0) {
     ret= libiso_msgs_lock(m,0);
     if(ret<=0)
       return(-1);
     fprintf(stderr,"%s( Most recent system error: %d  '%s' )\n",
                    m->print_id,os_errno,strerror(os_errno));
     libiso_msgs_unlock(m,0);
   }
 
 }
 if(severity < m->queue_severity)
   return(0);
 
 ret= libiso_msgs_lock(m,0);
 if(ret<=0)
   return(-1);
 ret= libiso_msgs_item_new(&item,m->youngest,0);
 if(ret<=0)
   goto failed;
 item->origin= origin;
 item->error_code= error_code;
 item->severity= severity;
 item->priority= priority;
 if(msg_text!=NULL) {
   item->msg_text= malloc(strlen(msg_text)+1);
   if(item->msg_text==NULL)
     goto failed;
   strcpy(item->msg_text,msg_text);
 }
 item->os_errno= os_errno;
 if(m->oldest==NULL)
   m->oldest= item;
 m->youngest= item;
 m->count++;
 libiso_msgs_unlock(m,0);
 
/*
fprintf(stderr,"libiso_experimental: message submitted to queue (now %d)\n",
                m->count);
*/
 
 return(1);
failed:;
 libiso_msgs_item_destroy(&item,0);
 libiso_msgs_unlock(m,0);
 return(-1);
}

References libiso_msgs__sev_to_text(), libiso_msgs_item_destroy(), libiso_msgs_item_new(), libiso_msgs_lock(), and libiso_msgs_unlock().

Referenced by iso_msg_debug(), iso_msg_submit(), iso_msgs_submit(), and iso_report_errfile().

libiso_msgs_unlock()

static int libiso_msgs_unlock ( struct libiso_msgs *  m, int  flag  )

static

Definition at line 175 of file libiso_msgs.c.

{
 
#ifndef LIBISO_MSGS_SINGLE_THREADED
 int ret;
 
 ret= pthread_mutex_unlock(&(m->lock_mutex));
 if(ret!=0)
   return(0);
#endif
 
 return(1);
}

Referenced by libiso_msgs_destroy(), libiso_msgs_destroy_item(), libiso_msgs_obtain(), libiso_msgs_refer(), libiso_msgs_set_severities(), and libiso_msgs_submit().