← Back to branch summary

~ubuntu-branches/ubuntu/wily/clamav/wily-proposed

« back to all changes in this revision

Viewing changes to .pc/0006-Fix-STAT64-definition-and-add-missing-includes.patch/shared/output.c

  • Committer: Package Import Robot
  • Author(s): Scott Kitterman
  • Date: 2014-03-15 12:47:13 UTC
  • mfrom: (0.35.39 sid)
  • Revision ID: package-import@ubuntu.com-20140315124713-xqgr3h376zqnw9yb
Tags: 0.98.1+dfsg-3ubuntu1
* Merge from Debian unstable.  Remaining changes:
  - Drop build-dep on electric-fence (in Universe)
  - Add apparmor profiles for clamd and freshclam along with maintainer
    script changes

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/0006-Fix-STAT64-definition-and-add-missing-includes.patch/shared/output.c
 
1
/*
 
2
 *  Copyright (C) 2007-2009 Sourcefire, Inc.
 
3
 *
 
4
 *  Authors: Tomasz Kojm
 
5
 *
 
6
 *  This program is free software; you can redistribute it and/or modify
 
7
 *  it under the terms of the GNU General Public License version 2 as
 
8
 *  published by the Free Software Foundation.
 
9
 *
 
10
 *  This program is distributed in the hope that it will be useful,
 
11
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *  GNU General Public License for more details.
 
14
 *
 
15
 *  You should have received a copy of the GNU General Public License
 
16
 *  along with this program; if not, write to the Free Software
 
17
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 
18
 *  MA 02110-1301, USA.
 
19
 */
 
20
 
 
21
#if HAVE_CONFIG_H
 
22
#include "clamav-config.h"
 
23
#endif
 
24
 
 
25
#include <stdio.h>
 
26
#include <stdarg.h>
 
27
#include <stdlib.h>
 
28
#include <string.h>
 
29
#include <ctype.h>
 
30
#ifdef HAVE_UNISTD_H
 
31
#include <unistd.h>
 
32
#endif
 
33
#include <fcntl.h>
 
34
#include <time.h>
 
35
#include <sys/stat.h>
 
36
#include <errno.h>
 
37
#ifndef _WIN32
 
38
#include <sys/time.h>
 
39
#include <sys/socket.h>
 
40
#endif
 
41
#if HAVE_SYS_TYPES_H
 
42
#include <sys/types.h>
 
43
#endif
 
44
 
 
45
#ifdef HAVE_SYS_SELECT_H
 
46
#include <sys/select.h>
 
47
#endif
 
48
 
 
49
#if defined(USE_SYSLOG) && !defined(C_AIX)
 
50
#include <syslog.h>
 
51
#endif
 
52
 
 
53
#include "output.h"
 
54
#include "libclamav/others.h"
 
55
#include "libclamav/str.h"
 
56
 
 
57
#ifdef CL_NOTHREADS
 
58
#undef CL_THREAD_SAFE
 
59
#endif
 
60
 
 
61
#ifdef CL_THREAD_SAFE
 
62
#include <pthread.h>
 
63
pthread_mutex_t logg_mutex = PTHREAD_MUTEX_INITIALIZER;
 
64
pthread_mutex_t mdprintf_mutex = PTHREAD_MUTEX_INITIALIZER;
 
65
#endif
 
66
 
 
67
#if defined(C_LINUX) && defined(HAVE_LIBINTL_H)
 
68
#include <libintl.h>
 
69
#include <locale.h>
 
70
 
 
71
#define gettext_noop(s) s
 
72
#define _(s)    gettext(s)
 
73
#define N_(s)   gettext_noop(s)
 
74
 
 
75
#else
 
76
 
 
77
#define _(s)    s
 
78
#define N_(s)   s
 
79
 
 
80
#endif
 
81
 
 
82
FILE *logg_fp = NULL;
 
83
 
 
84
short int logg_verbose = 0, logg_nowarn = 0, logg_lock = 1, logg_time = 0, logg_foreground = 1, logg_noflush = 0, logg_rotate = 0;
 
85
off_t logg_size = 0;
 
86
const char *logg_file = NULL;
 
87
#if defined(USE_SYSLOG) && !defined(C_AIX)
 
88
short logg_syslog;
 
89
#endif
 
90
 
 
91
short int mprintf_disabled = 0, mprintf_verbose = 0, mprintf_quiet = 0,
 
