自学教程：C++ GNUNET_SCHEDULER_add_now函数代码示例

/** * Callback indicating that the hostkey was created for a peer. * * @param cls NULL * @param id the peer identity * @param d the daemon handle (pretty useless at this point, remove?) * @param emsg non-null on failure */voidhostkey_callback (void *cls, const struct GNUNET_PeerIdentity *id,                  struct GNUNET_TESTING_Daemon *d, const char *emsg){  if (emsg != NULL)  {    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,                "Hostkey callback received error: %s/n", emsg);  }#if VERBOSE > 1  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,              "Hostkey (%d/%d) created for peer `%s'/n", num_peers - peers_left,              num_peers, GNUNET_i2s (id));#endif#if VERBOSE  if ((num_peers - peers_left) % modnum == 0)  {    if (num_peers - peers_left == 0)      FPRINTF (stdout, "%s",  "0%%");    else      FPRINTF (stdout, "%d%%",               (int) (((float) (num_peers - peers_left) / num_peers) * 100));  }  else if ((num_peers - peers_left) % dotnum == 0)  {    FPRINTF (stdout, "%s",  ".");  }  fflush (stdout);#endif  peers_left--;  if (peers_left == 0)  {#if VERBOSE    FPRINTF (stdout, "%s",  "100%%]/n");    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,                "All %d hostkeys created, now creating topology!/n", num_peers);#endif    GNUNET_SCHEDULER_cancel (die_task);    /* Set up task in case topology creation doesn't finish     * within a reasonable amount of time */    die_task =        GNUNET_SCHEDULER_add_delayed (test_timeout, &end_badly,                                      "from create_topology");    GNUNET_SCHEDULER_add_now (&create_topology, NULL);    ok = 0;  }}

static voidtesting_connect_cb (struct PeerContext *p1, struct PeerContext *p2, void *cls){  cc = NULL;  char *p1_c = GNUNET_strdup (GNUNET_i2s (&p1->id));  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peers connected: %u (%s) <-> %u (%s)/n",              p1->no, p1_c, p2->no, GNUNET_i2s (&p2->id));  GNUNET_free (p1_c);  send_task = GNUNET_SCHEDULER_add_now (&sendtask, NULL);}

static voidadd_peer_done (void *cls, const char *emsg){  if (NULL == emsg)  {    return;  }  else  {    GNUNET_break(0);    GNUNET_SCHEDULER_cancel (timeout_task);    timeout_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL );  }}

/** * Function executed after stream has been established * * @param cls the closure from GNUNET_STREAM_open * @param socket socket to use to communicate with the other side (read/write) */static void stream_open_cb (void *cls,                struct GNUNET_STREAM_Socket *socket){  struct PeerData *peer=cls;  GNUNET_assert (&peer1 == peer);  GNUNET_assert (socket == peer1.socket);  GNUNET_assert (socket == peer->socket);  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stream established from peer1/n");  peer->bytes_wrote = 0;  GNUNET_SCHEDULER_add_now (&stream_write_task, peer);}

/** * Stats callback. Finish the stats testbed operation and when all stats have * been iterated, shutdown the test. * * @param cls Closure (line number from which termination was requested). * @param op the operation that has been finished * @param emsg error message in case the operation has failed; will be NULL if *          operation has executed successfully. */static voidstats_cont (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg){  GNUNET_log (GNUNET_ERROR_TYPE_INFO, " KA sent: %u, KA received: %u/n",              ka_sent, ka_received);  if (KEEPALIVE == test && (ka_sent < 2 || ka_sent > ka_received + 1))    ok--;  GNUNET_TESTBED_operation_done (stats_op);  if (NULL != disconnect_task)    GNUNET_SCHEDULER_cancel (disconnect_task);  disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,					      cls);}

