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

static voidtestNamespace (){  struct GNUNET_CRYPTO_EcdsaPrivateKey *ns;  struct GNUNET_FS_BlockOptions bo;  struct GNUNET_CONTAINER_MetaData *meta;  struct GNUNET_FS_Uri *ksk_uri;  struct GNUNET_FS_Uri *sks_uri;  ns = GNUNET_CRYPTO_ecdsa_key_create ();  meta = GNUNET_CONTAINER_meta_data_create ();  ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/testnsa", NULL);  bo.content_priority = 1;  bo.anonymity_level = 1;  bo.replication_level = 0;  bo.expiration_time =      GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);  sks_uri = GNUNET_FS_uri_sks_create (&nsid, "root");  GNUNET_FS_publish_ksk (fs,			 ksk_uri, meta, sks_uri,			 &bo, GNUNET_FS_PUBLISH_OPTION_NONE,			 &adv_cont, NULL);  GNUNET_FS_uri_destroy (sks_uri);  kill_task =      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &do_timeout,                                    NULL);  GNUNET_FS_uri_destroy (ksk_uri);  GNUNET_CONTAINER_meta_data_destroy (meta);  GNUNET_free (ns);}

/** * Request a list of running services. * * @param h handle to ARM * @param timeout how long to wait before failing for good * @param cont callback to invoke after request is sent or is not sent * @param cont_cls closure for callback */voidGNUNET_ARM_request_service_list (struct GNUNET_ARM_Handle *h,                                 struct GNUNET_TIME_Relative timeout,                                 GNUNET_ARM_ServiceListCallback cont,                                 void *cont_cls){  struct ARMControlMessage *cm;  struct GNUNET_ARM_Message *msg;  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Requesting LIST from ARM service with timeout: %s/n",       GNUNET_STRINGS_relative_time_to_string (timeout, GNUNET_YES));  cm = GNUNET_new (struct ARMControlMessage);  cm->h = h;  cm->list_cont = cont;  cm->cont_cls = cont_cls;  cm->timeout = GNUNET_TIME_relative_to_absolute (timeout);  msg = GNUNET_malloc (sizeof (struct GNUNET_ARM_Message));  msg->header.size = htons (sizeof (struct GNUNET_ARM_Message));  msg->header.type = htons (GNUNET_MESSAGE_TYPE_ARM_LIST);  msg->reserved = htonl (0);  cm->msg = msg;  GNUNET_CONTAINER_DLL_insert_tail (h->control_pending_head,                                    h->control_pending_tail, cm);  cm->timeout_task_id =      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining                                    (cm->timeout), &control_message_timeout, cm);  trigger_next_request (h, GNUNET_NO);}

/** * Close down any existing connection to the ARM service and * try re-establishing it later. * * @param h our handle */static voidreconnect_arm_later (struct GNUNET_ARM_Handle *h){  if (GNUNET_NO != h->currently_down)    return;  if (NULL != h->cth)  {    GNUNET_CLIENT_notify_transmit_ready_cancel (h->cth);    h->cth = NULL;  }  if (NULL != h->client)  {    GNUNET_CLIENT_disconnect (h->client);    h->client = NULL;  }  h->currently_down = GNUNET_YES;  GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->reconnect_task);  h->reconnect_task =      GNUNET_SCHEDULER_add_delayed (h->retry_backoff, &reconnect_arm_task, h);  /* Don't clear pending messages on disconnection, deliver them later  clear_pending_messages (h, GNUNET_ARM_REQUEST_DISCONNECTED);  GNUNET_assert (NULL == h->control_pending_head);  */  h->retry_backoff = GNUNET_TIME_STD_BACKOFF (h->retry_backoff);  if (NULL != h->conn_status)    h->conn_status (h->conn_status_cls, GNUNET_NO);}

static voidrun (void *cls,     char *const *args,     const char *cfgfile,     const struct GNUNET_CONFIGURATION_Handle *cfg){  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,                                           &end_badly, NULL);  test_send_timeout = GNUNET_NO;  p1 = GNUNET_TRANSPORT_TESTING_start_peer (tth, cfg_file_p1, 1,                                            &notify_receive, &notify_connect,                                            &notify_disconnect, &start_cb,                                            NULL);  p2 = GNUNET_TRANSPORT_TESTING_start_peer (tth, cfg_file_p2, 2,                                            &notify_receive, &notify_connect,                                            &notify_disconnect, &start_cb,                                            NULL);  if ((p1 == NULL) || (p2 == NULL))  {    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Fail! Could not start peers!/n");    if (die_task != NULL)      GNUNET_SCHEDULER_cancel (die_task);    //die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);    return;  }}

static voidrun (void *cls, char *const *args, const char *cfgfile,     const struct GNUNET_CONFIGURATION_Handle *cfg){  ret = 1;  tth = GNUNET_TRANSPORT_TESTING_init ();  GNUNET_assert (NULL != tth);  timeout_task =      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &end_badly, NULL);  p = GNUNET_TRANSPORT_TESTING_start_peer(tth, cfgfile, 1,                                          NULL, /* receive cb */                                          NULL, /* connect cb */                                          NULL, /* disconnect cb */                                          start_cb, /* startup cb */                                          NULL); /* closure */  if (NULL == p)  {    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to start peer/n");    if (timeout_task != NULL)      GNUNET_SCHEDULER_cancel (timeout_task);    timeout_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);  }}

/** * peergroup_ready: start test when all peers are connected * @param cls closure * @param emsg error message */static voidpeergroup_ready (void *cls, const char *emsg){  if (emsg != NULL)  {    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,                "test: Peergroup callback called with error, aborting test!/n");    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Error from testing: `%s'/n",                emsg);    ok--;    GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);    return;  }  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,              "test: Peer Group started successfully with %u connections/n",              total_connections);  peers_running = GNUNET_TESTING_daemons_running (pg);  if (0 < failed_connections)  {    ok = GNUNET_SYSERR;    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "test: %u connections have FAILED!/n",                failed_connections);    disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_peers, NULL);  }  else  {    GNUNET_TESTING_get_topology (pg, &topo_cb, NULL);    disconnect_task =        GNUNET_SCHEDULER_add_delayed (SHORT_TIME, &disconnect_peers, NULL);    ok = GNUNET_OK;  }}

/** * Callback for lock status changes * * @param cls the closure from GNUNET_LOCKMANAGER_lock call * * @param domain_name the locking domain of the lock * * @param lock the lock for which this status is relevant * * @param status GNUNET_LOCKMANAGER_SUCCESS if the lock has been successfully *          acquired; GNUNET_LOCKMANAGER_RELEASE when the acquired lock is lost */static voidstatus_cb (void *cls, const char *domain_name, uint32_t lock,           enum GNUNET_LOCKMANAGER_Status status){  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Status change callback called on lock: %d of domain: %s/n", lock,       domain_name);  switch (result)  {  case LOCK1_ACQUIRE:    GNUNET_assert (GNUNET_LOCKMANAGER_SUCCESS == status);    GNUNET_assert (NULL != request);    //GNUNET_LOCKMANAGER_cancel_request (request);    //request = NULL;    result = LOCK2_ACQUIRE;    request2 =        GNUNET_LOCKMANAGER_acquire_lock (handle, "GNUNET_LOCKMANAGER_TESTING",                                         100, &status_cb, NULL);    GNUNET_assert (NULL != request2);    break;  case LOCK2_ACQUIRE:    GNUNET_assert (GNUNET_LOCKMANAGER_SUCCESS == status);    GNUNET_assert (NULL != request);    GNUNET_SCHEDULER_add_delayed (TIME_REL_SECONDS (1), &do_shutdown, NULL);    break;  default:    GNUNET_break (0);  }}

/** * Reduce absolute preferences since they got old. * * @param cls unused * @param tc context */static voidpreference_aging (void *cls,                  const struct GNUNET_SCHEDULER_TaskContext *tc){  struct AgeContext ac;  aging_task = NULL;  GAS_plugin_solver_lock ();  ac.values_to_update = 0;  for (ac.cur_client = pc_head; NULL != ac.cur_client; ac.cur_client = ac.cur_client->next)    GNUNET_CONTAINER_multipeermap_iterate (ac.cur_client->peer2pref,                                           &age_values,                                           &ac);  GAS_plugin_solver_unlock ();  if (ac.values_to_update > 0)  {    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,                "Rescheduling aging task due to %u elements remaining to age/n",                ac.values_to_update);    if (NULL == aging_task)      aging_task = GNUNET_SCHEDULER_add_delayed (PREF_AGING_INTERVAL,                                                 &preference_aging,                                                 NULL);  }  else  {    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,                "No values to age left, not rescheduling aging task/n");  }}

/** * Initiate core service. * * @param cls closure * @param server the initialized server * @param c configuration to use */static voidrun (void *cls, struct GNUNET_SERVER_Handle *server,     const struct GNUNET_CONFIGURATION_Handle *c){  char *keyfile;  GSC_cfg = c;  GSC_server = server;  if (GNUNET_OK !=      GNUNET_CONFIGURATION_get_value_filename (GSC_cfg, "GNUNETD", "HOSTKEY",                                               &keyfile))  {    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,                _                ("Core service is lacking HOSTKEY configuration setting.  Exiting./n"));    GNUNET_SCHEDULER_shutdown ();    return;  }  GSC_stats = GNUNET_STATISTICS_create ("core", GSC_cfg);  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,                                NULL);  GNUNET_SERVER_suspend (server);  GSC_TYPEMAP_init ();  GST_keygen = GNUNET_CRYPTO_rsa_key_create_start (keyfile, &key_generation_cb, NULL);  GNUNET_free (keyfile);  if (NULL == GST_keygen)  {    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,                _("Transport service is unable to access hostkey. Exiting./n"));    GNUNET_SCHEDULER_shutdown ();  }}

/** * Main function run with scheduler. */static voidrun (void *cls, char *const *args, const char *cfgfile,     const struct GNUNET_CONFIGURATION_Handle *cfg){  struct GNUNET_NAT_Handle *nat;  struct addr_cls data;  struct sockaddr *addr;  data.addr = NULL;  GNUNET_OS_network_interfaces_list (process_if, &data);  if (NULL == data.addr)  {    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,                "Could not find a valid interface address!/n");    exit (77); /* marks test as skipped */  }  addr = data.addr;  GNUNET_assert (addr->sa_family == AF_INET || addr->sa_family == AF_INET6);  if (addr->sa_family == AF_INET)    ((struct sockaddr_in *) addr)->sin_port = htons (2086);  else    ((struct sockaddr_in6 *) addr)->sin6_port = htons (2086);  GNUNET_log (GNUNET_ERROR_TYPE_INFO,              "Requesting NAT redirection from address %s.../n",              GNUNET_a2s (addr, data.addrlen));  nat = GNUNET_NAT_register (cfg, GNUNET_YES /* tcp */ ,                             2086, 1, (const struct sockaddr **) &addr,                             &data.addrlen, &addr_callback, NULL, NULL, NULL);  GNUNET_free (addr);  GNUNET_SCHEDULER_add_delayed (TIMEOUT, &stop, nat);}

/** * Start mapping the given port using (mini)upnpc.  This function * should typically not be used directly (it is used within the * general-purpose #GNUNET_NAT_register() code).  However, it can be * used if specifically UPnP-based NAT traversal is to be used or * tested. * * @param port port to map * @param is_tcp #GNUNET_YES to map TCP, #GNUNET_NO for UDP * @param ac function to call with mapping result * @param ac_cls closure for @a ac * @return NULL on error (no 'upnpc' installed) */struct GNUNET_NAT_MiniHandle *GNUNET_NAT_mini_map_start (uint16_t port,                           int is_tcp,                           GNUNET_NAT_MiniAddressCallback ac,                           void *ac_cls){  struct GNUNET_NAT_MiniHandle *ret;  if (GNUNET_SYSERR ==      GNUNET_OS_check_helper_binary ("upnpc",				     GNUNET_NO,				     NULL))  {    LOG (GNUNET_ERROR_TYPE_INFO,	 _("`upnpc' command not found/n"));    ac (ac_cls,        GNUNET_SYSERR,        NULL, 0,        GNUNET_NAT_ERROR_UPNPC_NOT_FOUND);    return NULL;  }  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Running `upnpc' to install mapping/n");  ret = GNUNET_new (struct GNUNET_NAT_MiniHandle);  ret->ac = ac;  ret->ac_cls = ac_cls;  ret->is_tcp = is_tcp;  ret->port = port;  ret->refresh_task =    GNUNET_SCHEDULER_add_delayed (MAP_REFRESH_FREQ,				  &do_refresh,				  ret);  run_upnpc_r (ret);  return ret;}

/** * Figure out when and how to transmit to the given peer. * * @param cls the 'struct PeerPlan' * @param tc scheduler context */static voidschedule_peer_transmission (void *cls,                            const struct GNUNET_SCHEDULER_TaskContext *tc){  struct PeerPlan *pp = cls;  struct GSF_RequestPlan *rp;  size_t msize;  struct GNUNET_TIME_Relative delay;  pp->task = GNUNET_SCHEDULER_NO_TASK;  if (NULL != pp->pth)  {    GSF_peer_transmit_cancel_ (pp->pth);    pp->pth = NULL;  }  /* move ready requests to priority queue */  while ((NULL != (rp = GNUNET_CONTAINER_heap_peek (pp->delay_heap))) &&         (GNUNET_TIME_absolute_get_remaining          (rp->earliest_transmission).rel_value == 0))  {    GNUNET_assert (rp == GNUNET_CONTAINER_heap_remove_root (pp->delay_heap));    rp->hn = GNUNET_CONTAINER_heap_insert (pp->priority_heap, rp, rp->priority);  }  if (0 == GNUNET_CONTAINER_heap_get_size (pp->priority_heap))  {    /* priority heap (still) empty, check for delay... */    rp = GNUNET_CONTAINER_heap_peek (pp->delay_heap);    if (NULL == rp)    {      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No active requests for plan %p./n",                  pp);      return;                   /* both queues empty */    }    delay = GNUNET_TIME_absolute_get_remaining (rp->earliest_transmission);    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,                "Sleeping for %llu ms before retrying requests on plan %p./n",                (unsigned long long) delay.rel_value, pp);    GNUNET_STATISTICS_set (GSF_stats, gettext_noop ("# delay heap timeout"),                           delay.rel_value, GNUNET_NO);    pp->task =        GNUNET_SCHEDULER_add_delayed (delay, &schedule_peer_transmission, pp);    return;  }#if INSANE_STATISTICS  GNUNET_STATISTICS_update (GSF_stats, gettext_noop ("# query plans executed"),                            1, GNUNET_NO);#endif  /* process from priority heap */  rp = GNUNET_CONTAINER_heap_peek (pp->priority_heap);  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Executing query plan %p/n", rp);  GNUNET_assert (NULL != rp);  msize = GSF_pending_request_get_message_ (get_latest (rp), 0, NULL);  pp->pth =      GSF_peer_transmit_ (pp->cp, GNUNET_YES, rp->priority,                          GNUNET_TIME_UNIT_FOREVER_REL, msize,                          &transmit_message_callback, pp);  GNUNET_assert (NULL != pp->pth);}

static voidsrv_status (void *cls,            const char *service,            enum GNUNET_ARM_ServiceStatus status){  if (status == GNUNET_ARM_SERVICE_MONITORING_STARTED)  {    LOG ("ARM monitor started, starting mock service/n");    phase++;    GNUNET_ARM_request_service_start (arm,                                      SERVICE,                                      GNUNET_OS_INHERIT_STD_OUT_AND_ERR,                                      NULL,                                      NULL);    return;  }  if (0 != strcasecmp (service, SERVICE))    return; /* not what we care about */  if (phase == 1)  {    GNUNET_break (status == GNUNET_ARM_SERVICE_STARTING);    GNUNET_break (phase == 1);    LOG ("do-nothing is starting/n");    phase++;    ok = 1;    GNUNET_assert (NULL == kt);    startedWaitingAt = GNUNET_TIME_absolute_get ();    kt = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,                                       &kill_task,                                       NULL);  }  else if (phase == 2)  {    /* We passively monitor ARM for status updates. ARM should tell us     * when do-nothing dies (no need to run a service upness test ourselves).     */    if (status == GNUNET_ARM_SERVICE_STARTING)    {      waitedFor = GNUNET_TIME_absolute_get_duration (startedWaitingAt);      LOG ("Waited for: %s/n",           GNUNET_STRINGS_relative_time_to_string (waitedFor,                                                   GNUNET_YES));      LOG ("do-nothing is starting, killing it.../n");      GNUNET_assert (NULL == kt);      kt = GNUNET_SCHEDULER_add_now (&kill_task, &ok);    }    else if ((status == GNUNET_ARM_SERVICE_STOPPED) && (trialCount == 14))    {      phase++;      LOG ("do-nothing stopped working %u times, we are done here/n",           (unsigned int) trialCount);      GNUNET_ARM_request_service_stop (arm,                                       "arm",                                       &arm_stop_cb,                                       NULL);    }  }}

static voidsend_test_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc){  struct TestMessageContext *pos = cls;  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 create topology (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! */  }  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,              "Attempting to send test message from %s to %s/n",              pos->peer1->shortname, pos->peer2->shortname);  /*   * Connect to the sending peer   */  pos->peer1handle =      GNUNET_CORE_connect (pos->peer1->cfg, pos, &init_notify_peer1,                           &connect_notify_peer1, 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);  }}

/** * Task that triggers a NSE P2P transmission. * * @param cls the `struct NSEPeerEntry *` */static voidtransmit_task_cb (void *cls){  struct NSEPeerEntry *peer_entry = cls;  unsigned int idx;  struct GNUNET_MQ_Envelope *env;  peer_entry->transmit_task = NULL;  idx = estimate_index;  if (GNUNET_NO == peer_entry->previous_round)  {    idx = (idx + HISTORY_SIZE - 1) % HISTORY_SIZE;    peer_entry->previous_round = GNUNET_YES;    peer_entry->transmit_task      = GNUNET_SCHEDULER_add_delayed (get_transmit_delay (0),				      &transmit_task_cb,				      peer_entry);  }  if ((0 == ntohl (size_estimate_messages[idx].hop_count)) &&      (NULL != proof_task))  {    GNUNET_STATISTICS_update (stats,                              "# flood messages not generated (no proof yet)",                              1,			      GNUNET_NO);    return;  }  if (0 == ntohs (size_estimate_messages[idx].header.size))  {    GNUNET_STATISTICS_update (stats,                              "# flood messages not generated (lack of history)",                              1,			      GNUNET_NO);    return;  }  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,              "In round %s, sending to `%s' estimate with %u bits/n",              GNUNET_STRINGS_absolute_time_to_string (GNUNET_TIME_absolute_ntoh (size_estimate_messages[idx].timestamp)),              GNUNET_i2s (peer_entry->id),              (unsigned int) ntohl (size_estimate_messages[idx].matching_bits));  if (0 == ntohl (size_estimate_messages[idx].hop_count))    GNUNET_STATISTICS_update (stats,			      "# flood messages started",			      1,			      GNUNET_NO);  GNUNET_STATISTICS_update (stats,			    "# flood messages transmitted",			    1,                            GNUNET_NO);#if ENABLE_NSE_HISTOGRAM  peer_entry->transmitted_messages++;  peer_entry->last_transmitted_size    = ntohl(size_estimate_messages[idx].matching_bits);#endif  env = GNUNET_MQ_msg_copy (&size_estimate_messages[idx].header);  GNUNET_MQ_send (peer_entry->mq,		  env);}

/** * Calculate when we would like to send the next HELLO to this * peer and ask for it. * * @param cls for which peer to schedule the HELLO */static voidschedule_next_hello (void *cls){  struct Peer *pl = cls;  struct FindAdvHelloContext fah;  struct GNUNET_MQ_Envelope *env;  size_t want;  struct GNUNET_TIME_Relative delay;  struct GNUNET_HashCode hc;  pl->hello_delay_task = NULL;  GNUNET_assert (NULL != pl->mq);  /* find applicable HELLOs */  fah.peer = pl;  fah.result = NULL;  fah.max_size = GNUNET_SERVER_MAX_MESSAGE_SIZE - 1;  fah.next_adv = GNUNET_TIME_UNIT_FOREVER_REL;  GNUNET_CONTAINER_multipeermap_iterate (peers,                                         &find_advertisable_hello,                                         &fah);  pl->hello_delay_task =      GNUNET_SCHEDULER_add_delayed (fah.next_adv,                                    &schedule_next_hello,                                    pl);  if (NULL == fah.result)    return;  delay = GNUNET_TIME_absolute_get_remaining (pl->next_hello_allowed);  if (0 != delay.rel_value_us)    return;  want = GNUNET_HELLO_size (fah.result->hello);  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,	      "Sending HELLO with %u bytes",	      (unsigned int) want);  env = GNUNET_MQ_msg_copy (&fah.result->hello->header);  GNUNET_MQ_send (pl->mq,		  env);  /* avoid sending this one again soon */  GNUNET_CRYPTO_hash (&pl->pid,		      sizeof (struct GNUNET_PeerIdentity),		      &hc);  GNUNET_CONTAINER_bloomfilter_add (fah.result->filter,				    &hc);  GNUNET_STATISTICS_update (stats,			    gettext_noop ("# HELLO messages gossipped"),			    1,			    GNUNET_NO);  /* prepare to send the next one */  if (NULL != pl->hello_delay_task)    GNUNET_SCHEDULER_cancel (pl->hello_delay_task);  pl->next_hello_allowed    = GNUNET_TIME_relative_to_absolute (HELLO_ADVERTISEMENT_MIN_FREQUENCY);  pl->hello_delay_task    = GNUNET_SCHEDULER_add_now (&schedule_next_hello,				pl);}

static voidstop_arm (struct PeerContext *p){  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,	      "Asking ARM to stop core service/n");  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,				&waitpid_task,				p);}

