[apt.git] / apt-pkg / contrib / error.cc

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
/* ######################################################################

   Global Error Class - Global error mechanism

   We use a simple STL vector to store each error record. A PendingFlag
   is kept which indicates when the vector contains a Sever error.

   This source is placed in the Public Domain, do with it what you will
   It was originally written by Jason Gunthorpe.

   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#include <apt-pkg/error.h>

#include <iostream>
#include <errno.h>
#include <stdio.h>
#include <unistd.h>

#include <string>
#include <cstring>

#include "config.h"
   									/*}}}*/

// Global Error Object							/*{{{*/
/* If the implementation supports posix threads then the accessor function
   is compiled to be thread safe otherwise a non-safe version is used. A
   Per-Thread error object is maintained in much the same manner as libc
   manages errno */
#if defined(_POSIX_THREADS) && defined(HAVE_PTHREAD)
	#include <pthread.h>

	static pthread_key_t ErrorKey;
	static void ErrorDestroy(void *Obj) {delete (GlobalError *)Obj;};
	static void KeyAlloc() {pthread_key_create(&ErrorKey,ErrorDestroy);};

	GlobalError *_GetErrorObj() {
		static pthread_once_t Once = PTHREAD_ONCE_INIT;
		pthread_once(&Once,KeyAlloc);

		void *Res = pthread_getspecific(ErrorKey);
		if (Res == 0)
			pthread_setspecific(ErrorKey,Res = new GlobalError);
		return (GlobalError *)Res;
	}
#else
	GlobalError *_GetErrorObj() {
		static GlobalError *Obj = new GlobalError;
		return Obj;
	}
#endif
									/*}}}*/
// GlobalError::GlobalError - Constructor				/*{{{*/
GlobalError::GlobalError() : PendingFlag(false) {}
									/*}}}*/
// GlobalError::FatalE - Get part of the error string from errno	/*{{{*/
bool GlobalError::FatalE(const char *Function,const char *Description,...) {
	va_list args;
	va_start(args,Description);
	return InsertErrno(FATAL, Function, Description, args);
}
									/*}}}*/
// GlobalError::Errno - Get part of the error string from errno		/*{{{*/
bool GlobalError::Errno(const char *Function,const char *Description,...) {
	va_list args;
	va_start(args,Description);
	return InsertErrno(ERROR, Function, Description, args);
}
									/*}}}*/
// GlobalError::WarningE - Get part of the warning string from errno	/*{{{*/
bool GlobalError::WarningE(const char *Function,const char *Description,...) {
	va_list args;
	va_start(args,Description);
	return InsertErrno(WARNING, Function, Description, args);
}
									/*}}}*/
// GlobalError::NoticeE - Get part of the notice string from errno	/*{{{*/
bool GlobalError::NoticeE(const char *Function,const char *Description,...) {
	va_list args;
	va_start(args,Description);
	return InsertErrno(NOTICE, Function, Description, args);
}
									/*}}}*/
// GlobalError::DebugE - Get part of the debug string from errno	/*{{{*/
bool GlobalError::DebugE(const char *Function,const char *Description,...) {
	va_list args;
	va_start(args,Description);
	return InsertErrno(DEBUG, Function, Description, args);
}
									/*}}}*/
// GlobalError::InsertErrno - Get part of the errortype string from errno/*{{{*/
bool GlobalError::InsertErrno(MsgType const &type, const char *Function,
				const char *Description,...) {
	va_list args;
	va_start(args,Description);
	return InsertErrno(type, Function, Description, args);
}
									/*}}}*/
// GlobalError::InsertErrno - formats an error message with the errno	/*{{{*/
bool GlobalError::InsertErrno(MsgType type, const char* Function,
			      const char* Description, va_list &args) {
	char S[400];
	snprintf(S, sizeof(S), "%s - %s (%i: %s)", Description,
		 Function, errno, strerror(errno));
	return Insert(type, S, args);
}
									/*}}}*/
// GlobalError::Fatal - Add a fatal error to the list			/*{{{*/
bool GlobalError::Fatal(const char *Description,...) {
	va_list args;
	va_start(args,Description);
	return Insert(FATAL, Description, args);
}
									/*}}}*/
// GlobalError::Error - Add an error to the list			/*{{{*/
bool GlobalError::Error(const char *Description,...) {
	va_list args;
	va_start(args,Description);
	return Insert(ERROR, Description, args);
}
									/*}}}*/
// GlobalError::Warning - Add a warning to the list			/*{{{*/
bool GlobalError::Warning(const char *Description,...) {
	va_list args;
	va_start(args,Description);
	return Insert(WARNING, Description, args);
}
									/*}}}*/
// GlobalError::Notice - Add a notice to the list			/*{{{*/
bool GlobalError::Notice(const char *Description,...)
{
	va_list args;
	va_start(args,Description);
	return Insert(NOTICE, Description, args);
}
									/*}}}*/
// GlobalError::Debug - Add a debug to the list				/*{{{*/
bool GlobalError::Debug(const char *Description,...)
{
	va_list args;
	va_start(args,Description);
	return Insert(DEBUG, Description, args);
}
									/*}}}*/
// GlobalError::Insert - Add a errotype message to the list		/*{{{*/
bool GlobalError::Insert(MsgType const &type, const char *Description,...)
{
	va_list args;
	va_start(args,Description);
	return Insert(type, Description, args);
}
									/*}}}*/
// GlobalError::Insert - Insert a new item at the end			/*{{{*/
bool GlobalError::Insert(MsgType type, const char* Description,
			 va_list &args) {
	char S[400];
	vsnprintf(S,sizeof(S),Description,args);

	Item const m(S, type);
	Messages.push_back(m);

	if (type == ERROR || type == FATAL)
		PendingFlag = true;

	if (type == FATAL || type == DEBUG)
		std::clog << m << std::endl;

	return false;
}
									/*}}}*/
// GlobalError::PopMessage - Pulls a single message out			/*{{{*/
bool GlobalError::PopMessage(std::string &Text) {
	if (Messages.empty() == true)
		return false;

	Item const msg = Messages.front();
	Messages.pop_front();

	bool const Ret = (msg.Type == ERROR || msg.Type == FATAL);
	Text = msg.Text;
	if (PendingFlag == false || Ret == false)
		return Ret;

	// check if another error message is pending
	for (std::list<Item>::const_iterator m = Messages.begin();
	     m != Messages.end(); m++)
		if (m->Type == ERROR || m->Type == FATAL)
			return Ret;

	PendingFlag = false;
	return Ret;
}
									/*}}}*/
// GlobalError::DumpErrors - Dump all of the errors/warns to cerr	/*{{{*/
void GlobalError::DumpErrors(std::ostream &out, MsgType const &threshold,
			     bool const &mergeStack) {
	if (mergeStack == true)
		for (std::list<MsgStack>::const_reverse_iterator s = Stacks.rbegin();
		     s != Stacks.rend(); ++s)
			Messages.insert(Messages.begin(), s->Messages.begin(), s->Messages.end());

	for (std::list<Item>::const_iterator m = Messages.begin();
	     m != Messages.end(); m++)
		if (m->Type >= threshold)
			out << (*m) << std::endl;
	Discard();
}
									/*}}}*/
// GlobalError::Discard - Discard					/*{{{*/
void GlobalError::Discard() {
	Messages.clear();
	PendingFlag = false;
};
									/*}}}*/
// GlobalError::empty - does our error list include anything?		/*{{{*/
bool GlobalError::empty(MsgType const &trashhold) const {
	if (PendingFlag == true)
		return false;

	if (Messages.empty() == true)
		return true;

	for (std::list<Item>::const_iterator m = Messages.begin();
	     m != Messages.end(); m++)
		if (m->Type >= trashhold)
			return false;

	return true;
}
									/*}}}*/
// GlobalError::PushToStack						/*{{{*/
void GlobalError::PushToStack() {
	MsgStack pack(Messages, PendingFlag);
	Stacks.push_back(pack);
	Discard();
}
									/*}}}*/