static voidnotify_receive (void *cls, const struct GNUNET_PeerIdentity *peer,                const struct GNUNET_MessageHeader *message,                const struct GNUNET_ATS_Information *ats, uint32_t ats_count){  struct PeerContext *p = cls;  struct PeerContext *t = NULL;  if (0 == memcmp (peer, &p1->id, sizeof (struct GNUNET_PeerIdentity)))    t = p1;  if (0 == memcmp (peer, &p2->id, sizeof (struct GNUNET_PeerIdentity)))    t = p2;  GNUNET_assert (t != NULL);  char *ps = GNUNET_strdup (GNUNET_i2s (&p->id));  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,              "Peer %u (`%4s') received message of type %d and size %u size from peer %u (`%4s')!/n",              p->no, ps, ntohs (message->type), ntohs (message->size), t->no,              GNUNET_i2s (&t->id));  GNUNET_free (ps);  if ((MTYPE == ntohs (message->type)) &&      (sizeof (struct GNUNET_MessageHeader) == ntohs (message->size)))  {    if (restarted == GNUNET_NO)    {      restarted = GNUNET_YES;      restart (p1, cfg_file_p1);      restart (p2, cfg_file_p2);      return;    }    else    {      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,                  "Restarted peers connected, stopping test.../n");      ok = 0;      end ();    }  }  else  {    GNUNET_break (0);    ok = 1;    if (die_task != GNUNET_SCHEDULER_NO_TASK)      GNUNET_SCHEDULER_cancel (die_task);    die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);  }}

static voidon_lookup_result(void *cls, uint32_t rd_count,                 const struct GNUNET_NAMESTORE_RecordData *rd){  struct in_addr a;  int i;  char* addr;    if (GNUNET_SCHEDULER_NO_TASK != die_task)  {      GNUNET_SCHEDULER_cancel (die_task);      die_task = GNUNET_SCHEDULER_NO_TASK;  }  GNUNET_NAMESTORE_disconnect (namestore_handle);  namestore_handle = NULL;  if (rd_count == 0)  {    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,                "Lookup failed, this is good!/n");    ok = 0;  }  else  {    ok = 1;    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "name: %s/n", (char*)cls);    for (i=0; i<rd_count; i++)    {      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "type: %d/n", rd[i].record_type);      if (rd[i].record_type == GNUNET_GNS_RECORD_A)      {        memcpy(&a, rd[i].data, sizeof(a));        addr = inet_ntoa(a);        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "address: %s/n", addr);        if (0 == strcmp(addr, TEST_IP))        {          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,                    "%s incorrectly resolved to %s!/n", TEST_DOMAIN, addr);          ok = 2;        }      }      else      {        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No resolution!/n");      }    }  }  GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);}

void ats_perf_cb (void *cls,                  const struct                  GNUNET_HELLO_Address *                  address,                  struct                  GNUNET_BANDWIDTH_Value32NBO                  bandwidth_out,                  struct                  GNUNET_BANDWIDTH_Value32NBO                  bandwidth_in,                  const struct                  GNUNET_ATS_Information *                  ats, uint32_t ats_count){  struct PendingResolutions * pr;  if (NULL != address)  {    pr = GNUNET_malloc (sizeof (struct PendingResolutions) +                        ats_count * sizeof (struct GNUNET_ATS_Information));    pr->ats_count = ats_count;    pr->ats = (struct GNUNET_ATS_Information *) &pr[1];    if (ats_count > 0)      memcpy (pr->ats, ats, ats_count * sizeof (struct GNUNET_ATS_Information));    pr->address = GNUNET_HELLO_address_copy (address);    pr->bandwidth_in = bandwidth_in;    pr->bandwidth_out = bandwidth_out;    pr->tats_ctx = GNUNET_TRANSPORT_address_to_string(cfg, address,                      resolve_addresses_numeric, GNUNET_TIME_UNIT_FOREVER_REL, transport_addr_to_str_cb, pr);    GNUNET_CONTAINER_DLL_insert (head, tail, pr);    results++;    pending++;  }  else  {    /* All messages received */    receive_done = GNUNET_YES;    alh = NULL;    if (0 == pending)    {      /* All messages received and no resolutions pending*/      if (end_task != GNUNET_SCHEDULER_NO_TASK)        GNUNET_SCHEDULER_cancel (end_task);      end_task = GNUNET_SCHEDULER_add_now (end, NULL);    }  }}

static voidon_lookup_result(void *cls, uint32_t rd_count,                 const struct GNUNET_NAMESTORE_RecordData *rd){  int i;  uint16_t *srv_data;  char* srv;    if (GNUNET_SCHEDULER_NO_TASK != die_task)  {      GNUNET_SCHEDULER_cancel (die_task);      die_task = GNUNET_SCHEDULER_NO_TASK;  }  GNUNET_NAMESTORE_disconnect (namestore_handle);  if (rd_count == 0)  {    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,                "Lookup failed, rp_filtering?/n");    ok = 2;  }  else  {    ok = 1;    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "name: %s/n", (char*)cls);    for (i=0; i<rd_count; i++)    {      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "type: %d/n", rd[i].record_type);      if (rd[i].record_type == GNUNET_GNS_RECORD_SRV)      {        srv_data = (uint16_t*)rd[i].data;        srv = (char*)&srv_data[3];        GNUNET_log (GNUNET_ERROR_TYPE_INFO,                    "Got SRV %s with p=%d,w=%d,port=%d/n",                    srv, srv_data, &srv_data[1], &srv_data[2]);        if (0 == strcmp(srv, TEST_EXPECTED_SRV))        {          GNUNET_log (GNUNET_ERROR_TYPE_INFO,                      "%s correctly resolved to %s!/n", TEST_DOMAIN,                      TEST_EXPECTED_SRV);          ok = 0;        }      }    }  }  GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);}

