ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/conf_db.c
(Generate patch)

Comparing ircd-hybrid/trunk/src/conf_db.c (file contents):
Revision 6927 by michael, Fri Oct 30 17:37:27 2015 UTC vs.
Revision 6928 by michael, Fri Dec 11 19:11:41 2015 UTC

# Line 489 | Line 489 | write_string(const char *s, struct dbFIL
489   } while (0)
490  
491   void
492 < save_kline_database(void)
492 > save_kline_database(const char *filename)
493   {
494    uint32_t i = 0;
495    uint32_t records = 0;
496    struct dbFILE *f = NULL;
497    dlink_node *ptr = NULL;
498  
499 <  if (!(f = open_db(KPATH, "w", KLINE_DB_VERSION)))
499 >  if (!(f = open_db(filename, "w", KLINE_DB_VERSION)))
500      return;
501  
502    for (i = 0; i < ATABLE_SIZE; ++i)
# Line 510 | Line 510 | save_kline_database(void)
510      }
511    }
512  
513 <  SAFE_WRITE(write_uint32(records, f), KPATH);
513 >  SAFE_WRITE(write_uint32(records, f), filename);
514  
515    for (i = 0; i < ATABLE_SIZE; ++i)
516    {
# Line 520 | Line 520 | save_kline_database(void)
520  
521        if (arec->type == CONF_KLINE && IsConfDatabase(arec->conf))
522        {
523 <        SAFE_WRITE(write_string(arec->conf->user, f), KPATH);
524 <        SAFE_WRITE(write_string(arec->conf->host, f), KPATH);
525 <        SAFE_WRITE(write_string(arec->conf->reason, f), KPATH);
526 <        SAFE_WRITE(write_uint64(arec->conf->setat, f), KPATH);
527 <        SAFE_WRITE(write_uint64(arec->conf->until, f), KPATH);
523 >        SAFE_WRITE(write_string(arec->conf->user, f), filename);
524 >        SAFE_WRITE(write_string(arec->conf->host, f), filename);
525 >        SAFE_WRITE(write_string(arec->conf->reason, f), filename);
526 >        SAFE_WRITE(write_uint64(arec->conf->setat, f), filename);
527 >        SAFE_WRITE(write_uint64(arec->conf->until, f), filename);
528        }
529      }
530    }
# Line 533 | Line 533 | save_kline_database(void)
533   }
534  
535   void
536 < load_kline_database(void)
536 > load_kline_database(const char *filename)
537   {
538    struct dbFILE *f = NULL;
539    struct MaskItem *conf = NULL;
# Line 545 | Line 545 | load_kline_database(void)
545    uint64_t field_4 = 0;
546    uint64_t field_5 = 0;
547  
548 <  if (!(f = open_db(KPATH, "r", KLINE_DB_VERSION)))
548 >  if (!(f = open_db(filename, "r", KLINE_DB_VERSION)))
549      return;
550  
551    if (get_file_version(f) < 1)
# Line 579 | Line 579 | load_kline_database(void)
579   }
580  
581   void
582 < save_dline_database(void)
582 > save_dline_database(const char *filename)
583   {
584    uint32_t i = 0;
585    uint32_t records = 0;
586    struct dbFILE *f = NULL;
587    dlink_node *ptr = NULL;
588  
589 <  if (!(f = open_db(DLPATH, "w", KLINE_DB_VERSION)))
589 >  if (!(f = open_db(filename, "w", KLINE_DB_VERSION)))
590      return;
591  
592    for (i = 0; i < ATABLE_SIZE; ++i)
# Line 600 | Line 600 | save_dline_database(void)
600      }
601    }
602  
603 <  SAFE_WRITE(write_uint32(records, f), DLPATH);
603 >  SAFE_WRITE(write_uint32(records, f), filename);
604  
605    for (i = 0; i < ATABLE_SIZE; ++i)
606    {
# Line 610 | Line 610 | save_dline_database(void)
610  
611        if (arec->type == CONF_DLINE && IsConfDatabase(arec->conf))
612        {
613 <        SAFE_WRITE(write_string(arec->conf->host, f), DLPATH);
614 <        SAFE_WRITE(write_string(arec->conf->reason, f), DLPATH);
615 <        SAFE_WRITE(write_uint64(arec->conf->setat, f), DLPATH);
616 <        SAFE_WRITE(write_uint64(arec->conf->until, f), DLPATH);
613 >        SAFE_WRITE(write_string(arec->conf->host, f), filename);
614 >        SAFE_WRITE(write_string(arec->conf->reason, f), filename);
615 >        SAFE_WRITE(write_uint64(arec->conf->setat, f), filename);
616 >        SAFE_WRITE(write_uint64(arec->conf->until, f), filename);
617        }
618      }
619    }
# Line 622 | Line 622 | save_dline_database(void)
622   }
623  
624   void
625 < load_dline_database(void)
625 > load_dline_database(const char *filename)
626   {
627    struct dbFILE *f = NULL;
628    struct MaskItem *conf = NULL;
# Line 633 | Line 633 | load_dline_database(void)
633    uint64_t field_3 = 0;
634    uint64_t field_4 = 0;
635  
636 <  if (!(f = open_db(DLPATH, "r", KLINE_DB_VERSION)))
636 >  if (!(f = open_db(filename, "r", KLINE_DB_VERSION)))
637      return;
638  
639    if (get_file_version(f) < 1)
# Line 665 | Line 665 | load_dline_database(void)
665   }
666  
667   void
668 < save_resv_database(void)
668 > save_resv_database(const char *filename)
669   {
670    uint32_t records = 0;
671    struct dbFILE *f = NULL;
672    dlink_node *ptr = NULL;
673    struct MaskItem *conf = NULL;
674  
675 <  if (!(f = open_db(RESVPATH, "w", KLINE_DB_VERSION)))
675 >  if (!(f = open_db(filename, "w", KLINE_DB_VERSION)))
676      return;
677  
678    DLINK_FOREACH(ptr, cresv_items.head)
# Line 691 | Line 691 | save_resv_database(void)
691        ++records;
692    }
693  
694 <  SAFE_WRITE(write_uint32(records, f), RESVPATH);
694 >  SAFE_WRITE(write_uint32(records, f), filename);
695  
696    DLINK_FOREACH(ptr, cresv_items.head)
697    {
# Line 700 | Line 700 | save_resv_database(void)
700      if (!IsConfDatabase(conf))
701        continue;
702  
703 <    SAFE_WRITE(write_string(conf->name, f), RESVPATH);
704 <    SAFE_WRITE(write_string(conf->reason, f), RESVPATH);
705 <    SAFE_WRITE(write_uint64(conf->setat, f), RESVPATH);
706 <    SAFE_WRITE(write_uint64(conf->until, f), RESVPATH);
703 >    SAFE_WRITE(write_string(conf->name, f), filename);
704 >    SAFE_WRITE(write_string(conf->reason, f), filename);
705 >    SAFE_WRITE(write_uint64(conf->setat, f), filename);
706 >    SAFE_WRITE(write_uint64(conf->until, f), filename);
707    }
708  
709    DLINK_FOREACH(ptr, nresv_items.head)
# Line 713 | Line 713 | save_resv_database(void)
713      if (!IsConfDatabase(conf))
714        continue;
715  
716 <    SAFE_WRITE(write_string(conf->name, f), RESVPATH);
717 <    SAFE_WRITE(write_string(conf->reason, f), RESVPATH);
718 <    SAFE_WRITE(write_uint64(conf->setat, f), RESVPATH);
719 <    SAFE_WRITE(write_uint64(conf->until, f), RESVPATH);
716 >    SAFE_WRITE(write_string(conf->name, f), filename);
717 >    SAFE_WRITE(write_string(conf->reason, f), filename);
718 >    SAFE_WRITE(write_uint64(conf->setat, f), filename);
719 >    SAFE_WRITE(write_uint64(conf->until, f), filename);
720    }
721  
722    close_db(f);
723   }
724  
725   void
726 < load_resv_database(void)
726 > load_resv_database(const char *filename)
727   {
728    uint32_t i = 0;
729    uint32_t records = 0;
# Line 733 | Line 733 | load_resv_database(void)
733    char *reason = NULL;
734    struct MaskItem *conf = NULL;
735  
736 <  if (!(f = open_db(RESVPATH, "r", KLINE_DB_VERSION)))
736 >  if (!(f = open_db(filename, "r", KLINE_DB_VERSION)))
737      return;
738  
739    if (get_file_version(f) < 1)
# Line 766 | Line 766 | load_resv_database(void)
766   }
767  
768   void
769 < save_xline_database(void)
769 > save_xline_database(const char *filename)
770   {
771    uint32_t records = 0;
772    struct dbFILE *f = NULL;
773    dlink_node *ptr = NULL;
774    struct MaskItem *conf = NULL;
775  
776 <  if (!(f = open_db(XPATH, "w", KLINE_DB_VERSION)))
776 >  if (!(f = open_db(filename, "w", KLINE_DB_VERSION)))
777      return;
778  
779    DLINK_FOREACH(ptr, gecos_items.head)
# Line 784 | Line 784 | save_xline_database(void)
784        ++records;
785    }
786  
787 <  SAFE_WRITE(write_uint32(records, f), XPATH);
787 >  SAFE_WRITE(write_uint32(records, f), filename);
788  
789    DLINK_FOREACH(ptr, gecos_items.head)
790    {
# Line 793 | Line 793 | save_xline_database(void)
793      if (!IsConfDatabase(conf))
794        continue;
795  
796 <    SAFE_WRITE(write_string(conf->name, f), XPATH);
797 <    SAFE_WRITE(write_string(conf->reason, f), XPATH);
798 <    SAFE_WRITE(write_uint64(conf->setat, f), XPATH);
799 <    SAFE_WRITE(write_uint64(conf->until, f), XPATH);
796 >    SAFE_WRITE(write_string(conf->name, f), filename);
797 >    SAFE_WRITE(write_string(conf->reason, f), filename);
798 >    SAFE_WRITE(write_uint64(conf->setat, f), filename);
799 >    SAFE_WRITE(write_uint64(conf->until, f), filename);
800    }
801  
802    close_db(f);
803   }
804  
805   void
806 < load_xline_database(void)
806 > load_xline_database(const char *filename)
807   {
808    uint32_t i = 0;
809    uint32_t records = 0;
# Line 813 | Line 813 | load_xline_database(void)
813    char *reason = NULL;
814    struct MaskItem *conf = NULL;
815  
816 <  if (!(f = open_db(XPATH, "r", KLINE_DB_VERSION)))
816 >  if (!(f = open_db(filename, "r", KLINE_DB_VERSION)))
817      return;
818  
819    if (get_file_version(f) < 1)
# Line 847 | Line 847 | load_xline_database(void)
847   void
848   save_all_databases(void *unused)
849   {
850 <  save_kline_database();
851 <  save_dline_database();
852 <  save_xline_database();
853 <  save_resv_database();
850 >  save_kline_database(ConfigGeneral.klinefile);
851 >  save_dline_database(ConfigGeneral.dlinefile);
852 >  save_xline_database(ConfigGeneral.xlinefile);
853 >  save_resv_database(ConfigGeneral.resvfile);
854   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines