← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/pbms/src/cslib/CSLog.cc

  • Committer: Brian Aker
  • Date: 2010-10-20 20:26:18 UTC
  • mfrom: (1859.2.13 refactor)
  • Revision ID: brian@tangent.org-20101020202618-9222n39lm329urv5
Merge for Brian 

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/pbms/src/cslib/CSLog.cc
1
 
/* Copyright (C) 2008 PrimeBase Technologies GmbH, Germany
 
1
/* Copyright (c) 2008 PrimeBase Technologies GmbH, Germany
2
2
 *
3
3
 * PrimeBase Media Stream for MySQL
4
4
 *
29
29
 
30
30
#include <string.h>
31
31
#include <time.h>
32
 
#include <stdarg.h>
33
 
#include <stdio.h>
34
 
#include <stdlib.h>
35
32
 
36
33
#include "CSLog.h"
37
34
#include "CSMemory.h"
39
36
#include "CSStrUtil.h"
40
37
#include "CSThread.h"
41
38
#include "CSGlobal.h"
42
 
 
43
 
 
44
 
//#ifdef DEBUG
45
 
//#define DEFAULT_LOG_BUFFER_SIZE                       10
46
 
//#else
47
 
#define DEFAULT_LOG_BUFFER_SIZE                 2000
48
 
//#endif
49
 
 
50
39
/*
51
40
 * The global logging object.
52
41
 */
107
96
{
108
97
        const char      *end_ptr;
109
98
        size_t          len;
110
 
        size_t ret;
111
99
 
112
100
        if (level > iLogLevel)
113
101
                return;
121
109
                /* Write until the next \n... */
122
110
                if ((end_ptr = strchr((char*)buffer, '\n'))) {
123
111
                        len = end_ptr - buffer;
124
 
                        ret= fwrite(buffer, len, 1, iStream);
 
112
                        fwrite(buffer, len, 1, iStream);
125
113
                        fprintf(iStream, "\n");
126
114
                        fflush(iStream);
127
115
                        iHeaderPending = true;
129
117
                }
130
118
                else {
131
119
                        len = strlen(buffer);
132
 
                        ret = fwrite(buffer, len, 1, iStream);
133
 
 
 
120
                        fwrite(buffer, len, 1, iStream);
134
121
                }
135
122
                buffer += len;
136
123
        }
137
124
        unlock();
138
 
        (void)ret;
139
125
}
140
126
 
141
127
void CSLog::log(CSThread *self, int level, const char *buffer)
174
160
        unlock();
175
161
}
176
162
 
177
 
void CSLog::log_va(CSThread *self, int level, const char *func, const char *file, int line, const char *fmt, va_list ap)
178
 
{
179
 
        char buffer[DEFAULT_LOG_BUFFER_SIZE];
180
 
        char *log_string = NULL;
181
 
 
182
 
        lock();
183
 
 
184
 
#if !defined(va_copy) || defined(OS_SOLARIS)
185
 
        int len;
186
 
 
187
 
        len = vsnprintf(buffer, DEFAULT_LOG_BUFFER_SIZE-1, fmt, ap);
188
 
        if (len > DEFAULT_LOG_BUFFER_SIZE-1)
189
 
                len = DEFAULT_LOG_BUFFER_SIZE-1;
190
 
        buffer[len] = 0;
191
 
        log_string = buffer;
192
 
#else
193
 
        /* Use the buffer, unless it is too small */
194
 
        va_list ap2;
195
 
 
196
 
        va_copy(ap2, ap);
197
 
        if (vsnprintf(buffer, DEFAULT_LOG_BUFFER_SIZE, fmt, ap) >= DEFAULT_LOG_BUFFER_SIZE) {
198
 
                if (vasprintf(&log_string, fmt, ap2) == -1)
199
 
                        log_string = NULL;
200
 
        }
201
 
        else
202
 
                log_string = buffer;
203
 
#endif
204
 
 
205
 
        if (log_string) {
206
 
                log(self, func, file, line, level, log_string);
207
 
 
208
 
                if (log_string != buffer)
209
 
                        free(log_string);
210
 
        }
211
 
 
212
 
        unlock();
213
 
}
214
 
 
215
 
void CSLog::logf(CSThread *self, int level, const char *fmt, ...)
216
 
{
217
 
        va_list ap;
218
 
 
219
 
        va_start(ap, fmt);
220
 
        log_va(self, level, NULL, NULL, 0, fmt, ap);
221
 
        va_end(ap);
222
 
}
223
 
 
224
 
void CSLog::logf(CSThread *self, int level, const char *func, const char *file, int line, const char *fmt, ...)
225
 
{
226
 
        va_list ap;
227
 
 
228
 
        va_start(ap, fmt);
229
 
        log_va(self, level, func, file, line, fmt, ap);
230
 
        va_end(ap);
231
 
}
 
163
 
232
164