static voidsend_test_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc){  struct TestMessageContext *pos = cls;  if ((pos == test_messages) && (settle_time.rel_value > 0))  {    topology_connections = 0;    GNUNET_TESTING_get_topology (pg, &topology_cb, NULL);  }  if (((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0) || (cls == NULL))    return;  if (die_task == GNUNET_SCHEDULER_NO_TASK)  {    die_task =        GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT, &end_badly,                                      "from send test messages (timeout)");  }  if (total_server_connections >= MAX_OUTSTANDING_CONNECTIONS)  {    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply                                  (GNUNET_TIME_UNIT_SECONDS, 1),                                  &send_test_messages, pos);    return;                     /* Otherwise we'll double schedule messages here! */  }  /*   * Connect to the sending peer   */  pos->peer1handle =      GNUNET_CORE_connect (pos->peer1->cfg, pos, &init_notify_peer1,                           &connect_notify_peers, NULL, NULL, GNUNET_NO, NULL,                           GNUNET_NO, no_handlers);  GNUNET_assert (pos->peer1handle != NULL);  if (total_server_connections < MAX_OUTSTANDING_CONNECTIONS)  {    GNUNET_SCHEDULER_add_now (&send_test_messages, pos->next);  }  else  {    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply                                  (GNUNET_TIME_UNIT_SECONDS, 1),                                  &send_test_messages, pos->next);  }}

/** * Main point of test execution */static voidrun (void *cls, char *const *args, const char *cfgfile,     const struct GNUNET_CONFIGURATION_Handle *cfg){  struct TestingContext *test_ctx;  char *emsg;  struct GNUNET_PeerIdentity id;  struct GNUNET_TESTING_SharedService ss[] = {    {"peerinfo", cfg, 2},    {NULL, NULL, 0}  };  struct GNUNET_TESTING_Peer *peer;  unsigned int cnt;  test_ctx = GNUNET_new (struct TestingContext);  test_ctx->system =      GNUNET_TESTING_system_create ("test-gnunet-testing",                                    "127.0.0.1", NULL, ss);  emsg = NULL;  if (NULL == test_ctx->system)    goto end;  test_ctx->cfg = GNUNET_CONFIGURATION_dup (cfg);  for (cnt = 0; cnt < NUM_PEERS; cnt++)  {    peer = GNUNET_TESTING_peer_configure (test_ctx->system,                                          test_ctx->cfg,                                          0, &id, &emsg);    if (NULL == peer)    {      if (NULL != emsg)        printf ("Test failed upon error: %s", emsg);      goto end;    }    if (GNUNET_OK != GNUNET_TESTING_peer_start (peer))    {      GNUNET_TESTING_peer_destroy (peer);      goto end;    }    test_ctx->peers[cnt] = peer;  }  status = GNUNET_OK;  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,                                &do_shutdown, test_ctx);  return; end:  GNUNET_SCHEDULER_add_now (&do_shutdown, test_ctx);  GNUNET_free_non_null (emsg);}

