ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/svn/ircd-hybrid/trunk/src/conf_db.c

Comparing ircd-hybrid/trunk/src/conf_db.c (file contents):
Revision 1631 by michael, Thu Nov 1 21:08:56 2012 UTC vs.
Revision 1632 by michael, Sun Nov 4 15:37:10 2012 UTC

#	Line 627 | Line 627 | save_kline_database(void)
627		{
628		struct AddressRec *arec = ptr->data;
629
630	<	if (arec->type == CONF_KLINE && IsConfDatabase(arec->aconf))
630	>	if (arec->type == CONF_KLINE && IsConfDatabase(arec->conf))
631		++records;
632		}
633		}
#	Line 640 | Line 640 | save_kline_database(void)
640		{
641		struct AddressRec *arec = ptr->data;
642
643	<	if (arec->type == CONF_KLINE && IsConfDatabase(arec->aconf))
643	>	if (arec->type == CONF_KLINE && IsConfDatabase(arec->conf))
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);
645	>	SAFE_WRITE(write_string(arec->conf->user, f), KPATH);
646	>	SAFE_WRITE(write_string(arec->conf->host, f), KPATH);
647	>	SAFE_WRITE(write_string(arec->conf->reason, f), KPATH);
648	>	SAFE_WRITE(write_uint64(arec->conf->setat, f), KPATH);
649	>	SAFE_WRITE(write_uint64(arec->conf->hold, f), KPATH);
650		}
651		}
652		}
#	Line 658 | Line 658 | void
658		load_kline_database(void)
659		{
660		struct dbFILE *f = NULL;
661	<	struct AccessItem *aconf = NULL;
661	>	struct MaskItem *conf = NULL;
662		char *field_1 = NULL;
663		char *field_2 = NULL;
664		char *field_3 = NULL;
#	Line 686 | Line 686 | load_kline_database(void)
686		SAFE_READ(read_uint64(&field_4, f));
687		SAFE_READ(read_uint64(&field_5, f));
688
689	<	aconf = map_to_conf(make_conf_item(KLINE_TYPE));
690	<	aconf->user = field_1;
691	<	aconf->host = field_2;
692	<	aconf->reason = field_3;
693	<	aconf->setat = field_4;
694	<	aconf->hold = field_5;
695	<	SetConfDatabase(aconf);
689	>	conf = conf_make(CONF_KLINE);
690	>	conf->user = field_1;
691	>	conf->host = field_2;
692	>	conf->reason = field_3;
693	>	conf->setat = field_4;
694	>	conf->hold = field_5;
695	>	SetConfDatabase(conf);
696
697	<	add_conf_by_address(CONF_KLINE, aconf);
697	>	add_conf_by_address(CONF_KLINE, conf);
698		}
699
700		close_db(f);
#	Line 717 | Line 717 | save_dline_database(void)
717		{
718		struct AddressRec *arec = ptr->data;
719
720	<	if (arec->type == CONF_DLINE && IsConfDatabase(arec->aconf))
720	>	if (arec->type == CONF_DLINE && IsConfDatabase(arec->conf))
721		++records;
722		}
723		}
#	Line 730 | Line 730 | save_dline_database(void)
730		{
731		struct AddressRec *arec = ptr->data;
732
733	<	if (arec->type == CONF_DLINE && IsConfDatabase(arec->aconf))
733	>	if (arec->type == CONF_DLINE && IsConfDatabase(arec->conf))
734		{
735	<	SAFE_WRITE(write_string(arec->aconf->host, f), DLPATH);
736	<	SAFE_WRITE(write_string(arec->aconf->reason, f), DLPATH);
737	<	SAFE_WRITE(write_uint64(arec->aconf->setat, f), DLPATH);
738	<	SAFE_WRITE(write_uint64(arec->aconf->hold, f), DLPATH);
735	>	SAFE_WRITE(write_string(arec->conf->host, f), DLPATH);
736	>	SAFE_WRITE(write_string(arec->conf->reason, f), DLPATH);
737	>	SAFE_WRITE(write_uint64(arec->conf->setat, f), DLPATH);
738	>	SAFE_WRITE(write_uint64(arec->conf->hold, f), DLPATH);
739		}
740		}
741		}
#	Line 747 | Line 747 | void
747		load_dline_database(void)
748		{
749		struct dbFILE *f = NULL;
750	<	struct AccessItem *aconf = NULL;
750	>	struct MaskItem *conf = NULL;
751		char *field_1 = NULL;
752		char *field_2 = NULL;
753		uint32_t i = 0;
#	Line 773 | Line 773 | load_dline_database(void)
773		SAFE_READ(read_uint64(&field_3, f));
774		SAFE_READ(read_uint64(&field_4, f));
775
776	<	aconf = map_to_conf(make_conf_item(DLINE_TYPE));
777	<	aconf->host = field_1;
778	<	aconf->reason = field_2;
779	<	aconf->setat = field_3;
780	<	aconf->hold = field_4;
781	<	SetConfDatabase(aconf);
776	>	conf = conf_make(CONF_DLINE);
777	>	conf->host = field_1;
778	>	conf->reason = field_2;
779	>	conf->setat = field_3;
780	>	conf->hold = field_4;
781	>	SetConfDatabase(conf);
782
783	<	add_conf_by_address(CONF_DLINE, aconf);
783	>	add_conf_by_address(CONF_DLINE, conf);
784		}
785
786		close_db(f);
#	Line 803 | Line 803 | save_gline_database(void)
803		{
804		struct AddressRec *arec = ptr->data;
805
806	<	if (arec->type == CONF_GLINE && IsConfDatabase(arec->aconf))
806	>	if (arec->type == CONF_GLINE && IsConfDatabase(arec->conf))
807		++records;
808		}
809		}
#	Line 816 | Line 816 | save_gline_database(void)
816		{
817		struct AddressRec *arec = ptr->data;
818
819	<	if (arec->type == CONF_GLINE && IsConfDatabase(arec->aconf))
819	>	if (arec->type == CONF_GLINE && IsConfDatabase(arec->conf))
820		{
821	<	SAFE_WRITE(write_string(arec->aconf->user, f), GPATH);
822	<	SAFE_WRITE(write_string(arec->aconf->host, f), GPATH);
823	<	SAFE_WRITE(write_string(arec->aconf->reason, f), GPATH);
824	<	SAFE_WRITE(write_uint64(arec->aconf->setat, f), GPATH);
825	<	SAFE_WRITE(write_uint64(arec->aconf->hold, f), GPATH);
821	>	SAFE_WRITE(write_string(arec->conf->user, f), GPATH);
822	>	SAFE_WRITE(write_string(arec->conf->host, f), GPATH);
823	>	SAFE_WRITE(write_string(arec->conf->reason, f), GPATH);
824	>	SAFE_WRITE(write_uint64(arec->conf->setat, f), GPATH);
825	>	SAFE_WRITE(write_uint64(arec->conf->hold, f), GPATH);
826		}
827		}
828		}
#	Line 834 | Line 834 | void
834		load_gline_database(void)
835		{
836		struct dbFILE *f = NULL;
837	<	struct AccessItem *aconf = NULL;
837	>	struct MaskItem *conf = NULL;
838		char *field_1 = NULL;
839		char *field_2 = NULL;
840		char *field_3 = NULL;
#	Line 862 | Line 862 | load_gline_database(void)
862		SAFE_READ(read_uint64(&field_4, f));
863		SAFE_READ(read_uint64(&field_5, f));
864
865	<	aconf = map_to_conf(make_conf_item(KLINE_TYPE));
866	<	aconf->user = field_1;
867	<	aconf->host = field_2;
868	<	aconf->reason = field_3;
869	<	aconf->setat = field_4;
870	<	aconf->hold = field_5;
871	<	SetConfDatabase(aconf);
865	>	conf = conf_make(CONF_GLINE);
866	>	conf->user = field_1;
867	>	conf->host = field_2;
868	>	conf->reason = field_3;
869	>	conf->setat = field_4;
870	>	conf->hold = field_5;
871	>	SetConfDatabase(conf);
872
873	<	add_conf_by_address(CONF_GLINE, aconf);
873	>	add_conf_by_address(CONF_GLINE, conf);
874		}
875
876		close_db(f);
#	Line 882 | Line 882 | save_resv_database(void)
882		uint32_t records = 0;
883		struct dbFILE *f = NULL;
884		dlink_node *ptr = NULL;
885	<	struct ConfItem *conf;
886	<	struct ResvChannel *resv_cp;
887	<	struct MatchItem *resv_np;
885	>	struct MaskItem *conf = NULL;
886
887		if (!(f = open_db("resv", RESVPATH, "w", KLINE_DB_VERSION)))
888		return;
889
890		DLINK_FOREACH(ptr, resv_channel_list.head)
891		{
892	<	resv_cp = ptr->data;
892	>	conf = ptr->data;
893
894	<	if (IsConfDatabase(resv_cp))
894	>	if (IsConfDatabase(conf))
895		++records;
896		}
897
898		DLINK_FOREACH(ptr, nresv_items.head)
899		{
900	<	resv_np = map_to_conf(ptr->data);
900	>	conf = ptr->data;
901
902	<	if (IsConfDatabase(resv_np))
902	>	if (IsConfDatabase(conf))
903		++records;
904		}
905
#	Line 909 | Line 907 | save_resv_database(void)
907
908		DLINK_FOREACH(ptr, resv_channel_list.head)
909		{
910	<	resv_cp = ptr->data;
910	>	conf = ptr->data;
911
912	<	if (!IsConfDatabase(resv_cp))
912	>	if (!IsConfDatabase(conf))
913		continue;
914
915	<	SAFE_WRITE(write_string(resv_cp->name, f), RESVPATH);
916	<	SAFE_WRITE(write_string(resv_cp->reason, f), RESVPATH);
917	<	SAFE_WRITE(write_uint64(resv_cp->setat, f), RESVPATH);
918	<	SAFE_WRITE(write_uint64(resv_cp->hold, f), RESVPATH);
915	>	SAFE_WRITE(write_string(conf->name, f), RESVPATH);
916	>	SAFE_WRITE(write_string(conf->reason, f), RESVPATH);
917	>	SAFE_WRITE(write_uint64(conf->setat, f), RESVPATH);
918	>	SAFE_WRITE(write_uint64(conf->hold, f), RESVPATH);
919		}
920
921		DLINK_FOREACH(ptr, nresv_items.head)
922		{
923		conf = ptr->data;
926	–	resv_np = map_to_conf(conf);
924
925	<	if (!IsConfDatabase(resv_np))
925	>	if (!IsConfDatabase(conf))
926		continue;
927
928		SAFE_WRITE(write_string(conf->name, f), RESVPATH);
929	<	SAFE_WRITE(write_string(resv_np->reason, f), RESVPATH);
930	<	SAFE_WRITE(write_uint64(resv_np->setat, f), RESVPATH);
931	<	SAFE_WRITE(write_uint64(resv_np->hold, f), RESVPATH);
929	>	SAFE_WRITE(write_string(conf->reason, f), RESVPATH);
930	>	SAFE_WRITE(write_uint64(conf->setat, f), RESVPATH);
931	>	SAFE_WRITE(write_uint64(conf->hold, f), RESVPATH);
932		}
933
934		close_db(f);
#	Line 946 | Line 943 | load_resv_database(void)
943		struct dbFILE *f = NULL;
944		char *name = NULL;
945		char *reason = NULL;
946	<	struct ConfItem *conf;
950	<	struct ResvChannel *resv_cp;
951	<	struct MatchItem *resv_np;
946	>	struct MaskItem *conf = NULL;
947
948		if (!(f = open_db("resv", RESVPATH, "r", KLINE_DB_VERSION)))
949		return;
#	Line 973 | Line 968 | load_resv_database(void)
968		if ((conf = create_channel_resv(name, reason, 0)) == NULL)
969		continue;
970
971	<	resv_cp = map_to_conf(conf);
972	<	resv_cp->setat = tmp64_setat;
973	<	resv_cp->hold = tmp64_hold;
979	<	SetConfDatabase(resv_cp);
971	>	conf->setat = tmp64_setat;
972	>	conf->hold = tmp64_hold;
973	>	SetConfDatabase(conf);
974		}
975		else
976		{
977		if ((conf = create_nick_resv(name, reason, 0)) == NULL)
978		continue;
979
980	<	resv_np = map_to_conf(conf);
981	<	resv_np->setat = tmp64_setat;
982	<	resv_np->hold = tmp64_hold;
989	<	SetConfDatabase(resv_np);
980	>	conf->setat = tmp64_setat;
981	>	conf->hold = tmp64_hold;
982	>	SetConfDatabase(conf);
983		}
984
985		MyFree(name);
#	Line 1002 | Line 995 | save_xline_database(void)
995		uint32_t records = 0;
996		struct dbFILE *f = NULL;
997		dlink_node *ptr = NULL;
998	<	struct ConfItem *conf = NULL;
1006	<	struct MatchItem *xconf = NULL;
998	>	struct MaskItem *conf = NULL;
999
1000		if (!(f = open_db("xline", XPATH, "w", KLINE_DB_VERSION)))
1001		return;
#	Line 1012 | Line 1004 | save_xline_database(void)
1004		{
1005		conf = ptr->data;
1006
1007	<	if (IsConfDatabase(xconf))
1007	>	if (IsConfDatabase(conf))
1008		++records;
1009		}
1010
#	Line 1021 | Line 1013 | save_xline_database(void)
1013		DLINK_FOREACH(ptr, xconf_items.head)
1014		{
1015		conf = ptr->data;
1024	–	xconf = map_to_conf(conf);
1016
1017	<	if (!IsConfDatabase(xconf))
1017	>	if (!IsConfDatabase(conf))
1018		continue;
1019
1020		SAFE_WRITE(write_string(conf->name, f), XPATH);
1021	<	SAFE_WRITE(write_string(xconf->reason, f), XPATH);
1022	<	SAFE_WRITE(write_uint64(xconf->setat, f), XPATH);
1023	<	SAFE_WRITE(write_uint64(xconf->hold, f), XPATH);
1021	>	SAFE_WRITE(write_string(conf->reason, f), XPATH);
1022	>	SAFE_WRITE(write_uint64(conf->setat, f), XPATH);
1023	>	SAFE_WRITE(write_uint64(conf->hold, f), XPATH);
1024		}
1025
1026		close_db(f);
#	Line 1044 | Line 1035 | load_xline_database(void)
1035		struct dbFILE *f = NULL;
1036		char *name = NULL;
1037		char *reason = NULL;
1038	<	struct ConfItem *conf = NULL;
1048	<	struct MatchItem *xconf = NULL;
1038	>	struct MaskItem *conf = NULL;
1039
1040		if (!(f = open_db("xline", XPATH, "r", KLINE_DB_VERSION)))
1041		return;
#	Line 1065 | Line 1055 | load_xline_database(void)
1055		SAFE_READ(read_uint64(&tmp64_setat, f));
1056		SAFE_READ(read_uint64(&tmp64_hold, f));
1057
1058	<	conf = make_conf_item(XLINE_TYPE);
1069	<	xconf = map_to_conf(conf);
1058	>	conf = conf_make(CONF_XLINE);
1059
1060	<	SetConfDatabase(xconf);
1060	>	SetConfDatabase(conf);
1061
1062		conf->name = name;
1063	<	xconf->reason = reason;
1064	<	xconf->setat = tmp64_setat;
1065	<	xconf->hold = tmp64_hold;
1063	>	conf->reason = reason;
1064	>	conf->setat = tmp64_setat;
1065	>	conf->hold = tmp64_hold;
1066		}
1067
1068		close_db(f);

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines