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

/** * Store an item in the datastore. * * @param h handle to the datacache * @param key key to store data under * @param size number of bytes in data * @param data data to store * @param type type of the value * @param discard_time when to discard the value in any case * @param path_info_len number of entries in 'path_info' * @param path_info a path through the network * @return GNUNET_OK on success, GNUNET_SYSERR on error, GNUNET_NO if duplicate */intGNUNET_DATACACHE_put (struct GNUNET_DATACACHE_Handle *h,                      const struct GNUNET_HashCode * key, size_t size,                      const char *data, enum GNUNET_BLOCK_Type type,                      struct GNUNET_TIME_Absolute discard_time,		      unsigned int path_info_len,		      const struct GNUNET_PeerIdentity *path_info){  ssize_t used;  used = h->api->put (h->api->cls, key, 		      size, data, 		      type, discard_time,		      path_info_len, path_info);  if (-1 == used)  {    GNUNET_break (0);    return GNUNET_SYSERR;  }  if (0 == used)  {    /* duplicate */    return GNUNET_NO;  }  LOG (GNUNET_ERROR_TYPE_DEBUG, "Stored data under key `%s' in cache/n",       GNUNET_h2s (key));  GNUNET_STATISTICS_update (h->stats, gettext_noop ("# bytes stored"), size,                            GNUNET_NO);  GNUNET_STATISTICS_update (h->stats, gettext_noop ("# items stored"), 1,                            GNUNET_NO);  if (NULL != h->filter)    GNUNET_CONTAINER_bloomfilter_add (h->filter, key);  while (h->utilization + used > h->env.quota)    GNUNET_assert (GNUNET_OK == h->api->del (h->api->cls));  h->utilization += used;  return GNUNET_OK;}

/** * Delete an existing identity. * * @param id identity service to use * @param name name of the identity to delete * @param cb function to call with the result (will only be called once) * @param cb_cls closure for @a cb * @return handle to abort the operation */struct GNUNET_IDENTITY_Operation *GNUNET_IDENTITY_delete (struct GNUNET_IDENTITY_Handle *id,			const char *name,			GNUNET_IDENTITY_Continuation cb,			void *cb_cls){  struct GNUNET_IDENTITY_Operation *op;  struct GNUNET_IDENTITY_DeleteMessage *gdm;  size_t slen;  slen = strlen (name) + 1;  if (slen >= GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct GNUNET_IDENTITY_DeleteMessage))  {    GNUNET_break (0);    return NULL;  }  op = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_Operation) +		      sizeof (struct GNUNET_IDENTITY_DeleteMessage) +		      slen);  op->h = id;  op->cont = cb;  op->cls = cb_cls;  gdm = (struct GNUNET_IDENTITY_DeleteMessage *) &op[1];  gdm->header.type = htons (GNUNET_MESSAGE_TYPE_IDENTITY_DELETE);  gdm->header.size = htons (sizeof (struct GNUNET_IDENTITY_DeleteMessage) +			    slen);  gdm->name_len = htons (slen);  gdm->reserved = htons (0);  memcpy (&gdm[1], name, slen);  op->msg = &gdm->header;  GNUNET_CONTAINER_DLL_insert_tail (id->op_head,				    id->op_tail,				    op);  if (NULL == id->th)    transmit_next (id);  return op;}

/** * Disconnect from the peerinfo service.  Note that all iterators must * have completed or have been cancelled by the time this function is * called (otherwise, calling this function is a serious error). * Furthermore, if 'GNUNET_PEERINFO_add_peer' operations are still * pending, they will be cancelled silently on disconnect. * * @param h handle to disconnect */voidGNUNET_PEERINFO_disconnect (struct GNUNET_PEERINFO_Handle *h){  struct GNUNET_PEERINFO_AddContext *ac;  struct GNUNET_PEERINFO_IteratorContext *ic;  while (NULL != (ic = h->ic_head))  {    GNUNET_break (GNUNET_YES == ic->in_receive);    ic->in_receive = GNUNET_NO;    GNUNET_PEERINFO_iterate_cancel (ic);  }  while (NULL != (ac = h->ac_head))  {    GNUNET_CONTAINER_DLL_remove (h->ac_head, h->ac_tail, ac);    if (NULL != ac->cont)      ac->cont (ac->cont_cls, _("aborted due to explicit disconnect request"));    GNUNET_free (ac);  }  if (NULL != h->th)  {    GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);    h->th = NULL;  }  if (NULL != h->client)  {    GNUNET_CLIENT_disconnect (h->client);    h->client = NULL;  }  if (GNUNET_SCHEDULER_NO_TASK != h->r_task)  {    GNUNET_SCHEDULER_cancel (h->r_task);    h->r_task = GNUNET_SCHEDULER_NO_TASK;  }  GNUNET_free (h);}

/** * Callback which will be called to after a host registration succeeded or failed * * @param cls the host which has been registered * @param emsg the error message; NULL if host registration is successful */static voidregistration_cont (void *cls, const char *emsg){  rh = NULL;  switch (result)  {  case MASTER_PEER_START_SUCCESS:    GNUNET_assert (NULL == emsg);    GNUNET_assert (NULL != mc);    result = SLAVE1_REGISTERED;    slave2 = GNUNET_TESTBED_host_create_with_id (2, "127.0.0.1", NULL, 0);    GNUNET_assert (NULL != slave2);    rh = GNUNET_TESTBED_register_host (mc, slave2, &registration_cont, NULL);    GNUNET_assert (NULL != rh);    break;  case SLAVE1_REGISTERED:    GNUNET_assert (NULL == emsg);    GNUNET_assert (NULL != mc);    result = SLAVE2_REGISTERED;    GNUNET_assert (NULL != cfg);    op = GNUNET_TESTBED_controller_link (NULL, mc, slave, NULL, cfg, GNUNET_YES);    GNUNET_assert (NULL != op);    break;  case SLAVE2_PEER_DESTROY_SUCCESS:    GNUNET_assert (NULL == emsg);    GNUNET_assert (NULL != mc);    GNUNET_assert (NULL == op);    result = SLAVE3_REGISTERED;    op = GNUNET_TESTBED_controller_link (NULL, mc, slave3, NULL, cfg, GNUNET_YES);    GNUNET_assert (NULL != op);    break;  default:    GNUNET_break (0);    do_abort_now (NULL);  }}

/** * Update statistics * * @param m peermap to update values from */static voidupdate_stats (struct GNUNET_CONTAINER_MultiPeerMap *m){  GNUNET_assert (NULL != m);  GNUNET_assert (NULL != GED_stats);  if (m == nodes_active)  {    GNUNET_STATISTICS_set (GED_stats, "# nodes active",			   GNUNET_CONTAINER_multipeermap_size(m), GNUNET_NO);  }  else if (m == nodes_inactive)  {    GNUNET_STATISTICS_set (GED_stats, "# nodes inactive",			   GNUNET_CONTAINER_multipeermap_size(m), GNUNET_NO);  }  else if (m == nodes_requested)  {    GNUNET_STATISTICS_set (GED_stats, "# nodes requested",			   GNUNET_CONTAINER_multipeermap_size(m), GNUNET_NO);  }  else    GNUNET_break (0);}