static voidput_cont (void *cls, int32_t success, const char *emsg){  const char *name = cls;  nsqe = NULL;  GNUNET_assert (NULL != cls);  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,	      "Name store added record for `%s': %s/n",	      name,	      (success == GNUNET_OK) ? "SUCCESS" : "FAIL");  GNUNET_SCHEDULER_cancel (endbadly_task);  endbadly_task = NULL;  GNUNET_SCHEDULER_add_now (&end, NULL);}

static voidtest_get_iterator (void *cls, struct GNUNET_TIME_Absolute exp,                   const struct GNUNET_HashCode * key,                   const struct GNUNET_PeerIdentity *get_path,                   unsigned int get_path_length,                   const struct GNUNET_PeerIdentity *put_path,                   unsigned int put_path_length,                   enum GNUNET_BLOCK_Type type,                   size_t size, const void *data){  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,              "test_get_iterator called (we got a result), stopping get request!/n");  GNUNET_SCHEDULER_add_now (&test_get_stop,                            NULL);}

static voidhandle_test (void *cls,	     const struct GNUNET_MessageHeader *message){  const struct GNUNET_PeerIdentity *peer = cls;  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,              "Receiving message from `%s'./n",              GNUNET_i2s (peer));  GNUNET_assert (ok == 5);  OKPP;  GNUNET_SCHEDULER_cancel (err_task);  err_task = GNUNET_SCHEDULER_add_now (&terminate_task,				       NULL);}

/** * Callback which will be called to after a host registration succeeded or failed * * @param cls the closure * @param emsg the error message; NULL if host registration is successful */static voidhost_registration_completion (void *cls, const char *emsg){  struct GNUNET_TESTBED_RunHandle *rc = cls;  rc->reg_handle = NULL;  if (NULL != emsg)  {    LOG (GNUNET_ERROR_TYPE_WARNING,         _("Host registration failed for a host. Error: %s/n"), emsg);    GNUNET_SCHEDULER_shutdown ();    return;  }  rc->register_hosts_task = GNUNET_SCHEDULER_add_now (&register_hosts, rc);}

/** * Iterator callback to go over all addresses and try to validate them * (unless blocked or already validated). * * @param cls pointer to a 'struct ValidateAddressContext' * @param address the address * @param expiration expiration time * @return GNUNET_OK (keep the address) */static intvalidate_address_iterator (void *cls,                           const struct GNUNET_HELLO_Address *address,                           struct GNUNET_TIME_Absolute expiration){  const struct ValidateAddressContext *vac = cls;  struct ValidationEntry *ve;  if (GNUNET_TIME_absolute_get_remaining (expiration).rel_value == 0)    return GNUNET_OK;           /* expired */  ve = find_validation_entry (&vac->public_key, address);  if (GNUNET_SCHEDULER_NO_TASK == ve->revalidation_task)    ve->revalidation_task = GNUNET_SCHEDULER_add_now (&revalidate_address, ve);  return GNUNET_OK;}

static voidaddress_suggest_cb (void *cls,                    const struct GNUNET_PeerIdentity *peer,                    const struct GNUNET_HELLO_Address *address,                    struct Session *session,                    struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,                    struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,                    const struct GNUNET_ATS_Information *atsi,                    uint32_t ats_count){  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Did not expect suggestion callback!/n");  GNUNET_SCHEDULER_add_now (&end_badly, NULL);  return;}

static voidread_call (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc){  struct GNUNET_DISK_FileHandle *stdout_read_handle = cls;  char buf[16];  memset (&buf, 0, sizeof (buf));  int bytes;  bytes = GNUNET_DISK_file_read (stdout_read_handle, &buf, sizeof (buf));  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "bytes is %d/n", bytes);  if (bytes < 1)  {    GNUNET_break (0);    ok = 1;    GNUNET_SCHEDULER_cancel (die_task);    GNUNET_SCHEDULER_add_now (&end_task, NULL);    return;  }  ok = strncmp (&buf[0], test_phrase, strlen (test_phrase));  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "read %s/n", &buf[0]);  if (0 == ok)  {    GNUNET_SCHEDULER_cancel (die_task);    GNUNET_SCHEDULER_add_now (&end_task, NULL);    return;  }  GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,                                  stdout_read_handle, &read_call,                                  stdout_read_handle);}