static voidrun_property (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc){  struct SysmonProperty *sp = cls;  sp->task_id = GNUNET_SCHEDULER_NO_TASK;  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Running continous property `%s' /n", sp->desc);  sp->task (cls, tc);  sp->task_id = GNUNET_SCHEDULER_add_delayed (sp->interval, &run_property, sp);}

/** * Schedule a task to try to connect to the specified peer. * * @param pos peer to connect to */static voidschedule_attempt_connect (struct Peer *pos){  if (GNUNET_SCHEDULER_NO_TASK != pos->attempt_connect_task)    return;  pos->attempt_connect_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining (next_connect_attempt),							    &do_attempt_connect,							    pos);}

/** * This function is called *before* the DNS request has been  * given to a "local" DNS resolver.  Tunneling for DNS requests * was enabled, so we now need to send the request via some MESH * tunnel to a DNS EXIT for resolution. * * @param cls closure * @param rh request handle to user for reply * @param request_length number of bytes in request * @param request udp payload of the DNS request */static void dns_pre_request_handler (void *cls,			 struct GNUNET_DNS_RequestHandle *rh,			 size_t request_length,			 const char *request){  struct RequestContext *rc;  size_t mlen;  struct GNUNET_MessageHeader hdr;  struct GNUNET_TUN_DnsHeader dns;  GNUNET_STATISTICS_update (stats,			    gettext_noop ("# DNS requests intercepted"),			    1, GNUNET_NO);  if (0 == dns_exit_available)  {    GNUNET_STATISTICS_update (stats,			      gettext_noop ("# DNS requests dropped (DNS mesh tunnel down)"),			      1, GNUNET_NO);    GNUNET_DNS_request_drop (rh);    return;  }  if (request_length < sizeof (dns))  {    GNUNET_STATISTICS_update (stats,			      gettext_noop ("# DNS requests dropped (malformed)"),			      1, GNUNET_NO);    GNUNET_DNS_request_drop (rh);    return;  }  memcpy (&dns, request, sizeof (dns));  GNUNET_assert (NULL != mesh_tunnel);  mlen = sizeof (struct GNUNET_MessageHeader) + request_length;  rc = GNUNET_malloc (sizeof (struct RequestContext) + mlen);  rc->rh = rh;  rc->mesh_message = (const struct GNUNET_MessageHeader*) &rc[1];  rc->timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,						   &timeout_request,						   rc);  rc->dns_id = dns.id;  hdr.type = htons (GNUNET_MESSAGE_TYPE_VPN_DNS_TO_INTERNET);  hdr.size = htons (mlen);  memcpy (&rc[1], &hdr, sizeof (struct GNUNET_MessageHeader));  memcpy (&(((char*)&rc[1])[sizeof (struct GNUNET_MessageHeader)]),	  request,	  request_length);  GNUNET_CONTAINER_DLL_insert_tail (transmit_queue_head,				    transmit_queue_tail,				    rc);  if (NULL == mesh_th)    mesh_th = GNUNET_MESH_notify_transmit_ready (mesh_tunnel,						 GNUNET_NO, 0,						 TIMEOUT,						 NULL, mlen,						 &transmit_dns_request_to_mesh,						 NULL);}

/** * Reset the timeout for the stream client (due to activity). * * @param sc client handle to reset timeout for */static voidrefresh_timeout_task (struct StreamClient *sc){  if (GNUNET_SCHEDULER_NO_TASK != sc->timeout_task)    GNUNET_SCHEDULER_cancel (sc->timeout_task);   sc->timeout_task = GNUNET_SCHEDULER_add_delayed (IDLE_TIMEOUT,						   &timeout_stream_task,						   sc);}

static voidtry_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc){  connect_task =      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &try_connect,                                    NULL);  GNUNET_TRANSPORT_try_connect (p1.th, &p2.id, NULL, NULL); /*FIXME TRY_CONNECT change */  GNUNET_TRANSPORT_try_connect (p2.th, &p1.id, NULL, NULL); /*FIXME TRY_CONNECT change */}

/** * Perform a PUT operation storing data in the DHT.  FIXME: we should * change the protocol to get a confirmation for the PUT from the DHT * and call 'cont' only after getting the confirmation; otherwise, the * client has no good way of telling if the 'PUT' message actually got * to the DHT service! * * @param handle handle to DHT service * @param key the key to store under * @param desired_replication_level estimate of how many *                nearest peers this request should reach * @param options routing options for this message * @param type type of the value * @param size number of bytes in data; must be less than 64k * @param data the data to store * @param exp desired expiration time for the value * @param timeout how long to wait for transmission of this request * @param cont continuation to call when done (transmitting request to service) *        You must not call #GNUNET_DHT_disconnect in this continuation * @param cont_cls closure for @a cont */struct GNUNET_DHT_PutHandle *GNUNET_DHT_put (struct GNUNET_DHT_Handle *handle,		const struct GNUNET_HashCode * key,                uint32_t desired_replication_level,                enum GNUNET_DHT_RouteOption options,                enum GNUNET_BLOCK_Type type, size_t size,		const void *data,                struct GNUNET_TIME_Absolute exp,                struct GNUNET_TIME_Relative timeout,		GNUNET_DHT_PutContinuation cont,                void *cont_cls){  struct GNUNET_DHT_ClientPutMessage *put_msg;  size_t msize;  struct PendingMessage *pending;  struct GNUNET_DHT_PutHandle *ph;  msize = sizeof (struct GNUNET_DHT_ClientPutMessage) + size;  if ((msize >= GNUNET_SERVER_MAX_MESSAGE_SIZE) ||      (size >= GNUNET_SERVER_MAX_MESSAGE_SIZE))  {    GNUNET_break (0);    return NULL;  }  ph = GNUNET_new (struct GNUNET_DHT_PutHandle);  ph->dht_handle = handle;  ph->timeout_task = GNUNET_SCHEDULER_add_delayed (timeout, &timeout_put_request, ph);  ph->cont = cont;  ph->cont_cls = cont_cls;  ph->unique_id = ++handle->uid_gen;  pending = GNUNET_malloc (sizeof (struct PendingMessage) + msize);  ph->pending = pending;  put_msg = (struct GNUNET_DHT_ClientPutMessage *) &pending[1];  pending->msg = &put_msg->header;  pending->handle = handle;  pending->cont = &mark_put_message_gone;  pending->cont_cls = ph;  pending->free_on_send = GNUNET_YES;  put_msg->header.size = htons (msize);  put_msg->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT);  put_msg->type = htonl (type);  put_msg->options = htonl ((uint32_t) options);  put_msg->desired_replication_level = htonl (desired_replication_level);  put_msg->unique_id = ph->unique_id;  put_msg->expiration = GNUNET_TIME_absolute_hton (exp);  put_msg->key = *key;  memcpy (&put_msg[1], data, size);  GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail,                               pending);  pending->in_pending_queue = GNUNET_YES;  GNUNET_CONTAINER_DLL_insert_tail (handle->put_head,				    handle->put_tail,				    ph);  process_pending_messages (handle);  return ph;}

/** * Start the helper process. * * @param h handle to the helper process */static voidstart_helper (struct GNUNET_HELPER_Handle *h){  h->helper_in = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO);  h->helper_out = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);  if ( (h->helper_in == NULL) || (h->helper_out == NULL))  {    /* out of file descriptors? try again later... */    stop_helper (h, GNUNET_NO);    h->restart_task =      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,								  h->retry_back_off),				    &restart_task, h);    return;  }  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,	      "Starting HELPER process `%s'/n",	      h->binary_name);  h->fh_from_helper =      GNUNET_DISK_pipe_handle (h->helper_out, GNUNET_DISK_PIPE_END_READ);  h->fh_to_helper =      GNUNET_DISK_pipe_handle (h->helper_in, GNUNET_DISK_PIPE_END_WRITE);  h->helper_proc =    GNUNET_OS_start_process_vap (h->with_control_pipe, GNUNET_OS_INHERIT_STD_ERR,				 h->helper_in, h->helper_out, NULL,				 h->binary_name,				 h->binary_argv);  if (NULL == h->helper_proc)  {    /* failed to start process? try again later... */    stop_helper (h, GNUNET_NO);    h->restart_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,										  h->retry_back_off),						    &restart_task, h);    return;  }  GNUNET_DISK_pipe_close_end (h->helper_out, GNUNET_DISK_PIPE_END_WRITE);  GNUNET_DISK_pipe_close_end (h->helper_in, GNUNET_DISK_PIPE_END_READ);  if (NULL != h->mst)    h->read_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,						   h->fh_from_helper,						   &helper_read,						   h);}

/** * Call a method for each known matching host and change its trust * value.  The callback method will be invoked once for each matching * host and then finally once with a NULL pointer.  After that final * invocation, the iterator context must no longer be used. * * Instead of calling this function with 'peer == NULL' it is often * better to use 'GNUNET_PEERINFO_notify'. * * @param h handle to the peerinfo service * @param peer restrict iteration to this peer only (can be NULL) * @param timeout how long to wait until timing out * @param callback the method to call for each peer * @param callback_cls closure for callback * @return iterator context */struct GNUNET_PEERINFO_IteratorContext *GNUNET_PEERINFO_iterate (struct GNUNET_PEERINFO_Handle *h,                         const struct GNUNET_PeerIdentity *peer,                         struct GNUNET_TIME_Relative timeout,                         GNUNET_PEERINFO_Processor callback, void *callback_cls){  struct GNUNET_MessageHeader *lapm;  struct ListPeerMessage *lpm;  struct GNUNET_PEERINFO_IteratorContext *ic;  struct GNUNET_PEERINFO_AddContext *ac;  ic = GNUNET_malloc (sizeof (struct GNUNET_PEERINFO_IteratorContext));  if (NULL == peer)  {    LOG (GNUNET_ERROR_TYPE_DEBUG,         "Requesting list of peers from PEERINFO service/n");    ac =        GNUNET_malloc (sizeof (struct GNUNET_PEERINFO_AddContext) +                       sizeof (struct GNUNET_MessageHeader));    ac->size = sizeof (struct GNUNET_MessageHeader);    lapm = (struct GNUNET_MessageHeader *) &ac[1];    lapm->size = htons (sizeof (struct GNUNET_MessageHeader));    lapm->type = htons (GNUNET_MESSAGE_TYPE_PEERINFO_GET_ALL);  }  else  {    LOG (GNUNET_ERROR_TYPE_DEBUG,         "Requesting information on peer `%4s' from PEERINFO service/n",         GNUNET_i2s (peer));    ac =        GNUNET_malloc (sizeof (struct GNUNET_PEERINFO_AddContext) +                       sizeof (struct ListPeerMessage));    ac->size = sizeof (struct ListPeerMessage);    lpm = (struct ListPeerMessage *) &ac[1];    lpm->header.size = htons (sizeof (struct ListPeerMessage));    lpm->header.type = htons (GNUNET_MESSAGE_TYPE_PEERINFO_GET);    memcpy (&lpm->peer, peer, sizeof (struct GNUNET_PeerIdentity));    ic->have_peer = GNUNET_YES;    ic->peer = *peer;  }  ic->h = h;  ic->ac = ac;  ic->callback = callback;  ic->callback_cls = callback_cls;  ic->timeout = GNUNET_TIME_relative_to_absolute (timeout);  ic->timeout_task =      GNUNET_SCHEDULER_add_delayed (timeout, &signal_timeout, ic);  ac->cont = &iterator_start_receive;  ac->cont_cls = ic;  GNUNET_CONTAINER_DLL_insert_tail (h->ac_head, h->ac_tail, ac);  GNUNET_CONTAINER_DLL_insert_tail (h->ic_head,				    h->ic_tail,				    ic);  trigger_transmit (h);  return ic;}

static voidrun_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc){  char *fn;  const struct GNUNET_DISK_FileHandle *stdout_read_handle;  const struct GNUNET_DISK_FileHandle *wh;  GNUNET_asprintf (&fn, "cat");  hello_pipe_stdin = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO);  hello_pipe_stdout = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);  if ((hello_pipe_stdout == NULL) || (hello_pipe_stdin == NULL))  {    GNUNET_break (0);    ok = 1;    GNUNET_free (fn);    return;  }  proc =      GNUNET_OS_start_process (GNUNET_NO, hello_pipe_stdin, hello_pipe_stdout, fn,                               "test_gnunet_echo_hello", "-", NULL);  GNUNET_free (fn);  /* Close the write end of the read pipe */  GNUNET_DISK_pipe_close_end (hello_pipe_stdout, GNUNET_DISK_PIPE_END_WRITE);  /* Close the read end of the write pipe */  GNUNET_DISK_pipe_close_end (hello_pipe_stdin, GNUNET_DISK_PIPE_END_READ);  wh = GNUNET_DISK_pipe_handle (hello_pipe_stdin, GNUNET_DISK_PIPE_END_WRITE);  /* Write the test_phrase to the cat process */  if (GNUNET_DISK_file_write (wh, test_phrase, strlen (test_phrase) + 1) !=      strlen (test_phrase) + 1)  {    GNUNET_break (0);    ok = 1;    return;  }  /* Close the write end to end the cycle! */  GNUNET_DISK_pipe_close_end (hello_pipe_stdin, GNUNET_DISK_PIPE_END_WRITE);  stdout_read_handle =      GNUNET_DISK_pipe_handle (hello_pipe_stdout, GNUNET_DISK_PIPE_END_READ);  die_task =      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply                                    (GNUNET_TIME_UNIT_MINUTES, 1), &end_task,                                    NULL);  GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,                                  stdout_read_handle, &read_call,                                  (void *) stdout_read_handle);}

