rpmio/rpmlog.c

   1 /** \ingroup rpmio
   2  * \file rpmio/rpmlog.c
   3  */
   4
   5 #include "system.h"
   6 #include <stdarg.h>
   7 #include <rpm/rpmlog.h>
   8 #include "debug.h"
   9
  10 static int nrecs = 0;
  11 static rpmlogRec recs = NULL;
  12
  13 struct rpmlogRec_s {
  14     int         code;           /* unused */
  15     rpmlogLvl   pri;            /* priority */
  16     char * message;             /* log message string */
  17 };
  18
  19 int rpmlogGetNrecs(void)
  20 {
  21     return nrecs;
  22 }
  23
  24 int rpmlogCode(void)
  25 {
  26     if (recs != NULL && nrecs > 0)
  27         return recs[nrecs-1].code;
  28     return -1;
  29 }
  30
  31
  32 const char * rpmlogMessage(void)
  33 {
  34     if (recs != NULL && nrecs > 0)
  35         return recs[nrecs-1].message;
  36     return _("(no error)");
  37 }
  38
  39 const char * rpmlogRecMessage(rpmlogRec rec)
  40 {
  41     assert(rec != NULL);
  42     return (rec->message);
  43 }
  44
  45 rpmlogLvl rpmlogRecPriority(rpmlogRec rec)
  46 {
  47     assert(rec != NULL);
  48     return (rec->pri);
  49 }
  50
  51 void rpmlogPrint(FILE *f)
  52 {
  53     int i;
  54
  55     if (f == NULL)
  56         f = stderr;
  57
  58     if (recs)
  59     for (i = 0; i < nrecs; i++) {
  60         rpmlogRec rec = recs + i;
  61         if (rec->message && *rec->message)
  62             fprintf(f, "    %s", rec->message);
  63     }
  64 }
  65
  66 void rpmlogClose (void)
  67 {
  68     int i;
  69
  70     if (recs)
  71     for (i = 0; i < nrecs; i++) {
  72         rpmlogRec rec = recs + i;
  73         rec->message = _free(rec->message);
  74     }
  75     recs = _free(recs);
  76     nrecs = 0;
  77 }
  78
  79 void rpmlogOpen (const char *ident, int option,
  80                 int facility)
  81 {
  82 }
  83
  84 static unsigned rpmlogMask = RPMLOG_UPTO( RPMLOG_NOTICE );
  85
  86 #ifdef NOTYET
  87 static unsigned rpmlogFacility = RPMLOG_USER;
  88 #endif
  89
  90 int rpmlogSetMask (int mask)
  91 {
  92     int omask = rpmlogMask;
  93     if (mask)
  94         rpmlogMask = mask;
  95     return omask;
  96 }
  97
  98 static rpmlogCallback _rpmlogCallback = NULL;
  99 static rpmlogCallbackData _rpmlogCallbackData = NULL;
 100
 101 rpmlogCallback rpmlogSetCallback(rpmlogCallback cb, rpmlogCallbackData data)
 102 {
 103     rpmlogCallback ocb = _rpmlogCallback;
 104     _rpmlogCallback = cb;
 105     _rpmlogCallbackData = data;
 106     return ocb;
 107 }
 108
 109 static FILE * _stdlog = NULL;
 110
 111 static int rpmlogDefault(rpmlogRec rec)
 112 {
 113     FILE *msgout = (_stdlog ? _stdlog : stderr);
 114
 115     switch (rec->pri) {
 116     case RPMLOG_INFO:
 117     case RPMLOG_NOTICE:
 118         msgout = (_stdlog ? _stdlog : stdout);
 119         break;
 120     case RPMLOG_EMERG:
 121     case RPMLOG_ALERT:
 122     case RPMLOG_CRIT:
 123     case RPMLOG_ERR:
 124     case RPMLOG_WARNING:
 125     case RPMLOG_DEBUG:
 126     default:
 127         break;
 128     }
 129
 130     (void) fputs(rpmlogLevelPrefix(rec->pri), msgout);
 131
 132     (void) fputs(rec->message, msgout);
 133     (void) fflush(msgout);
 134
 135     return (rec->pri <= RPMLOG_CRIT ? RPMLOG_EXIT : 0);
 136 }
 137
 138
 139 FILE * rpmlogSetFile(FILE * fp)
 140 {
 141     FILE * ofp = _stdlog;
 142     _stdlog = fp;
 143     return ofp;
 144 }
 145
 146 static const char * const rpmlogMsgPrefix[] = {
 147     N_("fatal error: "),/*!< RPMLOG_EMERG */
 148     N_("fatal error: "),/*!< RPMLOG_ALERT */
 149     N_("fatal error: "),/*!< RPMLOG_CRIT */
 150     N_("error: "),      /*!< RPMLOG_ERR */
 151     N_("warning: "),    /*!< RPMLOG_WARNING */
 152     "",                 /*!< RPMLOG_NOTICE */
 153     "",                 /*!< RPMLOG_INFO */
 154     "D: ",              /*!< RPMLOG_DEBUG */
 155 };
 156
 157 const char * rpmlogLevelPrefix(rpmlogLvl pri)
 158 {
 159     const char * prefix = "";
 160     if (rpmlogMsgPrefix[pri] && *rpmlogMsgPrefix[pri])
 161         prefix = _(rpmlogMsgPrefix[pri]);
 162     return prefix;
 163 }
 164
 165 /* FIX: rpmlogMsgPrefix[] dependent, not unqualified */
 166 /* FIX: rpmlogMsgPrefix[] may be NULL */
 167 static void vrpmlog (unsigned code, const char *fmt, va_list ap)
 168 {
 169     unsigned pri = RPMLOG_PRI(code);
 170     unsigned mask = RPMLOG_MASK(pri);
 171 #ifdef NOTYET
 172     unsigned fac = RPMLOG_FAC(code);
 173 #endif
 174     char *msgbuf, *msg;
 175     int msgnb = BUFSIZ, nb;
 176     int cbrc = RPMLOG_DEFAULT;
 177     int needexit = 0;
 178
 179     struct rpmlogRec_s rec;
 180
 181     if ((mask & rpmlogMask) == 0)
 182         return;
 183
 184     msgbuf = xmalloc(msgnb);
 185     *msgbuf = '\0';
 186
 187     /* Allocate a sufficently large buffer for output. */
 188     while (1) {
 189         va_list apc;
 190         va_copy(apc, ap);
 191         nb = vsnprintf(msgbuf, msgnb, fmt, apc);
 192         if (nb > -1 && nb < msgnb)
 193             break;
 194         if (nb > -1)            /* glibc 2.1 (and later) */
 195             msgnb = nb+1;
 196         else                    /* glibc 2.0 */
 197             msgnb *= 2;
 198         msgbuf = xrealloc(msgbuf, msgnb);
 199         va_end(apc);
 200     }
 201     msgbuf[msgnb - 1] = '\0';
 202     msg = msgbuf;
 203
 204     rec.code = code;
 205     rec.message = msg;
 206     rec.pri = pri;
 207
 208     /* Save copy of all messages at warning (or below == "more important"). */
 209     if (pri <= RPMLOG_WARNING) {
 210
 211         if (recs == NULL)
 212             recs = xmalloc((nrecs+2) * sizeof(*recs));
 213         else
 214             recs = xrealloc(recs, (nrecs+2) * sizeof(*recs));
 215         recs[nrecs].code = rec.code;
 216         recs[nrecs].pri = rec.pri;
 217         recs[nrecs].message = msg = xrealloc(msgbuf, strlen(msgbuf)+1);
 218         msgbuf = NULL;          /* XXX don't free at exit. */
 219         recs[nrecs+1].code = 0;
 220         recs[nrecs+1].message = NULL;
 221         ++nrecs;
 222     }
 223
 224     if (_rpmlogCallback) {
 225         cbrc = _rpmlogCallback(&rec, _rpmlogCallbackData);
 226         needexit += cbrc & RPMLOG_EXIT;
 227     }
 228
 229     if (cbrc & RPMLOG_DEFAULT) {
 230         cbrc = rpmlogDefault(&rec);
 231         needexit += cbrc & RPMLOG_EXIT;
 232     }
 233
 234     msgbuf = _free(msgbuf);
 235     if (needexit)
 236         exit(EXIT_FAILURE);
 237 }
 238
 239 void rpmlog (int code, const char *fmt, ...)
 240 {
 241     va_list ap;
 242
 243     va_start(ap, fmt);
 244     /* FIX: shrug */
 245     vrpmlog(code, fmt, ap);
 246     va_end(ap);
 247 }
 248