/** * Function scheduled to be run on the successful start of services * tries to look up the dns record for TEST_DOMAIN * * @param cls closure * @param success GNUNET_SYSERR on failure (including timeout/queue drop/failure to validate) * GNUNET_NO if content was already there or not found * GNUNET_YES (or other positive value) on success * @param emsg NULL on success, otherwise an error message */ static void commence_testing (void *cls, int32_t success, const char *emsg) { nsqe = NULL; if (NULL != emsg) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to store record in namestore: %s\n", emsg); end_badly_now (); return; } gns_handle = GNUNET_GNS_connect (cfg); if (NULL == gns_handle) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to connect to GNS!\n"); end_badly_now (); return; } lr = GNUNET_GNS_lookup (gns_handle, TEST_DOMAIN, GNUNET_GNS_RECORD_A, GNUNET_YES, NULL, &on_lookup_result, TEST_DOMAIN); }
static void do_check (void *cls, const struct GNUNET_CONFIGURATION_Handle *ccfg, struct GNUNET_TESTING_Peer *peer) { struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey; struct GNUNET_CRYPTO_RsaPrivateKey *alice_key; struct GNUNET_NAMESTORE_RecordData rd; char* alice_keyfile; char* ip = TEST_IP; struct in_addr web; cfg = ccfg; die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL); /* put records into namestore */ namestore_handle = GNUNET_NAMESTORE_connect(cfg); if (NULL == namestore_handle) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n"); end_badly_now (); return; } if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns", "ZONEKEY", &alice_keyfile)) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n"); end_badly_now (); return; } alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile); GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey); GNUNET_free (alice_keyfile); rd.expiration_time = UINT64_MAX; GNUNET_assert (1 == inet_pton (AF_INET, ip, &web)); rd.data_size = sizeof(struct in_addr); rd.data = &web; rd.record_type = GNUNET_DNSPARSER_TYPE_A; rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY; nsqe = GNUNET_NAMESTORE_record_create (namestore_handle, alice_key, TEST_RECORD_NAME, &rd, &commence_testing, NULL); GNUNET_CRYPTO_rsa_key_free (alice_key); }
/** * Function scheduled to be run on the successful start of services * tries to look up the dns record for TEST_DOMAIN */ static void commence_testing (void *cls, int32_t success, const char *emsg) { char name[GNUNET_DNSPARSER_MAX_NAME_LENGTH]; char* pos; struct GNUNET_CRYPTO_ShortHashAsciiEncoded hash_str; gns_handle = GNUNET_GNS_connect(cfg); if (NULL == gns_handle) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to connect to GNS!\n"); end_badly_now (); return; } pos = name; strcpy(pos, TEST_RECORD_NAME); pos += strlen(TEST_RECORD_NAME); strcpy(pos, "."); pos++; GNUNET_CRYPTO_short_hash_to_enc(&bob_hash, &hash_str); strcpy(pos, (char*)&hash_str); pos += strlen((char*)&hash_str); strcpy(pos, "."); pos++; strcpy(pos, GNUNET_GNS_TLD_ZKEY); GNUNET_GNS_lookup(gns_handle, name, GNUNET_GNS_RECORD_A, GNUNET_NO, NULL, &on_lookup_result, NULL); }
/** * Function scheduled to be run on the successful start of services * tries to look up the dns record for TEST_DOMAIN */ static void commence_testing (void *cls, int32_t success, const char *emsg) { gns_handle = GNUNET_GNS_connect(cfg); if (NULL == gns_handle) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to connect to GNS!\n"); end_badly_now(); return; } GNUNET_GNS_lookup(gns_handle, TEST_DOMAIN, GNUNET_GNS_RECORD_MX, GNUNET_NO, NULL, &on_lookup_result, TEST_DOMAIN); }
/** * Function scheduled to be run on the successful start of services * tries to shorten the name TEST_DOMAIN using gns */ static void commence_testing (void *cls, int32_t success, const char *emsg) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting to gns\n"); gns_handle = GNUNET_GNS_connect(cfg); if (NULL == gns_handle) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to connect to gns\n"); end_badly_now(); return; } GNUNET_GNS_get_authority(gns_handle, TEST_DOMAIN, &process_auth_result, TEST_DOMAIN); }
static void do_check (void *cls, const struct GNUNET_CONFIGURATION_Handle *ccfg, struct GNUNET_TESTING_Peer *peer) { struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey; struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey; struct GNUNET_CRYPTO_RsaPrivateKey *alice_key; struct GNUNET_CRYPTO_RsaPrivateKey *bob_key; struct GNUNET_CRYPTO_ShortHashCode bob_hash; struct GNUNET_CRYPTO_RsaSignature *sig; char* alice_keyfile; struct srv_data *srv_data; struct GNUNET_TIME_Absolute et; cfg = ccfg; die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL); /* put records into namestore */ namestore_handle = GNUNET_NAMESTORE_connect(cfg); if (NULL == namestore_handle) { GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n"); end_badly_now(); return; } if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns", "ZONEKEY", &alice_keyfile)) { GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n"); end_badly_now(); return; } alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile); bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB); GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey); GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey); struct GNUNET_NAMESTORE_RecordData rd; char* ip = TEST_IP; struct in_addr *sipserver = GNUNET_malloc (sizeof (struct in_addr)); srv_data = GNUNET_malloc (sizeof (struct srv_data) + strlen (TEST_SRV_NAME) + 1); uint16_t srv_weight = 60; uint16_t srv_prio = 50; uint16_t srv_port = 5060; rd.expiration_time = UINT64_MAX; GNUNET_assert(1 == inet_pton (AF_INET, ip, sipserver)); GNUNET_CRYPTO_short_hash(&bob_pkey, sizeof(bob_pkey), &bob_hash); rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode); rd.data = &bob_hash; rd.record_type = GNUNET_GNS_RECORD_PKEY; rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY; GNUNET_NAMESTORE_record_create (namestore_handle, alice_key, TEST_AUTHORITY_NAME, &rd, NULL, NULL); rd.data_size = sizeof (struct in_addr); rd.data = sipserver; rd.record_type = GNUNET_DNSPARSER_TYPE_A; sig = GNUNET_NAMESTORE_create_signature(bob_key, GNUNET_TIME_UNIT_FOREVER_ABS, TEST_RECORD_NAME, &rd, 1); et.abs_value = rd.expiration_time; GNUNET_NAMESTORE_record_put (namestore_handle, &bob_pkey, TEST_RECORD_NAME, et, 1, &rd, sig, NULL, NULL); GNUNET_free (sig); rd.data_size = sizeof (struct srv_data)+strlen(TEST_SRV_NAME)+1; srv_data->port = srv_port; srv_data->prio = srv_prio; srv_data->weight = srv_weight; strcpy((char*)&srv_data[1], TEST_SRV_NAME); rd.data = srv_data; rd.record_type = GNUNET_GNS_RECORD_SRV; sig = GNUNET_NAMESTORE_create_signature(bob_key, GNUNET_TIME_UNIT_FOREVER_ABS, TEST_RECORD_NAME_SRV, &rd, 1); et.abs_value = rd.expiration_time; GNUNET_NAMESTORE_record_put (namestore_handle, &bob_pkey, TEST_RECORD_NAME_SRV, et, 1, &rd, sig, &commence_testing, NULL); GNUNET_free (alice_keyfile); GNUNET_free (srv_data); GNUNET_free (sipserver); GNUNET_free (sig); GNUNET_CRYPTO_rsa_key_free (bob_key); GNUNET_CRYPTO_rsa_key_free (alice_key); }
/** * Callback to be called when the requested peer information is available * * @param cb_cls the closure from GNUNET_TETSBED_peer_get_information() * @param op the operation this callback corresponds to * @param pinfo the result; will be NULL if the operation has failed * @param emsg error message if the operation has failed; will be NULL if the * operation is successfull */ static void peerinfo_cb (void *cb_cls, struct GNUNET_TESTBED_Operation *op, const struct GNUNET_TESTBED_PeerInformation *pinfo, const char *emsg) { int res; GNUNET_assert (GNUNET_TESTBED_PIT_CONFIGURATION == pinfo->pit); if (GNUNET_NO == dave_is_setup) res = setup_dave (pinfo->result.cfg); else if (GNUNET_NO == bob_is_setup) res = setup_bob (pinfo->result.cfg); else res = setup_alice (pinfo->result.cfg); if (get_cfg_ops[0] == op) get_cfg_ops[0] = NULL; else if (get_cfg_ops[1] == op) get_cfg_ops[1] = NULL; else get_cfg_ops[2] = NULL; GNUNET_TESTBED_operation_done (op); op = NULL; if (GNUNET_SYSERR == res) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to setup peer \n"); end_badly_now(); } else connect_peers (); /*if (get_cfg_ops[0] == op) { GNUNET_assert (GNUNET_TESTBED_PIT_CONFIGURATION == pinfo->pit); res = setup_dave (pinfo->result.cfg); GNUNET_TESTBED_operation_done (get_cfg_ops[0]); get_cfg_ops[0] = NULL; if (GNUNET_SYSERR == res) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to setup dave \n"); end_badly_now(); } else { connect_peers (); } } else if (get_cfg_ops[1] == op) { GNUNET_assert (GNUNET_TESTBED_PIT_CONFIGURATION == pinfo->pit); res = setup_bob (pinfo->result.cfg); GNUNET_TESTBED_operation_done (get_cfg_ops[1]); get_cfg_ops[1] = NULL; if (GNUNET_SYSERR == res) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to setup dave \n"); end_badly_now(); } else { connect_peers (); } } else if (get_cfg_ops[2] == op) { GNUNET_assert (GNUNET_TESTBED_PIT_CONFIGURATION == pinfo->pit); res = setup_alice (pinfo->result.cfg); GNUNET_TESTBED_operation_done (get_cfg_ops[2]); get_cfg_ops[2] = NULL; if (GNUNET_SYSERR == res) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to setup dave \n"); end_badly_now(); } else { connect_peers (); } }*/ }
void do_check (void *cls, const struct GNUNET_CONFIGURATION_Handle *ccfg, struct GNUNET_TESTING_Peer *peer) { struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded our_pkey; struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey; struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey; struct GNUNET_CRYPTO_RsaPrivateKey *our_key; struct GNUNET_CRYPTO_RsaPrivateKey *alice_key; struct GNUNET_CRYPTO_RsaPrivateKey *bob_key; struct GNUNET_CRYPTO_ShortHashCode bob_hash; struct GNUNET_CRYPTO_ShortHashCode alice_hash; struct GNUNET_CRYPTO_RsaSignature *sig; char* our_keyfile; cfg = ccfg; die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Running test\n"); /* put records into namestore */ namestore_handle = GNUNET_NAMESTORE_connect(cfg); if (NULL == namestore_handle) { GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n"); end_badly_now(); return; } if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns", "ZONEKEY", &our_keyfile)) { GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n"); end_badly_now(); return; } our_key = GNUNET_CRYPTO_rsa_key_create_from_file (our_keyfile); GNUNET_free(our_keyfile); bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB); alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_ALICE); GNUNET_CRYPTO_rsa_key_get_public (our_key, &our_pkey); GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey); GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey); struct GNUNET_NAMESTORE_RecordData rd; char* ip = TEST_IP; struct in_addr *web = GNUNET_malloc (sizeof(struct in_addr)); rd.expiration_time = UINT64_MAX; GNUNET_assert (1 == inet_pton (AF_INET, ip, web)); GNUNET_CRYPTO_short_hash(&bob_pkey, sizeof(bob_pkey), &bob_hash); rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode); rd.data = &bob_hash; rd.record_type = GNUNET_GNS_RECORD_PKEY; rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY; /* put bob into our zone */ GNUNET_NAMESTORE_record_create (namestore_handle, our_key, TEST_AUTHORITY_BOB, &rd, NULL, NULL); /* put alice into bobs zone */ GNUNET_CRYPTO_short_hash(&alice_pkey, sizeof(alice_pkey), &alice_hash); rd.data = &alice_hash; sig = GNUNET_NAMESTORE_create_signature(bob_key, GNUNET_TIME_UNIT_FOREVER_ABS, TEST_AUTHORITY_ALICE, &rd, 1); GNUNET_NAMESTORE_record_put (namestore_handle, &bob_pkey, TEST_AUTHORITY_ALICE, GNUNET_TIME_UNIT_FOREVER_ABS, 1, &rd, sig, NULL, NULL); GNUNET_free (sig); /* put www A record and PSEU into alice's zone */ rd.data_size = sizeof(struct in_addr); rd.data = web; rd.record_type = GNUNET_DNSPARSER_TYPE_A; sig = GNUNET_NAMESTORE_create_signature(alice_key,GNUNET_TIME_UNIT_FOREVER_ABS, TEST_RECORD_NAME, &rd, 1); GNUNET_NAMESTORE_record_put (namestore_handle, &alice_pkey, TEST_RECORD_NAME, GNUNET_TIME_UNIT_FOREVER_ABS, 1, &rd, sig, NULL, NULL); rd.data_size = strlen(TEST_ALICE_PSEU); rd.data = TEST_ALICE_PSEU; rd.record_type = GNUNET_GNS_RECORD_PSEU; GNUNET_free(sig); sig = GNUNET_NAMESTORE_create_signature(alice_key,GNUNET_TIME_UNIT_FOREVER_ABS, "", &rd, 1); GNUNET_NAMESTORE_record_put (namestore_handle, &alice_pkey, "", GNUNET_TIME_UNIT_FOREVER_ABS, 1, &rd, sig, &commence_testing, NULL); GNUNET_free (web); GNUNET_free (sig); GNUNET_CRYPTO_rsa_key_free (alice_key); GNUNET_CRYPTO_rsa_key_free (bob_key); GNUNET_CRYPTO_rsa_key_free (our_key); }