/** * Periodic task to refresh our announcement of the regex. * * @param cls the `struct ClientEntry *` of the client that triggered the *        announcement */static voidreannounce (void *cls){  struct ClientEntry *ce = cls;  REGEX_INTERNAL_reannounce (ce->ah);  ce->refresh_task = GNUNET_SCHEDULER_add_delayed (ce->frequency,						   &reannounce,						   ce);}

static voidreconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc){  struct PeerContext *p = cls;  reconnect_task = GNUNET_SCHEDULER_NO_TASK;  GNUNET_TRANSPORT_try_connect (p1->th, &p2->id, NULL, NULL); /*FIXME TRY_CONNECT change */  reconnect_task =      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &reconnect, p);}

/** * Disconnect from service and then reconnect. * * @param h our handle */static voidforce_reconnect (struct GNUNET_NAMESTORE_Handle *h){  h->reconnect = GNUNET_NO;  GNUNET_CLIENT_disconnect (h->client);  h->client = NULL;  h->reconnect_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,                                    &reconnect_task,                                    h);}

/** * Continuation called from expected-to-fail rename operation. * * @param cls NULL * @param emsg (should also be NULL) */static voidfail_rename_cont (void *cls,		  const char *emsg){  GNUNET_assert (NULL != emsg);  op = NULL;  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,                                &finally_delete,                                NULL);}