/** * Functions of this type are called upon new stream connection from other peers * * @param cls the closure from GNUNET_STREAM_listen * @param socket the socket representing the stream * @param initiator the identity of the peer who wants to establish a stream *            with us * @return GNUNET_OK to keep the socket open, GNUNET_SYSERR to close the *             stream (the socket will be invalid after the call) */static intstream_listen_cb (void *cls, struct GNUNET_STREAM_Socket *socket,		  const struct GNUNET_PeerIdentity *initiator){  struct PeerData *pdata = cls;    if ((NULL == socket) || (NULL == initiator))  {    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Binding error/n");    if (GNUNET_SCHEDULER_NO_TASK != abort_task)      GNUNET_SCHEDULER_cancel (abort_task);    abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);    return GNUNET_OK;  }  GNUNET_assert (NULL != socket);  GNUNET_assert (pdata == &peer_data[1]);  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer connected: %s/n",	      GNUNET_i2s(initiator));  pdata->socket = socket;  pdata->bytes_read = 0;  read_task = GNUNET_SCHEDULER_add_now (&stream_read_task, pdata);  return GNUNET_OK;}

/** * Connect to the network size estimation service. * * @param cfg the configuration to use * @param func funtion to call with network size estimate * @param func_cls closure to pass for network size estimate callback * * @return handle to use */struct GNUNET_NSE_Handle *GNUNET_NSE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,                    GNUNET_NSE_Callback func, void *func_cls){    struct GNUNET_NSE_Handle *ret;    GNUNET_assert (func != NULL);    ret = GNUNET_malloc (sizeof (struct GNUNET_NSE_Handle));    ret->cfg = cfg;    ret->recv_cb = func;    ret->recv_cb_cls = func_cls;    ret->reconnect_delay = GNUNET_TIME_UNIT_ZERO;    ret->reconnect_task = GNUNET_SCHEDULER_add_now (&reconnect, ret);    return ret;}

static voidrd_decrypt_cb (void *cls,               unsigned int rd_count,               const struct GNUNET_GNSRECORD_Data *rd){  char rd_cmp_data[TEST_RECORD_DATALEN];  if (1 != rd_count)  {    GNUNET_SCHEDULER_add_now (&endbadly, NULL);    GNUNET_break (0);    return;  }  if (NULL == rd)  {    GNUNET_SCHEDULER_add_now (&endbadly, NULL);    GNUNET_break (0);    return;  }  memset (rd_cmp_data, 'a', TEST_RECORD_DATALEN);  if (TEST_RECORD_TYPE != rd[0].record_type)  {    GNUNET_SCHEDULER_add_now (&endbadly, NULL);    GNUNET_break (0);    return;  }  if (TEST_RECORD_DATALEN != rd[0].data_size)  {    GNUNET_SCHEDULER_add_now (&endbadly, NULL);    GNUNET_break (0);    return;  }  if (0 != memcmp (&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN))  {    GNUNET_SCHEDULER_add_now (&endbadly, NULL);    GNUNET_break (0);    return;  }  if (0 != (GNUNET_GNSRECORD_RF_SHADOW_RECORD & rd[0].flags))  {    GNUNET_SCHEDULER_add_now (&endbadly, NULL);    GNUNET_break (0);    return;  }  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,	      "Block was decrypted successfully /n");	GNUNET_SCHEDULER_add_now (&end, NULL);}

static voidarm_stop_cb (void *cls,	     enum GNUNET_ARM_RequestStatus status,	     const char *servicename,	     enum GNUNET_ARM_Result result){  GNUNET_break (status == GNUNET_ARM_REQUEST_SENT_OK);  GNUNET_break (result == GNUNET_ARM_RESULT_STOPPED);  if (result != GNUNET_ARM_RESULT_STOPPED)  {    GNUNET_break (0);    ret = 4;  }  GNUNET_SCHEDULER_add_now (&trigger_disconnect, NULL);}