92
          mprintf_stdout = 0, mprintf_nowarn = 0, mprintf_send_timeout = 100;
 
93
 
 
94
#define ARGLEN(args, str, len)                      \
 
95
{                                                   \
 
96
        size_t arglen = 1, i;                       \
 
97
        char *pt;                                   \
 
98
    va_start(args, str);                            \
 
99
    len = strlen(str);                              \
 
100
    for(i = 0; i < len - 1; i++) {                  \
 
101
        if(str[i] == '%') {                         \
 
102
            switch(str[++i]) {                      \
 
103
                case 's':                           \
 
104
                    pt  = va_arg(args, char *);     \
 
105
                    if(pt)                          \
 
106
                        arglen += strlen(pt);       \
 
107
                    break;                          \
 
108
                case 'f':                           \
 
109
                    va_arg(args, double);           \
 
110
                    arglen += 25;                   \
 
111
                    break;                          \
 
112
                case 'l':                           \
 
113
                    va_arg(args, long);             \
 
114
                    arglen += 20;                   \
 
115
                    break;                          \
 
116
                default:                            \
 
117
                    va_arg(args, int);              \
 
118
                    arglen += 10;                   \
 
119
                    break;                          \
 
120
            }                                       \
 
121
        }                                           \
 
122
    }                                               \
 
123
    va_end(args);                                   \
 
124
    len += arglen;                                  \
 
125
}
 
126
 
 
127
int mdprintf(int desc, const char *str, ...)
 
128
{
 
129
        va_list args;
 
130
        char buffer[512], *abuffer = NULL, *buff;
 
131
        int bytes, todo, ret=0;
 
132
        size_t len;
 
133
 
 
134
    ARGLEN(args, str, len);
 
135
    if(len <= sizeof(buffer)) {
 
136
        len = sizeof(buffer);
 
137
        buff = buffer;
 
138
    } else {
 
139
        abuffer = malloc(len);
 
140
        if(!abuffer) {
 
141
            len = sizeof(buffer);
 
142
            buff = buffer;
 
143
        } else {
 
144
            buff = abuffer;
 
145
        }
 
146
    }
 
147
    va_start(args, str);
 
148
    bytes = vsnprintf(buff, len, str, args);
 
149
    va_end(args);
 
150
    buff[len - 1] = 0;
 
151
 
 
152
    if(bytes < 0) {
 
153
        if(len > sizeof(buffer))
 
154
            free(abuffer);
 
155
        return bytes;
 
156
    }
 
157
    if((size_t) bytes >= len)
 
158
        bytes = len - 1;
 
159
 
 
160
    todo = bytes;
 
161
#ifdef CL_THREAD_SAFE
 
162
    /* make sure we don't mix sends from multiple threads,
 
163
     * important for IDSESSION */
 
164
    pthread_mutex_lock(&mdprintf_mutex);
 
165
#endif
 
166
    while (todo > 0) {
 
167
        ret = send(desc, buff, bytes, 0);
 
168
        if (ret < 0) {
 
169
            struct timeval tv;
 
170
            if (errno != EWOULDBLOCK)
 
171
                break;
 
172
            /* didn't send anything yet */
 
173
#ifdef CL_THREAD_SAFE
 
174
            pthread_mutex_unlock(&mdprintf_mutex);
 
175
#endif
 
176
            tv.tv_sec = 0;
 
177
            tv.tv_usec = mprintf_send_timeout*1000;
 
178
            do {
 
179
                fd_set wfds;
 
180
                FD_ZERO(&wfds);
 
181
                FD_SET(desc, &wfds);
 
182
                ret = select(desc+1, NULL, &wfds, NULL, &tv);
 
183
            } while (ret < 0 && errno == EINTR);
 
184
#ifdef CL_THREAD_SAFE
 
185
            pthread_mutex_lock(&mdprintf_mutex);
 
186
#endif
 
187
            if (!ret) {
 
188
                /* timed out */
 
189
                ret = -1;
 
190
                break;
 
191
            }
 
192
        } else {
 
193
            todo -= ret;
 
194
            buff += ret;
 
195
        }
 
196
    }
 
197
#ifdef CL_THREAD_SAFE
 
198
    pthread_mutex_unlock(&mdprintf_mutex);
 
199
#endif
 
200
 
 
201
    if(len > sizeof(buffer))
 
202
        free(abuffer);
 
203
 
 
204
    return ret < 0 ? -1 : bytes;
 
205
}
 