// GlobalError::RevertToStack						/*{{{*/
void GlobalError::RevertToStack() {
	Discard();
	MsgStack pack = Stacks.back();
	Messages = pack.Messages;
	PendingFlag = pack.PendingFlag;
	Stacks.pop_back();
}
									/*}}}*/
// GlobalError::MergeWithStack						/*{{{*/
void GlobalError::MergeWithStack() {
	MsgStack pack = Stacks.back();
	Messages.insert(Messages.begin(), pack.Messages.begin(), pack.Messages.end());
	PendingFlag = PendingFlag || pack.PendingFlag;
	Stacks.pop_back();
}
									/*}}}*/
Commit	Line	Data
578bfd0a AL	1	// -- mode: cpp; mode: fold --
578bfd0a AL	2	// Description /{{{/
578bfd0a	3	/* ######################################################################
98ee7cd3 DK	4
98ee7cd3 DK	5	Global Error Class - Global error mechanism
578bfd0a AL	6
	7	We use a simple STL vector to store each error record. A PendingFlag
	8	is kept which indicates when the vector contains a Sever error.
98ee7cd3	9
578bfd0a AL	10	This source is placed in the Public Domain, do with it what you will
578bfd0a AL	11	It was originally written by Jason Gunthorpe.
98ee7cd3	12
578bfd0a AL	13	##################################################################### */
	14	/}}}/
	15	// Include Files /{{{/
6f27a7fc AL	16	#include <apt-pkg/error.h>
6f27a7fc AL	17
90f057fd	18	#include <iostream>
578bfd0a AL	19	#include <errno.h>
578bfd0a AL	20	#include <stdio.h>
6f27a7fc	21	#include <unistd.h>
578bfd0a	22
4f333a8b MV	23	#include <string>
	24	#include <cstring>
	25
afd9aaf3	26	#include "config.h"
578bfd0a AL	27	/}}}/
578bfd0a AL	28
6f27a7fc AL	29	// Global Error Object /{{{/
	30	/* If the implementation supports posix threads then the accessor function
	31	is compiled to be thread safe otherwise a non-safe version is used. A
	32	Per-Thread error object is maintained in much the same manner as libc
	33	manages errno */
b2e465d6	34	#if defined(_POSIX_THREADS) && defined(HAVE_PTHREAD)
98ee7cd3 DK	35	#include <pthread.h>
	36
	37	static pthread_key_t ErrorKey;
	38	static void ErrorDestroy(void Obj) {delete (GlobalError )Obj;};
	39	static void KeyAlloc() {pthread_key_create(&ErrorKey,ErrorDestroy);};
	40
	41	GlobalError *_GetErrorObj() {
	42	static pthread_once_t Once = PTHREAD_ONCE_INIT;
	43	pthread_once(&Once,KeyAlloc);
	44
	45	void *Res = pthread_getspecific(ErrorKey);
	46	if (Res == 0)
	47	pthread_setspecific(ErrorKey,Res = new GlobalError);
	48	return (GlobalError *)Res;
	49	}
6f27a7fc	50	#else
98ee7cd3 DK	51	GlobalError *_GetErrorObj() {
	52	static GlobalError *Obj = new GlobalError;
	53	return Obj;
	54	}
6f27a7fc AL	55	#endif
6f27a7fc AL	56	/}}}/
578bfd0a	57	// GlobalError::GlobalError - Constructor /{{{/
98ee7cd3 DK	58	GlobalError::GlobalError() : PendingFlag(false) {}
	59	/}}}/
	60	// GlobalError::FatalE - Get part of the error string from errno /{{{/
	61	bool GlobalError::FatalE(const char Function,const char Description,...) {
	62	va_list args;
	63	va_start(args,Description);
	64	return InsertErrno(FATAL, Function, Description, args);
578bfd0a AL	65	}
	66	/}}}/
	67	// GlobalError::Errno - Get part of the error string from errno /{{{/