/** * Find a path to a peer that offers a regex service compatible * with a given string. * * @param key The key of the accepting state. * @param ctx Context containing info about the string, tunnel, etc. */static voidregex_find_path (const struct GNUNET_HashCode *key,                 struct RegexSearchContext *ctx){  struct GNUNET_DHT_GetHandle *get_h;  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Accept state found, now searching for paths to %s/n",       GNUNET_h2s (key),       (unsigned int) ctx->position);  get_h = GNUNET_DHT_get_start (ctx->info->dht,    /* handle */                                GNUNET_BLOCK_TYPE_REGEX_ACCEPT, /* type */                                key,     /* key to search */                                DHT_REPLICATION, /* replication level */                                DHT_OPT | GNUNET_DHT_RO_RECORD_ROUTE,                                NULL,       /* xquery */ // FIXME BLOOMFILTER                                0,     /* xquery bits */ // FIXME BLOOMFILTER SIZE                                &dht_get_string_accept_handler, ctx);  GNUNET_break (GNUNET_OK ==                GNUNET_CONTAINER_multihashmap_put(ctx->info->dht_get_handles,                                                  key,                                                  get_h,                                                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));}

/** * Perform an asynchronous reverse lookup operation on the GNS. * * @param handle handle to the GNS service * @param zone_key zone to find a name for * @param root_key our zone * @param proc processor to call on result * @param proc_cls closure for @a proc * @return handle to the request */struct GNUNET_GNS_ReverseLookupRequest*GNUNET_GNS_reverse_lookup (struct GNUNET_GNS_Handle *handle,                           const struct GNUNET_CRYPTO_EcdsaPublicKey *zone_key,                           const struct GNUNET_CRYPTO_EcdsaPublicKey *root_key,                           GNUNET_GNS_ReverseLookupResultProcessor proc,                           void *proc_cls){    /* IPC to shorten gns names, return shorten_handle */    struct ReverseLookupMessage *rev_lookup_msg;    struct GNUNET_GNS_ReverseLookupRequest *lr;    if ((NULL == zone_key) || (NULL == root_key))    {        GNUNET_break (0);        return NULL;    }    LOG (GNUNET_ERROR_TYPE_DEBUG,         "Trying to reverse lookup in GNS/n");    lr = GNUNET_new (struct GNUNET_GNS_ReverseLookupRequest);    lr->gns_handle = handle;    lr->lookup_proc = proc;    lr->proc_cls = proc_cls;    lr->r_id = handle->r_id_gen++;    lr->env = GNUNET_MQ_msg (rev_lookup_msg,                             GNUNET_MESSAGE_TYPE_GNS_REVERSE_LOOKUP);    rev_lookup_msg->id = htonl (lr->r_id);    rev_lookup_msg->zone_pkey = *zone_key;    rev_lookup_msg->root_pkey = *root_key;    GNUNET_CONTAINER_DLL_insert (handle->rev_lookup_head,                                 handle->rev_lookup_tail,                                 lr);    if (NULL != handle->mq)        GNUNET_MQ_send_copy (handle->mq,                             lr->env);    return lr;}

/** * Handle element for iteration over the set.  Notifies the * iterator and sends an acknowledgement to the service. * * @param cls the `struct GNUNET_SET_Handle *` * @param mh the message */static voidhandle_copy_lazy (void *cls,                  const struct GNUNET_MessageHeader *mh){  struct GNUNET_SET_CopyLazyResponseMessage *msg;  struct GNUNET_SET_Handle *set = cls;  struct SetCopyRequest *req;  struct GNUNET_SET_Handle *new_set;  msg = (struct GNUNET_SET_CopyLazyResponseMessage *) mh;  req = set->copy_req_head;  if (NULL == req)  {    /* Service sent us unsolicited lazy copy response */    GNUNET_break (0);    return;  }  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Handling response to lazy copy/n");    GNUNET_CONTAINER_DLL_remove (set->copy_req_head,                               set->copy_req_tail,                               req);    // We pass none as operation here, since it doesn't matter when  // cloning.  new_set = create_internal (set->cfg, GNUNET_SET_OPERATION_NONE, &msg->cookie);  req->cb (req->cls, new_set);  GNUNET_free (req);}

static voidconnect_notify (void *cls, const struct GNUNET_PeerIdentity *peer){  struct PeerContext *pc = cls;  if (0 == memcmp (&pc->id, peer, sizeof (struct GNUNET_PeerIdentity)))    return;                     /* loopback */  GNUNET_assert (pc->connect_status == 0);  pc->connect_status = 1;  if (pc == &p1)  {    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,                "Encrypted connection established to peer `%4s'/n",                GNUNET_i2s (peer));    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,                "Asking core (1) for transmission to peer `%4s'/n",                GNUNET_i2s (&p2.id));    if (err_task != NULL)      GNUNET_SCHEDULER_cancel (err_task);    err_task =        GNUNET_SCHEDULER_add_delayed (TIMEOUT, &terminate_task_error, NULL);    start_time = GNUNET_TIME_absolute_get ();    running = GNUNET_YES;    measure_task =        GNUNET_SCHEDULER_add_delayed (MEASUREMENT_LENGTH, &measurement_stop,                                      NULL);    GNUNET_break (NULL !=                  (p1.nth =                   GNUNET_CORE_notify_transmit_ready (p1.ch, GNUNET_NO,                                                      GNUNET_CORE_PRIO_BEST_EFFORT,                                                      TIMEOUT, &p2.id,                                                      MESSAGESIZE,                                                      &transmit_ready, &p1)));  }}

/** * Handler for port open requests. * * @param cls Identification of the client. * @param pmsg The actual message. */static voidhandle_port_open (void *cls,                  const struct GNUNET_CADET_PortMessage *pmsg){  struct CadetClient *c = cls;  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Open port %s requested by client %u/n",       GNUNET_h2s (&pmsg->port),       c->id);  if (NULL == c->ports)    c->ports = GNUNET_CONTAINER_multihashmap_create (4,                                                     GNUNET_NO);  if (GNUNET_OK !=      GNUNET_CONTAINER_multihashmap_put (c->ports,                                         &pmsg->port,                                         c,                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))  {    GNUNET_break (0);    GNUNET_SERVICE_client_drop (c->client);    return;  }  /* store in global hashmap */  /* FIXME only allow one client to have the port open,   *       have a backup hashmap with waiting clients */  GNUNET_CONTAINER_multihashmap_put (open_ports,                                     &pmsg->port,                                     c,                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);  GNUNET_CONTAINER_multihashmap_get_multiple (loose_channels,                                              &pmsg->port,                                              &bind_loose_channel,                                              c);  GNUNET_SERVICE_client_continue (c->client);}

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);}

/** * Create a new entry in the peer list. * * @param peer identity of the new entry * @param hello hello message, can be NULL * @param is_friend is the new entry for a friend? * @return the new entry */static struct Peer *make_peer (const struct GNUNET_PeerIdentity *peer,           const struct GNUNET_HELLO_Message *hello,           int is_friend){  struct Peer *ret;  ret = GNUNET_new (struct Peer);  ret->pid = *peer;  ret->is_friend = is_friend;  if (NULL != hello)  {    ret->hello = GNUNET_malloc (GNUNET_HELLO_size (hello));    GNUNET_memcpy (ret->hello,		   hello,		   GNUNET_HELLO_size (hello));  }  GNUNET_break (GNUNET_OK ==                GNUNET_CONTAINER_multipeermap_put (peers,                                                   peer,                                                   ret,                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));  return ret;}