206
 
 
207
static int rename_logg(STATBUF *sb)
 
208
{
 
209
    char *rotate_file;
 
210
    size_t rotate_file_len;
 
211
    time_t t;
 
212
    struct tm tmp;
 
213
 
 
214
    if (!logg_rotate) {
 
215
        if (logg_fp) {
 
216
            fprintf(logg_fp, "Log size = %zu, max = %zu\n", sb->st_size, logg_size);
 
217
            fprintf(logg_fp, "WARNING: Log size limit met but log file rotation turned off. Forcing log file rotation anyways.\n");
 
218
        }
 
219
 
 
220
        logg_rotate = 1;
 
221
    }
 
222
 
 
223
    rotate_file_len = strlen(logg_file) + sizeof("-YYYY-MM-DD_HH:MM:SS");
 
224
    rotate_file = calloc(1, rotate_file_len + 1);
 
225
    if (!rotate_file) {
 
226
        if (logg_fp)
 
227
            fprintf(logg_fp, "Need to rotate log file due to size but ran out of memory.\n");
 
228
 
 
229
        return -1;
 
230
    }
 
231
 
 
232
    t = time(NULL);
 
233
    if (!localtime_r(&t, &tmp)) {
 
234
        if (logg_fp)
 
235
            fprintf(logg_fp, "Need to rotate log file due to size but could not get local time.\n");
 
236
 
 
237
        free(rotate_file);
 
238
        return -1;
 
239
    }
 
240
 
 
241
    strcpy(rotate_file, logg_file);
 
242
    strftime(rotate_file+strlen(rotate_file), rotate_file_len-strlen(rotate_file), "-%Y%m%d_%H%M%S", &tmp);
 
243
 
 
244
    if (logg_fp) {
 
245
        fclose(logg_fp);
 
246
        logg_fp = NULL;
 
247
    }
 
248
 
 
249
    if (rename(logg_file, rotate_file)) {
 
250
        free(rotate_file);
 
251
        return -1;
 
252
    }
 
253
 
 
254
    free(rotate_file);
 
255
    return 0;
 
256
}
 
257
 
 
258
static int logg_open(void)
 
259
{
 
260
    STATBUF sb;
 
261
 
 
262
    if(logg_file)
 
263
        if(logg_size > 0)
 
264
            if(CLAMSTAT(logg_file, &sb) != -1)
 
265
                if(sb.st_size > logg_size)
 
266
                        if (rename_logg(&sb))
 
267
                        return -1;
 
268
 
 
269
    
 
270
    return 0;
 
271
}
 
272
 
 
273
void logg_close(void)
 
274
{
 
275
#if defined(USE_SYSLOG) && !defined(C_AIX)
 
276
    if(logg_syslog)
 
277
        closelog();
 
278
#endif
 
279
 
 
280
#ifdef CL_THREAD_SAFE
 
281
    pthread_mutex_lock(&logg_mutex);
 
282
#endif
 
283
    if(logg_fp) {
 
284
        fclose(logg_fp);
 
285
        logg_fp = NULL;
 
286
    }
 
287
#ifdef CL_THREAD_SAFE
 
288
    pthread_mutex_unlock(&logg_mutex);
 
289
#endif
 
290
}
 
291
 
 
292
/*
 
293
 * legend:
 
294
 *  ! - ERROR:
 
295
 *  ^ - WARNING:
 
296
 *  ~ - normal
 
297
 *  # - normal, not foreground (logfile and syslog only)
 
298
 *  * - verbose
 
299
 *  $ - debug
 
300
 *  none - normal
 
301
 *
 
302
 *      Default  Foreground LogVerbose Debug  Syslog
 
303
 *  !     yes      mprintf     yes      yes   LOG_ERR
 
304
 *  ^     yes      mprintf     yes      yes   LOG_WARNING
 
305
 *  ~     yes      mprintf     yes      yes   LOG_INFO
 
306
 *  #     yes        no        yes      yes   LOG_INFO
 
307
 *  *     no       mprintf     yes      yes   LOG_DEBUG
 
308
 *  $     no       mprintf     no       yes   LOG_DEBUG
 
309
 *  none  yes      mprintf     yes      yes   LOG_INFO
 
310
 */
 
311
int logg(const char *str, ...)
 