98ee7cd3 DK	68	bool GlobalError::Errno(const char Function,const char Description,...) {
	69	va_list args;
	70	va_start(args,Description);
	71	return InsertErrno(ERROR, Function, Description, args);
c5162d56 AL	72	}
c5162d56 AL	73	/}}}/
98ee7cd3 DK	74	// GlobalError::WarningE - Get part of the warning string from errno /{{{/
	75	bool GlobalError::WarningE(const char Function,const char Description,...) {
	76	va_list args;
	77	va_start(args,Description);
	78	return InsertErrno(WARNING, Function, Description, args);
	79	}
	80	/}}}/
	81	// GlobalError::NoticeE - Get part of the notice string from errno /{{{/
	82	bool GlobalError::NoticeE(const char Function,const char Description,...) {
	83	va_list args;
	84	va_start(args,Description);
	85	return InsertErrno(NOTICE, Function, Description, args);
	86	}
	87	/}}}/
	88	// GlobalError::DebugE - Get part of the debug string from errno /{{{/
	89	bool GlobalError::DebugE(const char Function,const char Description,...) {
	90	va_list args;
	91	va_start(args,Description);
	92	return InsertErrno(DEBUG, Function, Description, args);
	93	}
	94	/}}}/
cd7bbc47 DK	95	// GlobalError::InsertErrno - Get part of the errortype string from errno/{{{/
	96	bool GlobalError::InsertErrno(MsgType const &type, const char *Function,
	97	const char *Description,...) {
	98	va_list args;
	99	va_start(args,Description);
	100	return InsertErrno(type, Function, Description, args);
	101	}
	102	/}}}/
98ee7cd3 DK	103	// GlobalError::InsertErrno - formats an error message with the errno /{{{/
98ee7cd3 DK	104	bool GlobalError::InsertErrno(MsgType type, const char* Function,
3c0929ec	105	const char* Description, va_list &args) {
98ee7cd3	106	char S[400];
3c0929ec DK	107	snprintf(S, sizeof(S), "%s - %s (%i: %s)", Description,
3c0929ec DK	108	Function, errno, strerror(errno));
98ee7cd3 DK	109	return Insert(type, S, args);
	110	}
	111	/}}}/
	112	// GlobalError::Fatal - Add a fatal error to the list /{{{/
	113	bool GlobalError::Fatal(const char *Description,...) {
	114	va_list args;
	115	va_start(args,Description);
	116	return Insert(FATAL, Description, args);
578bfd0a AL	117	}
	118	/}}}/
	119	// GlobalError::Error - Add an error to the list /{{{/
98ee7cd3 DK	120	bool GlobalError::Error(const char *Description,...) {
	121	va_list args;
	122	va_start(args,Description);
	123	return Insert(ERROR, Description, args);
578bfd0a AL	124	}
	125	/}}}/
	126	// GlobalError::Warning - Add a warning to the list /{{{/
98ee7cd3 DK	127	bool GlobalError::Warning(const char *Description,...) {
	128	va_list args;
	129	va_start(args,Description);
	130	return Insert(WARNING, Description, args);
	131	}
	132	/}}}/
	133	// GlobalError::Notice - Add a notice to the list /{{{/
	134	bool GlobalError::Notice(const char *Description,...)
578bfd0a	135	{
98ee7cd3 DK	136	va_list args;
	137	va_start(args,Description);
	138	return Insert(NOTICE, Description, args);
578bfd0a AL	139	}
578bfd0a AL	140	/}}}/
98ee7cd3 DK	141	// GlobalError::Debug - Add a debug to the list /{{{/
98ee7cd3 DK	142	bool GlobalError::Debug(const char *Description,...)
578bfd0a	143	{
98ee7cd3 DK	144	va_list args;
	145	va_start(args,Description);
	146	return Insert(DEBUG, Description, args);
	147	}
	148	/}}}/
cd7bbc47 DK	149	// GlobalError::Insert - Add a errotype message to the list /{{{/
	150	bool GlobalError::Insert(MsgType const &type, const char *Description,...)
	151	{
	152	va_list args;
	153	va_start(args,Description);
	154	return Insert(type, Description, args);
	155	}
	156	/}}}/