/** * Main function that will be run by the scheduler. * * @param cls closure * @param args remaining command-line arguments * @param cfgfile name of the configuration file used (for saving, can be NULL!) * @param c configuration */static voidrun (void *cls, char *const *args, const char *cfgfile,     const struct GNUNET_CONFIGURATION_Handle *c){  struct GNUNET_CRYPTO_RsaPrivateKey *priv;  char *fn;  cfg = c;  if (args[0] != NULL)  {    FPRINTF (stderr, _("Invalid command line argument `%s'/n"), args[0]);    return;  }  peerinfo = GNUNET_PEERINFO_connect (cfg);  if (peerinfo == NULL)  {    FPRINTF (stderr, "%s",  _("Could not access PEERINFO service.  Exiting./n"));    return;  }  if ( (GNUNET_YES == get_self) || (GNUNET_YES == get_uri) )  {    /* load private key */    if (GNUNET_OK !=	GNUNET_CONFIGURATION_get_value_filename (cfg, "GNUNETD", "HOSTKEY",						 &fn))    {      FPRINTF (stderr, _("Could not find option `%s:%s' in configuration./n"),	       "GNUNETD", "HOSTKEYFILE");      return;    }    if (NULL == (priv = GNUNET_CRYPTO_rsa_key_create_from_file (fn)))    {      FPRINTF (stderr, _("Loading hostkey from `%s' failed./n"), fn);      GNUNET_free (fn);      return;    }    GNUNET_free (fn);    GNUNET_CRYPTO_rsa_key_get_public (priv, &my_public_key);    GNUNET_CRYPTO_rsa_key_free (priv);    GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key), &my_peer_identity.hashPubKey);  }  tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,				&shutdown_task,				NULL);}

static voidon_lookup_result(void *cls, uint32_t rd_count,                 const struct GNUNET_NAMESTORE_RecordData *rd){  int i;  uint16_t mx_preference;  char* mx;    if (GNUNET_SCHEDULER_NO_TASK != die_task)  {      GNUNET_SCHEDULER_cancel (die_task);      die_task = GNUNET_SCHEDULER_NO_TASK;  }  GNUNET_NAMESTORE_disconnect (namestore_handle);  if (rd_count == 0)  {    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,                "Lookup failed, rp_filtering?/n");    ok = 2;  }  else  {    ok = 1;    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "name: %s/n", (char*)cls);    for (i=0; i<rd_count; i++)    {      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "type: %d/n", rd[i].record_type);      if (rd[i].record_type == GNUNET_GNS_RECORD_MX)      {        mx = (char*)rd[i].data+sizeof(uint16_t);        mx_preference = *(uint16_t*)rd[i].data;        GNUNET_log (GNUNET_ERROR_TYPE_INFO,                    "Got MX %s with preference %d/n", mx, mx_preference);        if (0 == strcmp(mx, TEST_EXPECTED_MX))        {          GNUNET_log (GNUNET_ERROR_TYPE_INFO,                      "%s correctly resolved to %s!/n", TEST_DOMAIN,                      TEST_EXPECTED_MX);          ok = 0;        }      }    }  }    GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);}

/** * Method called whenever a peer disconnects. * * @param cls closure * @param peer peer identity this notification is about */static voiddisconnect_notify (void *cls, const struct GNUNET_PeerIdentity *peer){  struct Peer *pos;  if (0 == memcmp (&my_identity, peer, sizeof (struct GNUNET_PeerIdentity)))    return;  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,              "Core told us that we disconnected from `%s'/n",              GNUNET_i2s (peer));  pos = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);  if (NULL == pos)  {    GNUNET_break (0);    return;  }  if (pos->is_connected != GNUNET_YES)  {    GNUNET_break (0);    return;  }  pos->is_connected = GNUNET_NO;  connection_count--;  if (NULL != pos->hello_req)  {    GNUNET_CORE_notify_transmit_ready_cancel (pos->hello_req);    pos->hello_req = NULL;  }  if (GNUNET_SCHEDULER_NO_TASK != pos->hello_delay_task)  {    GNUNET_SCHEDULER_cancel (pos->hello_delay_task);    pos->hello_delay_task = GNUNET_SCHEDULER_NO_TASK;  }  GNUNET_STATISTICS_set (stats, gettext_noop ("# peers connected"),                         connection_count, GNUNET_NO);  if (pos->is_friend)  {    friend_count--;    GNUNET_STATISTICS_set (stats, gettext_noop ("# friends connected"),                           friend_count, GNUNET_NO);  }  if (((connection_count < target_connection_count) ||       (friend_count < minimum_friend_count)) &&      (GNUNET_SCHEDULER_NO_TASK == add_task))    add_task = GNUNET_SCHEDULER_add_now (&add_peer_task, NULL);  if ((friend_count < minimum_friend_count) && (blacklist == NULL))    blacklist = GNUNET_TRANSPORT_blacklist (cfg, &blacklist_check, NULL);}

