/** * Callback indicating that the hostkey was created for a peer. * * @param cls NULL * @param id the peer identity * @param d the daemon handle (pretty useless at this point, remove?) * @param emsg non-null on failure */ void hostkey_callback (void *cls, const struct GNUNET_PeerIdentity *id, struct GNUNET_TESTING_Daemon *d, const char *emsg) { if (emsg != NULL) { GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Hostkey callback received error: %s\n", emsg); } #if VERBOSE > 1 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Hostkey (%d/%d) created for peer `%s'\n", num_peers - peers_left, num_peers, GNUNET_i2s (id)); #endif #if VERBOSE if ((num_peers - peers_left) % modnum == 0) { if (num_peers - peers_left == 0) FPRINTF (stdout, "%s", "0%%"); else FPRINTF (stdout, "%d%%", (int) (((float) (num_peers - peers_left) / num_peers) * 100)); } else if ((num_peers - peers_left) % dotnum == 0) { FPRINTF (stdout, "%s", "."); } fflush (stdout); #endif peers_left--; if (peers_left == 0) { #if VERBOSE FPRINTF (stdout, "%s", "100%%]\n"); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All %d hostkeys created, now creating topology!\n", num_peers); #endif GNUNET_SCHEDULER_cancel (die_task); /* Set up task in case topology creation doesn't finish * within a reasonable amount of time */ die_task = GNUNET_SCHEDULER_add_delayed (test_timeout, &end_badly, "from create_topology"); GNUNET_SCHEDULER_add_now (&create_topology, NULL); ok = 0; } }
static void testing_connect_cb (struct PeerContext *p1, struct PeerContext *p2, void *cls) { cc = NULL; char *p1_c = GNUNET_strdup (GNUNET_i2s (&p1->id)); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peers connected: %u (%s) <-> %u (%s)\n", p1->no, p1_c, p2->no, GNUNET_i2s (&p2->id)); GNUNET_free (p1_c); send_task = GNUNET_SCHEDULER_add_now (&sendtask, NULL); }
static void add_peer_done (void *cls, const char *emsg) { if (NULL == emsg) { return; } else { GNUNET_break(0); GNUNET_SCHEDULER_cancel (timeout_task); timeout_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL ); } }
/** * Function executed after stream has been established * * @param cls the closure from GNUNET_STREAM_open * @param socket socket to use to communicate with the other side (read/write) */ static void stream_open_cb (void *cls, struct GNUNET_STREAM_Socket *socket) { struct PeerData *peer=cls; GNUNET_assert (&peer1 == peer); GNUNET_assert (socket == peer1.socket); GNUNET_assert (socket == peer->socket); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stream established from peer1\n"); peer->bytes_wrote = 0; GNUNET_SCHEDULER_add_now (&stream_write_task, peer); }
/** * Stats callback. Finish the stats testbed operation and when all stats have * been iterated, shutdown the test. * * @param cls Closure (line number from which termination was requested). * @param op the operation that has been finished * @param emsg error message in case the operation has failed; will be NULL if * operation has executed successfully. */ static void stats_cont (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg) { GNUNET_log (GNUNET_ERROR_TYPE_INFO, " KA sent: %u, KA received: %u\n", ka_sent, ka_received); if (KEEPALIVE == test && (ka_sent < 2 || ka_sent > ka_received + 1)) ok--; GNUNET_TESTBED_operation_done (stats_op); if (NULL != disconnect_task) GNUNET_SCHEDULER_cancel (disconnect_task); disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers, cls); }
static void notify_receive (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_MessageHeader *message, const struct GNUNET_ATS_Information *ats, uint32_t ats_count) { struct PeerContext *p = cls; struct PeerContext *t = NULL; if (0 == memcmp (peer, &p1->id, sizeof (struct GNUNET_PeerIdentity))) t = p1; if (0 == memcmp (peer, &p2->id, sizeof (struct GNUNET_PeerIdentity))) t = p2; GNUNET_assert (t != NULL); char *ps = GNUNET_strdup (GNUNET_i2s (&p->id)); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer %u (`%4s') received message of type %d and size %u size from peer %u (`%4s')!\n", p->no, ps, ntohs (message->type), ntohs (message->size), t->no, GNUNET_i2s (&t->id)); GNUNET_free (ps); if ((MTYPE == ntohs (message->type)) && (sizeof (struct GNUNET_MessageHeader) == ntohs (message->size))) { if (restarted == GNUNET_NO) { restarted = GNUNET_YES; restart (p1, cfg_file_p1); restart (p2, cfg_file_p2); return; } else { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Restarted peers connected, stopping test...\n"); ok = 0; end (); } } else { GNUNET_break (0); ok = 1; if (die_task != GNUNET_SCHEDULER_NO_TASK) GNUNET_SCHEDULER_cancel (die_task); die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL); } }
static void on_lookup_result(void *cls, uint32_t rd_count, const struct GNUNET_NAMESTORE_RecordData *rd) { struct in_addr a; int i; char* addr; if (GNUNET_SCHEDULER_NO_TASK != die_task) { GNUNET_SCHEDULER_cancel (die_task); die_task = GNUNET_SCHEDULER_NO_TASK; } GNUNET_NAMESTORE_disconnect (namestore_handle); namestore_handle = NULL; if (rd_count == 0) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Lookup failed, this is good!\n"); ok = 0; } else { ok = 1; GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "name: %s\n", (char*)cls); for (i=0; i<rd_count; i++) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "type: %d\n", rd[i].record_type); if (rd[i].record_type == GNUNET_GNS_RECORD_A) { memcpy(&a, rd[i].data, sizeof(a)); addr = inet_ntoa(a); GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "address: %s\n", addr); if (0 == strcmp(addr, TEST_IP)) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s incorrectly resolved to %s!\n", TEST_DOMAIN, addr); ok = 2; } } else { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No resolution!\n"); } } } GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); }
void ats_perf_cb (void *cls, const struct GNUNET_HELLO_Address * address, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, const struct GNUNET_ATS_Information * ats, uint32_t ats_count) { struct PendingResolutions * pr; if (NULL != address) { pr = GNUNET_malloc (sizeof (struct PendingResolutions) + ats_count * sizeof (struct GNUNET_ATS_Information)); pr->ats_count = ats_count; pr->ats = (struct GNUNET_ATS_Information *) &pr[1]; if (ats_count > 0) memcpy (pr->ats, ats, ats_count * sizeof (struct GNUNET_ATS_Information)); pr->address = GNUNET_HELLO_address_copy (address); pr->bandwidth_in = bandwidth_in; pr->bandwidth_out = bandwidth_out; pr->tats_ctx = GNUNET_TRANSPORT_address_to_string(cfg, address, resolve_addresses_numeric, GNUNET_TIME_UNIT_FOREVER_REL, transport_addr_to_str_cb, pr); GNUNET_CONTAINER_DLL_insert (head, tail, pr); results++; pending++; } else { /* All messages received */ receive_done = GNUNET_YES; alh = NULL; if (0 == pending) { /* All messages received and no resolutions pending*/ if (end_task != GNUNET_SCHEDULER_NO_TASK) GNUNET_SCHEDULER_cancel (end_task); end_task = GNUNET_SCHEDULER_add_now (end, NULL); } } }
static void on_lookup_result(void *cls, uint32_t rd_count, const struct GNUNET_NAMESTORE_RecordData *rd) { int i; uint16_t *srv_data; char* srv; if (GNUNET_SCHEDULER_NO_TASK != die_task) { GNUNET_SCHEDULER_cancel (die_task); die_task = GNUNET_SCHEDULER_NO_TASK; } GNUNET_NAMESTORE_disconnect (namestore_handle); if (rd_count == 0) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Lookup failed, rp_filtering?\n"); ok = 2; } else { ok = 1; GNUNET_log (GNUNET_ERROR_TYPE_INFO, "name: %s\n", (char*)cls); for (i=0; i<rd_count; i++) { GNUNET_log (GNUNET_ERROR_TYPE_INFO, "type: %d\n", rd[i].record_type); if (rd[i].record_type == GNUNET_GNS_RECORD_SRV) { srv_data = (uint16_t*)rd[i].data; srv = (char*)&srv_data[3]; GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Got SRV %s with p=%d,w=%d,port=%d\n", srv, srv_data, &srv_data[1], &srv_data[2]); if (0 == strcmp(srv, TEST_EXPECTED_SRV)) { GNUNET_log (GNUNET_ERROR_TYPE_INFO, "%s correctly resolved to %s!\n", TEST_DOMAIN, TEST_EXPECTED_SRV); ok = 0; } } } } GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); }
static void send_test_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct TestMessageContext *pos = cls; if ((pos == test_messages) && (settle_time.rel_value > 0)) { topology_connections = 0; GNUNET_TESTING_get_topology (pg, &topology_cb, NULL); } if (((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0) || (cls == NULL)) return; if (die_task == GNUNET_SCHEDULER_NO_TASK) { die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT, &end_badly, "from send test messages (timeout)"); } if (total_server_connections >= MAX_OUTSTANDING_CONNECTIONS) { GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1), &send_test_messages, pos); return; /* Otherwise we'll double schedule messages here! */ } /* * Connect to the sending peer */ pos->peer1handle = GNUNET_CORE_connect (pos->peer1->cfg, pos, &init_notify_peer1, &connect_notify_peers, NULL, NULL, GNUNET_NO, NULL, GNUNET_NO, no_handlers); GNUNET_assert (pos->peer1handle != NULL); if (total_server_connections < MAX_OUTSTANDING_CONNECTIONS) { GNUNET_SCHEDULER_add_now (&send_test_messages, pos->next); } else { GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1), &send_test_messages, pos->next); } }
/** * Main point of test execution */ static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg) { struct TestingContext *test_ctx; char *emsg; struct GNUNET_PeerIdentity id; struct GNUNET_TESTING_SharedService ss[] = { {"peerinfo", cfg, 2}, {NULL, NULL, 0} }; struct GNUNET_TESTING_Peer *peer; unsigned int cnt; test_ctx = GNUNET_new (struct TestingContext); test_ctx->system = GNUNET_TESTING_system_create ("test-gnunet-testing", "127.0.0.1", NULL, ss); emsg = NULL; if (NULL == test_ctx->system) goto end; test_ctx->cfg = GNUNET_CONFIGURATION_dup (cfg); for (cnt = 0; cnt < NUM_PEERS; cnt++) { peer = GNUNET_TESTING_peer_configure (test_ctx->system, test_ctx->cfg, 0, &id, &emsg); if (NULL == peer) { if (NULL != emsg) printf ("Test failed upon error: %s", emsg); goto end; } if (GNUNET_OK != GNUNET_TESTING_peer_start (peer)) { GNUNET_TESTING_peer_destroy (peer); goto end; } test_ctx->peers[cnt] = peer; } status = GNUNET_OK; GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &do_shutdown, test_ctx); return; end: GNUNET_SCHEDULER_add_now (&do_shutdown, test_ctx); GNUNET_free_non_null (emsg); }
static void put_cont (void *cls, int32_t success, const char *emsg) { const char *name = cls; nsqe = NULL; GNUNET_assert (NULL != cls); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Name store added record for `%s': %s\n", name, (success == GNUNET_OK) ? "SUCCESS" : "FAIL"); GNUNET_SCHEDULER_cancel (endbadly_task); endbadly_task = NULL; GNUNET_SCHEDULER_add_now (&end, NULL); }
static void test_get_iterator (void *cls, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode * key, const struct GNUNET_PeerIdentity *get_path, unsigned int get_path_length, const struct GNUNET_PeerIdentity *put_path, unsigned int put_path_length, enum GNUNET_BLOCK_Type type, size_t size, const void *data) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test_get_iterator called (we got a result), stopping get request!\n"); GNUNET_SCHEDULER_add_now (&test_get_stop, NULL); }
static void handle_test (void *cls, const struct GNUNET_MessageHeader *message) { const struct GNUNET_PeerIdentity *peer = cls; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving message from `%s'.\n", GNUNET_i2s (peer)); GNUNET_assert (ok == 5); OKPP; GNUNET_SCHEDULER_cancel (err_task); err_task = GNUNET_SCHEDULER_add_now (&terminate_task, NULL); }
/** * Callback which will be called to after a host registration succeeded or failed * * @param cls the closure * @param emsg the error message; NULL if host registration is successful */ static void host_registration_completion (void *cls, const char *emsg) { struct GNUNET_TESTBED_RunHandle *rc = cls; rc->reg_handle = NULL; if (NULL != emsg) { LOG (GNUNET_ERROR_TYPE_WARNING, _("Host registration failed for a host. Error: %s\n"), emsg); GNUNET_SCHEDULER_shutdown (); return; } rc->register_hosts_task = GNUNET_SCHEDULER_add_now (®ister_hosts, rc); }
/** * Iterator callback to go over all addresses and try to validate them * (unless blocked or already validated). * * @param cls pointer to a 'struct ValidateAddressContext' * @param address the address * @param expiration expiration time * @return GNUNET_OK (keep the address) */ static int validate_address_iterator (void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration) { const struct ValidateAddressContext *vac = cls; struct ValidationEntry *ve; if (GNUNET_TIME_absolute_get_remaining (expiration).rel_value == 0) return GNUNET_OK; /* expired */ ve = find_validation_entry (&vac->public_key, address); if (GNUNET_SCHEDULER_NO_TASK == ve->revalidation_task) ve->revalidation_task = GNUNET_SCHEDULER_add_now (&revalidate_address, ve); return GNUNET_OK; }
static void address_suggest_cb (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, struct Session *session, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, const struct GNUNET_ATS_Information *atsi, uint32_t ats_count) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Did not expect suggestion callback!\n"); GNUNET_SCHEDULER_add_now (&end_badly, NULL); return; }
static void read_call (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct GNUNET_DISK_FileHandle *stdout_read_handle = cls; char buf[16]; memset (&buf, 0, sizeof (buf)); int bytes; bytes = GNUNET_DISK_file_read (stdout_read_handle, &buf, sizeof (buf)); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "bytes is %d\n", bytes); if (bytes < 1) { GNUNET_break (0); ok = 1; GNUNET_SCHEDULER_cancel (die_task); GNUNET_SCHEDULER_add_now (&end_task, NULL); return; } ok = strncmp (&buf[0], test_phrase, strlen (test_phrase)); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "read %s\n", &buf[0]); if (0 == ok) { GNUNET_SCHEDULER_cancel (die_task); GNUNET_SCHEDULER_add_now (&end_task, NULL); return; } GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, stdout_read_handle, &read_call, stdout_read_handle); }
/** * Functions of this type are called upon new stream connection from other peers * * @param cls the closure from GNUNET_STREAM_listen * @param socket the socket representing the stream * @param initiator the identity of the peer who wants to establish a stream * with us * @return GNUNET_OK to keep the socket open, GNUNET_SYSERR to close the * stream (the socket will be invalid after the call) */ static int stream_listen_cb (void *cls, struct GNUNET_STREAM_Socket *socket, const struct GNUNET_PeerIdentity *initiator) { struct PeerData *pdata = cls; if ((NULL == socket) || (NULL == initiator)) { GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Binding error\n"); if (GNUNET_SCHEDULER_NO_TASK != abort_task) GNUNET_SCHEDULER_cancel (abort_task); abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL); return GNUNET_OK; } GNUNET_assert (NULL != socket); GNUNET_assert (pdata == &peer_data[1]); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer connected: %s\n", GNUNET_i2s(initiator)); pdata->socket = socket; pdata->bytes_read = 0; read_task = GNUNET_SCHEDULER_add_now (&stream_read_task, pdata); return GNUNET_OK; }
/** * Connect to the network size estimation service. * * @param cfg the configuration to use * @param func funtion to call with network size estimate * @param func_cls closure to pass for network size estimate callback * * @return handle to use */ struct GNUNET_NSE_Handle * GNUNET_NSE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_NSE_Callback func, void *func_cls) { struct GNUNET_NSE_Handle *ret; GNUNET_assert (func != NULL); ret = GNUNET_malloc (sizeof (struct GNUNET_NSE_Handle)); ret->cfg = cfg; ret->recv_cb = func; ret->recv_cb_cls = func_cls; ret->reconnect_delay = GNUNET_TIME_UNIT_ZERO; ret->reconnect_task = GNUNET_SCHEDULER_add_now (&reconnect, ret); return ret; }
static void rd_decrypt_cb (void *cls, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd) { char rd_cmp_data[TEST_RECORD_DATALEN]; if (1 != rd_count) { GNUNET_SCHEDULER_add_now (&endbadly, NULL); GNUNET_break (0); return; } if (NULL == rd) { GNUNET_SCHEDULER_add_now (&endbadly, NULL); GNUNET_break (0); return; } memset (rd_cmp_data, 'a', TEST_RECORD_DATALEN); if (TEST_RECORD_TYPE != rd[0].record_type) { GNUNET_SCHEDULER_add_now (&endbadly, NULL); GNUNET_break (0); return; } if (TEST_RECORD_DATALEN != rd[0].data_size) { GNUNET_SCHEDULER_add_now (&endbadly, NULL); GNUNET_break (0); return; } if (0 != memcmp (&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN)) { GNUNET_SCHEDULER_add_now (&endbadly, NULL); GNUNET_break (0); return; } if (0 != (GNUNET_GNSRECORD_RF_SHADOW_RECORD & rd[0].flags)) { GNUNET_SCHEDULER_add_now (&endbadly, NULL); GNUNET_break (0); return; } GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Block was decrypted successfully \n"); GNUNET_SCHEDULER_add_now (&end, NULL); }
static void arm_stop_cb (void *cls, enum GNUNET_ARM_RequestStatus status, const char *servicename, enum GNUNET_ARM_Result result) { GNUNET_break (status == GNUNET_ARM_REQUEST_SENT_OK); GNUNET_break (result == GNUNET_ARM_RESULT_STOPPED); if (result != GNUNET_ARM_RESULT_STOPPED) { GNUNET_break (0); ret = 4; } GNUNET_SCHEDULER_add_now (&trigger_disconnect, NULL); }
/** * Main function that will be run by the scheduler. * * @param cls closure * @param args remaining command-line arguments * @param cfgfile name of the configuration file used (for saving, can be NULL!) * @param c configuration */ static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c) { struct GNUNET_CRYPTO_RsaPrivateKey *priv; char *fn; cfg = c; if (args[0] != NULL) { FPRINTF (stderr, _("Invalid command line argument `%s'\n"), args[0]); return; } peerinfo = GNUNET_PEERINFO_connect (cfg); if (peerinfo == NULL) { FPRINTF (stderr, "%s", _("Could not access PEERINFO service. Exiting.\n")); return; } if ( (GNUNET_YES == get_self) || (GNUNET_YES == get_uri) ) { /* load private key */ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "GNUNETD", "HOSTKEY", &fn)) { FPRINTF (stderr, _("Could not find option `%s:%s' in configuration.\n"), "GNUNETD", "HOSTKEYFILE"); return; } if (NULL == (priv = GNUNET_CRYPTO_rsa_key_create_from_file (fn))) { FPRINTF (stderr, _("Loading hostkey from `%s' failed.\n"), fn); GNUNET_free (fn); return; } GNUNET_free (fn); GNUNET_CRYPTO_rsa_key_get_public (priv, &my_public_key); GNUNET_CRYPTO_rsa_key_free (priv); GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key), &my_peer_identity.hashPubKey); } tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL); GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task, NULL); }
static void on_lookup_result(void *cls, uint32_t rd_count, const struct GNUNET_NAMESTORE_RecordData *rd) { int i; uint16_t mx_preference; char* mx; if (GNUNET_SCHEDULER_NO_TASK != die_task) { GNUNET_SCHEDULER_cancel (die_task); die_task = GNUNET_SCHEDULER_NO_TASK; } GNUNET_NAMESTORE_disconnect (namestore_handle); if (rd_count == 0) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Lookup failed, rp_filtering?\n"); ok = 2; } else { ok = 1; GNUNET_log (GNUNET_ERROR_TYPE_INFO, "name: %s\n", (char*)cls); for (i=0; i<rd_count; i++) { GNUNET_log (GNUNET_ERROR_TYPE_INFO, "type: %d\n", rd[i].record_type); if (rd[i].record_type == GNUNET_GNS_RECORD_MX) { mx = (char*)rd[i].data+sizeof(uint16_t); mx_preference = *(uint16_t*)rd[i].data; GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Got MX %s with preference %d\n", mx, mx_preference); if (0 == strcmp(mx, TEST_EXPECTED_MX)) { GNUNET_log (GNUNET_ERROR_TYPE_INFO, "%s correctly resolved to %s!\n", TEST_DOMAIN, TEST_EXPECTED_MX); ok = 0; } } } } GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); }
/** * Method called whenever a peer disconnects. * * @param cls closure * @param peer peer identity this notification is about */ static void disconnect_notify (void *cls, const struct GNUNET_PeerIdentity *peer) { struct Peer *pos; if (0 == memcmp (&my_identity, peer, sizeof (struct GNUNET_PeerIdentity))) return; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Core told us that we disconnected from `%s'\n", GNUNET_i2s (peer)); pos = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey); if (NULL == pos) { GNUNET_break (0); return; } if (pos->is_connected != GNUNET_YES) { GNUNET_break (0); return; } pos->is_connected = GNUNET_NO; connection_count--; if (NULL != pos->hello_req) { GNUNET_CORE_notify_transmit_ready_cancel (pos->hello_req); pos->hello_req = NULL; } if (GNUNET_SCHEDULER_NO_TASK != pos->hello_delay_task) { GNUNET_SCHEDULER_cancel (pos->hello_delay_task); pos->hello_delay_task = GNUNET_SCHEDULER_NO_TASK; } GNUNET_STATISTICS_set (stats, gettext_noop ("# peers connected"), connection_count, GNUNET_NO); if (pos->is_friend) { friend_count--; GNUNET_STATISTICS_set (stats, gettext_noop ("# friends connected"), friend_count, GNUNET_NO); } if (((connection_count < target_connection_count) || (friend_count < minimum_friend_count)) && (GNUNET_SCHEDULER_NO_TASK == add_task)) add_task = GNUNET_SCHEDULER_add_now (&add_peer_task, NULL); if ((friend_count < minimum_friend_count) && (blacklist == NULL)) blacklist = GNUNET_TRANSPORT_blacklist (cfg, &blacklist_check, NULL); }
/** * Callback invoked from the namestore service once record is * created. * * @param cls closure * @param af address family, AF_INET or AF_INET6; AF_UNSPEC on error; * will match 'result_af' from the request * @param address IP address (struct in_addr or struct in_addr6, depending on 'af') * that the VPN allocated for the redirection; * traffic to this IP will now be redirected to the * specified target peer; NULL on error */ static void commence_testing (void *cls, int32_t success, const char *emsg) { GNUNET_SCHEDULER_add_now (&disco_ns, NULL); if ((emsg != NULL) && (GNUNET_YES != success)) { fprintf (stderr, "NS failed to create record %s\n", emsg); GNUNET_SCHEDULER_shutdown (); return; } GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1), start_curl, NULL); }
static int process_downloads (void *cls, const char *subsystem, const char *name, uint64_t value, int is_persistent) { if ((value >= 2) && (learned_hostlist_downloaded == GNUNET_NO)) { GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Peer has successfully downloaded advertised URI\n"); learned_hostlist_downloaded = GNUNET_YES; if ((learned_hostlist_saved == GNUNET_YES) && (adv_sent == GNUNET_YES)) { GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); } } return GNUNET_OK; }
/** * Create a tunnel to @a destionation. Must only be called * from within #GCP_get_tunnel(). * * @param destination where to create the tunnel to * @return new tunnel to @a destination */ struct CadetTunnel * GCT_create_tunnel (struct CadetPeer *destination) { struct CadetTunnel *t; t = GNUNET_new (struct CadetTunnel); t->destination = destination; t->channels = GNUNET_CONTAINER_multihashmap32_create (8); (void) GCP_iterate_paths (destination, &consider_path_cb, t); t->maintain_connections_task = GNUNET_SCHEDULER_add_now (&maintain_connections_cb, t); return t; }
/** * Completion callback for shutdown * * @param cls the closure from GNUNET_STREAM_shutdown call * @param operation the operation that was shutdown (SHUT_RD, SHUT_WR, * SHUT_RDWR) */ static void shutdown_completion (void *cls, int operation) { static int shutdowns; if (++shutdowns == 1) { peer_data[0].shutdown_handle = NULL; peer_data[1].shutdown_handle = GNUNET_STREAM_shutdown (peer_data[1].socket, SHUT_RDWR, &shutdown_completion, cls); return; } GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "STREAM shutdown successful\n"); GNUNET_SCHEDULER_add_now (&do_close, cls); }
/** * Connect to the service-dns * * @param cfg configuration to use * @param flags when to call rh * @param rh function to call with DNS requests * @param rh_cls closure to pass to rh * @return DNS handle */ struct GNUNET_DNS_Handle * GNUNET_DNS_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_DNS_Flags flags, GNUNET_DNS_RequestHandler rh, void *rh_cls) { struct GNUNET_DNS_Handle *dh; dh = GNUNET_new (struct GNUNET_DNS_Handle); dh->cfg = cfg; dh->flags = flags; dh->rh = rh; dh->rh_cls = rh_cls; dh->reconnect_task = GNUNET_SCHEDULER_add_now (&reconnect, dh); return dh; }