/[svn]/ircd-hybrid/trunk/src/conf_db.c
ViewVC logotype

Annotation of /ircd-hybrid/trunk/src/conf_db.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1625 - (hide annotations)
Thu Nov 1 13:49:25 2012 UTC (7 years, 10 months ago) by michael
File MIME type: text/x-chdr
File size: 24153 byte(s)
- dbs are now periodically flushed on disc every 5 minutes

1 michael 1620 /*
2     * ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3     *
4     * Copyright (C) 1996-2002 by Andrew Church <achurch@achurch.org>
5     * Copyright (C) 2012 by the Hybrid Development Team.
6     *
7     * This program is free software; you can redistribute it and/or modify
8     * it under the terms of the GNU General Public License as published by
9     * the Free Software Foundation; either version 2 of the License, or
10     * (at your option) any later version.
11     *
12     * This program is distributed in the hope that it will be useful,
13     * but WITHOUT ANY WARRANTY; without even the implied warranty of
14     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15     * GNU General Public License for more details.
16     *
17     * You should have received a copy of the GNU General Public License
18     * along with this program; if not, write to the Free Software
19     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20     * USA
21     */
22    
23     /*! \file conf_db.c
24     * \brief Includes file utilities for database handling
25     * \version $Id: conf_db.c 1569 2012-10-16 18:46:53Z michael $
26     */
27    
28     #include "stdinc.h"
29     #include "conf_db.h"
30     #include "memory.h"
31     #include "client.h"
32     #include "log.h"
33     #include "send.h"
34     #include "irc_string.h"
35 michael 1622 #include "conf.h"
36     #include "hostmask.h"
37     #include "resv.h"
38 michael 1620
39    
40     /*! \brief Return the version number on the file. Return 0 if there is no version
41     * number or the number doesn't make sense (i.e. less than 1 or greater
42     * than FILE_VERSION).
43     *
44     * \param f dbFile Struct Member
45     * \return int 0 if failure, 1 > is the version number
46     */
47 michael 1621 uint32_t
48 michael 1620 get_file_version(struct dbFILE *f)
49     {
50 michael 1621 uint32_t version = 0;
51 michael 1620
52 michael 1621 if (read_uint32(&version, f) == -1)
53 michael 1620 {
54 michael 1621 ilog(LOG_TYPE_IRCD, "Error reading version number on %s: %s",
55     f->filename, strerror(errno));
56 michael 1620 return 0;
57     }
58 michael 1621
59     if (version < 1)
60 michael 1620 {
61 michael 1621 ilog(LOG_TYPE_IRCD, "Invalid version number (%u) on %s",
62 michael 1620 version, f->filename);
63     return 0;
64     }
65    
66     return version;
67     }
68    
69     /*! \brief Write the current version number to the file.
70     * \param f dbFile Struct Member
71     * \return 0 on error, 1 on success.
72     */
73     int
74     write_file_version(struct dbFILE *f, uint32_t version)
75     {
76     if (write_uint32(version, f) == -1)
77     {
78     ilog(LOG_TYPE_IRCD, "Error writing version number on %s",
79     f->filename);
80     return 0;
81     }
82    
83     return 1;
84     }
85    
86     /*! \brief Open the database for reading
87     * \param service If error whom to return the error as
88     * \param filename File to open as the database
89     * \return dbFile struct
90     */
91     static struct dbFILE *
92     open_db_read(const char *service, const char *filename)
93     {
94     struct dbFILE *f = MyMalloc(sizeof(*f));
95     FILE *fp = NULL;
96    
97     strlcpy(f->filename, filename, sizeof(f->filename));
98    
99     f->mode = 'r';
100     fp = fopen(f->filename, "rb");
101    
102     if (!fp)
103     {
104     int errno_save = errno;
105    
106     if (errno != ENOENT)
107 michael 1622 ilog(LOG_TYPE_IRCD, "Can't read %s database %s", service,
108 michael 1620 f->filename);
109    
110     MyFree(f);
111     errno = errno_save;
112     return NULL;
113     }
114    
115     f->fp = fp;
116     f->backupfp = NULL;
117    
118     return f;
119     }
120    
121     /*! \brief Open the database for writting
122     * \param service If error whom to return the error as
123     * \param filename File to open as the database
124     * \param version Database Version
125     * \return dbFile struct
126     */
127     static struct dbFILE *
128     open_db_write(const char *service, const char *filename,
129     uint32_t version)
130     {
131     struct dbFILE *f = MyMalloc(sizeof(*f));
132     int fd = 0;
133    
134     strlcpy(f->filename, filename, sizeof(f->filename));
135    
136     filename = f->filename;
137     f->mode = 'w';
138    
139     snprintf(f->backupname, sizeof(f->backupname), "%s.save", filename);
140    
141     if (!*f->backupname || !strcmp(f->backupname, filename))
142     {
143     int errno_save = errno;
144    
145     ilog(LOG_TYPE_IRCD, "Opening %s database %s for write: Filename too long",
146     service, filename);
147     MyFree(f);
148     errno = errno_save;
149     return NULL;
150     }
151    
152     unlink(filename);
153    
154     f->backupfp = fopen(filename, "rb");
155    
156     if (rename(filename, f->backupname) < 0 && errno != ENOENT)
157     {
158     int errno_save = errno;
159     static int walloped = 0;
160    
161     if (!walloped++)
162     sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
163 michael 1622 "Can't back up %s database %s",
164 michael 1620 service, filename);
165    
166     errno = errno_save;
167 michael 1622 ilog(LOG_TYPE_IRCD, "Can't back up %s database %s", service, filename);
168 michael 1620
169     if (f->backupfp)
170     fclose(f->backupfp);
171    
172     MyFree(f);
173     errno = errno_save;
174     return NULL;
175     }
176    
177     unlink(filename);
178    
179     /* Use open() to avoid people sneaking a new file in under us */
180     fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0666);
181     f->fp = fdopen(fd, "wb"); /* will fail and return NULL if fd < 0 */
182    
183     if (!f->fp || !write_file_version(f, version))
184     {
185     int errno_save = errno;
186     static int walloped = 0;
187    
188     if (!walloped++)
189     sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
190     "Can't write to %s database %s",
191     service, filename);
192    
193     errno = errno_save;
194     ilog(LOG_TYPE_IRCD, "Can't write to %s database %s",
195     service, filename);
196    
197     if (f->fp)
198     {
199     fclose(f->fp);
200     unlink(filename);
201     }
202    
203     if (f->backupname[0] && rename(f->backupname, filename) < 0)
204 michael 1622 ilog(LOG_TYPE_IRCD, "Can't restore backup copy of %s",
205 michael 1620 filename);
206    
207     MyFree(f);
208     errno = errno_save;
209     return NULL;
210     }
211    
212     return f;
213     }
214    
215     /*! \brief Open a database file for reading (*mode == 'r') or writing (*mode == 'w').
216     * Return the stream pointer, or NULL on error. When opening for write, it
217     * is an error for rename() to return an error (when backing up the original
218     * file) other than ENOENT, if NO_BACKUP_OKAY is not defined; it is an error
219     * if the version number cannot be written to the file; and it is a fatal
220     * error if opening the file for write fails and the backup was successfully
221     * made but cannot be restored.
222     *
223     * \param service If error whom to return the error as
224     * \param filename File to open as the database
225     * \param mode Mode for writting or reading
226     * \param version Database Version
227     * \return dbFile struct
228     */
229     struct dbFILE *
230     open_db(const char *service, const char *filename,
231     const char *mode, uint32_t version)
232     {
233     switch (*mode)
234     {
235     case 'r':
236     return open_db_read(service, filename);
237     break;
238     case 'w':
239     return open_db_write(service, filename, version);
240     break;
241     default:
242     errno = EINVAL;
243     return NULL;
244     }
245     }
246    
247     /*! \brief Restore the database file to its condition before open_db(). This is
248     * identical to close_db() for files open for reading; however, for files
249     * open for writing, we first attempt to restore any backup file before
250     * closing files.
251     *
252     * \param dbFile struct
253     */
254     void
255     restore_db(struct dbFILE *f)
256     {
257     int errno_save = errno;
258    
259     if (f->mode == 'w')
260     {
261     int ok = 0; /* Did we manage to restore the old file? */
262    
263     errno = errno_save = 0;
264    
265     if (f->backupname[0] && strcmp(f->backupname, f->filename))
266     if (rename(f->backupname, f->filename) == 0)
267     ok = 1;
268    
269     if (!ok && f->backupfp)
270     {
271     char buf[1024];
272     size_t i;
273    
274     ok = fseek(f->fp, 0, SEEK_SET) == 0;
275    
276     while (ok && (i = fread(buf, 1, sizeof(buf), f->backupfp)) > 0)
277     if (fwrite(buf, 1, i, f->fp) != i)
278     ok = 0;
279    
280     if (ok)
281     {
282     fflush(f->fp);
283     ftruncate(fileno(f->fp), ftell(f->fp));
284     }
285     }
286    
287     if (!ok && errno > 0)
288     ilog(LOG_TYPE_IRCD, "Unable to restore backup of %s", f->filename);
289    
290     errno_save = errno;
291    
292     if (f->backupfp)
293     fclose(f->backupfp);
294     if (f->backupname[0])
295     unlink(f->backupname);
296     }
297    
298     fclose(f->fp);
299    
300     if (!errno_save)
301     errno_save = errno;
302    
303     MyFree(f);
304     errno = errno_save;
305     }
306    
307     /*! \brief Close a database file. If the file was opened for write, remove the
308     * backup we (may have) created earlier.
309     *
310     * \param dbFile struct
311     */
312     void
313     close_db(struct dbFILE *f)
314     {
315     if (f->mode == 'w' && f->backupname[0] &&
316     strcmp(f->backupname, f->filename))
317     {
318     if (f->backupfp)
319     fclose(f->backupfp);
320    
321     unlink(f->backupname);
322     }
323    
324     fclose(f->fp);
325     MyFree(f);
326     }
327    
328     /*
329     * Read and write 2-, 4- and 8-byte quantities, pointers, and strings. All
330     * multibyte values are stored in big-endian order (most significant byte
331     * first). A pointer is stored as a byte, either 0 if NULL or 1 if not,
332     * and read pointers are returned as either (void *)0 or (void *)1. A
333     * string is stored with a 2-byte unsigned length (including the trailing
334     * \0) first; a length of 0 indicates that the string pointer is NULL.
335     * Written strings are truncated silently at 65534 bytes, and are always
336     * null-terminated.
337     */
338    
339     /*! \brief Read a unsigned 8bit integer
340     *
341     * \param ret 8bit integer to read
342     * \param dbFile struct
343     * \return -1 on error, 0 otherwise.
344     */
345     int
346     read_uint8(unsigned char *ret, struct dbFILE *f)
347     {
348     int c = fgetc(f->fp);
349    
350     if (c == EOF)
351     return -1;
352    
353     *ret = c;
354     return 0;
355     }
356    
357     /*! \brief Write a 8bit integer
358     *
359     * \param ret 8bit integer to write
360     * \param dbFile struct
361     * \return -1 on error, 0 otherwise.
362     */
363     int
364     write_uint8(unsigned char val, struct dbFILE *f)
365     {
366     if (fputc(val, f->fp) == EOF)
367     return -1;
368    
369     return 0;
370     }
371    
372     /*! \brief Read a unsigned 8bit integer
373     *
374     * \param ret 8bit integer to read
375     * \param dbFile struct
376     * \return -1 on error, 0 otherwise.
377     */
378     int
379     read_uint16(uint16_t *ret, struct dbFILE *f)
380     {
381     int c1 = fgetc(f->fp);
382     int c2 = fgetc(f->fp);
383    
384     if (c1 == EOF || c2 == EOF)
385     return -1;
386    
387     *ret = c1 << 8 | c2;
388     return 0;
389     }
390    
391     /*! \brief Write a unsigned 16bit integer
392     *
393     * \param ret 16bit integer to write
394     * \param dbFile struct
395     * \return -1 on error, 0 otherwise.
396     */
397     int
398     write_uint16(uint16_t val, struct dbFILE *f)
399     {
400     if (fputc((val >> 8) & 0xFF, f->fp) == EOF ||
401     fputc(val & 0xFF, f->fp) == EOF)
402     return -1;
403    
404     return 0;
405     }
406    
407     /*! \brief Read a unsigned 32bit integer
408     *
409     * \param ret unsigned 32bit integer to read
410     * \param dbFile struct
411     * \return -1 on error, 0 otherwise.
412     */
413     int
414     read_uint32(uint32_t *ret, struct dbFILE *f)
415     {
416     int c1 = fgetc(f->fp);
417     int c2 = fgetc(f->fp);
418     int c3 = fgetc(f->fp);
419     int c4 = fgetc(f->fp);
420    
421     if (c1 == EOF || c2 == EOF || c3 == EOF || c4 == EOF)
422     return -1;
423    
424     *ret = c1 << 24 | c2 << 16 | c3 << 8 | c4;
425     return 0;
426     }
427    
428    
429     /*! \brief Write a unsigned 32bit integer
430     *
431     * \param ret unsigned 32bit integer to write
432     * \param dbFile struct
433     * \return -1 on error, 0 otherwise.
434     */
435     int
436     write_uint32(uint32_t val, struct dbFILE *f)
437     {
438     if (fputc((val >> 24) & 0xFF, f->fp) == EOF)
439     return -1;
440     if (fputc((val >> 16) & 0xFF, f->fp) == EOF)
441     return -1;
442     if (fputc((val >> 8) & 0xFF, f->fp) == EOF)
443     return -1;
444     if (fputc((val) & 0xFF, f->fp) == EOF)
445     return -1;
446     return 0;
447     }
448    
449     /*! \brief Read a unsigned 64bit integer
450     *
451     * \param ret unsigned 64bit integer to read
452     * \param dbFile struct
453     * \return -1 on error, 0 otherwise.
454     */
455     int
456     read_uint64(uint64_t *ret, struct dbFILE *f)
457     {
458     int64_t c1 = fgetc(f->fp);
459     int64_t c2 = fgetc(f->fp);
460     int64_t c3 = fgetc(f->fp);
461     int64_t c4 = fgetc(f->fp);
462     int64_t c5 = fgetc(f->fp);
463     int64_t c6 = fgetc(f->fp);
464     int64_t c7 = fgetc(f->fp);
465     int64_t c8 = fgetc(f->fp);
466    
467     if (c1 == EOF || c2 == EOF || c3 == EOF || c4 == EOF ||
468     c5 == EOF || c6 == EOF || c7 == EOF || c8 == EOF)
469     return -1;
470    
471     *ret = c1 << 56 | c2 << 48 | c3 << 40 | c4 << 32 |
472     c5 << 24 | c6 << 16 | c7 << 8 | c8;
473     return 0;
474     }
475    
476    
477     /*! \brief Write a unsigned 64bit integer
478     *
479     * \param ret unsigned 64bit integer to write
480     * \param dbFile struct
481     * \return -1 on error, 0 otherwise.
482     */
483     int
484     write_uint64(uint64_t val, struct dbFILE *f)
485     {
486     if (fputc((val >> 56) & 0xFF, f->fp) == EOF)
487     return -1;
488     if (fputc((val >> 48) & 0xFF, f->fp) == EOF)
489     return -1;
490     if (fputc((val >> 40) & 0xFF, f->fp) == EOF)
491     return -1;
492     if (fputc((val >> 32) & 0xFF, f->fp) == EOF)
493     return -1;
494     if (fputc((val >> 24) & 0xFF, f->fp) == EOF)
495     return -1;
496     if (fputc((val >> 16) & 0xFF, f->fp) == EOF)
497     return -1;
498     if (fputc((val >> 8) & 0xFF, f->fp) == EOF)
499     return -1;
500     if (fputc((val) & 0xFF, f->fp) == EOF)
501     return -1;
502     return 0;
503     }
504    
505     /*! \brief Read Pointer
506     *
507     * \param ret pointer to read
508     * \param dbFile struct
509     * \return -1 on error, 0 otherwise.
510     */
511     int
512     read_ptr(void **ret, struct dbFILE *f)
513     {
514     int c = fgetc(f->fp);
515    
516     if (c == EOF)
517     return -1;
518    
519     *ret = (c ? (void *)1 : (void *)0);
520     return 0;
521     }
522    
523    
524     /*! \brief Write Pointer
525     *
526     * \param ret pointer to write
527     * \param dbFile struct
528     * \return -1 on error, 0 otherwise.
529     */
530     int
531     write_ptr(const void *ptr, struct dbFILE *f)
532     {
533     if (fputc(ptr ? 1 : 0, f->fp) == EOF)
534     return -1;
535     return 0;
536     }
537    
538     /*! \brief Read String
539     *
540     * \param ret string
541     * \param dbFile struct
542     * \return -1 on error, 0 otherwise.
543     */
544     int
545     read_string(char **ret, struct dbFILE *f)
546     {
547     char *s = NULL;
548     uint16_t len = 0;
549    
550     if (read_uint16(&len, f) < 0)
551     return -1;
552    
553     if (len == 0)
554     {
555     *ret = NULL;
556     return 0;
557     }
558    
559     s = MyMalloc(len);
560    
561     if (len != fread(s, 1, len, f->fp))
562     {
563     MyFree(s);
564     return -1;
565     }
566    
567     *ret = s;
568     return 0;
569     }
570    
571     /*! \brief Write String
572     *
573     * \param ret string
574     * \param dbFile struct
575     * \return -1 on error, 0 otherwise.
576     */
577     int
578     write_string(const char *s, struct dbFILE *f)
579     {
580     uint32_t len = 0;
581    
582     if (!s)
583     return write_uint16(0, f);
584    
585     len = strlen(s);
586    
587     if (len > 65534)
588     len = 65534;
589     if (write_uint16((uint16_t)(len + 1), f) < 0)
590     return -1;
591     if (len > 0 && fwrite(s, 1, len, f->fp) != len)
592     return -1;
593     if (fputc(0, f->fp) == EOF)
594     return -1;
595    
596     return 0;
597     }
598 michael 1622
599     #define SAFE_READ(x) do { \
600     if ((x) < 0) { \
601     break; \
602     } \
603     } while (0)
604    
605     #define SAFE_WRITE(x,db) do { \
606     if ((x) < 0) { \
607     restore_db(f); \
608     ilog(LOG_TYPE_IRCD, "Write error on %s", db); \
609     return; \
610     } \
611     } while (0)
612    
613     void
614     save_kline_database(void)
615     {
616     unsigned int i = 0;
617     uint32_t cnt = 0, version = 0;
618     struct dbFILE *f = NULL;
619     dlink_node *ptr = NULL;
620    
621     if (!(f = open_db("kline", KPATH, "w", KLINE_DB_VERSION)))
622     return;
623    
624     for (i = 0; i < ATABLE_SIZE; ++i)
625     {
626     DLINK_FOREACH(ptr, atable[i].head)
627     {
628     struct AddressRec *arec = ptr->data;
629    
630     if (arec->type == CONF_KLINE && !IsConfMain(arec->aconf))
631     ++cnt;
632     }
633     }
634    
635     SAFE_WRITE(write_uint32(cnt, f), KPATH);
636    
637     for (i = 0; i < ATABLE_SIZE; ++i)
638     {
639     DLINK_FOREACH(ptr, atable[i].head)
640     {
641     struct AddressRec *arec = ptr->data;
642    
643     if (arec->type == CONF_KLINE && !IsConfMain(arec->aconf))
644     {
645     SAFE_WRITE(write_string(arec->aconf->user, f), KPATH);
646     SAFE_WRITE(write_string(arec->aconf->host, f), KPATH);
647     SAFE_WRITE(write_string(arec->aconf->reason, f), KPATH);
648     SAFE_WRITE(write_uint64(arec->aconf->setat, f), KPATH);
649     SAFE_WRITE(write_uint64(arec->aconf->hold, f), KPATH);
650     }
651     }
652     }
653    
654     close_db(f);
655     }
656    
657     void
658     load_kline_database(void)
659     {
660     unsigned int i = 0;
661     uint32_t cnt = 0, version = 0;
662     uint64_t tmp64 = 0;
663     struct dbFILE *f = NULL;
664     dlink_node *ptr = NULL, *ptr_next = NULL;
665    
666     if (!(f = open_db("kline", KPATH, "r", KLINE_DB_VERSION)))
667     return;
668    
669     if ((version = get_file_version(f) < 1))
670     {
671     close_db(f);
672     return;
673     }
674    
675     read_uint32(&cnt, f);
676    
677     for (i = 0; i < cnt; ++i)
678     {
679     struct AccessItem *aconf = map_to_conf(make_conf_item(KLINE_TYPE));
680    
681     SAFE_READ(read_string(&aconf->user, f));
682     SAFE_READ(read_string(&aconf->host, f));
683     SAFE_READ(read_string(&aconf->reason, f));
684    
685     SAFE_READ(read_uint64(&tmp64, f));
686     aconf->setat = tmp64;
687    
688     SAFE_READ(read_uint64(&tmp64, f));
689     aconf->hold = tmp64;
690    
691     if (aconf->hold)
692     SetConfTemporary(aconf);
693    
694     add_conf_by_address(CONF_KLINE, aconf);
695     }
696    
697     close_db(f);
698     }
699    
700     void
701     save_dline_database(void)
702     {
703     unsigned int i = 0;
704     uint32_t cnt = 0, version = 0;
705     struct dbFILE *f = NULL;
706     dlink_node *ptr = NULL;
707    
708     if (!(f = open_db("dline", DLPATH, "w", KLINE_DB_VERSION)))
709     return;
710    
711     for (i = 0; i < ATABLE_SIZE; ++i)
712     {
713     DLINK_FOREACH(ptr, atable[i].head)
714     {
715     struct AddressRec *arec = ptr->data;
716    
717     if (arec->type == CONF_DLINE && !IsConfMain(arec->aconf))
718     ++cnt;
719     }
720     }
721    
722     SAFE_WRITE(write_uint32(cnt, f), DLPATH);
723    
724     for (i = 0; i < ATABLE_SIZE; ++i)
725     {
726     DLINK_FOREACH(ptr, atable[i].head)
727     {
728     struct AddressRec *arec = ptr->data;
729    
730     if (arec->type == CONF_DLINE && !IsConfMain(arec->aconf))
731     {
732     SAFE_WRITE(write_string(arec->aconf->host, f), DLPATH);
733     SAFE_WRITE(write_string(arec->aconf->reason, f), DLPATH);
734     SAFE_WRITE(write_uint64(arec->aconf->setat, f), DLPATH);
735     SAFE_WRITE(write_uint64(arec->aconf->hold, f), DLPATH);
736     }
737     }
738     }
739    
740     close_db(f);
741     }
742    
743     void
744     load_dline_database(void)
745     {
746     unsigned int i = 0;
747     uint32_t cnt = 0, version = 0;
748     uint64_t tmp64 = 0;
749     struct dbFILE *f = NULL;
750     dlink_node *ptr = NULL, *ptr_next = NULL;
751    
752     if (!(f = open_db("dline", DLPATH, "r", KLINE_DB_VERSION)))
753     return;
754    
755     if ((version = get_file_version(f) < 1))
756     {
757     close_db(f);
758     return;
759     }
760    
761     read_uint32(&cnt, f);
762    
763     for (i = 0; i < cnt; ++i)
764     {
765     struct AccessItem *aconf = map_to_conf(make_conf_item(DLINE_TYPE));
766    
767     SAFE_READ(read_string(&aconf->host, f));
768     SAFE_READ(read_string(&aconf->reason, f));
769    
770     SAFE_READ(read_uint64(&tmp64, f));
771     aconf->setat = tmp64;
772    
773     SAFE_READ(read_uint64(&tmp64, f));
774     aconf->hold = tmp64;
775    
776     if (aconf->hold)
777     SetConfTemporary(aconf);
778    
779     add_conf_by_address(CONF_DLINE, aconf);
780     }
781    
782     close_db(f);
783     }
784    
785     void
786     save_gline_database(void)
787     {
788     unsigned int i = 0;
789     uint32_t cnt = 0, version = 0;
790     struct dbFILE *f = NULL;
791     dlink_node *ptr = NULL;
792    
793     if (!(f = open_db("gline", GPATH, "w", KLINE_DB_VERSION)))
794     return;
795    
796     for (i = 0; i < ATABLE_SIZE; ++i)
797     {
798     DLINK_FOREACH(ptr, atable[i].head)
799     {
800     struct AddressRec *arec = ptr->data;
801    
802     if (arec->type == CONF_GLINE && !IsConfMain(arec->aconf))
803     ++cnt;
804     }
805     }
806    
807     SAFE_WRITE(write_uint32(cnt, f), GPATH);
808    
809     for (i = 0; i < ATABLE_SIZE; ++i)
810     {
811     DLINK_FOREACH(ptr, atable[i].head)
812     {
813     struct AddressRec *arec = ptr->data;
814    
815     if (arec->type == CONF_GLINE && !IsConfMain(arec->aconf))
816     {
817     SAFE_WRITE(write_string(arec->aconf->user, f), GPATH);
818     SAFE_WRITE(write_string(arec->aconf->host, f), GPATH);
819     SAFE_WRITE(write_string(arec->aconf->reason, f), GPATH);
820     SAFE_WRITE(write_uint64(arec->aconf->setat, f), GPATH);
821     SAFE_WRITE(write_uint64(arec->aconf->hold, f), GPATH);
822     }
823     }
824     }
825    
826     close_db(f);
827     }
828    
829     void
830     load_gline_database(void)
831     {
832     unsigned int i = 0;
833     uint32_t cnt = 0, version = 0;
834     uint64_t tmp64 = 0;
835     struct dbFILE *f = NULL;
836     dlink_node *ptr = NULL, *ptr_next = NULL;
837    
838     if (!(f = open_db("gline", GPATH, "r", KLINE_DB_VERSION)))
839     return;
840    
841     if ((version = get_file_version(f) < 1))
842     {
843     close_db(f);
844     return;
845     }
846    
847     read_uint32(&cnt, f);
848    
849     for (i = 0; i < cnt; ++i)
850     {
851     struct AccessItem *aconf = map_to_conf(make_conf_item(GLINE_TYPE));
852    
853     SAFE_READ(read_string(&aconf->user, f));
854     SAFE_READ(read_string(&aconf->host, f));
855     SAFE_READ(read_string(&aconf->reason, f));
856    
857     SAFE_READ(read_uint64(&tmp64, f));
858     aconf->setat = tmp64;
859    
860     SAFE_READ(read_uint64(&tmp64, f));
861     aconf->hold = tmp64;
862    
863     if (aconf->hold)
864     SetConfTemporary(aconf);
865    
866     add_conf_by_address(CONF_GLINE, aconf);
867     }
868    
869     close_db(f);
870     }
871    
872     void
873     save_resv_database(void)
874     {
875     unsigned int i = 0;
876     uint32_t cnt = 0, version = 0;
877     struct dbFILE *f = NULL;
878     dlink_node *ptr = NULL;
879     struct ConfItem *conf;
880     struct ResvChannel *resv_cp;
881     struct MatchItem *resv_np;
882    
883     if (!(f = open_db("resv", RESVPATH, "w", KLINE_DB_VERSION)))
884     return;
885    
886     DLINK_FOREACH(ptr, resv_channel_list.head)
887     {
888     resv_cp = ptr->data;
889    
890     if (!resv_cp->conf)
891     ++cnt;
892     }
893    
894     DLINK_FOREACH(ptr, nresv_items.head)
895     {
896     resv_np = map_to_conf(ptr->data);
897    
898     if (!resv_np->action)
899     ++cnt;
900     }
901    
902     SAFE_WRITE(write_uint32(cnt, f), RESVPATH);
903    
904    
905     DLINK_FOREACH(ptr, resv_channel_list.head)
906     {
907     resv_cp = ptr->data;
908    
909     SAFE_WRITE(write_string(resv_cp->name, f), RESVPATH);
910     SAFE_WRITE(write_string(resv_cp->reason, f), RESVPATH);
911     SAFE_WRITE(write_uint64(resv_cp->setat, f), RESVPATH);
912     SAFE_WRITE(write_uint64(resv_cp->hold, f), RESVPATH);
913     }
914    
915     DLINK_FOREACH(ptr, nresv_items.head)
916     {
917     conf = ptr->data;
918     resv_np = map_to_conf(conf);
919    
920     SAFE_WRITE(write_string(conf->name, f), RESVPATH);
921     SAFE_WRITE(write_string(resv_np->reason, f), RESVPATH);
922     SAFE_WRITE(write_uint64(resv_np->setat, f), RESVPATH);
923     SAFE_WRITE(write_uint64(resv_np->hold, f), RESVPATH);
924     }
925    
926     close_db(f);
927     }
928    
929     void
930     load_resv_database(void)
931     {
932     unsigned int i = 0;
933     uint32_t cnt = 0, version = 0;
934     uint64_t tmp64_hold = 0, tmp64_setat = 0;
935     struct dbFILE *f = NULL;
936     dlink_node *ptr = NULL, *ptr_next = NULL;
937     char *name = NULL;
938     char *reason = NULL;
939     struct ConfItem *conf;
940     struct ResvChannel *resv_cp;
941     struct MatchItem *resv_np;
942    
943     if (!(f = open_db("resv", RESVPATH, "r", KLINE_DB_VERSION)))
944     return;
945    
946     if ((version = get_file_version(f) < 1))
947     {
948     close_db(f);
949     return;
950     }
951    
952     read_uint32(&cnt, f);
953    
954     for (i = 0; i < cnt; ++i)
955     {
956     SAFE_READ(read_string(&name, f));
957     SAFE_READ(read_string(&reason, f));
958     SAFE_READ(read_uint64(&tmp64_setat, f));
959     SAFE_READ(read_uint64(&tmp64_hold, f));
960    
961     if (IsChanPrefix(*name))
962     {
963     if ((conf = create_channel_resv(name, reason, 0)) == NULL)
964     continue;
965    
966     resv_cp = map_to_conf(conf);
967     resv_cp->setat = tmp64_setat;
968     resv_cp->hold = tmp64_hold;
969    
970     if (resv_cp->hold)
971     add_temp_line(conf);
972     }
973     else
974     {
975     if ((conf = create_nick_resv(name, reason, 0)) == NULL)
976     continue;
977    
978     resv_np = map_to_conf(conf);
979     resv_np->setat = tmp64_setat;
980     resv_np->hold = tmp64_hold;
981    
982     if (resv_np->hold)
983     add_temp_line(conf);
984     }
985    
986     MyFree(name);
987     MyFree(reason);
988     }
989    
990     close_db(f);
991     }
992    
993     void
994     save_xline_database(void)
995     {
996     unsigned int i = 0;
997     uint32_t cnt = 0, version = 0;
998     struct dbFILE *f = NULL;
999     dlink_node *ptr = NULL;
1000     struct ConfItem *conf = NULL;
1001     struct MatchItem *xconf = NULL;
1002    
1003     if (!(f = open_db("xline", XPATH, "w", KLINE_DB_VERSION)))
1004     return;
1005    
1006     DLINK_FOREACH(ptr, xconf_items.head)
1007     {
1008     conf = ptr->data;
1009    
1010     if (!IsConfMain(conf))
1011     ++cnt;
1012     }
1013    
1014     SAFE_WRITE(write_uint32(cnt, f), XPATH);
1015    
1016    
1017     DLINK_FOREACH(ptr, xconf_items.head)
1018     {
1019     conf = ptr->data;
1020     xconf = map_to_conf(conf);
1021    
1022     SAFE_WRITE(write_string(conf->name, f), XPATH);
1023     SAFE_WRITE(write_string(xconf->reason, f), XPATH);
1024     SAFE_WRITE(write_uint64(xconf->setat, f), XPATH);
1025     SAFE_WRITE(write_uint64(xconf->hold, f), XPATH);
1026     }
1027    
1028     close_db(f);
1029     }
1030    
1031     void
1032     load_xline_database(void)
1033     {
1034     unsigned int i = 0;
1035     uint32_t cnt = 0, version = 0;
1036     uint64_t tmp64_hold = 0, tmp64_setat = 0;
1037     struct dbFILE *f = NULL;
1038     dlink_node *ptr = NULL, *ptr_next = NULL;
1039     char *name = NULL;
1040     char *reason = NULL;
1041     struct ConfItem *conf = NULL;
1042     struct MatchItem *xconf = NULL;
1043    
1044     if (!(f = open_db("xline", XPATH, "r", KLINE_DB_VERSION)))
1045     return;
1046    
1047     if ((version = get_file_version(f) < 1))
1048     {
1049     close_db(f);
1050     return;
1051     }
1052    
1053     read_uint32(&cnt, f);
1054    
1055     for (i = 0; i < cnt; ++i)
1056     {
1057     SAFE_READ(read_string(&name, f));
1058     SAFE_READ(read_string(&reason, f));
1059     SAFE_READ(read_uint64(&tmp64_setat, f));
1060     SAFE_READ(read_uint64(&tmp64_hold, f));
1061    
1062     conf = make_conf_item(XLINE_TYPE);
1063     xconf = map_to_conf(conf);
1064    
1065     conf->name = name;
1066     xconf->reason = reason;
1067     xconf->setat = tmp64_setat;
1068     xconf->hold = tmp64_hold;
1069    
1070     if (xconf->hold)
1071     SetConfTemporary(conf);
1072     }
1073    
1074     close_db(f);
1075     }
1076 michael 1625
1077     void
1078     save_all_databases(void *unused)
1079     {
1080     save_kline_database();
1081     save_dline_database();
1082     save_gline_database();
1083     save_xline_database();
1084     save_resv_database();
1085     }

svnadmin@ircd-hybrid.org
ViewVC Help
Powered by ViewVC 1.1.28