312
{
 
313
        va_list args;
 
314
        char buffer[1025], *abuffer = NULL, *buff;
 
315
        time_t currtime;
 
316
        size_t len;
 
317
        mode_t old_umask;
 
318
#ifdef F_WRLCK
 
319
        struct flock fl;
 
320
#endif
 
321
 
 
322
    if ((*str == '$' && logg_verbose < 2) ||
 
323
        (*str == '*' && !logg_verbose))
 
324
        return 0;
 
325
 
 
326
    ARGLEN(args, str, len);
 
327
    if(len <= sizeof(buffer)) {
 
328
        len = sizeof(buffer);
 
329
        buff = buffer;
 
330
    } else {
 
331
        abuffer = malloc(len);
 
332
        if(!abuffer) {
 
333
            len = sizeof(buffer);
 
334
            buff = buffer;
 
335
        } else {
 
336
            buff = abuffer;
 
337
        }
 
338
    }
 
339
    va_start(args, str);
 
340
    vsnprintf(buff, len, str, args);
 
341
    va_end(args);
 
342
    buff[len - 1] = 0;
 
343
 
 
344
#ifdef CL_THREAD_SAFE
 
345
    pthread_mutex_lock(&logg_mutex);
 
346
#endif
 
347
 
 
348
    logg_open();
 
349
 
 
350
    if(!logg_fp && logg_file) {
 
351
        old_umask = umask(0037);
 
352
        if((logg_fp = fopen(logg_file, "at")) == NULL) {
 
353
            umask(old_umask);
 
354
#ifdef CL_THREAD_SAFE
 
355
            pthread_mutex_unlock(&logg_mutex);
 
356
#endif
 
357
            printf("ERROR: Can't open %s in append mode (check permissions!).\n", logg_file);
 
358
            if(len > sizeof(buffer))
 
359
                free(abuffer);
 
360
            return -1;
 
361
        } else umask(old_umask);
 
362
 
 
363
#ifdef F_WRLCK
 
364
        if(logg_lock) {
 
365
            memset(&fl, 0, sizeof(fl));
 
366
            fl.l_type = F_WRLCK;
 
367
            if(fcntl(fileno(logg_fp), F_SETLK, &fl) == -1) {
 
368
#ifdef EOPNOTSUPP
 
369
                if(errno == EOPNOTSUPP)
 
370
                    printf("WARNING: File locking not supported (NFS?)\n");
 
371
                else
 
372
#endif
 
373
                {
 
374
#ifdef CL_THREAD_SAFE
 
375
                    pthread_mutex_unlock(&logg_mutex);
 
376
#endif
 
377
                    printf("ERROR: %s is locked by another process\n", logg_file);
 
378
                    if(len > sizeof(buffer))
 
379
                    free(abuffer);
 
380
                    return -1;
 
381
                }
 
382
            }
 
383
        }
 
384
#endif
 
385
    }
 
386
 
 
387
        if(logg_fp) {
 
388
            char flush = !logg_noflush;
 
389
            /* Need to avoid logging time for verbose messages when logverbose
 
390
               is not set or we get a bunch of timestamps in the log without
 
391
               newlines... */
 
392
            if(logg_time && ((*buff != '*') || logg_verbose)) {
 
393
                char timestr[32];
 
394
                time(&currtime);
 
395
                cli_ctime(&currtime, timestr, sizeof(timestr));
 
396
                /* cut trailing \n */
 
397
                timestr[strlen(timestr)-1] = '\0';
 
398
                fprintf(logg_fp, "%s -> ", timestr);
 
399
            }
 
400
 
 
401
            if(*buff == '!') {
 
402
                fprintf(logg_fp, "ERROR: %s", buff + 1);
 
403
                flush = 1;
 
404
            } else if(*buff == '^') {
 
405
                if(!logg_nowarn)
 
406
                    fprintf(logg_fp, "WARNING: %s", buff + 1);
 
407
                flush = 1;
 
408
            } else if(*buff == '*' || *buff == '$') {
 
409
                    fprintf(logg_fp, "%s", buff + 1);
 
410
            } else if(*buff == '#' || *buff == '~') {
 
411
                fprintf(logg_fp, "%s", buff + 1);
 
412
            } else
 
413
                fprintf(logg_fp, "%s", buff);
 
414
 
 
415
            if (flush)
 
416
                fflush(logg_fp);
 
417
        }
 
418
 
 
419
    if(logg_foreground) {
 
420
        if(buff[0] != '#')
 
421
            mprintf("%s", buff);
 
422
    }
 
423
 
 
424
#if defined(USE_SYSLOG) && !defined(C_AIX)
 
425
    if(logg_syslog) {
 
426
        cli_chomp(buff);
 
427
        if(buff[0] == '!') {
 
428
            syslog(LOG_ERR, "%s", buff + 1);
 
429
        } else if(buff[0] == '^') {
 
430
            if(!logg_nowarn)
 
431
                syslog(LOG_WARNING, "%s", buff + 1);
 
432
        } else if(buff[0] == '*' || buff[0] == '$') {
 
433
            syslog(LOG_DEBUG, "%s", buff + 1);
 
434
        } else if(buff[0] == '#' || buff[0] == '~') {
 
435
            syslog(LOG_INFO, "%s", buff + 1);
 
436
        } else syslog(LOG_INFO, "%s", buff);
 
437
 
 
438
    }
 
439
#endif
 
440
 
 
441
#ifdef CL_THREAD_SAFE
 
442
    pthread_mutex_unlock(&logg_mutex);
 
443
#endif
 
444
 
 
445
    if(len > sizeof(buffer))
 
446
        free(abuffer);
 
447
    return 0;
 
448
}
 
