[GNUnet-SVN] r33523 - gnunet/src/revocation

[gnunet]

Author: grothoff
Date: 2014-06-04 18:51:45 +0200 (Wed, 04 Jun 2014)
New Revision: 33523

Modified:
   gnunet/src/revocation/test_revocation.c
Log:
-indentation, logging fixes

Modified: gnunet/src/revocation/test_revocation.c
===================================================================
--- gnunet/src/revocation/test_revocation.c     2014-06-04 16:38:42 UTC (rev 
33522)
+++ gnunet/src/revocation/test_revocation.c     2014-06-04 16:51:45 UTC (rev 
33523)
@@ -55,8 +55,10 @@
  */
 static int ok;
 
+
 static void
-do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_shutdown (void *cls,
+             const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   int c;
 
@@ -99,6 +101,7 @@
   ok = 0;
 }
 
+
 static void
 do_shutdown_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
@@ -129,26 +132,31 @@
   me->idh = NULL;
 }
 
+
 static void
 check_revocation ();
 
+
 static void
 revocation_remote_cb (void *cls, int is_valid)
 {
   static int repeat = 0;
   if (GNUNET_NO == is_valid)
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Local revocation successful\n");
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+               "Local revocation successful\n");
     GNUNET_SCHEDULER_add_now (&do_shutdown, NULL );
   }
   else if (repeat < 10)
   {
-    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &check_revocation,
-        NULL );
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                  &check_revocation,
+                                  NULL );
   }
   else
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Flooding of revocation failed\n");
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+               "Flooding of revocation failed\n");
     if (GNUNET_SCHEDULER_NO_TASK != die_task)
     {
       GNUNET_SCHEDULER_cancel (die_task);
@@ -159,28 +167,35 @@
   repeat++;
 }
 
+
 static void
 check_revocation ()
 {
-  GNUNET_REVOCATION_query (testpeers[0].cfg, &testpeers[1].pubkey,
-      &revocation_remote_cb, NULL );
+  GNUNET_REVOCATION_query (testpeers[0].cfg,
+                           &testpeers[1].pubkey,
+                           &revocation_remote_cb, NULL);
 }
 
+
 static void
 revocation_cb (void *cls, int is_valid)
 {
   testpeers[1].revok_handle = NULL;
   if (GNUNET_NO == is_valid)
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Revocation successful\n");
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+               "Revocation successful\n");
     check_revocation ();
   }
 }
 
+
 static void
-ego_cb (void *cls, const struct GNUNET_IDENTITY_Ego *ego)
+ego_cb (void *cls,
+        const struct GNUNET_IDENTITY_Ego *ego)
 {
   static int completed = 0;
+
   if ((NULL != ego) && (cls == &testpeers[0]))
   {
     testpeers[0].ego_lookup = NULL;
@@ -195,32 +210,41 @@
     GNUNET_IDENTITY_ego_get_public_key (ego, &testpeers[1].pubkey);
     GNUNET_REVOCATION_sign_revocation (testpeers[1].privkey, 
&testpeers[1].sig);
 
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Calculating proof of work...\n");
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+               "Calculating proof of work...\n");
     testpeers[1].pow = 0;
     int res = GNUNET_REVOCATION_check_pow (&testpeers[1].pubkey,
         testpeers[1].pow, 5);
     while (GNUNET_OK != res)
     {
       testpeers[1].pow++;
-      res = GNUNET_REVOCATION_check_pow (&testpeers[1].pubkey, 
testpeers[1].pow,
-          5);
+      res = GNUNET_REVOCATION_check_pow (&testpeers[1].pubkey,
+                                         testpeers[1].pow,
+                                         5);
     }
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Done calculating proof of work\n");
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+               "Done calculating proof of work\n");
     completed++;
   }
   if (2 == completed)
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Egos retrieved\n");
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+               "Egos retrieved\n");
     testpeers[1].revok_handle = GNUNET_REVOCATION_revoke (testpeers[1].cfg,
-        &testpeers[1].pubkey, &testpeers[1].sig, testpeers[1].pow,
-        revocation_cb, NULL );
+                                                          &testpeers[1].pubkey,
+                                                          &testpeers[1].sig,
+                                                          testpeers[1].pow,
+                                                          revocation_cb, NULL);
   }
 }
 
-void
-identity_create_cb (void *cls, const char *emsg)
+
+static void
+identity_create_cb (void *cls,
+                    const char *emsg)
 {
   static int completed = 0;
+
   if ((NULL == emsg) && (cls == &testpeers[0]))
   {
     testpeers[0].create_id_op = NULL;
@@ -233,23 +257,32 @@
   }
   if (2 == completed)
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Identities created\n");
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+               "Identities created\n");
     testpeers[0].ego_lookup = GNUNET_IDENTITY_ego_lookup (testpeers[0].cfg,
-        "client", ego_cb, &testpeers[0]);
+                                                          "client",
+                                                          ego_cb,
+                                                          &testpeers[0]);
     testpeers[1].ego_lookup = GNUNET_IDENTITY_ego_lookup (testpeers[1].cfg,
-        "toberevoked", ego_cb, &testpeers[1]);
+                                                          "toberevoked",
+                                                          ego_cb,
+                                                          &testpeers[1]);
   }
 }
 
+
 static void
-identity_completion_cb (void *cls, struct GNUNET_TESTBED_Operation *op,
-    void *ca_result, const char *emsg)
+identity_completion_cb (void *cls,
+                        struct GNUNET_TESTBED_Operation *op,
+                        void *ca_result,
+                        const char *emsg)
 {
   static int completed = 0;
   completed++;
   if (NUM_TEST_PEERS == completed)
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Connected to identity\n");
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+               "Connected to identity\n");
     testpeers[0].create_id_op = GNUNET_IDENTITY_create (testpeers[0].idh,
         "client", identity_create_cb, &testpeers[0]);
     testpeers[1].create_id_op = GNUNET_IDENTITY_create (testpeers[1].idh,
@@ -257,13 +290,18 @@
   }
 }
 
-void static connect_cb (void *cls, const struct GNUNET_PeerIdentity *peer)
+
+static void
+connect_cb (void *cls,
+            const struct GNUNET_PeerIdentity *peer)
 {
   static int connects = 0;
+
   connects++;
   if (4 == connects)
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "All peers connected ...\n");
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+               "All peers connected ...\n");
 
     /* Connect to identity service */
     testpeers[0].identity_op = GNUNET_TESTBED_service_connect (NULL,
@@ -279,14 +317,17 @@
 
 
 static void
-core_completion_cb (void *cls, struct GNUNET_TESTBED_Operation *op,
-    void *ca_result, const char *emsg)
+core_completion_cb (void *cls,
+                    struct GNUNET_TESTBED_Operation *op,
+                    void *ca_result,
+                    const char *emsg)
 {
   static int completed = 0;
   completed++;
   if (NUM_TEST_PEERS == completed)
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Connected to CORE\n");
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+               "Connected to CORE\n");
   }
 }
 
@@ -297,39 +338,52 @@
 {
   struct TestPeer *me = cls;
   me->cfg = cfg;
-  me->ch = GNUNET_CORE_connect (cfg, me, NULL, &connect_cb, NULL, NULL, 
GNUNET_NO, NULL, GNUNET_NO, NULL);
+  me->ch = GNUNET_CORE_connect (cfg, me, NULL,
+                                &connect_cb, NULL,
+                                NULL, GNUNET_NO,
+                                NULL, GNUNET_NO, NULL);
   if (NULL == me->ch)
-    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to create CORE handle \n");
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+               "Failed to create CORE handle \n");
   return me->ch;
 }
 
 
 static void
-core_disconnect_adapter (void *cls, void *op_result)
+core_disconnect_adapter (void *cls,
+                         void *op_result)
 {
   struct TestPeer *me = cls;
   GNUNET_CORE_disconnect (me->ch);
   me->ch = NULL;
 }
 
+
 static void
-test_connection (void *cls, struct GNUNET_TESTBED_RunHandle *h,
-    unsigned int num_peers, struct GNUNET_TESTBED_Peer **peers,
-    unsigned int links_succeeded, unsigned int links_failed)
+test_connection (void *cls,
+                 struct GNUNET_TESTBED_RunHandle *h,
+                 unsigned int num_peers,
+                 struct GNUNET_TESTBED_Peer **peers,
+                 unsigned int links_succeeded,
+                 unsigned int links_failed)
 {
   int c;
 
   die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
-      &do_shutdown_badly, NULL );
+                                           &do_shutdown_badly, NULL);
   if (NUM_TEST_PEERS != num_peers)
   {
     ok = 1;
-    fprintf (stderr, "Only %u out of 2 peers were started ...\n", num_peers);
+    fprintf (stderr,
+             "Only %u out of %u peers were started ...\n",
+             num_peers,
+             NUM_TEST_PEERS);
   }
 
   if (0 == links_failed)
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Testbed connected peers\n");
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+               "Testbed connected peers\n");
     for (c = 0; c < num_peers; c++)
     {
       testpeers[c].p = peers[c];
@@ -342,13 +396,16 @@
   }
 }
 
+
 int
 main (int argc, char *argv[])
 {
   ok = 1;
   /* Connecting initial topology */
-  (void) GNUNET_TESTBED_test_run ("test-revocation", "test_revocation.conf",
-      NUM_TEST_PEERS, 0, NULL, NULL, &test_connection, NULL );
+  (void) GNUNET_TESTBED_test_run ("test-revocation",
+                                  "test_revocation.conf",
+                                  NUM_TEST_PEERS, 0, NULL, NULL,
+                                  &test_connection, NULL );
   return ok;
 }