/** * Store an item in the datastore. * * @param h handle to the datacache * @param key key to store data under * @param size number of bytes in data * @param data data to store * @param type type of the value * @param discard_time when to discard the value in any case * @return GNUNET_OK on success, GNUNET_SYSERR on error (full, etc.) */intGNUNET_DATACACHE_put (struct GNUNET_DATACACHE_Handle *h,                      const GNUNET_HashCode * key, size_t size,                      const char *data, enum GNUNET_BLOCK_Type type,                      struct GNUNET_TIME_Absolute discard_time){  uint32_t used;  used = h->api->put (h->api->cls, key, size, data, type, discard_time);  if (used == 0)  {    GNUNET_break (0);    return GNUNET_SYSERR;  }  LOG (GNUNET_ERROR_TYPE_DEBUG, "Stored data under key `%s' in cache/n",       GNUNET_h2s (key));  GNUNET_STATISTICS_update (h->stats, gettext_noop ("# bytes stored"), size,                            GNUNET_NO);  GNUNET_CONTAINER_bloomfilter_add (h->filter, key);  while (h->utilization + used > h->env.quota)    GNUNET_assert (GNUNET_OK == h->api->del (h->api->cls));  h->utilization += used;  return GNUNET_OK;}

static intrun_properties (void){  struct SysmonProperty *sp;  for (sp = sp_head; NULL != sp; sp = sp->next)  {      if (t_static == sp->type)      {          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Running static property `%s' /n", sp->desc);          put_property (sp);      }      else      {          if (NULL == sp->task)          {            GNUNET_break (0);            continue;          }          sp->task_id = GNUNET_SCHEDULER_add_now (&run_property, sp);      }  }  return GNUNET_OK;}

/** * Convert IP address to string without DNS resolution. * * @param af address family * @param ip the address * @param ip_len number of bytes in @a ip * @return address as a string, NULL on error */static char *no_resolve (int af,            const void *ip, socklen_t ip_len){    char buf[INET6_ADDRSTRLEN];    switch (af)    {    case AF_INET:        if (ip_len != sizeof (struct in_addr))            return NULL;        if (NULL ==                inet_ntop (AF_INET, ip, buf, sizeof (buf)))        {            LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,                          "inet_ntop");            return NULL;        }        break;    case AF_INET6:        if (ip_len != sizeof (struct in6_addr))            return NULL;        if (NULL ==                inet_ntop (AF_INET6, ip, buf, sizeof (buf)))        {            LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,                          "inet_ntop");            return NULL;        }        break;    default:        GNUNET_break (0);        return NULL;    }    return GNUNET_strdup (buf);}

/** * Notify the tracker that a certain number of bytes of bandwidth have * been consumed.  Note that it is legal to consume bytes even if not * enough bandwidth is available (in that case, * #GNUNET_BANDWIDTH_tracker_get_delay may return non-zero delay values * even for a size of zero for a while). * * @param av tracker to update * @param size number of bytes consumed * @return #GNUNET_YES if this consumption is above the limit */intGNUNET_BANDWIDTH_tracker_consume (struct GNUNET_BANDWIDTH_Tracker *av,                                  ssize_t size){  int64_t nc;  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Tracker %p consumes %d bytes/n",       av,       (int) size);  if (size > 0)  {    nc = av->consumption_since_last_update__ + size;    if (nc < av->consumption_since_last_update__)    {      GNUNET_break (0);      return GNUNET_SYSERR;    }    av->consumption_since_last_update__ = nc;    update_tracker (av);    update_excess (av);    if (av->consumption_since_last_update__ > 0)    {      LOG (GNUNET_ERROR_TYPE_DEBUG,           "Tracker %p consumption %llu bytes above limit/n", av,           (unsigned long long) av->consumption_since_last_update__);      return GNUNET_YES;    }  }  else  {    av->consumption_since_last_update__ += size;    update_excess (av);  }  return GNUNET_NO;}

static inttest_policy6toregex (const char *policy,                     const char *regex){  char *r;  int ret;  ret = 0;  r = GNUNET_TUN_ipv6policy2regex (policy);  if (NULL == r)  {    GNUNET_break (0);    return 1;  }  if (0 != strcmp (regex, r))  {    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,                "Expected: `%s' but got: `%s'/n",                regex, r);    ret = 2;  }  GNUNET_free (r);  return ret;}

intmain (int argc, char *argv[]){  int errCnt = 0;  GNUNET_log_setup ("test_getopt", "WARNING", NULL);  /* suppress output from -h, -v options */#ifndef MINGW  GNUNET_break (0 == CLOSE (1));#endif  if (0 != testMinimal ())    errCnt++;  if (0 != testVerbose ())    errCnt++;  if (0 != testVersion ())    errCnt++;  if (0 != testAbout ())    errCnt++;  if (0 != testLogOpts ())    errCnt++;  if (0 != testFlagNum ())    errCnt++;  return errCnt;}

static voidcurl_main (){  fd_set rs;  fd_set ws;  fd_set es;  int max;  struct GNUNET_NETWORK_FDSet nrs;  struct GNUNET_NETWORK_FDSet nws;  struct GNUNET_TIME_Relative delay;  long timeout;  int running;  struct CURLMsg *msg;  max = 0;  FD_ZERO (&rs);  FD_ZERO (&ws);  FD_ZERO (&es);  curl_multi_perform (multi, &running);  if (running == 0)  {    GNUNET_assert (NULL != (msg = curl_multi_info_read (multi, &running)));    if (msg->msg == CURLMSG_DONE)    {      if (msg->data.result != CURLE_OK)      {	fprintf (stderr,		 "%s failed at %s:%d: `%s'/n",		 "curl_multi_perform",		__FILE__,		__LINE__, curl_easy_strerror (msg->data.result));	global_ret = 1;      }    }    curl_multi_remove_handle (multi, curl);    curl_multi_cleanup (multi);    curl_easy_cleanup (curl);    curl = NULL;    multi = NULL;    if (cbc.pos != strlen ("/hello_world"))    {      GNUNET_break (0);      global_ret = 2;    }    if (0 != strncmp ("/hello_world", cbc.buf, strlen ("/hello_world")))    {      GNUNET_break (0);      global_ret = 3;    }    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download complete, shutting down!/n");    do_shutdown ();    return;  }  GNUNET_assert (CURLM_OK == curl_multi_fdset (multi, &rs, &ws, &es, &max));  if ( (CURLM_OK != curl_multi_timeout (multi, &timeout)) ||       (-1 == timeout) )    delay = GNUNET_TIME_UNIT_SECONDS;  else    delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, (unsigned int) timeout);  GNUNET_NETWORK_fdset_copy_native (&nrs,				    &rs,				    max + 1);  GNUNET_NETWORK_fdset_copy_native (&nws,				    &ws,				    max + 1);  curl_task_id = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,					      delay,					      &nrs,					      &nws,					      &curl_task,					      NULL);}

voidGNUNET_ATS_TEST_logging_write_to_file (struct LoggingHandle *l,    char *experiment_name, int plots){  struct GNUNET_DISK_FileHandle *f[l->num_slaves];  struct GNUNET_DISK_FileHandle *f_m;  char *tmp_exp_name;  char *filename_master;  char *filename_slaves[l->num_slaves];  char *data;  struct PeerLoggingTimestep *cur_lt;  struct PartnerLoggingTimestep *plt;  struct GNUNET_TIME_Absolute timestamp;  int c_m;  int c_s;  timestamp = GNUNET_TIME_absolute_get();  tmp_exp_name = experiment_name;  for (c_m = 0; c_m < l->num_masters; c_m++)  {    GNUNET_asprintf (&filename_master, "%s_%llu_master%u_%s",        experiment_name, timestamp.abs_value_us, c_m, l->name);    fprintf (stderr, "Writing data for master %u to file `%s'/n",        c_m,filename_master);    f_m = GNUNET_DISK_file_open (filename_master,        GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE,        GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);    if (NULL == f_m)    {      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot open log file `%s'/n", filename_master);      GNUNET_free (filename_master);      return;    }    GNUNET_asprintf (&data, "# master %u; experiment : %s/n"        "timestamp; timestamp delta; #messages sent; #bytes sent; #throughput sent; #messages received; #bytes received; #throughput received; /n" ,        c_m,  experiment_name);    if (GNUNET_SYSERR == GNUNET_DISK_file_write(f_m, data, strlen(data)))      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,          "Cannot write data to log file `%s'/n",filename_master);    GNUNET_free (data);    for (c_s = 0; c_s < l->lp[c_m].peer->num_partners; c_s++)    {      GNUNET_asprintf (&filename_slaves[c_s], "%s_%llu_master%u_slave_%u_%s",          tmp_exp_name, timestamp.abs_value_us, c_m, c_s, l->name);      fprintf (stderr, "Writing data for master %u slave %u to file `%s'/n",          c_m, c_s, filename_slaves[c_s]);      f[c_s] = GNUNET_DISK_file_open (filename_slaves[c_s],          GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE,          GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);      if (NULL == f[c_s])      {        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot open log file `%s'/n", filename_slaves[c_s]);        GNUNET_free (filename_slaves[c_s]);        GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close(f_m));        GNUNET_free (filename_master);        return;      }      /* Header */      GNUNET_asprintf (&data, "# master %u; slave %u ; experiment : %s/n"          "timestamp; timestamp delta; #messages sent; #bytes sent; #throughput sent; #messages received; #bytes received; #throughput received; " /          "rtt; bw in; bw out; ats_cost_lan; ats_cost_wlan; ats_delay; ats_distance; ats_network_type; ats_utilization_up ;ats_utilization_down;" /          "pref bandwidth; pref delay/n",          c_m, c_s, experiment_name);      if (GNUNET_SYSERR == GNUNET_DISK_file_write(f[c_s], data, strlen(data)))        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,            "Cannot write data to log file `%s'/n",filename_slaves[c_s]);      GNUNET_free (data);    }    for (cur_lt = l->lp[c_m].head; NULL != cur_lt; cur_lt = cur_lt->next)    {      if (l->verbose)        fprintf (stderr,           "Master [%u]: timestamp %llu %llu ; %u %u %u ; %u %u %u/n",           l->lp[c_m].peer->no,           (long long unsigned int) cur_lt->timestamp.abs_value_us,           (long long unsigned int) GNUNET_TIME_absolute_get_difference(l->lp[c_m].start,               cur_lt->timestamp).rel_value_us / 1000,           cur_lt->total_messages_sent,           cur_lt->total_bytes_sent,           cur_lt->total_throughput_send,           cur_lt->total_messages_received,           cur_lt->total_bytes_received,           cur_lt->total_throughput_recv);      /* Assembling master string */      GNUNET_asprintf (&data, "%llu;%llu;%u;%u;%u;%u;%u;%u;/n",          (long long unsigned int) cur_lt->timestamp.abs_value_us,          (long long unsigned int) GNUNET_TIME_absolute_get_difference(l->lp[c_m].start,              cur_lt->timestamp).rel_value_us / 1000,          cur_lt->total_messages_sent,          cur_lt->total_bytes_sent,//.........这里部分代码省略.........

/** * Function called when the transport service is ready to receive a * message for the respective peer * * @param cls neighbour to use message from * @param size number of bytes we can transmit * @param buf where to copy the message * @return number of bytes transmitted */static size_ttransmit_ready (void *cls,                size_t size,                void *buf){  struct Neighbour *n = cls;  struct NeighbourMessageEntry *m;  size_t ret;  char *cbuf;  struct GNUNET_TIME_Relative delay;  struct GNUNET_TIME_Relative overdue;  n->th = NULL;  m = n->message_head;  if (NULL == m)  {    GNUNET_break (0);    return 0;  }  GNUNET_CONTAINER_DLL_remove (n->message_head,                               n->message_tail,                               m);  n->queue_size--;  if (NULL == buf)  {    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,                "Transmission of message of type %u and size %u failed/n",                (unsigned int)                ntohs (((struct GNUNET_MessageHeader *) &m[1])->type),                (unsigned int) m->size);    GNUNET_free (m);    process_queue (n);    return 0;  }  delay = GNUNET_TIME_absolute_get_duration (m->submission_time);  overdue = GNUNET_TIME_absolute_get_duration (m->deadline);  cbuf = buf;  GNUNET_assert (size >= m->size);  memcpy (cbuf,          &m[1],          m->size);  ret = m->size;  if (overdue.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,                "Copied overdue message of type %u and size %u into transport buffer for `%s' with delay of %s/n",                (unsigned int)                ntohs (((struct GNUNET_MessageHeader *) &m[1])->type),                (unsigned int) ret,                GNUNET_i2s (&n->peer),                GNUNET_STRINGS_relative_time_to_string (delay,                                                        GNUNET_YES));  else    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,                "Copied message of type %u and size %u into transport buffer for `%s' with delay of %s/n",                (unsigned int)                ntohs (((struct GNUNET_MessageHeader *) &m[1])->type),                (unsigned int) ret,                GNUNET_i2s (&n->peer),                GNUNET_STRINGS_relative_time_to_string (delay,                                                        GNUNET_YES));  GNUNET_free (m);  n->has_excess_bandwidth = GNUNET_NO;  process_queue (n);  GNUNET_STATISTICS_update (GSC_stats,                            gettext_noop                            ("# encrypted bytes given to transport"), ret,                            GNUNET_NO);  return ret;}

/** * Handler for DHT GET messages from the client. * * @param cls closure for the service * @param client the client we received this message from * @param message the actual message received */static voidhandle_dht_local_get (void *cls, struct GNUNET_SERVER_Client *client,                      const struct GNUNET_MessageHeader *message){  const struct GNUNET_DHT_ClientGetMessage *get;  struct ClientQueryRecord *cqr;  size_t xquery_size;  const char *xquery;  uint16_t size;  size = ntohs (message->size);  if (size < sizeof (struct GNUNET_DHT_ClientGetMessage))  {    GNUNET_break (0);    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);    return;  }  xquery_size = size - sizeof (struct GNUNET_DHT_ClientGetMessage);  get = (const struct GNUNET_DHT_ClientGetMessage *) message;  xquery = (const char *) &get[1];  GNUNET_STATISTICS_update (GDS_stats,                            gettext_noop                            ("# GET requests received from clients"), 1,                            GNUNET_NO);  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Received GET request for %s from local client %p, xq: %.*s/n",       GNUNET_h2s (&get->key), client, xquery_size, xquery);  LOG_TRAFFIC (GNUNET_ERROR_TYPE_DEBUG, "XDHT CLIENT-GET %s @ %u/n",               GNUNET_h2s (&get->key), getpid ());  cqr = GNUNET_malloc (sizeof (struct ClientQueryRecord) + xquery_size);  cqr->key = get->key;  cqr->client = find_active_client (client);  cqr->xquery = (void *) &cqr[1];  memcpy (&cqr[1], xquery, xquery_size);  cqr->hnode = GNUNET_CONTAINER_heap_insert (retry_heap, cqr, 0);  cqr->retry_frequency = GNUNET_TIME_UNIT_SECONDS;  cqr->retry_time = GNUNET_TIME_absolute_get ();  cqr->unique_id = get->unique_id;  cqr->xquery_size = xquery_size;  cqr->replication = ntohl (get->desired_replication_level);  cqr->msg_options = ntohl (get->options);  cqr->type = ntohl (get->type);  // FIXME use cqr->key, set multihashmap create to GNUNET_YES  GNUNET_CONTAINER_multihashmap_put (forward_map, &get->key, cqr,                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);  GDS_CLIENTS_process_get (ntohl (get->options),                           ntohl (get->type),                           0,                           ntohl (get->desired_replication_level),                           1,                           GDS_NEIGHBOURS_get_id(),                           &get->key);  /* start remote requests */  if (GNUNET_SCHEDULER_NO_TASK != retry_task)    GNUNET_SCHEDULER_cancel (retry_task);  retry_task = GNUNET_SCHEDULER_add_now (&transmit_next_request_task, NULL);  /* perform local lookup */  GDS_DATACACHE_handle_get (&get->key, cqr->type, cqr->xquery, xquery_size,                            NULL, 0);  GNUNET_SERVER_receive_done (client, GNUNET_OK);}

static void *progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event){  struct GNUNET_FS_Uri *kuri;  switch (event->status)  {  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,		"Publish is progressing (%llu/%llu at level %u off %llu).../n",		(unsigned long long) event->value.publish.completed,		(unsigned long long) event->value.publish.size,		event->value.publish.specifics.progress.depth,		(unsigned long long) event->value.publish.specifics.		progress.offset);    break;  case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:    break;  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:  	processed_files++;	if(processed_files == NUM_FILES)	{	  char *emsg = NULL;	  kuri = GNUNET_FS_uri_ksk_create ("+down_foo +down_bar", &emsg);      GNUNET_assert (kuri != NULL);      start = GNUNET_TIME_absolute_get ();      search =          GNUNET_FS_search_start (fs, kuri, 1, GNUNET_FS_SEARCH_OPTION_NONE,                                  "search");      GNUNET_FS_uri_destroy (kuri);      GNUNET_assert (search != NULL);	}    break;  case GNUNET_FS_STATUS_SEARCH_RESULT:    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,		"Search complete./n");    GNUNET_SCHEDULER_add_now (&abort_search_task, NULL);    break;  case GNUNET_FS_STATUS_PUBLISH_ERROR:    FPRINTF (stderr, "Error publishing file: %s/n",             event->value.publish.specifics.error.message);    GNUNET_break (0);    GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);    break;  case GNUNET_FS_STATUS_SEARCH_ERROR:    FPRINTF (stderr, "Error searching file: %s/n",             event->value.search.specifics.error.message);    GNUNET_SCHEDULER_add_now (&abort_search_task, NULL);    break;  case GNUNET_FS_STATUS_PUBLISH_START:    GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx));    GNUNET_assert (NULL == event->value.publish.pctx);    GNUNET_assert (FILESIZE == event->value.publish.size);    GNUNET_assert (0 == event->value.publish.completed);    GNUNET_assert (1 == event->value.publish.anonymity);    break;  case GNUNET_FS_STATUS_PUBLISH_STOPPED:    GNUNET_assert (publish == event->value.publish.pc);    GNUNET_assert (FILESIZE == event->value.publish.size);    GNUNET_assert (1 == event->value.publish.anonymity);    GNUNET_FS_stop (fs);    fs = NULL;    break;  case GNUNET_FS_STATUS_SEARCH_START:    GNUNET_assert (search == NULL);    GNUNET_assert (0 == strcmp ("search", event->value.search.cctx));    GNUNET_assert (1 == event->value.search.anonymity);    break;  case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:    break;  case GNUNET_FS_STATUS_SEARCH_STOPPED:    GNUNET_assert (search == event->value.search.sc);    GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);    break;  default:    FPRINTF (stderr, "Unexpected event: %d/n", event->status);    break;  }  return NULL;}

