+2536. [cleanup] Silence some warnings when -Werror=format-security is
+ specified. [RT #19083]
+
2535. [bug] dig +showsearh and +trace interacted badly. [RT #19091]
2532. [bug] dig: check the question section of the response to
* PERFORMANCE OF THIS SOFTWARE.
*/
-/* $Id: t_db.c,v 1.31.18.3 2005/11/30 23:52:53 marka Exp $ */
+/* $Id: t_db.c,v 1.31.18.4 2009/01/22 05:55:29 marka Exp $ */
#include <config.h>
t1(void) {
int result;
- t_assert("dns_db_load", 1, T_REQUIRED, a1);
+ t_assert("dns_db_load", 1, T_REQUIRED, "%s", a1);
result = t_eval("dns_db_load_data", t_dns_db_load, 9);
t_result(result);
}
t2(void) {
int result;
- t_assert("dns_db_iscache", 2, T_REQUIRED, a2);
+ t_assert("dns_db_iscache", 2, T_REQUIRED, "%s", a2);
result = test_dns_db_zc_x("dns_db_iscache_1_data",
dns_dbtype_cache, dns_db_iscache, ISC_TRUE);
t_result(result);
t3(void) {
int result;
- t_assert("dns_db_iscache", 3, T_REQUIRED, a3);
+ t_assert("dns_db_iscache", 3, T_REQUIRED, "%s", a3);
result = test_dns_db_zc_x("dns_db_iscache_2_data",
dns_dbtype_zone, dns_db_iscache, ISC_FALSE);
t_result(result);
t4(void) {
int result;
- t_assert("dns_db_iszone", 4, T_REQUIRED, a4);
+ t_assert("dns_db_iszone", 4, T_REQUIRED, "%s", a4);
result = test_dns_db_zc_x("dns_db_iszone_1_data",
dns_dbtype_zone, dns_db_iszone, ISC_TRUE);
t_result(result);
t5(void) {
int result;
- t_assert("dns_db_iszone", 5, T_REQUIRED, a5);
+ t_assert("dns_db_iszone", 5, T_REQUIRED, "%s", a5);
result = test_dns_db_zc_x("dns_db_iszone_2_data",
dns_dbtype_cache, dns_db_iszone, ISC_FALSE);
t_result(result);
t6(void) {
int result;
- t_assert("dns_db_origin", 6, T_REQUIRED, a6);
+ t_assert("dns_db_origin", 6, T_REQUIRED, "%s", a6);
result = t_eval("dns_db_origin_data", t_dns_db_origin, 2);
t_result(result);
}
t7(void) {
int result;
- t_assert("dns_db_class", 7, T_REQUIRED, a7);
+ t_assert("dns_db_class", 7, T_REQUIRED, "%s", a7);
result = t_eval("dns_db_class_data", t_dns_db_class, 2);
t_result(result);
}
t8(void) {
int result;
- t_assert("dns_db_currentversion", 8, T_REQUIRED, a8);
+ t_assert("dns_db_currentversion", 8, T_REQUIRED, "%s", a8);
result = t_eval("dns_db_currentversion_data",
t_dns_db_currentversion, 7);
t_result(result);
t9(void) {
int result;
- t_assert("dns_db_newversion", 9, T_REQUIRED, a9);
+ t_assert("dns_db_newversion", 9, T_REQUIRED, "%s", a9);
result = t_eval("dns_db_newversion_data", t_dns_db_newversion, 7);
t_result(result);
}
t10(void) {
int result;
- t_assert("dns_db_closeversion", 10, T_REQUIRED, a10);
+ t_assert("dns_db_closeversion", 10, T_REQUIRED, "%s", a10);
result = t_eval("dns_db_closeversion_1_data",
t_dns_db_closeversion_1, 9);
t_result(result);
t11(void) {
int result;
- t_assert("dns_db_closeversion", 11, T_REQUIRED, a11);
+ t_assert("dns_db_closeversion", 11, T_REQUIRED, "%s", a11);
result = t_eval("dns_db_closeversion_2_data",
t_dns_db_closeversion_2, 9);
t_result(result);
t12(void) {
int result;
- t_assert("dns_db_expirenode", 12, T_REQUIRED, a12);
+ t_assert("dns_db_expirenode", 12, T_REQUIRED, "%s", a12);
result = t_eval("dns_db_expirenode_data", t_dns_db_expirenode, 8);
t_result(result);
}
t13(void) {
int result;
- t_assert("dns_db_findnode", 13, T_REQUIRED, a13);
+ t_assert("dns_db_findnode", 13, T_REQUIRED, "%s", a13);
result = t_eval("dns_db_findnode_1_data", t_dns_db_findnode_1, 8);
t_result(result);
}
t14(void) {
int result;
- t_assert("dns_db_findnode", 14, T_REQUIRED, a14);
+ t_assert("dns_db_findnode", 14, T_REQUIRED, "%s", a14);
result = t_eval("dns_db_findnode_2_data", t_dns_db_findnode_2, 6);
t_result(result);
}
t15(void) {
int result;
- t_assert("dns_db_find", 15, T_REQUIRED, a15);
+ t_assert("dns_db_find", 15, T_REQUIRED, "%s", a15);
result = t_eval("dns_db_find_1_data", t_dns_db_find_x, 10);
t_result(result);
}
t16(void) {
int result;
- t_assert("dns_db_find", 16, T_REQUIRED, a16);
+ t_assert("dns_db_find", 16, T_REQUIRED, "%s", a16);
result = t_eval("dns_db_find_2_data", t_dns_db_find_x, 10);
t_result(result);
}
t17(void) {
int result;
- t_assert("dns_db_find", 17, T_REQUIRED, a17);
+ t_assert("dns_db_find", 17, T_REQUIRED, "%s", a17);
result = t_eval("dns_db_find_3_data", t_dns_db_find_x, 10);
t_result(result);
}
t18(void) {
int result;
- t_assert("dns_db_find", 18, T_REQUIRED, a18);
+ t_assert("dns_db_find", 18, T_REQUIRED, "%s", a18);
result = t_eval("dns_db_find_4_data", t_dns_db_find_x, 10);
t_result(result);
}
t19(void) {
int result;
- t_assert("dns_db_find", 19, T_REQUIRED, a19);
+ t_assert("dns_db_find", 19, T_REQUIRED, "%s", a19);
result = t_eval("dns_db_find_5_data", t_dns_db_find_x, 10);
t_result(result);
}
t20(void) {
int result;
- t_assert("dns_db_find", 20, T_REQUIRED, a20);
+ t_assert("dns_db_find", 20, T_REQUIRED, "%s", a20);
result = t_eval("dns_db_find_6_data", t_dns_db_find_x, 10);
t_result(result);
}
t21(void) {
int result;
- t_assert("dns_db_find", 21, T_REQUIRED, a21);
+ t_assert("dns_db_find", 21, T_REQUIRED, "%s", a21);
result = t_eval("dns_db_find_7_data", t_dns_db_find_x, 10);
t_result(result);
}
t22(void) {
int result;
- t_assert("dns_db_find", 22, T_REQUIRED, a22);
+ t_assert("dns_db_find", 22, T_REQUIRED, "%s", a22);
result = t_eval("dns_db_find_8_data", t_dns_db_find_x, 10);
t_result(result);
}
t23(void) {
int result;
- t_assert("dns_db_find", 23, T_REQUIRED, a23);
+ t_assert("dns_db_find", 23, T_REQUIRED, "%s", a23);
result = t_eval("dns_db_find_9_data", t_dns_db_find_x, 10);
t_result(result);
}
t24(void) {
int result;
- t_assert("dns_db_find", 24, T_REQUIRED, a24);
+ t_assert("dns_db_find", 24, T_REQUIRED, "%s", a24);
result = t_eval("dns_db_find_10_data", t_dns_db_find_x, 10);
t_result(result);
}
t25(void) {
int result;
- t_assert("dns_db_load", 25, T_REQUIRED, a25);
+ t_assert("dns_db_load", 25, T_REQUIRED, "%s", a25);
result = t_eval("dns_db_load_soa_not_top", t_dns_db_load, 9);
t_result(result);
}
* PERFORMANCE OF THIS SOFTWARE.
*/
-/* $Id: t_dst.c,v 1.48.18.5 2008/01/12 23:46:06 tbox Exp $ */
+/* $Id: t_dst.c,v 1.48.18.6 2009/01/22 05:55:29 marka Exp $ */
#include <config.h>
dns_name_t *name;
isc_buffer_t b;
- t_assert("dst", 1, T_REQUIRED, a1);
+ t_assert("dst", 1, T_REQUIRED, "%s", a1);
nfails = 0;
nprobs = 0;
static void
t2(void) {
int result;
- t_assert("dst", 2, T_REQUIRED, a2);
+ t_assert("dst", 2, T_REQUIRED, "%s", a2);
result = t_eval("dst_2_data", t2_vfy, 6);
t_result(result);
}
* PERFORMANCE OF THIS SOFTWARE.
*/
-/* $Id: t_master.c,v 1.32.18.2 2005/11/30 23:52:53 marka Exp $ */
+/* $Id: t_master.c,v 1.32.18.3 2009/01/22 05:55:29 marka Exp $ */
#include <config.h>
static void
t1(void) {
int result;
- t_assert("dns_master_loadfile", 1, T_REQUIRED, a1);
+ t_assert("dns_master_loadfile", 1, T_REQUIRED, "%s", a1);
result = test_master_x("dns_master_load_1_data");
t_result(result);
}
static void
t2(void) {
int result;
- t_assert("dns_master_loadfile", 2, T_REQUIRED, a2);
+ t_assert("dns_master_loadfile", 2, T_REQUIRED, "%s", a2);
result = test_master_x("dns_master_load_2_data");
t_result(result);
}
static void
t3() {
int result;
- t_assert("dns_master_loadfile", 3, T_REQUIRED, a3);
+ t_assert("dns_master_loadfile", 3, T_REQUIRED, "%s", a3);
result = test_master_x("dns_master_load_3_data");
t_result(result);
}
static void
t4() {
int result;
- t_assert("dns_master_loadfile", 4, T_REQUIRED, a4);
+ t_assert("dns_master_loadfile", 4, T_REQUIRED, "%s", a4);
result = test_master_x("dns_master_load_4_data");
t_result(result);
}
t5() {
int result;
- t_assert("dns_master_loadfile", 5, T_REQUIRED, a5);
+ t_assert("dns_master_loadfile", 5, T_REQUIRED, "%s", a5);
result = test_master_x("dns_master_load_5_data");
t_result(result);
t6() {
int result;
- t_assert("dns_master_loadfile", 6, T_REQUIRED, a6);
+ t_assert("dns_master_loadfile", 6, T_REQUIRED, "%s", a6);
result = test_master_x("dns_master_load_6_data");
t_result(result);
t7() {
int result;
- t_assert("dns_master_loadfile", 7, T_REQUIRED, a7);
+ t_assert("dns_master_loadfile", 7, T_REQUIRED, "%s", a7);
result = test_master_x("dns_master_load_7_data");
t_result(result);
t8() {
int result;
- t_assert("dns_master_loadfile", 8, T_REQUIRED, a8);
+ t_assert("dns_master_loadfile", 8, T_REQUIRED, "%s", a8);
result = test_master_x("dns_master_load_8_data");
t_result(result);
t9() {
int result;
- t_assert("dns_master_loadfile", 9, T_REQUIRED, a9);
+ t_assert("dns_master_loadfile", 9, T_REQUIRED, "%s", a9);
result = test_master_x("dns_master_load_9_data");
t_result(result);
t10() {
int result;
- t_assert("dns_master_loadfile", 10, T_REQUIRED, a10);
+ t_assert("dns_master_loadfile", 10, T_REQUIRED, "%s", a10);
result = test_master_x("dns_master_load_10_data");
t_result(result);
t11() {
int result;
- t_assert("dns_master_loadfile", 11, T_REQUIRED, a11);
+ t_assert("dns_master_loadfile", 11, T_REQUIRED, "%s", a11);
result = test_master_x("dns_master_load_11_data");
t_result(result);
* PERFORMANCE OF THIS SOFTWARE.
*/
-/* $Id: t_mem.c,v 1.11 2004/03/05 04:58:53 marka Exp $ */
+/* $Id: t_mem.c,v 1.11.18.1 2009/01/22 05:55:29 marka Exp $ */
#include <config.h>
int rval;
int result;
- t_assert("mem", 1, T_REQUIRED, a1);
+ t_assert("mem", 1, T_REQUIRED, "%s", a1);
rval = memtest();
* PERFORMANCE OF THIS SOFTWARE.
*/
-/* $Id: t_names.c,v 1.36.18.8 2008/01/17 23:45:58 tbox Exp $ */
+/* $Id: t_names.c,v 1.36.18.9 2009/01/22 05:55:29 marka Exp $ */
#include <config.h>
unsigned char offsets[1];
rval = 0;
- t_assert("dns_name_init", 1, T_REQUIRED, a3);
+ t_assert("dns_name_init", 1, T_REQUIRED, "%s", a3);
dns_name_init(&name, offsets);
/* magic is hidden in name.c ...
dns_name_t name;
unsigned char offsets[1];
- t_assert("dns_name_invalidate", 1, T_REQUIRED, a4);
+ t_assert("dns_name_invalidate", 1, T_REQUIRED, "%s", a4);
rval = 0;
dns_name_init(&name, offsets);
dns_name_t name;
isc_buffer_t buffer;
- t_assert("dns_name_setbuffer", 1, T_REQUIRED, a5);
+ t_assert("dns_name_setbuffer", 1, T_REQUIRED, "%s", a5);
isc_buffer_init(&buffer, junk, BUFLEN);
dns_name_init(&name, NULL);
dns_name_t name;
isc_buffer_t buffer;
- t_assert("dns_name_hasbuffer", 1, T_REQUIRED, a6);
+ t_assert("dns_name_hasbuffer", 1, T_REQUIRED, "%s", a6);
rval = 0;
isc_buffer_init(&buffer, junk, BUFLEN);
char *p;
FILE *fp;
- t_assert("dns_name_isabsolute", 1, T_REQUIRED, a7);
+ t_assert("dns_name_isabsolute", 1, T_REQUIRED, "%s", a7);
result = T_UNRESOLVED;
fp = fopen("dns_name_isabsolute_data", "r");
char *p;
FILE *fp;
- t_assert("dns_name_hash", 1, T_REQUIRED, a8);
+ t_assert("dns_name_hash", 1, T_REQUIRED, "%s", a8);
result = T_UNRESOLVED;
fp = fopen("dns_name_hash_data", "r");
FILE *fp;
dns_namereln_t reln;
- t_assert("dns_name_fullcompare", 1, T_REQUIRED, a10);
+ t_assert("dns_name_fullcompare", 1, T_REQUIRED, "%s", a10);
result = T_UNRESOLVED;
fp = fopen("dns_name_fullcompare_data", "r");
char *p;
FILE *fp;
- t_assert("dns_name_compare", 1, T_REQUIRED, a23);
+ t_assert("dns_name_compare", 1, T_REQUIRED, "%s", a23);
result = T_UNRESOLVED;
fp = fopen("dns_name_compare_data", "r");
char *p;
FILE *fp;
- t_assert("dns_name_rdatacompare", 1, T_REQUIRED, a30);
+ t_assert("dns_name_rdatacompare", 1, T_REQUIRED, "%s", a30);
result = T_UNRESOLVED;
fp = fopen("dns_name_rdatacompare_data", "r");
char *p;
FILE *fp;
- t_assert("dns_name_issubdomain", 1, T_REQUIRED, a33);
+ t_assert("dns_name_issubdomain", 1, T_REQUIRED, "%s", a33);
result = T_UNRESOLVED;
fp = fopen("dns_name_issubdomain_data", "r");
char *p;
FILE *fp;
- t_assert("dns_name_countlabels", 1, T_REQUIRED, a35);
+ t_assert("dns_name_countlabels", 1, T_REQUIRED, "%s", a35);
result = T_UNRESOLVED;
fp = fopen("dns_name_countlabels_data", "r");
char *p;
FILE *fp;
- t_assert("dns_name_getlabel", 1, T_REQUIRED, a36);
+ t_assert("dns_name_getlabel", 1, T_REQUIRED, "%s", a36);
result = T_UNRESOLVED;
fp = fopen("dns_name_getlabel_data", "r");
char *p;
FILE *fp;
- t_assert("dns_name_getlabelsequence", 1, T_REQUIRED, a37);
+ t_assert("dns_name_getlabelsequence", 1, T_REQUIRED, "%s", a37);
result = T_UNRESOLVED;
fp = fopen("dns_name_getlabelsequence_data", "r");
char *p;
FILE *fp;
- t_assert("dns_name_fromregion", 1, T_REQUIRED, a38);
+ t_assert("dns_name_fromregion", 1, T_REQUIRED, "%s", a38);
result = T_UNRESOLVED;
fp = fopen("dns_name_fromregion_data", "r");
char *p;
FILE *fp;
- t_assert("dns_name_toregion", 1, T_REQUIRED, a39);
+ t_assert("dns_name_toregion", 1, T_REQUIRED, "%s", a39);
result = T_UNRESOLVED;
fp = fopen("dns_name_toregion_data", "r");
char *p;
FILE *fp;
- t_assert("dns_name_fromtext", 1, T_REQUIRED, a40);
+ t_assert("dns_name_fromtext", 1, T_REQUIRED, "%s", a40);
result = T_UNRESOLVED;
fp = fopen("dns_name_fromtext_data", "r");
char *p;
FILE *fp;
- t_assert("dns_name_totext", 1, T_REQUIRED, a41);
+ t_assert("dns_name_totext", 1, T_REQUIRED, "%s", a41);
result = T_UNRESOLVED;
fp = fopen("dns_name_totext_data", "r");
static void
t_dns_name_fromwire(void) {
- t_assert("dns_name_fromwire", 1, T_REQUIRED, a42);
+ t_assert("dns_name_fromwire", 1, T_REQUIRED, "%s", a42);
t_dns_name_fromwire_x("dns_name_fromwire_1_data", BUFLEN);
#if 0
* XXXRTH these tests appear to be broken, so I have
* disabled them.
*/
- t_assert("dns_name_fromwire", 2, T_REQUIRED, a43);
+ t_assert("dns_name_fromwire", 2, T_REQUIRED, "%s", a43);
t_dns_name_fromwire_x("dns_name_fromwire_2_data", BUFLEN);
- t_assert("dns_name_fromwire", 3, T_REQUIRED, a44);
+ t_assert("dns_name_fromwire", 3, T_REQUIRED, "%s", a44);
t_dns_name_fromwire_x("dns_name_fromwire_3_data", BUFLEN);
#endif
- t_assert("dns_name_fromwire", 4, T_REQUIRED, a45);
+ t_assert("dns_name_fromwire", 4, T_REQUIRED, "%s", a45);
t_dns_name_fromwire_x("dns_name_fromwire_4_data", BUFLEN);
- t_assert("dns_name_fromwire", 5, T_REQUIRED, a46);
+ t_assert("dns_name_fromwire", 5, T_REQUIRED, "%s", a46);
t_dns_name_fromwire_x("dns_name_fromwire_5_data", BUFLEN);
- t_assert("dns_name_fromwire", 6, T_REQUIRED, a47);
+ t_assert("dns_name_fromwire", 6, T_REQUIRED, "%s", a47);
t_dns_name_fromwire_x("dns_name_fromwire_6_data", BUFLEN);
- t_assert("dns_name_fromwire", 7, T_REQUIRED, a48);
+ t_assert("dns_name_fromwire", 7, T_REQUIRED, "%s", a48);
t_dns_name_fromwire_x("dns_name_fromwire_7_data", BUFLEN);
- t_assert("dns_name_fromwire", 9, T_REQUIRED, a49);
+ t_assert("dns_name_fromwire", 9, T_REQUIRED, "%s", a49);
t_dns_name_fromwire_x("dns_name_fromwire_8_data", 2);
}
static void
t_dns_name_towire_1(void) {
- t_assert("dns_name_towire", 1, T_REQUIRED, a51);
+ t_assert("dns_name_towire", 1, T_REQUIRED, "%s", a51);
t_dns_name_towire_x("dns_name_towire_1_data", BUFLEN);
}
static void
t_dns_name_towire_2(void) {
- t_assert("dns_name_towire", 2, T_REQUIRED, a52);
+ t_assert("dns_name_towire", 2, T_REQUIRED, "%s", a52);
t_dns_name_towire_x("dns_name_towire_2_data", 2);
}
static void
t_dns_name_concatenate(void) {
- t_assert("dns_name_concatenate", 1, T_REQUIRED, a53);
+ t_assert("dns_name_concatenate", 1, T_REQUIRED, "%s", a53);
t_result(T_UNTESTED);
}
#endif
* PERFORMANCE OF THIS SOFTWARE.
*/
-/* $Id: t_rbt.c,v 1.25.18.3 2005/11/30 23:52:53 marka Exp $ */
+/* $Id: t_rbt.c,v 1.25.18.4 2009/01/22 05:55:29 marka Exp $ */
#include <config.h>
t1() {
int result;
- t_assert("dns_rbt_create", 1, T_REQUIRED, a1);
+ t_assert("dns_rbt_create", 1, T_REQUIRED, "%s", a1);
result = test_dns_rbt_x("dns_rbt_create_1_data");
t_result(result);
}
t2() {
int result;
- t_assert("dns_rbt_addname", 2, T_REQUIRED, a2);
+ t_assert("dns_rbt_addname", 2, T_REQUIRED, "%s", a2);
result = test_dns_rbt_x("dns_rbt_addname_1_data");
t_result(result);
}
t3() {
int result;
- t_assert("dns_rbt_addname", 3, T_REQUIRED, a3);
+ t_assert("dns_rbt_addname", 3, T_REQUIRED, "%s", a3);
result = test_dns_rbt_x("dns_rbt_addname_2_data");
t_result(result);
}
t4() {
int result;
- t_assert("dns_rbt_deletename", 4, T_REQUIRED, a4);
+ t_assert("dns_rbt_deletename", 4, T_REQUIRED, "%s", a4);
result = test_dns_rbt_x("dns_rbt_deletename_1_data");
t_result(result);
}
t5() {
int result;
- t_assert("dns_rbt_deletename", 5, T_REQUIRED, a5);
+ t_assert("dns_rbt_deletename", 5, T_REQUIRED, "%s", a5);
result = test_dns_rbt_x("dns_rbt_deletename_2_data");
t_result(result);
}
t6() {
int result;
- t_assert("dns_rbt_findname", 6, T_REQUIRED, a6);
+ t_assert("dns_rbt_findname", 6, T_REQUIRED, "%s", a6);
result = test_dns_rbt_x("dns_rbt_findname_1_data");
t_result(result);
}
t7() {
int result;
- t_assert("dns_rbt_findname", 7, T_REQUIRED, a7);
+ t_assert("dns_rbt_findname", 7, T_REQUIRED, "%s", a7);
result = test_dns_rbt_x("dns_rbt_findname_2_data");
t_result(result);
}
t8() {
int result;
- t_assert("dns_rbt_findname", 8, T_REQUIRED, a8);
+ t_assert("dns_rbt_findname", 8, T_REQUIRED, "%s", a8);
result = test_dns_rbt_x("dns_rbt_findname_3_data");
t_result(result);
}
t9() {
int result;
- t_assert("dns_rbtnodechain_init", 9, T_REQUIRED, a9);
+ t_assert("dns_rbtnodechain_init", 9, T_REQUIRED, "%s", a9);
result = test_dns_rbtnodechain_init("dns_rbtnodechain_init_data");
t_result(result);
}
t10() {
int result;
- t_assert("dns_rbtnodechain_first", 10, T_REQUIRED, a10);
+ t_assert("dns_rbtnodechain_first", 10, T_REQUIRED, "%s", a10);
result = test_dns_rbtnodechain_first("dns_rbtnodechain_first_data");
t_result(result);
}
t11() {
int result;
- t_assert("dns_rbtnodechain_last", 11, T_REQUIRED, a11);
+ t_assert("dns_rbtnodechain_last", 11, T_REQUIRED, "%s", a11);
result = test_dns_rbtnodechain_last("dns_rbtnodechain_last_data");
t_result(result);
}
t12() {
int result;
- t_assert("dns_rbtnodechain_next", 12, T_REQUIRED, a12);
+ t_assert("dns_rbtnodechain_next", 12, T_REQUIRED, "%s", a12);
result = test_dns_rbtnodechain_next("dns_rbtnodechain_next_data");
t_result(result);
}
t13() {
int result;
- t_assert("dns_rbtnodechain_prev", 13, T_REQUIRED, a13);
+ t_assert("dns_rbtnodechain_prev", 13, T_REQUIRED, "%s", a13);
result = test_dns_rbtnodechain_prev("dns_rbtnodechain_prev_data");
t_result(result);
}
* PERFORMANCE OF THIS SOFTWARE.
*/
-/* $Id: t_tasks.c,v 1.32.18.6 2005/11/30 03:44:39 marka Exp $ */
+/* $Id: t_tasks.c,v 1.32.18.7 2009/01/22 05:55:29 marka Exp $ */
#include <config.h>
t1(void) {
int result;
- t_assert("tasks", 1, T_REQUIRED, a1);
+ t_assert("tasks", 1, T_REQUIRED, "%s", a1);
result = t_tasks1();
t_result(result);
}
static void
t2(void) {
- t_assert("tasks", 2, T_REQUIRED, a2);
+ t_assert("tasks", 2, T_REQUIRED, "%s", a2);
if (threaded)
t_result(t_tasks2());
"LIFO order.";
static void
t3(void) {
- t_assert("tasks", 3, T_REQUIRED, a3);
+ t_assert("tasks", 3, T_REQUIRED, "%s", a3);
if (threaded)
t_result(t_tasks3());
static void
t4(void) {
- t_assert("tasks", 4, T_REQUIRED, a4);
+ t_assert("tasks", 4, T_REQUIRED, "%s", a4);
if (threaded)
t_result(t_tasks4());
static void
t7(void) {
- t_assert("tasks", 7, T_REQUIRED, a7);
+ t_assert("tasks", 7, T_REQUIRED, "%s", a7);
if (threaded)
t_result(t_tasks7());
static void
t10(void) {
- t_assert("tasks", 10, T_REQUIRED, a10);
+ t_assert("tasks", 10, T_REQUIRED, "%s", a10);
if (threaded)
t_result(t_tasks10());
static void
t11(void) {
- t_assert("tasks", 11, T_REQUIRED, a11);
+ t_assert("tasks", 11, T_REQUIRED, "%s", a11);
if (threaded)
t_result(t_tasks11(1));
static void
t12(void) {
- t_assert("tasks", 12, T_REQUIRED, a12);
+ t_assert("tasks", 12, T_REQUIRED, "%s", a12);
if (threaded)
t_result(t_tasks12());
static void
t13(void) {
- t_assert("tasks", 13, T_REQUIRED, a13);
+ t_assert("tasks", 13, T_REQUIRED, "%s", a13);
if (threaded)
t_result(t_tasks13());
t14(void) {
int result;
- t_assert("tasks", 14, T_REQUIRED,
+ t_assert("tasks", 14, T_REQUIRED, "%s",
"isc_task_beginexclusive() gets exclusive access");
result = t_tasks14();
t_result(result);
* PERFORMANCE OF THIS SOFTWARE.
*/
-/* $Id: t_timers.c,v 1.23.18.3 2008/01/12 23:46:06 tbox Exp $ */
+/* $Id: t_timers.c,v 1.23.18.4 2009/01/22 05:55:29 marka Exp $ */
#include <config.h>
isc_time_t expires;
isc_interval_t interval;
- t_assert("isc_timer_create", 1, T_REQUIRED, a1);
+ t_assert("isc_timer_create", 1, T_REQUIRED, "%s", a1);
if (threaded) {
Tx_nfails = 0;
isc_time_t expires;
isc_interval_t interval;
- t_assert("isc_timer_create", 2, T_REQUIRED, a2);
+ t_assert("isc_timer_create", 2, T_REQUIRED, "%s", a2);
if (threaded) {
Tx_nfails = 0;
isc_time_t expires;
isc_interval_t interval;
- t_assert("isc_timer_create", 3, T_REQUIRED, a3);
+ t_assert("isc_timer_create", 3, T_REQUIRED, "%s", a3);
if (threaded) {
Tx_nfails = 0;
isc_time_t expires;
isc_interval_t interval;
- t_assert("isc_timer_reset", 4, T_REQUIRED, a4);
+ t_assert("isc_timer_reset", 4, T_REQUIRED, "%s", a4);
if (threaded) {
Tx_nfails = 0;
static void
t5(void) {
- t_assert("isc_timer_reset", 5, T_REQUIRED, a5);
+ t_assert("isc_timer_reset", 5, T_REQUIRED, "%s", a5);
if (threaded)
t_result(t_timers5());
* PERFORMANCE OF THIS SOFTWARE.
*/
-/* $Id: mem.c,v 1.116.18.21 2008/02/07 23:45:56 tbox Exp $ */
+/* $Id: mem.c,v 1.116.18.22 2009/01/22 05:55:29 marka Exp $ */
/*! \file */
const char *format;
isc_boolean_t found;
- fprintf(out, isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
+ fprintf(out, "%s", isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
ISC_MSG_DUMPALLOC,
"Dump of all outstanding "
"memory allocations:\n"));
}
}
if (!found)
- fprintf(out, isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
+ fprintf(out, "%s", isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
ISC_MSG_NONE, "\tNone.\n"));
}
}
*/
pool = ISC_LIST_HEAD(ctx->pools);
if (pool != NULL) {
- fprintf(out, isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
+ fprintf(out, "%s", isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
ISC_MSG_POOLSTATS,
"[Pool statistics]\n"));
fprintf(out, "%15s %10s %10s %10s %10s %10s %10s %10s %1s\n",
* PERFORMANCE OF THIS SOFTWARE.
*/
-/* $Id: timer.c,v 1.73.18.10 2008/08/22 05:59:04 marka Exp $ */
+/* $Id: timer.c,v 1.73.18.11 2009/01/22 05:55:29 marka Exp $ */
/*! \file */
isc_task_send(timer->task,
ISC_EVENT_PTR(&event));
} else
- UNEXPECTED_ERROR(__FILE__, __LINE__,
+ UNEXPECTED_ERROR(__FILE__, __LINE__, "%s",
isc_msgcat_get(isc_msgcat,
ISC_MSGSET_TIMER,
ISC_MSG_EVENTNOTALLOC,
if (need_schedule) {
result = schedule(timer, now, ISC_FALSE);
if (result != ISC_R_SUCCESS)
- UNEXPECTED_ERROR(__FILE__, __LINE__,
+ UNEXPECTED_ERROR(__FILE__, __LINE__, "%s",
isc_msgcat_get(isc_msgcat,
ISC_MSGSET_TIMER,
ISC_MSG_SCHEDFAIL,
* PERFORMANCE OF THIS SOFTWARE.
*/
-/* $Id: socket.c,v 1.237.18.63 2009/01/19 23:46:17 tbox Exp $ */
+/* $Id: socket.c,v 1.237.18.64 2009/01/22 05:55:29 marka Exp $ */
/*! \file */
#endif
}
- manager_log(manager, TRACE,
+ manager_log(manager, TRACE, "%s",
isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
ISC_MSG_EXITING, "watcher exiting"));
* Wait for all sockets to be destroyed.
*/
while (!ISC_LIST_EMPTY(manager->socklist)) {
- manager_log(manager, CREATION,
+ manager_log(manager, CREATION, "%s",
isc_msgcat_get(isc_msgcat, ISC_MSGSET_SOCKET,
ISC_MSG_SOCKETSREMAIN,
"sockets exist"));
* Hope all sockets have been destroyed.
*/
if (!ISC_LIST_EMPTY(manager->socklist)) {
- manager_log(manager, CREATION,
+ manager_log(manager, CREATION, "%s",
isc_msgcat_get(isc_msgcat, ISC_MSGSET_SOCKET,
ISC_MSG_SOCKETSREMAIN,
"sockets exist"));