/** * Callback invoked from the namestore service once record is * created. * * @param cls closure * @param af address family, AF_INET or AF_INET6; AF_UNSPEC on error; *                will match 'result_af' from the request * @param address IP address (struct in_addr or struct in_addr6, depending on 'af') *                that the VPN allocated for the redirection; *                traffic to this IP will now be redirected to the *                specified target peer; NULL on error */static voidcommence_testing (void *cls, int32_t success, const char *emsg){  GNUNET_SCHEDULER_add_now (&disco_ns, NULL);  if ((emsg != NULL) && (GNUNET_YES != success))  {    fprintf (stderr,	     "NS failed to create record %s/n", emsg);    GNUNET_SCHEDULER_shutdown ();    return;  }  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1), start_curl, NULL);}

static intprocess_downloads (void *cls, const char *subsystem, const char *name,                   uint64_t value, int is_persistent){  if ((value >= 2) && (learned_hostlist_downloaded == GNUNET_NO))  {    GNUNET_log (GNUNET_ERROR_TYPE_INFO,                "Peer has successfully downloaded advertised URI/n");    learned_hostlist_downloaded = GNUNET_YES;    if ((learned_hostlist_saved == GNUNET_YES) && (adv_sent == GNUNET_YES))    {      GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);    }  }  return GNUNET_OK;}

/** * Create a tunnel to @a destionation.  Must only be called * from within #GCP_get_tunnel(). * * @param destination where to create the tunnel to * @return new tunnel to @a destination */struct CadetTunnel *GCT_create_tunnel (struct CadetPeer *destination){  struct CadetTunnel *t;  t = GNUNET_new (struct CadetTunnel);  t->destination = destination;  t->channels = GNUNET_CONTAINER_multihashmap32_create (8);  (void) GCP_iterate_paths (destination,                            &consider_path_cb,                            t);  t->maintain_connections_task    = GNUNET_SCHEDULER_add_now (&maintain_connections_cb,                                t);  return t;}

/** * Completion callback for shutdown * * @param cls the closure from GNUNET_STREAM_shutdown call * @param operation the operation that was shutdown (SHUT_RD, SHUT_WR, *          SHUT_RDWR)  */static void shutdown_completion (void *cls,                     int operation){  static int shutdowns;  if (++shutdowns == 1)  {    peer_data[0].shutdown_handle = NULL;    peer_data[1].shutdown_handle = GNUNET_STREAM_shutdown (peer_data[1].socket, SHUT_RDWR,                                                           &shutdown_completion, cls);    return;  }    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "STREAM shutdown successful/n");  GNUNET_SCHEDULER_add_now (&do_close, cls);}

/** * Connect to the service-dns * * @param cfg configuration to use * @param flags when to call rh * @param rh function to call with DNS requests * @param rh_cls closure to pass to rh * @return DNS handle */struct GNUNET_DNS_Handle *GNUNET_DNS_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,		    enum GNUNET_DNS_Flags flags,		    GNUNET_DNS_RequestHandler rh,		    void *rh_cls){  struct GNUNET_DNS_Handle *dh;  dh = GNUNET_new (struct GNUNET_DNS_Handle);  dh->cfg = cfg;  dh->flags = flags;  dh->rh = rh;  dh->rh_cls = rh_cls;  dh->reconnect_task = GNUNET_SCHEDULER_add_now (&reconnect, dh);  return dh;}