/** * Iterator over hash map entries that send a given reply to * each of the matching clients.  With some tricky recycling * of the buffer. * * @param cls the 'struct ForwardReplyContext' * @param key current key * @param value value in the hash map, a ClientQueryRecord * @return GNUNET_YES (we should continue to iterate), *         if the result is mal-formed, GNUNET_NO */static intforward_reply (void *cls, const struct GNUNET_HashCode * key, void *value){  struct ForwardReplyContext *frc = cls;  struct ClientQueryRecord *record = value;  struct PendingMessage *pm;  struct GNUNET_DHT_ClientResultMessage *reply;  enum GNUNET_BLOCK_EvaluationResult eval;  int do_free;  struct GNUNET_HashCode ch;  unsigned int i;  LOG_TRAFFIC (GNUNET_ERROR_TYPE_DEBUG,	       "XDHT CLIENT-RESULT %s/n",               GNUNET_h2s (key));  if ((record->type != GNUNET_BLOCK_TYPE_ANY) && (record->type != frc->type))  {    LOG (GNUNET_ERROR_TYPE_DEBUG,         "Record type missmatch, not passing request for key %s to local client/n",         GNUNET_h2s (key));    GNUNET_STATISTICS_update (GDS_stats,                              gettext_noop                              ("# Key match, type mismatches in REPLY to CLIENT"),                              1, GNUNET_NO);    return GNUNET_YES;          /* type mismatch */  }  GNUNET_CRYPTO_hash (frc->data, frc->data_size, &ch);  for (i = 0; i < record->seen_replies_count; i++)    if (0 == memcmp (&record->seen_replies[i], &ch, sizeof (struct GNUNET_HashCode)))    {      LOG (GNUNET_ERROR_TYPE_DEBUG,           "Duplicate reply, not passing request for key %s to local client/n",           GNUNET_h2s (key));      GNUNET_STATISTICS_update (GDS_stats,                                gettext_noop                                ("# Duplicate REPLIES to CLIENT request dropped"),                                1, GNUNET_NO);      return GNUNET_YES;        /* duplicate */    }  eval =      GNUNET_BLOCK_evaluate (GDS_block_context, record->type, key, NULL, 0,                             record->xquery, record->xquery_size, frc->data,                             frc->data_size);  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Evaluation result is %d for key %s for local client's query/n",       (int) eval, GNUNET_h2s (key));  switch (eval)  {  case GNUNET_BLOCK_EVALUATION_OK_LAST:    do_free = GNUNET_YES;    break;  case GNUNET_BLOCK_EVALUATION_OK_MORE:    GNUNET_array_append (record->seen_replies, record->seen_replies_count, ch);    do_free = GNUNET_NO;    break;  case GNUNET_BLOCK_EVALUATION_OK_DUPLICATE:    /* should be impossible to encounter here */    GNUNET_break (0);    return GNUNET_YES;  case GNUNET_BLOCK_EVALUATION_RESULT_INVALID:    GNUNET_break_op (0);    return GNUNET_NO;  case GNUNET_BLOCK_EVALUATION_REQUEST_VALID:    GNUNET_break (0);    return GNUNET_NO;  case GNUNET_BLOCK_EVALUATION_REQUEST_INVALID:    GNUNET_break (0);    return GNUNET_NO;  case GNUNET_BLOCK_EVALUATION_RESULT_IRRELEVANT:    return GNUNET_YES;  case GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED:    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,                _("Unsupported block type (%u) in request!/n"), record->type);    return GNUNET_NO;  default:    GNUNET_break (0);    return GNUNET_NO;  }  if (GNUNET_NO == frc->do_copy)  {    /* first time, we can use the original data */    pm = frc->pm;    frc->do_copy = GNUNET_YES;  }  else  {    /* two clients waiting for same reply, must copy for queueing */    pm = GNUNET_malloc (sizeof (struct PendingMessage) +                        ntohs (frc->pm->msg->size));//.........这里部分代码省略.........

/** * Handler for PUT messages. * * @param cls closure for the service * @param client the client we received this message from * @param message the actual message received */static voidhandle_dht_local_put (void *cls, struct GNUNET_SERVER_Client *client,                      const struct GNUNET_MessageHeader *message){  const struct GNUNET_DHT_ClientPutMessage *dht_msg;  struct GNUNET_CONTAINER_BloomFilter *peer_bf;  uint16_t size;  struct PendingMessage *pm;  struct GNUNET_DHT_ClientPutConfirmationMessage *conf;  size = ntohs (message->size);  if (size < sizeof (struct GNUNET_DHT_ClientPutMessage))  {    GNUNET_break (0);    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);    return;  }  GNUNET_STATISTICS_update (GDS_stats,                            gettext_noop                            ("# PUT requests received from clients"), 1,                            GNUNET_NO);  dht_msg = (const struct GNUNET_DHT_ClientPutMessage *) message;  LOG_TRAFFIC (GNUNET_ERROR_TYPE_DEBUG, "XDHT CLIENT-PUT %s @ %u/n",               GNUNET_h2s (&dht_msg->key), getpid ());  /* give to local clients */  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Handling local PUT of %u-bytes for query %s/n",       size - sizeof (struct GNUNET_DHT_ClientPutMessage),       GNUNET_h2s (&dht_msg->key));  GDS_CLIENTS_handle_reply (GNUNET_TIME_absolute_ntoh (dht_msg->expiration),                            &dht_msg->key, 0, NULL, 0, NULL,                            ntohl (dht_msg->type),                            size - sizeof (struct GNUNET_DHT_ClientPutMessage),                            &dht_msg[1]);  /* store locally */  GDS_DATACACHE_handle_put (GNUNET_TIME_absolute_ntoh (dht_msg->expiration),                            &dht_msg->key, 0, NULL, ntohl (dht_msg->type),                            size - sizeof (struct GNUNET_DHT_ClientPutMessage),                            &dht_msg[1]);  /* route to other peers */  peer_bf =      GNUNET_CONTAINER_bloomfilter_init (NULL, DHT_BLOOM_SIZE,                                         GNUNET_CONSTANTS_BLOOMFILTER_K);  GDS_NEIGHBOURS_handle_put (ntohl (dht_msg->type), ntohl (dht_msg->options),                             ntohl (dht_msg->desired_replication_level),                             GNUNET_TIME_absolute_ntoh (dht_msg->expiration),                             0 /* hop count */ ,                             peer_bf, &dht_msg->key, 0, NULL, &dht_msg[1],                             size -                             sizeof (struct GNUNET_DHT_ClientPutMessage));  GDS_CLIENTS_process_put (ntohl (dht_msg->options),                           ntohl (dht_msg->type),                           0,                           ntohl (dht_msg->desired_replication_level),                           1,                           GDS_NEIGHBOURS_get_id(),                           GNUNET_TIME_absolute_ntoh (dht_msg->expiration),                           &dht_msg->key,                           &dht_msg[1],                           size - sizeof (struct GNUNET_DHT_ClientPutMessage));  GNUNET_CONTAINER_bloomfilter_free (peer_bf);  pm = GNUNET_malloc (sizeof (struct PendingMessage) +		      sizeof (struct GNUNET_DHT_ClientPutConfirmationMessage));  conf = (struct GNUNET_DHT_ClientPutConfirmationMessage *) &pm[1];  conf->header.size = htons (sizeof (struct GNUNET_DHT_ClientPutConfirmationMessage));  conf->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT_OK);  conf->reserved = htonl (0);  conf->unique_id = dht_msg->unique_id;  pm->msg = &conf->header;  add_pending_message (find_active_client (client), pm);  GNUNET_SERVER_receive_done (client, GNUNET_OK);}

/** * Handler for notification messages received from the core. * * @param cls our `struct GNUNET_CORE_Handle` * @param msg the message received from the core service */static voidmain_notify_handler (void *cls,                     const struct GNUNET_MessageHeader *msg){  struct GNUNET_CORE_Handle *h = cls;  const struct InitReplyMessage *m;  const struct ConnectNotifyMessage *cnm;  const struct DisconnectNotifyMessage *dnm;  const struct NotifyTrafficMessage *ntm;  const struct GNUNET_MessageHeader *em;  const struct SendMessageReady *smr;  const struct GNUNET_CORE_MessageHandler *mh;  GNUNET_CORE_StartupCallback init;  struct PeerRecord *pr;  struct GNUNET_CORE_TransmitHandle *th;  unsigned int hpos;  int trigger;  uint16_t msize;  uint16_t et;  if (NULL == msg)  {    LOG (GNUNET_ERROR_TYPE_INFO,         _("Client was disconnected from core service, trying to reconnect./n"));    reconnect_later (h);    return;  }  msize = ntohs (msg->size);  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Processing message of type %u and size %u from core service/n",       ntohs (msg->type), msize);  switch (ntohs (msg->type))  {  case GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY:    if (ntohs (msg->size) != sizeof (struct InitReplyMessage))    {      GNUNET_break (0);      reconnect_later (h);      return;    }    m = (const struct InitReplyMessage *) msg;    GNUNET_break (0 == ntohl (m->reserved));    /* start our message processing loop */    if (GNUNET_YES == h->currently_down)    {      h->currently_down = GNUNET_NO;      trigger_next_request (h, GNUNET_NO);    }    h->retry_backoff = GNUNET_TIME_UNIT_MILLISECONDS;    h->me = m->my_identity;    if (NULL != (init = h->init))    {      /* mark so we don't call init on reconnect */      h->init = NULL;      LOG (GNUNET_ERROR_TYPE_DEBUG, "Connected to core service of peer `%s'./n",           GNUNET_i2s (&h->me));      init (h->cls, &h->me);    }    else    {      LOG (GNUNET_ERROR_TYPE_DEBUG,           "Successfully reconnected to core service./n");    }    /* fake 'connect to self' */    pr = GNUNET_CONTAINER_multipeermap_get (h->peers, &h->me);    GNUNET_assert (NULL == pr);    pr = GNUNET_new (struct PeerRecord);    pr->peer = h->me;    pr->ch = h;    GNUNET_assert (GNUNET_YES ==                   GNUNET_CONTAINER_multipeermap_put (h->peers,                                                      &h->me, pr,                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));    if (NULL != h->connects)      h->connects (h->cls, &h->me);    break;  case GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT:    if (msize < sizeof (struct ConnectNotifyMessage))    {      GNUNET_break (0);      reconnect_later (h);      return;    }    cnm = (const struct ConnectNotifyMessage *) msg;    if (msize !=        sizeof (struct ConnectNotifyMessage))    {      GNUNET_break (0);      reconnect_later (h);      return;    }    LOG (GNUNET_ERROR_TYPE_DEBUG,         "Received notification about connection from `%s'./n",         GNUNET_i2s (&cnm->peer));    if (0 == memcmp (&h->me, &cnm->peer, sizeof (struct GNUNET_PeerIdentity)))//.........这里部分代码省略.........

//.........这里部分代码省略.........  struct ControlMessage *cm;  struct GNUNET_CORE_TransmitHandle *th;  struct PeerRecord *pr;  struct SendMessage *sm;  const struct GNUNET_MessageHeader *hdr;  uint16_t msize;  size_t ret;  GNUNET_assert (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK);  h->cth = NULL;  if (NULL == buf)  {    LOG (GNUNET_ERROR_TYPE_DEBUG,         "Transmission failed, initiating reconnect/n");    reconnect_later (h);    return 0;  }  /* first check for control messages */  if (NULL != (cm = h->control_pending_head))  {    hdr = (const struct GNUNET_MessageHeader *) &cm[1];    msize = ntohs (hdr->size);    if (size < msize)    {      trigger_next_request (h, GNUNET_NO);      return 0;    }    LOG (GNUNET_ERROR_TYPE_DEBUG,         "Transmitting control message with %u bytes of type %u to core./n",         (unsigned int) msize, (unsigned int) ntohs (hdr->type));    memcpy (buf, hdr, msize);    GNUNET_CONTAINER_DLL_remove (h->control_pending_head,                                 h->control_pending_tail, cm);    if (NULL != cm->th)      cm->th->cm = NULL;    if (NULL != cm->cont)      cm->cont (cm->cont_cls, GNUNET_OK);    GNUNET_free (cm);    trigger_next_request (h, GNUNET_NO);    return msize;  }  /* now check for 'ready' P2P messages */  if (NULL == (pr = h->ready_peer_head))    return 0;  GNUNET_assert (NULL != pr->th.peer);  th = &pr->th;  if (size < th->msize + sizeof (struct SendMessage))  {    trigger_next_request (h, GNUNET_NO);    return 0;  }  GNUNET_CONTAINER_DLL_remove (h->ready_peer_head, h->ready_peer_tail, pr);  th->peer = NULL;  if (GNUNET_SCHEDULER_NO_TASK != pr->timeout_task)  {    GNUNET_SCHEDULER_cancel (pr->timeout_task);    pr->timeout_task = GNUNET_SCHEDULER_NO_TASK;  }  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Transmitting SEND request to `%s' with %u bytes./n",       GNUNET_i2s (&pr->peer), (unsigned int) th->msize);  sm = (struct SendMessage *) buf;  sm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_SEND);  sm->priority = htonl ((uint32_t) th->priority);  sm->deadline = GNUNET_TIME_absolute_hton (th->timeout);  sm->peer = pr->peer;  sm->cork = htonl ((uint32_t) th->cork);  sm->reserved = htonl (0);  ret =    th->get_message (th->get_message_cls,		     size - sizeof (struct SendMessage), &sm[1]);  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Transmitting SEND request to `%s' yielded %u bytes./n",       GNUNET_i2s (&pr->peer), ret);  if (0 == ret)  {    LOG (GNUNET_ERROR_TYPE_DEBUG,	 "Size of clients message to peer %s is 0!/n",	 GNUNET_i2s (&pr->peer));    /* client decided to send nothing! */    request_next_transmission (pr);    return 0;  }  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Produced SEND message to core with %u bytes payload/n",       (unsigned int) ret);  GNUNET_assert (ret >= sizeof (struct GNUNET_MessageHeader));  if (ret + sizeof (struct SendMessage) >= GNUNET_SERVER_MAX_MESSAGE_SIZE)  {    GNUNET_break (0);    request_next_transmission (pr);    return 0;  }  ret += sizeof (struct SendMessage);  sm->header.size = htons (ret);  GNUNET_assert (ret <= size);  request_next_transmission (pr);  return ret;}

/** * Try to establish a connection given the specified address. * This function is called by the resolver once we have a DNS reply. * * @param cls our "struct GNUNET_CONNECTION_Handle *" * @param addr address to try, NULL for "last call" * @param addrlen length of addr */static voidtry_connect_using_address (void *cls, const struct sockaddr *addr,                           socklen_t addrlen){  struct GNUNET_CONNECTION_Handle *connection = cls;  struct AddressProbe *ap;  struct GNUNET_TIME_Relative delay;  if (NULL == addr)  {    connection->dns_active = NULL;    if ((NULL == connection->ap_head) && (NULL == connection->sock))      connect_fail_continuation (connection);    return;  }  if (NULL != connection->sock)    return;                     /* already connected */  GNUNET_assert (NULL == connection->addr);  /* try to connect */  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Trying to connect using address `%s:%u/%s:%u'/n", connection->hostname, connection->port,       GNUNET_a2s (addr, addrlen), connection->port);  ap = GNUNET_malloc (sizeof (struct AddressProbe) + addrlen);  ap->addr = (const struct sockaddr *) &ap[1];  memcpy (&ap[1], addr, addrlen);  ap->addrlen = addrlen;  ap->connection = connection;  switch (ap->addr->sa_family)  {  case AF_INET:    ((struct sockaddr_in *) ap->addr)->sin_port = htons (connection->port);    break;  case AF_INET6:    ((struct sockaddr_in6 *) ap->addr)->sin6_port = htons (connection->port);    break;  default:    GNUNET_break (0);    GNUNET_free (ap);    return;                     /* not supported by us */  }  ap->sock = GNUNET_NETWORK_socket_create (ap->addr->sa_family, SOCK_STREAM, 0);  if (NULL == ap->sock)  {    GNUNET_free (ap);    return;                     /* not supported by OS */  }  LOG (GNUNET_ERROR_TYPE_INFO, _("Trying to connect to `%s' (%p)/n"),       GNUNET_a2s (ap->addr, ap->addrlen), connection);  if ((GNUNET_OK !=       GNUNET_NETWORK_socket_connect (ap->sock, ap->addr, ap->addrlen)) &&      (EINPROGRESS != errno))  {    /* maybe refused / unsupported address, try next */    LOG_STRERROR (GNUNET_ERROR_TYPE_INFO, "connect");#if 0    LOG (GNUNET_ERROR_TYPE_INFO, _("Failed to connect to `%s' (%p)/n"),         GNUNET_a2s (ap->addr, ap->addrlen), connection);#endif    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (ap->sock));    GNUNET_free (ap);    return;  }  GNUNET_CONTAINER_DLL_insert (connection->ap_head, connection->ap_tail, ap);  delay = GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT;  if (NULL != connection->nth.notify_ready)    delay =        GNUNET_TIME_relative_min (delay,                                  GNUNET_TIME_absolute_get_remaining (connection->                                                                      nth.transmit_timeout));  if (NULL != connection->receiver)    delay =        GNUNET_TIME_relative_min (delay,                                  GNUNET_TIME_absolute_get_remaining                                  (connection->receive_timeout));  ap->task =      GNUNET_SCHEDULER_add_write_net (delay, ap->sock,                                      &connect_probe_continuation, ap);}

/** * Create a connection handle by accepting on a listen socket.  This * function may block if the listen socket has no connection ready. * * @param access function to use to check if access is allowed * @param access_cls closure for access * @param lsock listen socket * @return the connection handle, NULL on error */struct GNUNET_CONNECTION_Handle *GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access,                                      void *access_cls,                                      struct GNUNET_NETWORK_Handle *lsock){  struct GNUNET_CONNECTION_Handle *connection;  char addr[128];  socklen_t addrlen;  struct GNUNET_NETWORK_Handle *sock;  int aret;  struct sockaddr_in *v4;  struct sockaddr_in6 *v6;  struct sockaddr *sa;  void *uaddr;  struct GNUNET_CONNECTION_Credentials *gcp;  struct GNUNET_CONNECTION_Credentials gc;#ifdef SO_PEERCRED  struct ucred uc;  socklen_t olen;#endif  addrlen = sizeof (addr);  sock =      GNUNET_NETWORK_socket_accept (lsock, (struct sockaddr *) &addr, &addrlen);  if (NULL == sock)  {    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "accept");    return NULL;  }  if ((addrlen > sizeof (addr)) || (addrlen < sizeof (sa_family_t)))  {    GNUNET_break (0);    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));    return NULL;  }  sa = (struct sockaddr *) addr;  v6 = (struct sockaddr_in6 *) addr;  if ((AF_INET6 == sa->sa_family) && (IN6_IS_ADDR_V4MAPPED (&v6->sin6_addr)))  {    /* convert to V4 address */    v4 = GNUNET_malloc (sizeof (struct sockaddr_in));    memset (v4, 0, sizeof (struct sockaddr_in));    v4->sin_family = AF_INET;#if HAVE_SOCKADDR_IN_SIN_LEN    v4->sin_len = (u_char) sizeof (struct sockaddr_in);#endif    memcpy (&v4->sin_addr,            &((char *) &v6->sin6_addr)[sizeof (struct in6_addr) -                                       sizeof (struct in_addr)],            sizeof (struct in_addr));    v4->sin_port = v6->sin6_port;    uaddr = v4;    addrlen = sizeof (struct sockaddr_in);  }  else  {    uaddr = GNUNET_malloc (addrlen);    memcpy (uaddr, addr, addrlen);  }  gcp = NULL;  gc.uid = 0;  gc.gid = 0;  if (AF_UNIX == sa->sa_family)  {#if HAVE_GETPEEREID    /* most BSDs */    if (0 == getpeereid (GNUNET_NETWORK_get_fd (sock), &gc.uid, &gc.gid))      gcp = &gc;#else#ifdef SO_PEERCRED    /* largely traditional GNU/Linux */    olen = sizeof (uc);    if ((0 ==         getsockopt (GNUNET_NETWORK_get_fd (sock), SOL_SOCKET, SO_PEERCRED, &uc,                     &olen)) && (olen == sizeof (uc)))    {      gc.uid = uc.uid;      gc.gid = uc.gid;      gcp = &gc;    }#else#if HAVE_GETPEERUCRED    /* this is for Solaris 10 */    ucred_t *uc;    uc = NULL;    if (0 == getpeerucred (GNUNET_NETWORK_get_fd (sock), &uc))    {      gc.uid = ucred_geteuid (uc);      gc.gid = ucred_getegid (uc);//.........这里部分代码省略.........

/** * Handler for messages received from the DHT service * a demultiplexer which handles numerous message types * * @param cls the `struct GNUNET_DHT_Handle` * @param msg the incoming message */static voidservice_message_handler (void *cls, const struct GNUNET_MessageHeader *msg){  struct GNUNET_DHT_Handle *handle = cls;  const struct GNUNET_DHT_ClientResultMessage *dht_msg;  uint16_t msize;  int ret;  if (NULL == msg)  {    LOG (GNUNET_ERROR_TYPE_DEBUG,         "Error receiving data from DHT service, reconnecting/n");    do_disconnect (handle);    return;  }  GNUNET_CLIENT_receive (handle->client, &service_message_handler, handle,                         GNUNET_TIME_UNIT_FOREVER_REL);  ret = GNUNET_SYSERR;  msize = ntohs (msg->size);  switch (ntohs (msg->type))  {  case GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET:    if (msize < sizeof (struct GNUNET_DHT_MonitorGetMessage))    {      GNUNET_break (0);      break;    }    ret = process_monitor_get_message(handle,				      (const struct GNUNET_DHT_MonitorGetMessage *) msg);    break;  case GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP:    if (msize < sizeof (struct GNUNET_DHT_MonitorGetRespMessage))    {      GNUNET_break (0);      break;    }    ret = process_monitor_get_resp_message(handle,					   (const struct GNUNET_DHT_MonitorGetRespMessage *) msg);    break;  case GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT:    if (msize < sizeof (struct GNUNET_DHT_MonitorPutMessage))    {      GNUNET_break (0);      break;    }    ret = process_monitor_put_message(handle,				      (const struct GNUNET_DHT_MonitorPutMessage *) msg);    break;  case GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT_RESP:    /* Not implemented yet */    GNUNET_break(0);    break;  case GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT:    if (ntohs (msg->size) < sizeof (struct GNUNET_DHT_ClientResultMessage))    {      GNUNET_break (0);      break;    }    dht_msg = (const struct GNUNET_DHT_ClientResultMessage *) msg;    LOG (GNUNET_ERROR_TYPE_DEBUG,         "Received reply for `%s' from DHT service %p/n",         GNUNET_h2s (&dht_msg->key), handle);    GNUNET_CONTAINER_multihashmap_get_multiple (handle->active_requests,						&dht_msg->key,						&process_reply,						(void *) dht_msg);    ret = GNUNET_OK;    break;  case GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT_OK:    if (ntohs (msg->size) != sizeof (struct GNUNET_DHT_ClientPutConfirmationMessage))    {      GNUNET_break (0);      break;    }    ret = process_put_confirmation_message (handle,					    (const struct GNUNET_DHT_ClientPutConfirmationMessage*) msg);    break;#if ENABLE_MALICIOUS    case GNUNET_MESSAGE_TYPE_DHT_CLIENT_ACT_MALICIOUS_OK:       if(msize != sizeof (struct GNUNET_DHT_ClientActMaliciousConfirmationMessage))       {         GNUNET_break (0);         break;       }       ret = process_act_malicious_confirmation_message (handle,					    (const struct GNUNET_DHT_ClientActMaliciousConfirmationMessage*) msg);      break;#endif  default:    GNUNET_break(0);    LOG (GNUNET_ERROR_TYPE_WARNING,         "Unknown DHT message type: %hu (%hu) size: %hu/n",//.........这里部分代码省略.........