← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/pbms/src/SysTab_util.cc

Added the PBMS daemon plugin.

(Augen zu und durch!)

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/pbms/src/SysTab_util.cc
 
1
/* Copyright (c) 2009 PrimeBase Technologies GmbH, Germany
 
2
 *
 
3
 * PrimeBase Media Stream for MySQL
 
4
 *
 
5
 * This program is free software; you can redistribute it and/or modify
 
6
 * it under the terms of the GNU General Public License as published by
 
7
 * the Free Software Foundation; either version 2 of the License, or
 
8
 * (at your option) any later version.
 
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 
18
 *
 
19
 * Barry Leslie
 
20
 *
 
21
 * System table utility functions.
 
22
 *
 
23
 */
 
24
#include "CSConfig.h"
 
25
 
 
26
#include <sys/types.h>
 
27
#include <sys/stat.h>
 
28
#include <stdlib.h>
 
29
#include <time.h>
 
30
#include <inttypes.h>
 
31
 
 
32
#include "CSGlobal.h"
 
33
#include "CSStrUtil.h"
 
34
#include "CSPath.h"
 
35
 
 
36
#include "SysTab_util.h"
 
37
 
 
38
//======================
 
39
void SysTabRec::logError(const char *text)
 
40
{
 
41
        char msg[80];
 
42
        enter_();
 
43
        
 
44
        snprintf(msg, 80, ", damaged at or near position %"PRIdPTR" \n", ptr - getBuffer(0));
 
45
        CSL.log(self, CSLog::Warning, db_name);
 
46
        CSL.log(self, CSLog::Warning, ".");
 
47
        CSL.log(self, CSLog::Warning, table_name);
 
48
        CSL.log(self, CSLog::Warning, " table file ");
 
49
        CSL.log(self, CSLog::Warning, file_name);
 
50
        if (text) {
 
51
                CSL.log(self, CSLog::Warning, " ");
 
52
                CSL.log(self, CSLog::Warning, text);
 
53
        }
 
54
        CSL.log(self, CSLog::Warning, msg);
 
55
        exit_();
 
56
}
 
57
 
 
58
#define HEAD_MARKER ((uint32_t)0XABABABAB)
 
59
#define TAIL_MARKER ((uint32_t)0XCDCDCDCD)
 
60
//---------------------
 
61
bool SysTabRec::findRecord()
 
62
{
 
63
        uint32_t len, marker;
 
64
        CSDiskData d;
 
65
 
 
66
        badRecord = true;
 
67
        
 
68
        while (badRecord) {
 
69
                len = end_of_data - ptr;
 
70
                if (len < 12)
 
71
                        return false;
 
72
                
 
73
                // Look for the record header.
 
74
                d.rec_chars = ptr;      ptr +=4;        
 
75
                marker = CS_GET_DISK_4(d.int_val->val_4);
 
76
                if (marker != HEAD_MARKER) 
 
77
                        continue;
 
78
                        
 
79
                // Get the record length.
 
80
                d.rec_chars = ptr;      
 
81
                recordLength = CS_GET_DISK_4(d.int_val->val_4);
 
82
                if (len < recordLength)
 
83
                        continue;
 
84
                
 
85
                end_of_record = ptr + recordLength;
 
86
                
 
87
                // Look for the record trailer.
 
88
                d.rec_chars = end_of_record;    
 
89
                marker = CS_GET_DISK_4(d.int_val->val_4);
 
90
                if (marker != TAIL_MARKER) 
 
91
                        continue;
 
92
                        
 
93
                ptr +=4; // Skip the record length.
 
94
                badRecord = false;              
 
95
        }
 
96
        
 
97
        return true;
 
98
}
 
99
 
 
100
//---------------------
 
101
bool SysTabRec::firstRecord()
 
102
{
 
103
        ptr = getBuffer(0);
 
104
        end_of_data = ptr + length();
 
105
        
 
106
        if (!findRecord()) {
 
107
                logError("Missing record terminator, file being ignored");
 
108
                return false;
 
109
        }
 
110
        
 
111
        return true;
 
112
}
 
113
 
 
114
//---------------------
 
115
bool SysTabRec::nextRecord()
 
116
{
 
117
        if (!ptr)
 
118
                return firstRecord();
 
119
                
 
120
        if (ptr <= end_of_record) 
 
121
                ptr = end_of_record + 4;
 
122
        
 
123
        return findRecord();
 
124
}
 
125
        
 
126
//---------------------
 
127
uint8_t SysTabRec::getInt1Field()
 
128
{
 
129
        uint8_t val = 0;
 
130
        CSDiskData d;
 
131
        
 
132
        if (badRecord)
 
133
                return val;
 
134
                
 
135
        if (ptr > (end_of_record -1)) {
 
136
                logError("Missing 1 byte int field");
 
137
                ptr = end_of_record;
 
138
                badRecord = true;
 
139
                return val;
 
140
        }
 
141
        
 
142
        d.rec_chars = ptr;
 
143
        val = CS_GET_DISK_1(d.int_val->val_1);
 
144
        ptr += 1;               
 
145
        return val;
 
146
}
 
147
 
 
148
//---------------------
 
149
uint32_t SysTabRec::getInt4Field()
 
150
{
 
151
        uint32_t val = 0;
 
152
        CSDiskData d;
 
153
        
 
154
        if (badRecord)
 
155
                return val;
 
156
                
 
157
        if (ptr > (end_of_record -4)) {
 
158
                logError("Missing 4 byte int field");
 
159
                ptr = end_of_record;
 
160
                badRecord = true;
 
161
                return val;
 
162
        }
 
163
        
 
164
        d.rec_chars = ptr;
 
165
        val = CS_GET_DISK_4(d.int_val->val_4);
 
166
        ptr += 4;               
 
167
        return val;
 
168
}
 
