1 files changed, 180 insertions, 179 deletions
diff --git a/src/my/test_my.c b/src/my/test_my.c
index d9dcc71f9..c639fcfdd 100644
--- a/src/my/test_my.c
+++ b/src/my/test_my.c
@@ -36,17 +36,18 @@
 * @return 0 on succes
 */
 static int
-run_queries(struct GNUNET_MYSQL_Context *context)
+run_queries (struct GNUNET_MYSQL_Context *context)
 {
  struct GNUNET_CRYPTO_RsaPublicKey *pub = NULL;
  struct GNUNET_CRYPTO_RsaPublicKey *pub2 = NULL;
  struct GNUNET_CRYPTO_RsaSignature *sig = NULL;;
  struct GNUNET_CRYPTO_RsaSignature *sig2 = NULL;
-  struct GNUNET_TIME_Absolute abs_time = GNUNET_TIME_absolute_get();
+  struct GNUNET_TIME_Absolute abs_time = GNUNET_TIME_absolute_get ();
  struct GNUNET_TIME_Absolute abs_time2;
  struct GNUNET_TIME_Absolute forever = GNUNET_TIME_UNIT_FOREVER_ABS;
  struct GNUNET_TIME_Absolute forever2;
-  const struct GNUNET_TIME_AbsoluteNBO abs_time_nbo = GNUNET_TIME_absolute_hton(abs_time);
+  const struct GNUNET_TIME_AbsoluteNBO abs_time_nbo =
+    GNUNET_TIME_absolute_hton (abs_time);
  struct GNUNET_HashCode hc;
  struct GNUNET_HashCode hc2;
  const char msg[] = "hello";
@@ -71,163 +72,163 @@ run_queries(struct GNUNET_MYSQL_Context *context)
  struct GNUNET_CRYPTO_RsaPrivateKey *priv = NULL;
  struct GNUNET_HashCode hmsg;
-  priv = GNUNET_CRYPTO_rsa_private_key_create(1024);
+  priv = GNUNET_CRYPTO_rsa_private_key_create (1024);
-  pub = GNUNET_CRYPTO_rsa_private_key_get_public(priv);
+  pub = GNUNET_CRYPTO_rsa_private_key_get_public (priv);
-  memset(&hmsg, 42, sizeof(hmsg));
+  memset (&hmsg, 42, sizeof(hmsg));
-  sig = GNUNET_CRYPTO_rsa_sign_fdh(priv,
+  sig = GNUNET_CRYPTO_rsa_sign_fdh (priv,
-                                   &hmsg);
+                                    &hmsg);
  u16 = 16;
  u32 = 32;
  u64 = UINT64_MAX;
-  memset(&hc, 0, sizeof(hc));
+  memset (&hc, 0, sizeof(hc));
-  memset(&hc2, 0, sizeof(hc2));
+  memset (&hc2, 0, sizeof(hc2));
  statements_handle_insert
-    = GNUNET_MYSQL_statement_prepare(context,
+    = GNUNET_MYSQL_statement_prepare (context,
-                                     "INSERT INTO test_my2 ("
+                                      "INSERT INTO test_my2 ("
-                                     " pub"
+                                      " pub"
-                                     ",sig"
+                                      ",sig"
-                                     ",abs_time"
+                                      ",abs_time"
-                                     ",forever"
+                                      ",forever"
-                                     ",abs_time_nbo"
+                                      ",abs_time_nbo"
-                                     ",hash"
+                                      ",hash"
-                                     ",vsize"
+                                      ",vsize"
-                                     ",str"
+                                      ",str"
-                                     ",u16"
+                                      ",u16"
-                                     ",u32"
+                                      ",u32"
-                                     ",u64"
+                                      ",u64"
-                                     ") VALUES "
+                                      ") VALUES "
-                                     "( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+                                      "( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
  if (NULL == statements_handle_insert)
-    {
+  {
-      fprintf(stderr, "Failed to prepared statement INSERT\n");
+    fprintf (stderr, "Failed to prepared statement INSERT\n");
-      GNUNET_CRYPTO_rsa_signature_free(sig);
+    GNUNET_CRYPTO_rsa_signature_free (sig);
-      GNUNET_CRYPTO_rsa_private_key_free(priv);
+    GNUNET_CRYPTO_rsa_private_key_free (priv);
-      GNUNET_CRYPTO_rsa_public_key_free(pub);
+    GNUNET_CRYPTO_rsa_public_key_free (pub);
-      return 1;
+    return 1;
-    }
+  }
  struct GNUNET_MY_QueryParam params_insert[] = {
-    GNUNET_MY_query_param_rsa_public_key(pub),
+    GNUNET_MY_query_param_rsa_public_key (pub),
-    GNUNET_MY_query_param_rsa_signature(sig),
+    GNUNET_MY_query_param_rsa_signature (sig),
-    GNUNET_MY_query_param_absolute_time(&abs_time),
+    GNUNET_MY_query_param_absolute_time (&abs_time),
-    GNUNET_MY_query_param_absolute_time(&forever),
+    GNUNET_MY_query_param_absolute_time (&forever),
-    GNUNET_MY_query_param_absolute_time_nbo(&abs_time_nbo),
+    GNUNET_MY_query_param_absolute_time_nbo (&abs_time_nbo),
-    GNUNET_MY_query_param_auto_from_type(&hc),
+    GNUNET_MY_query_param_auto_from_type (&hc),
-    GNUNET_MY_query_param_fixed_size(msg, strlen(msg)),
+    GNUNET_MY_query_param_fixed_size (msg, strlen (msg)),
-    GNUNET_MY_query_param_string(msg3),
+    GNUNET_MY_query_param_string (msg3),
-    GNUNET_MY_query_param_uint16(&u16),
+    GNUNET_MY_query_param_uint16 (&u16),
-    GNUNET_MY_query_param_uint32(&u32),
+    GNUNET_MY_query_param_uint32 (&u32),
-    GNUNET_MY_query_param_uint64(&u64),
+    GNUNET_MY_query_param_uint64 (&u64),
    GNUNET_MY_query_param_end
  };
-  if (GNUNET_OK != GNUNET_MY_exec_prepared(context,
+  if (GNUNET_OK != GNUNET_MY_exec_prepared (context,
-                                           statements_handle_insert,
+                                            statements_handle_insert,
-                                           params_insert))
+                                            params_insert))
-    {
+  {
-      fprintf(stderr, "Failed to execute prepared statement INSERT\n");
+    fprintf (stderr, "Failed to execute prepared statement INSERT\n");
-      GNUNET_CRYPTO_rsa_signature_free(sig);
+    GNUNET_CRYPTO_rsa_signature_free (sig);
-      GNUNET_CRYPTO_rsa_private_key_free(priv);
+    GNUNET_CRYPTO_rsa_private_key_free (priv);
-      GNUNET_CRYPTO_rsa_public_key_free(pub);
+    GNUNET_CRYPTO_rsa_public_key_free (pub);
-      return 1;
+    return 1;
-    }
+  }
  statements_handle_select
-    = GNUNET_MYSQL_statement_prepare(context,
+    = GNUNET_MYSQL_statement_prepare (context,
-                                     "SELECT"
+                                      "SELECT"
-                                     " pub"
+                                      " pub"
-                                     ",sig"
+                                      ",sig"
-                                     ",abs_time"
+                                      ",abs_time"
-                                     ",forever"
+                                      ",forever"
-                                     ",hash"
+                                      ",hash"
-                                     ",vsize"
+                                      ",vsize"
-                                     ",str"
+                                      ",str"
-                                     ",u16"
+                                      ",u16"
-                                     ",u32"
+                                      ",u32"
-                                     ",u64"
+                                      ",u64"
-                                     " FROM test_my2");
+                                      " FROM test_my2");
  if (NULL == statements_handle_select)
-    {
+  {
-      fprintf(stderr, "Failed to prepared statement SELECT\n");
+    fprintf (stderr, "Failed to prepared statement SELECT\n");
-      GNUNET_CRYPTO_rsa_signature_free(sig);
+    GNUNET_CRYPTO_rsa_signature_free (sig);
-      GNUNET_CRYPTO_rsa_private_key_free(priv);
+    GNUNET_CRYPTO_rsa_private_key_free (priv);
-      GNUNET_CRYPTO_rsa_public_key_free(pub);
+    GNUNET_CRYPTO_rsa_public_key_free (pub);
-      return 1;
+    return 1;
-    }
+  }
  struct GNUNET_MY_QueryParam params_select[] = {
    GNUNET_MY_query_param_end
  };
-  if (GNUNET_OK != GNUNET_MY_exec_prepared(context,
+  if (GNUNET_OK != GNUNET_MY_exec_prepared (context,
-                                           statements_handle_select,
+                                            statements_handle_select,
-                                           params_select))
+                                            params_select))
-    {
+  {
-      fprintf(stderr, "Failed to execute prepared statement SELECT\n");
+    fprintf (stderr, "Failed to execute prepared statement SELECT\n");
-      GNUNET_CRYPTO_rsa_signature_free(sig);
+    GNUNET_CRYPTO_rsa_signature_free (sig);
-      GNUNET_CRYPTO_rsa_private_key_free(priv);
+    GNUNET_CRYPTO_rsa_private_key_free (priv);
-      GNUNET_CRYPTO_rsa_public_key_free(pub);
+    GNUNET_CRYPTO_rsa_public_key_free (pub);
-      return 1;
+    return 1;
-    }
+  }
  struct GNUNET_MY_ResultSpec results_select[] = {
-    GNUNET_MY_result_spec_rsa_public_key(&pub2),
+    GNUNET_MY_result_spec_rsa_public_key (&pub2),
-    GNUNET_MY_result_spec_rsa_signature(&sig2),
+    GNUNET_MY_result_spec_rsa_signature (&sig2),
-    GNUNET_MY_result_spec_absolute_time(&abs_time2),
+    GNUNET_MY_result_spec_absolute_time (&abs_time2),
-    GNUNET_MY_result_spec_absolute_time(&forever2),
+    GNUNET_MY_result_spec_absolute_time (&forever2),
-    GNUNET_MY_result_spec_auto_from_type(&hc2),
+    GNUNET_MY_result_spec_auto_from_type (&hc2),
-    GNUNET_MY_result_spec_variable_size(&msg2, &msg2_len),
+    GNUNET_MY_result_spec_variable_size (&msg2, &msg2_len),
-    GNUNET_MY_result_spec_string(&msg4),
+    GNUNET_MY_result_spec_string (&msg4),
-    GNUNET_MY_result_spec_uint16(&u162),
+    GNUNET_MY_result_spec_uint16 (&u162),
-    GNUNET_MY_result_spec_uint32(&u322),
+    GNUNET_MY_result_spec_uint32 (&u322),
-    GNUNET_MY_result_spec_uint64(&u642),
+    GNUNET_MY_result_spec_uint64 (&u642),
    GNUNET_MY_result_spec_end
  };
-  ret = GNUNET_MY_extract_result(statements_handle_select,
+  ret = GNUNET_MY_extract_result (statements_handle_select,
-                                 results_select);
+                                  results_select);
-  GNUNET_assert(GNUNET_YES == ret);
+  GNUNET_assert (GNUNET_YES == ret);
-  GNUNET_break(abs_time.abs_value_us == abs_time2.abs_value_us);
+  GNUNET_break (abs_time.abs_value_us == abs_time2.abs_value_us);
-  GNUNET_break(forever.abs_value_us == forever2.abs_value_us);
+  GNUNET_break (forever.abs_value_us == forever2.abs_value_us);
-  GNUNET_break(0 ==
+  GNUNET_break (0 ==
-               memcmp(&hc,
+                memcmp (&hc,
-                      &hc2,
+                        &hc2,
-                      sizeof(struct GNUNET_HashCode)));
+                        sizeof(struct GNUNET_HashCode)));
-  GNUNET_assert(NULL != sig2);
+  GNUNET_assert (NULL != sig2);
-  GNUNET_assert(NULL != pub2);
+  GNUNET_assert (NULL != pub2);
-  GNUNET_break(0 ==
+  GNUNET_break (0 ==
-               GNUNET_CRYPTO_rsa_signature_cmp(sig,
+                GNUNET_CRYPTO_rsa_signature_cmp (sig,
-                                               sig2));
+                                                 sig2));
-  GNUNET_break(0 ==
+  GNUNET_break (0 ==
-               GNUNET_CRYPTO_rsa_public_key_cmp(pub,
+                GNUNET_CRYPTO_rsa_public_key_cmp (pub,
-                                                pub2));
+                                                  pub2));
-  GNUNET_break(strlen(msg) == msg2_len);
+  GNUNET_break (strlen (msg) == msg2_len);
-  GNUNET_break(0 ==
+  GNUNET_break (0 ==
-               strncmp(msg,
+                strncmp (msg,
-                       msg2,
+                         msg2,
-                       msg2_len));
+                         msg2_len));
-  GNUNET_break(strlen(msg3) == strlen(msg4));
+  GNUNET_break (strlen (msg3) == strlen (msg4));
-  GNUNET_break(0 ==
+  GNUNET_break (0 ==
-               strcmp(msg3,
+                strcmp (msg3,
-                      msg4));
+                        msg4));
-  GNUNET_break(16 == u162);
+  GNUNET_break (16 == u162);
-  GNUNET_break(32 == u322);
+  GNUNET_break (32 == u322);
-  GNUNET_break(UINT64_MAX == u642);
+  GNUNET_break (UINT64_MAX == u642);
-  GNUNET_MY_cleanup_result(results_select);
+  GNUNET_MY_cleanup_result (results_select);
-  GNUNET_CRYPTO_rsa_signature_free(sig);
+  GNUNET_CRYPTO_rsa_signature_free (sig);
-  GNUNET_CRYPTO_rsa_private_key_free(priv);
+  GNUNET_CRYPTO_rsa_private_key_free (priv);
-  GNUNET_CRYPTO_rsa_public_key_free(pub);
+  GNUNET_CRYPTO_rsa_public_key_free (pub);
  if (GNUNET_OK != ret)
    return 1;
@@ -237,63 +238,63 @@ run_queries(struct GNUNET_MYSQL_Context *context)
 int
-main(int argc, const char *const argv[])
+main (int argc, const char *const argv[])
 {
  struct GNUNET_CONFIGURATION_Handle *config;
  struct GNUNET_MYSQL_Context *context;
  int ret;
-  GNUNET_log_setup("test-my",
+  GNUNET_log_setup ("test-my",
-                   "WARNING",
+                    "WARNING",
-                   NULL);
+                    NULL);
-  config = GNUNET_CONFIGURATION_create();
+  config = GNUNET_CONFIGURATION_create ();
  if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_parse(config, "test_my.conf"))
+      GNUNET_CONFIGURATION_parse (config, "test_my.conf"))
-    {
+  {
-      fprintf(stderr, "Failed to parse configuaration\n");
+    fprintf (stderr, "Failed to parse configuaration\n");
-      return 1;
+    return 1;
-    }
+  }
-  context = GNUNET_MYSQL_context_create(config,
+  context = GNUNET_MYSQL_context_create (config,
-                                        "datastore-mysql");
+                                         "datastore-mysql");
  if (NULL == context)
-    {
+  {
-      fprintf(stderr, "Failed to connect to database\n");
+    fprintf (stderr, "Failed to connect to database\n");
-      return 77;
+    return 77;
-    }
+  }
-  (void)GNUNET_MYSQL_statement_run(context,
+  (void) GNUNET_MYSQL_statement_run (context,
-                                   "DROP TABLE test_my2;");
+                                     "DROP TABLE test_my2;");
  if (GNUNET_OK !=
-      GNUNET_MYSQL_statement_run(context,
+      GNUNET_MYSQL_statement_run (context,
-                                 "CREATE TABLE IF NOT EXISTS test_my2("
+                                  "CREATE TABLE IF NOT EXISTS test_my2("
-                                 " pub BLOB NOT NULL"
+                                  " pub BLOB NOT NULL"
-                                 ",sig BLOB NOT NULL"
+                                  ",sig BLOB NOT NULL"
-                                 ",abs_time BIGINT NOT NULL"
+                                  ",abs_time BIGINT NOT NULL"
-                                 ",forever BIGINT NOT NULL"
+                                  ",forever BIGINT NOT NULL"
-                                 ",abs_time_nbo BIGINT NOT NULL"
+                                  ",abs_time_nbo BIGINT NOT NULL"
-                                 ",hash BLOB NOT NULL CHECK(LENGTH(hash)=64)"
+                                  ",hash BLOB NOT NULL CHECK(LENGTH(hash)=64)"
-                                 ",vsize BLOB NOT NULL"
+                                  ",vsize BLOB NOT NULL"
-                                 ",str BLOB NOT NULL"
+                                  ",str BLOB NOT NULL"
-                                 ",u16 SMALLINT NOT NULL"
+                                  ",u16 SMALLINT NOT NULL"
-                                 ",u32 INT NOT NULL"
+                                  ",u32 INT NOT NULL"
-                                 ",u64 BIGINT NOT NULL"
+                                  ",u64 BIGINT NOT NULL"
-                                 ")"))
+                                  ")"))
-    {
+  {
-      fprintf(stderr,
+    fprintf (stderr,
-              "Failed to create table. Database likely not setup correctly.\n");
+             "Failed to create table. Database likely not setup correctly.\n");
-      GNUNET_MYSQL_statements_invalidate(context);
+    GNUNET_MYSQL_statements_invalidate (context);
-      GNUNET_MYSQL_context_destroy(context);
+    GNUNET_MYSQL_context_destroy (context);
-      return 77;
+    return 77;
-    }
+  }
-  ret = run_queries(context);
+  ret = run_queries (context);
-  GNUNET_MYSQL_context_destroy(context);
+  GNUNET_MYSQL_context_destroy (context);
-  GNUNET_free(config);
+  GNUNET_free (config);
  return ret;
 }

diff --git a/src/my/test_my.c b/src/my/test_my.c index d9dcc71f9..c639fcfdd 100644 --- a/src/my/test_my.c +++ b/src/my/test_my.c
@@ -36,17 +36,18 @@
36	* @return 0 on succes	36	* @return 0 on succes
37	*/	37	*/
38	static int	38	static int
39	run_queries(struct GNUNET_MYSQL_Context *context)	39	run_queries (struct GNUNET_MYSQL_Context *context)
40	{	40	{
41	struct GNUNET_CRYPTO_RsaPublicKey *pub = NULL;	41	struct GNUNET_CRYPTO_RsaPublicKey *pub = NULL;
42	struct GNUNET_CRYPTO_RsaPublicKey *pub2 = NULL;	42	struct GNUNET_CRYPTO_RsaPublicKey *pub2 = NULL;
43	struct GNUNET_CRYPTO_RsaSignature *sig = NULL;;	43	struct GNUNET_CRYPTO_RsaSignature *sig = NULL;;
44	struct GNUNET_CRYPTO_RsaSignature *sig2 = NULL;	44	struct GNUNET_CRYPTO_RsaSignature *sig2 = NULL;
45	struct GNUNET_TIME_Absolute abs_time = GNUNET_TIME_absolute_get();	45	struct GNUNET_TIME_Absolute abs_time = GNUNET_TIME_absolute_get ();
46	struct GNUNET_TIME_Absolute abs_time2;	46	struct GNUNET_TIME_Absolute abs_time2;
47	struct GNUNET_TIME_Absolute forever = GNUNET_TIME_UNIT_FOREVER_ABS;	47	struct GNUNET_TIME_Absolute forever = GNUNET_TIME_UNIT_FOREVER_ABS;
48	struct GNUNET_TIME_Absolute forever2;	48	struct GNUNET_TIME_Absolute forever2;
49	const struct GNUNET_TIME_AbsoluteNBO abs_time_nbo = GNUNET_TIME_absolute_hton(abs_time);	49	const struct GNUNET_TIME_AbsoluteNBO abs_time_nbo =
		50	GNUNET_TIME_absolute_hton (abs_time);
50	struct GNUNET_HashCode hc;	51	struct GNUNET_HashCode hc;
51	struct GNUNET_HashCode hc2;	52	struct GNUNET_HashCode hc2;
52	const char msg[] = "hello";	53	const char msg[] = "hello";
@@ -71,163 +72,163 @@ run_queries(struct GNUNET_MYSQL_Context *context)
71	struct GNUNET_CRYPTO_RsaPrivateKey *priv = NULL;	72	struct GNUNET_CRYPTO_RsaPrivateKey *priv = NULL;
72	struct GNUNET_HashCode hmsg;	73	struct GNUNET_HashCode hmsg;
73		74
74	priv = GNUNET_CRYPTO_rsa_private_key_create(1024);	75	priv = GNUNET_CRYPTO_rsa_private_key_create (1024);
75	pub = GNUNET_CRYPTO_rsa_private_key_get_public(priv);	76	pub = GNUNET_CRYPTO_rsa_private_key_get_public (priv);
76	memset(&hmsg, 42, sizeof(hmsg));	77	memset (&hmsg, 42, sizeof(hmsg));
77	sig = GNUNET_CRYPTO_rsa_sign_fdh(priv,	78	sig = GNUNET_CRYPTO_rsa_sign_fdh (priv,
78	&hmsg);	79	&hmsg);
79	u16 = 16;	80	u16 = 16;
80	u32 = 32;	81	u32 = 32;
81	u64 = UINT64_MAX;	82	u64 = UINT64_MAX;
82		83
83	memset(&hc, 0, sizeof(hc));	84	memset (&hc, 0, sizeof(hc));
84	memset(&hc2, 0, sizeof(hc2));	85	memset (&hc2, 0, sizeof(hc2));
85		86
86	statements_handle_insert	87	statements_handle_insert
87	= GNUNET_MYSQL_statement_prepare(context,	88	= GNUNET_MYSQL_statement_prepare (context,
88	"INSERT INTO test_my2 ("	89	"INSERT INTO test_my2 ("
89	" pub"	90	" pub"
90	",sig"	91	",sig"
91	",abs_time"	92	",abs_time"
92	",forever"	93	",forever"
93	",abs_time_nbo"	94	",abs_time_nbo"
94	",hash"	95	",hash"
95	",vsize"	96	",vsize"
96	",str"	97	",str"
97	",u16"	98	",u16"
98	",u32"	99	",u32"
99	",u64"	100	",u64"
100	") VALUES "	101	") VALUES "
101	"( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");	102	"( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
102		103
103	if (NULL == statements_handle_insert)	104	if (NULL == statements_handle_insert)
104	{	105	{
105	fprintf(stderr, "Failed to prepared statement INSERT\n");	106	fprintf (stderr, "Failed to prepared statement INSERT\n");
106	GNUNET_CRYPTO_rsa_signature_free(sig);	107	GNUNET_CRYPTO_rsa_signature_free (sig);
107	GNUNET_CRYPTO_rsa_private_key_free(priv);	108	GNUNET_CRYPTO_rsa_private_key_free (priv);
108	GNUNET_CRYPTO_rsa_public_key_free(pub);	109	GNUNET_CRYPTO_rsa_public_key_free (pub);
109	return 1;	110	return 1;
110	}	111	}
111		112
112	struct GNUNET_MY_QueryParam params_insert[] = {	113	struct GNUNET_MY_QueryParam params_insert[] = {
113	GNUNET_MY_query_param_rsa_public_key(pub),	114	GNUNET_MY_query_param_rsa_public_key (pub),
114	GNUNET_MY_query_param_rsa_signature(sig),	115	GNUNET_MY_query_param_rsa_signature (sig),
115	GNUNET_MY_query_param_absolute_time(&abs_time),	116	GNUNET_MY_query_param_absolute_time (&abs_time),
116	GNUNET_MY_query_param_absolute_time(&forever),	117	GNUNET_MY_query_param_absolute_time (&forever),
117	GNUNET_MY_query_param_absolute_time_nbo(&abs_time_nbo),	118	GNUNET_MY_query_param_absolute_time_nbo (&abs_time_nbo),
118	GNUNET_MY_query_param_auto_from_type(&hc),	119	GNUNET_MY_query_param_auto_from_type (&hc),
119	GNUNET_MY_query_param_fixed_size(msg, strlen(msg)),	120	GNUNET_MY_query_param_fixed_size (msg, strlen (msg)),
120	GNUNET_MY_query_param_string(msg3),	121	GNUNET_MY_query_param_string (msg3),
121	GNUNET_MY_query_param_uint16(&u16),	122	GNUNET_MY_query_param_uint16 (&u16),
122	GNUNET_MY_query_param_uint32(&u32),	123	GNUNET_MY_query_param_uint32 (&u32),
123	GNUNET_MY_query_param_uint64(&u64),	124	GNUNET_MY_query_param_uint64 (&u64),
124	GNUNET_MY_query_param_end	125	GNUNET_MY_query_param_end
125	};	126	};
126		127
127	if (GNUNET_OK != GNUNET_MY_exec_prepared(context,	128	if (GNUNET_OK != GNUNET_MY_exec_prepared (context,
128	statements_handle_insert,	129	statements_handle_insert,
129	params_insert))	130	params_insert))
130	{	131	{
131	fprintf(stderr, "Failed to execute prepared statement INSERT\n");	132	fprintf (stderr, "Failed to execute prepared statement INSERT\n");
132	GNUNET_CRYPTO_rsa_signature_free(sig);	133	GNUNET_CRYPTO_rsa_signature_free (sig);
133	GNUNET_CRYPTO_rsa_private_key_free(priv);	134	GNUNET_CRYPTO_rsa_private_key_free (priv);
134	GNUNET_CRYPTO_rsa_public_key_free(pub);	135	GNUNET_CRYPTO_rsa_public_key_free (pub);
135	return 1;	136	return 1;
136	}	137	}
137		138
138	statements_handle_select	139	statements_handle_select
139	= GNUNET_MYSQL_statement_prepare(context,	140	= GNUNET_MYSQL_statement_prepare (context,
140	"SELECT"	141	"SELECT"
141	" pub"	142	" pub"
142	",sig"	143	",sig"
143	",abs_time"	144	",abs_time"
144	",forever"	145	",forever"
145	",hash"	146	",hash"
146	",vsize"	147	",vsize"
147	",str"	148	",str"
148	",u16"	149	",u16"
149	",u32"	150	",u32"
150	",u64"	151	",u64"
151	" FROM test_my2");	152	" FROM test_my2");
152		153
153	if (NULL == statements_handle_select)	154	if (NULL == statements_handle_select)
154	{	155	{
155	fprintf(stderr, "Failed to prepared statement SELECT\n");	156	fprintf (stderr, "Failed to prepared statement SELECT\n");
156	GNUNET_CRYPTO_rsa_signature_free(sig);	157	GNUNET_CRYPTO_rsa_signature_free (sig);
157	GNUNET_CRYPTO_rsa_private_key_free(priv);	158	GNUNET_CRYPTO_rsa_private_key_free (priv);
158	GNUNET_CRYPTO_rsa_public_key_free(pub);	159	GNUNET_CRYPTO_rsa_public_key_free (pub);
159	return 1;	160	return 1;
160	}	161	}
161		162
162	struct GNUNET_MY_QueryParam params_select[] = {	163	struct GNUNET_MY_QueryParam params_select[] = {
163	GNUNET_MY_query_param_end	164	GNUNET_MY_query_param_end
164	};	165	};
165		166
166	if (GNUNET_OK != GNUNET_MY_exec_prepared(context,	167	if (GNUNET_OK != GNUNET_MY_exec_prepared (context,
167	statements_handle_select,	168	statements_handle_select,
168	params_select))	169	params_select))
169	{	170	{
170	fprintf(stderr, "Failed to execute prepared statement SELECT\n");	171	fprintf (stderr, "Failed to execute prepared statement SELECT\n");
171	GNUNET_CRYPTO_rsa_signature_free(sig);	172	GNUNET_CRYPTO_rsa_signature_free (sig);
172	GNUNET_CRYPTO_rsa_private_key_free(priv);	173	GNUNET_CRYPTO_rsa_private_key_free (priv);
173	GNUNET_CRYPTO_rsa_public_key_free(pub);	174	GNUNET_CRYPTO_rsa_public_key_free (pub);
174	return 1;	175	return 1;
175	}	176	}
176		177
177	struct GNUNET_MY_ResultSpec results_select[] = {	178	struct GNUNET_MY_ResultSpec results_select[] = {
178	GNUNET_MY_result_spec_rsa_public_key(&pub2),	179	GNUNET_MY_result_spec_rsa_public_key (&pub2),
179	GNUNET_MY_result_spec_rsa_signature(&sig2),	180	GNUNET_MY_result_spec_rsa_signature (&sig2),
180	GNUNET_MY_result_spec_absolute_time(&abs_time2),	181	GNUNET_MY_result_spec_absolute_time (&abs_time2),
181	GNUNET_MY_result_spec_absolute_time(&forever2),	182	GNUNET_MY_result_spec_absolute_time (&forever2),
182	GNUNET_MY_result_spec_auto_from_type(&hc2),	183	GNUNET_MY_result_spec_auto_from_type (&hc2),
183	GNUNET_MY_result_spec_variable_size(&msg2, &msg2_len),	184	GNUNET_MY_result_spec_variable_size (&msg2, &msg2_len),
184	GNUNET_MY_result_spec_string(&msg4),	185	GNUNET_MY_result_spec_string (&msg4),
185	GNUNET_MY_result_spec_uint16(&u162),	186	GNUNET_MY_result_spec_uint16 (&u162),
186	GNUNET_MY_result_spec_uint32(&u322),	187	GNUNET_MY_result_spec_uint32 (&u322),
187	GNUNET_MY_result_spec_uint64(&u642),	188	GNUNET_MY_result_spec_uint64 (&u642),
188	GNUNET_MY_result_spec_end	189	GNUNET_MY_result_spec_end
189	};	190	};
190		191
191	ret = GNUNET_MY_extract_result(statements_handle_select,	192	ret = GNUNET_MY_extract_result (statements_handle_select,
192	results_select);	193	results_select);
193		194
194	GNUNET_assert(GNUNET_YES == ret);	195	GNUNET_assert (GNUNET_YES == ret);
195	GNUNET_break(abs_time.abs_value_us == abs_time2.abs_value_us);	196	GNUNET_break (abs_time.abs_value_us == abs_time2.abs_value_us);
196	GNUNET_break(forever.abs_value_us == forever2.abs_value_us);	197	GNUNET_break (forever.abs_value_us == forever2.abs_value_us);
197	GNUNET_break(0 ==	198	GNUNET_break (0 ==
198	memcmp(&hc,	199	memcmp (&hc,
199	&hc2,	200	&hc2,
200	sizeof(struct GNUNET_HashCode)));	201	sizeof(struct GNUNET_HashCode)));
201		202
202	GNUNET_assert(NULL != sig2);	203	GNUNET_assert (NULL != sig2);
203	GNUNET_assert(NULL != pub2);	204	GNUNET_assert (NULL != pub2);
204	GNUNET_break(0 ==	205	GNUNET_break (0 ==
205	GNUNET_CRYPTO_rsa_signature_cmp(sig,	206	GNUNET_CRYPTO_rsa_signature_cmp (sig,
206	sig2));	207	sig2));
207	GNUNET_break(0 ==	208	GNUNET_break (0 ==
208	GNUNET_CRYPTO_rsa_public_key_cmp(pub,	209	GNUNET_CRYPTO_rsa_public_key_cmp (pub,
209	pub2));	210	pub2));
210		211
211	GNUNET_break(strlen(msg) == msg2_len);	212	GNUNET_break (strlen (msg) == msg2_len);
212	GNUNET_break(0 ==	213	GNUNET_break (0 ==
213	strncmp(msg,	214	strncmp (msg,
214	msg2,	215	msg2,
215	msg2_len));	216	msg2_len));
216		217
217	GNUNET_break(strlen(msg3) == strlen(msg4));	218	GNUNET_break (strlen (msg3) == strlen (msg4));
218	GNUNET_break(0 ==	219	GNUNET_break (0 ==
219	strcmp(msg3,	220	strcmp (msg3,
220	msg4));	221	msg4));
221		222
222	GNUNET_break(16 == u162);	223	GNUNET_break (16 == u162);
223	GNUNET_break(32 == u322);	224	GNUNET_break (32 == u322);
224	GNUNET_break(UINT64_MAX == u642);	225	GNUNET_break (UINT64_MAX == u642);
225		226
226	GNUNET_MY_cleanup_result(results_select);	227	GNUNET_MY_cleanup_result (results_select);
227		228
228	GNUNET_CRYPTO_rsa_signature_free(sig);	229	GNUNET_CRYPTO_rsa_signature_free (sig);
229	GNUNET_CRYPTO_rsa_private_key_free(priv);	230	GNUNET_CRYPTO_rsa_private_key_free (priv);
230	GNUNET_CRYPTO_rsa_public_key_free(pub);	231	GNUNET_CRYPTO_rsa_public_key_free (pub);
231		232
232	if (GNUNET_OK != ret)	233	if (GNUNET_OK != ret)
233	return 1;	234	return 1;
@@ -237,63 +238,63 @@ run_queries(struct GNUNET_MYSQL_Context *context)
237		238
238		239
239	int	240	int
240	main(int argc, const char *const argv[])	241	main (int argc, const char *const argv[])
241	{	242	{
242	struct GNUNET_CONFIGURATION_Handle *config;	243	struct GNUNET_CONFIGURATION_Handle *config;
243	struct GNUNET_MYSQL_Context *context;	244	struct GNUNET_MYSQL_Context *context;
244	int ret;	245	int ret;
245		246
246	GNUNET_log_setup("test-my",	247	GNUNET_log_setup ("test-my",
247	"WARNING",	248	"WARNING",
248	NULL);	249	NULL);
249		250
250	config = GNUNET_CONFIGURATION_create();	251	config = GNUNET_CONFIGURATION_create ();
251	if (GNUNET_OK !=	252	if (GNUNET_OK !=
252	GNUNET_CONFIGURATION_parse(config, "test_my.conf"))	253	GNUNET_CONFIGURATION_parse (config, "test_my.conf"))
253	{	254	{
254	fprintf(stderr, "Failed to parse configuaration\n");	255	fprintf (stderr, "Failed to parse configuaration\n");
255	return 1;	256	return 1;
256	}	257	}
257		258
258	context = GNUNET_MYSQL_context_create(config,	259	context = GNUNET_MYSQL_context_create (config,
259	"datastore-mysql");	260	"datastore-mysql");
260	if (NULL == context)	261	if (NULL == context)
261	{	262	{
262	fprintf(stderr, "Failed to connect to database\n");	263	fprintf (stderr, "Failed to connect to database\n");
263	return 77;	264	return 77;
264	}	265	}
265		266
266	(void)GNUNET_MYSQL_statement_run(context,	267	(void) GNUNET_MYSQL_statement_run (context,
267	"DROP TABLE test_my2;");	268	"DROP TABLE test_my2;");
268		269
269	if (GNUNET_OK !=	270	if (GNUNET_OK !=
270	GNUNET_MYSQL_statement_run(context,	271	GNUNET_MYSQL_statement_run (context,
271	"CREATE TABLE IF NOT EXISTS test_my2("	272	"CREATE TABLE IF NOT EXISTS test_my2("
272	" pub BLOB NOT NULL"	273	" pub BLOB NOT NULL"
273	",sig BLOB NOT NULL"	274	",sig BLOB NOT NULL"
274	",abs_time BIGINT NOT NULL"	275	",abs_time BIGINT NOT NULL"
275	",forever BIGINT NOT NULL"	276	",forever BIGINT NOT NULL"
276	",abs_time_nbo BIGINT NOT NULL"	277	",abs_time_nbo BIGINT NOT NULL"
277	",hash BLOB NOT NULL CHECK(LENGTH(hash)=64)"	278	",hash BLOB NOT NULL CHECK(LENGTH(hash)=64)"
278	",vsize BLOB NOT NULL"	279	",vsize BLOB NOT NULL"
279	",str BLOB NOT NULL"	280	",str BLOB NOT NULL"
280	",u16 SMALLINT NOT NULL"	281	",u16 SMALLINT NOT NULL"
281	",u32 INT NOT NULL"	282	",u32 INT NOT NULL"
282	",u64 BIGINT NOT NULL"	283	",u64 BIGINT NOT NULL"
283	")"))	284	")"))
284	{	285	{
285	fprintf(stderr,	286	fprintf (stderr,
286	"Failed to create table. Database likely not setup correctly.\n");	287	"Failed to create table. Database likely not setup correctly.\n");
287	GNUNET_MYSQL_statements_invalidate(context);	288	GNUNET_MYSQL_statements_invalidate (context);
288	GNUNET_MYSQL_context_destroy(context);	289	GNUNET_MYSQL_context_destroy (context);
289		290
290	return 77;	291	return 77;
291	}	292	}
292		293
293	ret = run_queries(context);	294	ret = run_queries (context);
294		295
295	GNUNET_MYSQL_context_destroy(context);	296	GNUNET_MYSQL_context_destroy (context);
296	GNUNET_free(config);	297	GNUNET_free (config);
297		298
298	return ret;	299	return ret;
299	}	300	}