449
 
 
450
void mprintf(const char *str, ...)
 
451
{
 
452
        va_list args;
 
453
        FILE *fd;
 
454
        char buffer[512], *abuffer = NULL, *buff;
 
455
        size_t len;
 
456
 
 
457
 
 
458
    if(mprintf_disabled) 
 
459
        return;
 
460
 
 
461
    fd = stdout;
 
462
 
 
463
/* legend:
 
464
 * ! - error
 
465
 * @ - error with logging
 
466
 * ...
 
467
 */
 
468
 
 
469
/*
 
470
 *             ERROR    WARNING    STANDARD
 
471
 * normal      stderr   stderr     stdout
 
472
 * 
 
473
 * verbose     stderr   stderr     stdout
 
474
 * 
 
475
 * quiet       stderr     no         no
 
476
 */
 
477
 
 
478
    ARGLEN(args, str, len);
 
479
    if(len <= sizeof(buffer)) {
 
480
        len = sizeof(buffer);
 
481
        buff = buffer;
 
482
    } else {
 
483
        abuffer = malloc(len);
 
484
        if(!abuffer) {
 
485
            len = sizeof(buffer);
 
486
            buff = buffer;
 
487
        } else {
 
488
            buff = abuffer;
 
489
        }
 
490
    }
 
491
    va_start(args, str);
 
492
    vsnprintf(buff, len, str, args);
 
493
    va_end(args);
 
494
    buff[len - 1] = 0;
 
495
 
 
496
#ifdef _WIN32
 
497
    do {
 
498
        int tmplen = len + 1;
 
499
        wchar_t *tmpw = malloc(tmplen*sizeof(wchar_t));
 
500
        char *nubuff;
 
501
        if(!tmpw) break;
 
502
        if(!MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, buff, -1, tmpw, tmplen)) {
 
503
            free(tmpw);
 
504
            break;
 
505
        }
 
506
        /* FIXME CHECK IT'S REALLY UTF8 */
 
507
        nubuff = (char *)malloc(tmplen);
 
508
        if(!nubuff) {
 
509
            free(tmpw);
 
510
            break;
 
511
        }
 
512
        if(!WideCharToMultiByte(CP_OEMCP, 0, tmpw, -1, nubuff, tmplen, NULL, NULL)) {
 
513
            free(nubuff);
 
514
            free(tmpw);
 
515
            break;
 
516
        }
 
517
        free(tmpw);
 
518
        if(len > sizeof(buffer))
 
519
            free(abuffer);
 
520
        abuffer = buff = nubuff;
 
521
        len = sizeof(buffer) + 1;
 
522
    } while(0);
 
523
#endif
 