98ee7cd3 DK	157	// GlobalError::Insert - Insert a new item at the end /{{{/
98ee7cd3 DK	158	bool GlobalError::Insert(MsgType type, const char* Description,
3c0929ec	159	va_list &args) {
98ee7cd3 DK	160	char S[400];
	161	vsnprintf(S,sizeof(S),Description,args);
	162
	163	Item const m(S, type);
	164	Messages.push_back(m);
	165
	166	if (type == ERROR \|\| type == FATAL)
	167	PendingFlag = true;
	168
	169	if (type == FATAL \|\| type == DEBUG)
	170	std::clog << m << std::endl;
	171
	172	return false;
	173	}
	174	/}}}/
	175	// GlobalError::PopMessage - Pulls a single message out /{{{/
	176	bool GlobalError::PopMessage(std::string &Text) {
	177	if (Messages.empty() == true)
	178	return false;
	179
	180	Item const msg = Messages.front();
	181	Messages.pop_front();
	182
	183	bool const Ret = (msg.Type == ERROR \|\| msg.Type == FATAL);
	184	Text = msg.Text;
	185	if (PendingFlag == false \|\| Ret == false)
	186	return Ret;
	187
	188	// check if another error message is pending
	189	for (std::list<Item>::const_iterator m = Messages.begin();
	190	m != Messages.end(); m++)
	191	if (m->Type == ERROR \|\| m->Type == FATAL)
	192	return Ret;
	193
	194	PendingFlag = false;
	195	return Ret;
578bfd0a AL	196	}
	197	/}}}/
	198	// GlobalError::DumpErrors - Dump all of the errors/warns to cerr /{{{/
12be8a62	199	void GlobalError::DumpErrors(std::ostream &out, MsgType const &threshold,
c4ba7c44 DK	200	bool const &mergeStack) {
	201	if (mergeStack == true)
	202	for (std::list<MsgStack>::const_reverse_iterator s = Stacks.rbegin();
	203	s != Stacks.rend(); ++s)
	204	Messages.insert(Messages.begin(), s->Messages.begin(), s->Messages.end());
	205
98ee7cd3 DK	206	for (std::list<Item>::const_iterator m = Messages.begin();
98ee7cd3 DK	207	m != Messages.end(); m++)
12be8a62	208	if (m->Type >= threshold)
98ee7cd3 DK	209	out << (*m) << std::endl;
98ee7cd3 DK	210	Discard();
578bfd0a AL	211	}
578bfd0a AL	212	/}}}/
98ee7cd3 DK	213	// GlobalError::Discard - Discard /{{{/
	214	void GlobalError::Discard() {
	215	Messages.clear();
	216	PendingFlag = false;
6c139d6e AL	217	};
6c139d6e AL	218	/}}}/
98ee7cd3 DK	219	// GlobalError::empty - does our error list include anything? /{{{/
	220	bool GlobalError::empty(MsgType const &trashhold) const {
	221	if (PendingFlag == true)
	222	return false;
	223
	224	if (Messages.empty() == true)
	225	return true;
	226
	227	for (std::list<Item>::const_iterator m = Messages.begin();
	228	m != Messages.end(); m++)
	229	if (m->Type >= trashhold)
	230	return false;
	231
	232	return true;
6c139d6e AL	233	}
6c139d6e AL	234	/}}}/
c4ba7c44 DK	235	// GlobalError::PushToStack /{{{/
	236	void GlobalError::PushToStack() {
	237	MsgStack pack(Messages, PendingFlag);
	238	Stacks.push_back(pack);
	239	Discard();
	240	}
	241	/}}}/
	242	// GlobalError::RevertToStack /{{{/
	243	void GlobalError::RevertToStack() {
	244	Discard();
	245	MsgStack pack = Stacks.back();
	246	Messages = pack.Messages;
	247	PendingFlag = pack.PendingFlag;
	248	Stacks.pop_back();
	249	}
	250	/}}}/
	251	// GlobalError::MergeWithStack /{{{/
	252	void GlobalError::MergeWithStack() {
	253	MsgStack pack = Stacks.back();
	254	Messages.insert(Messages.begin(), pack.Messages.begin(), pack.Messages.end());
	255	PendingFlag = PendingFlag \|\| pack.PendingFlag;
	256	Stacks.pop_back();
	257	}
	258	/}}}/