169
 
 
170
//---------------------
 
171
const char *SysTabRec::getStringField()
 
172
{
 
173
        const char *val = "";
 
174
        
 
175
        if (badRecord)
 
176
                return val;
 
177
                
 
178
        if (ptr > (end_of_record -1)) {
 
179
                logError("Missing string field");
 
180
                badRecord = true;
 
181
                ptr = end_of_record;
 
182
        } else {
 
183
                val = ptr;
 
184
                while (*ptr && ptr < end_of_record) ptr++;
 
185
                if (ptr == end_of_record) {
 
186
                        logError("Unterminated string field");
 
187
                        badRecord = true;
 
188
                        val = "";
 
189
                } else
 
190
                        ptr++;
 
191
        }
 
192
        
 
193
        return val;
 
194
}
 
195
 
 
196
//---------------------
 
197
void SysTabRec::clear()
 
198
{
 
199
        setLength(0);
 
200
}
 
201
 
 
202
//---------------------
 
203
void SysTabRec::beginRecord()
 
204
{
 
205
        CSDiskData d;
 
206
        u_int len = length();
 
207
        
 
208
        setLength(len + 8); // Room for header marker and record length.
 
209
 
 
210
        d.rec_chars = getBuffer(len);
 
211
        CS_SET_DISK_4(d.int_val->val_4, HEAD_MARKER);   
 
212
 
 
213
        start_of_record = len + 4;
 
214
}
 
215
 
 
216
//---------------------
 
217
void SysTabRec::endRecord()
 
218
{
 
219
        CSDiskData d;
 
220
        u_int len = length();
 
221
        
 
222
        // Write the record length to the head of the record
 
223
        d.rec_chars = getBuffer(start_of_record);
 
224
        CS_SET_DISK_4(d.int_val->val_4, len - start_of_record); 
 
225
 
 
226
        // Write the record trailer
 
227
        setLength(len + 4); 
 
228
        d.rec_chars = getBuffer(len);
 
229
        CS_SET_DISK_4(d.int_val->val_4, TAIL_MARKER);           
 
230
}
 
231
 
 
232
//---------------------
 
233
void SysTabRec::setInt1Field(uint8_t val)
 
234
{
 
235
        CSDiskData d;
 
236
 
 
237
        u_int len = length();
 
238
        
 
239
        setLength(len +1); // Important: set the length before getting the buffer pointer
 
240
        d.rec_chars = getBuffer(len);
 
241
        CS_SET_DISK_1(d.int_val->val_1, val);   
 
242
}
 
243
 
 
244
//---------------------
 
245
void SysTabRec::setInt4Field(uint32_t val)
 
246
{
 
247
        CSDiskData d;
 
248
 
 
249
        u_int len = length();
 
250
        
 
251
        setLength(len +4); // Important: set the length before getting the buffer pointer
 
252
        d.rec_chars = getBuffer(len);
 
253
        CS_SET_DISK_4(d.int_val->val_4, val);   
 
254
}
 
255
 
 
256
//---------------------
 
257
void SysTabRec::setStringField(const char *val)
 
258
{
 
259
        if (!val) val = "";
 
260
        append(val, strlen(val) +1);
 
261
}
 
262
 
 
263
//---------------------
 
264
void SysTabRec::setStringField(const char *val, uint32_t len)
 
265
{
 
266
        if (val)
 
267
                append(val, len);
 
268
        append("", 1);
 
269
}
 
270
 
 
271
 
 
272
//======================
 
273
CSString *getPBMSPath(CSString *db_path)
 
274
{
 
275
        char pbms_path[PATH_MAX];
 
276
        enter_();
 
277
        
 
278
        push_(db_path); 
 
279
        cs_strcpy(PATH_MAX, pbms_path, db_path->getCString());
 
280
        release_(db_path);
 
281
        
 
282
        cs_remove_last_name_of_path(pbms_path);
 
283
 
 
284
        return_(CSString::newString(pbms_path));
 
285
}
 
286
 
 
287
 
 
288
//----------------------------
 
289
CSPath *getSysFile(CSString *db_path, const char *name_arg, size_t min_size)
 
290
{
 
291
        CSPath                  *path;
 
292
        CSStringBuffer  *name;
 
293
        char                    *ptr;
 
294
 
 
295
        enter_();
 
296
        
 
297
        push_(db_path);
 
298
        new_(name, CSStringBuffer());
 
299
        push_(name);
 
300
        name->append(name_arg);
 
301
        name->append(".dat");
 
302
        
 
303
        ptr = name->getBuffer(strlen(name_arg));
 
304
 
 
305
try_again:
 
306
        path = CSPath::newPath(RETAIN(db_path), name->getCString());
 
307
        push_(path);
 
308
        if (!path->exists()) {
 
309
                CSPath *tmp_path;
 
310
 
 
311
                strcpy(ptr, ".tmp");
 
312
                tmp_path = CSPath::newPath(RETAIN(db_path), name->getCString());
 
313
                push_(tmp_path);
 
314
                if (tmp_path->exists()) {
 
315
                        strcpy(ptr, ".dat");
 
316
                        tmp_path->rename(name->getCString());
 
317
                }
 
318
                release_(tmp_path);
 
319
        }
 
320
        
 
321
        // If the file if too small assume it is garbage.
 
322
        if (path->exists() && (path->getSize() < min_size)) {
 
323
                path->removeFile();
 
324
                release_(path);
 
325
                goto try_again;
 
326
        }
 
327
        
 
328
        pop_(path);
 
329
        release_(name);
 
330
        release_(db_path);
 
331
        return_(path);
 
332
}
 
333