524
    if(buff[0] == '!') {
 
525
       if(!mprintf_stdout)
 
526
           fd = stderr;
 
527
        fprintf(fd, "ERROR: %s", &buff[1]);
 
528
    } else if(buff[0] == '@') {
 
529
       if(!mprintf_stdout)
 
530
           fd = stderr;
 
531
        fprintf(fd, "ERROR: %s", &buff[1]);
 
532
    } else if(!mprintf_quiet) {
 
533
        if(buff[0] == '^') {
 
534
            if(!mprintf_nowarn) {
 
535
                if(!mprintf_stdout)
 
536
                    fd = stderr;
 
537
                fprintf(fd, "WARNING: %s", &buff[1]);
 
538
            }
 
539
        } else if(buff[0] == '*') {
 
540
            if(mprintf_verbose)
 
541
                fprintf(fd, "%s", &buff[1]);
 
542
        } else if(buff[0] == '~') {
 
543
            fprintf(fd, "%s", &buff[1]);
 
544
        } else fprintf(fd, "%s", buff);
 
545
    }
 
546
 
 
547
    if(fd == stdout)
 
548
        fflush(stdout);
 
549
 
 
550
    if(len > sizeof(buffer))
 
551
        free(abuffer);
 
552
}
 
553
 
 
554
struct facstruct {
 
555
    const char *name;
 
556
    int code;
 
557
};
 
558
 
 
559
#if defined(USE_SYSLOG) && !defined(C_AIX)
 
560
static const struct facstruct facilitymap[] = {
 
561
#ifdef LOG_AUTH
 
562
    { "LOG_AUTH",       LOG_AUTH },
 
563
#endif
 
564
#ifdef LOG_AUTHPRIV
 
565
    { "LOG_AUTHPRIV",   LOG_AUTHPRIV },
 
566
#endif
 
567
#ifdef LOG_CRON
 
568
    { "LOG_CRON",       LOG_CRON },
 
569
#endif
 
570
#ifdef LOG_DAEMON
 
571
    { "LOG_DAEMON",     LOG_DAEMON },
 
572
#endif
 
573
#ifdef LOG_FTP
 
574
    { "LOG_FTP",        LOG_FTP },
 
575
#endif
 
576
#ifdef LOG_KERN
 
577
    { "LOG_KERN",       LOG_KERN },
 
578
#endif
 
579
#ifdef LOG_LPR
 
580
    { "LOG_LPR",        LOG_LPR },
 
581
#endif
 
582
#ifdef LOG_MAIL
 
583
    { "LOG_MAIL",       LOG_MAIL },
 
584
#endif
 
585
#ifdef LOG_NEWS
 
586
    { "LOG_NEWS",       LOG_NEWS },
 
587
#endif
 
588
#ifdef LOG_AUTH
 
589
    { "LOG_AUTH",       LOG_AUTH },
 
590
#endif
 
591
#ifdef LOG_SYSLOG
 
592
    { "LOG_SYSLOG",     LOG_SYSLOG },
 
593
#endif
 
594
#ifdef LOG_USER
 
595
    { "LOG_USER",       LOG_USER },
 
596
#endif
 
597
#ifdef LOG_UUCP
 
598
    { "LOG_UUCP",       LOG_UUCP },
 
599
#endif
 
600
#ifdef LOG_LOCAL0
 
601
    { "LOG_LOCAL0",     LOG_LOCAL0 },
 
602
#endif
 
603
#ifdef LOG_LOCAL1
 
604
    { "LOG_LOCAL1",     LOG_LOCAL1 },
 
605
#endif
 
606
#ifdef LOG_LOCAL2
 
607
    { "LOG_LOCAL2",     LOG_LOCAL2 },
 
608
#endif
 
609
#ifdef LOG_LOCAL3
 
610
    { "LOG_LOCAL3",     LOG_LOCAL3 },
 
611
#endif
 
612
#ifdef LOG_LOCAL4
 
613
    { "LOG_LOCAL4",     LOG_LOCAL4 },
 
614
#endif
 
615
#ifdef LOG_LOCAL5
 
616
    { "LOG_LOCAL5",     LOG_LOCAL5 },
 
617
#endif
 
618
#ifdef LOG_LOCAL6
 
619
    { "LOG_LOCAL6",     LOG_LOCAL6 },
 
620
#endif
 
621
#ifdef LOG_LOCAL7
 
622
    { "LOG_LOCAL7",     LOG_LOCAL7 },
 
623
#endif
 
624
    { NULL,             -1 }
 
625
};
 
626
 
 
627
int logg_facility(const char *name)
 
628
{
 
629
        int i;
 
630
 
 
631
    for(i = 0; facilitymap[i].name; i++)
 
632
        if(!strcmp(facilitymap[i].name, name))
 
633
            return facilitymap[i].code;
 
634
 
 
635
    return -1;
 
636
}
 
637
#endif