diff options
Diffstat (limited to 'src/service')
-rw-r--r-- | src/service/fs/test_plugin_block_fs.c | 86 | ||||
-rw-r--r-- | src/service/gns/openssl.cnf | 244 | ||||
-rw-r--r-- | src/service/gns/test_gns_proxy.conf | 31 | ||||
-rwxr-xr-x | src/service/gns/test_gnunet_gns.sh.in | 47 | ||||
-rw-r--r-- | src/service/gns/zonefiles/188JSUMKEF25GVU8TTV0PBNNN8JVCPUEDFV1UHJJU884JD25V0T0.zkey | bin | 827 -> 0 bytes | |||
-rw-r--r-- | src/service/gns/zonefiles/J7POEUT41A8PBFS7KVVDRF88GBOU4HK8PSU5QKVLVE3R9T91E99G.zkey | bin | 826 -> 0 bytes | |||
-rw-r--r-- | src/service/gns/zonefiles/OEFL7A4VEF1B40QLEMTG5D8G1CN6EN16QUSG5R2DT71GRJN34LSG.zkey | bin | 826 -> 0 bytes | |||
-rw-r--r-- | src/service/gns/zonefiles/test_zonekey | bin | 827 -> 0 bytes | |||
-rw-r--r-- | src/service/namecache/test_plugin_namecache.c | 135 | ||||
-rw-r--r-- | src/service/namecache/test_plugin_namecache_flat.conf | 2 | ||||
-rw-r--r-- | src/service/namecache/test_plugin_namecache_postgres.conf | 3 | ||||
-rw-r--r-- | src/service/namecache/test_plugin_namecache_sqlite.conf | 2 | ||||
-rw-r--r-- | src/service/reclaim/pabc_helper.c | 366 | ||||
-rw-r--r-- | src/service/reclaim/pabc_helper.h | 41 |
14 files changed, 31 insertions, 926 deletions
diff --git a/src/service/fs/test_plugin_block_fs.c b/src/service/fs/test_plugin_block_fs.c deleted file mode 100644 index f15d10b17..000000000 --- a/src/service/fs/test_plugin_block_fs.c +++ /dev/null | |||
@@ -1,86 +0,0 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet | ||
3 | Copyright (C) 2010, 2012 GNUnet e.V. | ||
4 | |||
5 | GNUnet is free software: you can redistribute it and/or modify it | ||
6 | under the terms of the GNU Affero General Public License as published | ||
7 | by the Free Software Foundation, either version 3 of the License, | ||
8 | or (at your option) any later version. | ||
9 | |||
10 | GNUnet is distributed in the hope that it will be useful, but | ||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Affero General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Affero General Public License | ||
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
17 | |||
18 | SPDX-License-Identifier: AGPL3.0-or-later | ||
19 | */ | ||
20 | /** | ||
21 | * @file fs/test_plugin_block_fs.c | ||
22 | * @brief test for plugin_block_fs.c | ||
23 | * @author Christian Grothoff | ||
24 | */ | ||
25 | #include "platform.h" | ||
26 | #include "gnunet_block_lib.h" | ||
27 | |||
28 | |||
29 | static int | ||
30 | test_fs (struct GNUNET_BLOCK_Context *ctx) | ||
31 | { | ||
32 | struct GNUNET_HashCode key; | ||
33 | char block[4]; | ||
34 | |||
35 | memset (block, 1, sizeof(block)); | ||
36 | if (GNUNET_OK != | ||
37 | GNUNET_BLOCK_get_key (ctx, | ||
38 | GNUNET_BLOCK_TYPE_FS_DBLOCK, | ||
39 | block, | ||
40 | sizeof(block), | ||
41 | &key)) | ||
42 | return 1; | ||
43 | if (GNUNET_OK != | ||
44 | GNUNET_BLOCK_check_block (ctx, | ||
45 | GNUNET_BLOCK_TYPE_FS_DBLOCK, | ||
46 | block, | ||
47 | sizeof(block))) | ||
48 | return 2; | ||
49 | if (GNUNET_OK != | ||
50 | GNUNET_BLOCK_check_query (ctx, | ||
51 | GNUNET_BLOCK_TYPE_FS_DBLOCK, | ||
52 | &key, | ||
53 | NULL, 0)) | ||
54 | return 4; | ||
55 | GNUNET_log_skip (1, GNUNET_NO); | ||
56 | if (GNUNET_NO != | ||
57 | GNUNET_BLOCK_check_query (ctx, | ||
58 | GNUNET_BLOCK_TYPE_FS_DBLOCK, | ||
59 | &key, | ||
60 | "bogus", 5)) | ||
61 | return 8; | ||
62 | GNUNET_log_skip (0, GNUNET_YES); | ||
63 | return 0; | ||
64 | } | ||
65 | |||
66 | |||
67 | int | ||
68 | main (int argc, char *argv[]) | ||
69 | { | ||
70 | int ret; | ||
71 | struct GNUNET_BLOCK_Context *ctx; | ||
72 | struct GNUNET_CONFIGURATION_Handle *cfg; | ||
73 | |||
74 | GNUNET_log_setup ("test-block", "WARNING", NULL); | ||
75 | cfg = GNUNET_CONFIGURATION_create (); | ||
76 | ctx = GNUNET_BLOCK_context_create (cfg); | ||
77 | ret = test_fs (ctx); | ||
78 | GNUNET_BLOCK_context_destroy (ctx); | ||
79 | GNUNET_CONFIGURATION_destroy (cfg); | ||
80 | if (ret != 0) | ||
81 | fprintf (stderr, "Tests failed: %d\n", ret); | ||
82 | return ret; | ||
83 | } | ||
84 | |||
85 | |||
86 | /* end of test_plugin_block_fs.c */ | ||
diff --git a/src/service/gns/openssl.cnf b/src/service/gns/openssl.cnf deleted file mode 100644 index a2561b9b2..000000000 --- a/src/service/gns/openssl.cnf +++ /dev/null | |||
@@ -1,244 +0,0 @@ | |||
1 | # | ||
2 | # OpenSSL example configuration file. | ||
3 | # This is mostly being used for generation of certificate requests. | ||
4 | # | ||
5 | |||
6 | # This definition stops the following lines choking if HOME isn't | ||
7 | # defined. | ||
8 | HOME = . | ||
9 | RANDFILE = $ENV::HOME/.rnd | ||
10 | |||
11 | # Extra OBJECT IDENTIFIER info: | ||
12 | #oid_file = $ENV::HOME/.oid | ||
13 | oid_section = new_oids | ||
14 | |||
15 | # To use this configuration file with the "-extfile" option of the | ||
16 | # "openssl x509" utility, name here the section containing the | ||
17 | # X.509v3 extensions to use: | ||
18 | # extensions = | ||
19 | # (Alternatively, use a configuration file that has only | ||
20 | # X.509v3 extensions in its main [= default] section.) | ||
21 | |||
22 | [ new_oids ] | ||
23 | |||
24 | # We can add new OIDs in here for use by 'ca' and 'req'. | ||
25 | # Add a simple OID like this: | ||
26 | # testoid1=1.2.3.4 | ||
27 | # Or use config file substitution like this: | ||
28 | # testoid2=${testoid1}.5.6 | ||
29 | |||
30 | #################################################################### | ||
31 | [ ca ] | ||
32 | default_ca = CA_default # The default ca section | ||
33 | |||
34 | #################################################################### | ||
35 | [ CA_default ] | ||
36 | |||
37 | dir = ./demoCA # Where everything is kept | ||
38 | certs = $dir/certs # Where the issued certs are kept | ||
39 | crl_dir = $dir/crl # Where the issued crl are kept | ||
40 | database = $dir/index.txt # database index file. | ||
41 | new_certs_dir = $dir/newcerts # default place for new certs. | ||
42 | |||
43 | certificate = $dir/cacert.pem # The CA certificate | ||
44 | serial = $dir/serial # The current serial number | ||
45 | crl = $dir/crl.pem # The current CRL | ||
46 | private_key = $dir/private/cakey.pem# The private key | ||
47 | RANDFILE = $dir/private/.rand # private random number file | ||
48 | |||
49 | x509_extensions = usr_cert # The extensions to add to the cert | ||
50 | |||
51 | # Extensions to add to a CRL. Note: Netscape communicator chokes on V2 CRLs | ||
52 | # so this is commented out by default to leave a V1 CRL. | ||
53 | # crl_extensions = crl_ext | ||
54 | |||
55 | default_days = 365 # how long to certify for | ||
56 | default_crl_days= 30 # how long before next CRL | ||
57 | default_md = md5 # which md to use. | ||
58 | preserve = no # keep passed DN ordering | ||
59 | |||
60 | # A few difference way of specifying how similar the request should look | ||
61 | # For type CA, the listed attributes must be the same, and the optional | ||
62 | # and supplied fields are just that :-) | ||
63 | policy = policy_match | ||
64 | |||
65 | # For the CA policy | ||
66 | [ policy_match ] | ||
67 | countryName = match | ||
68 | stateOrProvinceName = match | ||
69 | organizationName = match | ||
70 | organizationalUnitName = optional | ||
71 | commonName = supplied | ||
72 | emailAddress = optional | ||
73 | |||
74 | # For the 'anything' policy | ||
75 | # At this point in time, you must list all acceptable 'object' | ||
76 | # types. | ||
77 | [ policy_anything ] | ||
78 | countryName = optional | ||
79 | stateOrProvinceName = optional | ||
80 | localityName = optional | ||
81 | organizationName = optional | ||
82 | organizationalUnitName = optional | ||
83 | commonName = supplied | ||
84 | emailAddress = optional | ||
85 | |||
86 | #################################################################### | ||
87 | [ req ] | ||
88 | default_bits = 1024 | ||
89 | default_keyfile = privkey.pem | ||
90 | distinguished_name = req_distinguished_name | ||
91 | attributes = req_attributes | ||
92 | x509_extensions = v3_ca # The extensions to add to the self signed cert | ||
93 | |||
94 | # Passwords for private keys if not present they will be prompted for | ||
95 | # input_password = secret | ||
96 | # output_password = secret | ||
97 | |||
98 | # This sets a mask for permitted string types. There are several options. | ||
99 | # default: PrintableString, T61String, BMPString. | ||
100 | # pkix : PrintableString, BMPString. | ||
101 | # utf8only: only UTF8Strings. | ||
102 | # nombstr : PrintableString, T61String (no BMPStrings or UTF8Strings). | ||
103 | # MASK:XXXX a literal mask value. | ||
104 | # WARNING: current versions of Netscape crash on BMPStrings or UTF8Strings | ||
105 | # so use this option with caution! | ||
106 | string_mask = nombstr | ||
107 | |||
108 | # req_extensions = v3_req # The extensions to add to a certificate request | ||
109 | |||
110 | [ req_distinguished_name ] | ||
111 | countryName = Country Name (2 letter code) | ||
112 | countryName_default = AU | ||
113 | countryName_min = 2 | ||
114 | countryName_max = 2 | ||
115 | |||
116 | stateOrProvinceName = State or Province Name (full name) | ||
117 | stateOrProvinceName_default = Some-State | ||
118 | |||
119 | localityName = Locality Name (eg, city) | ||
120 | |||
121 | 0.organizationName = Organization Name (eg, company) | ||
122 | 0.organizationName_default = Internet Widgits Pty Ltd | ||
123 | |||
124 | # we can do this but it is not needed normally :-) | ||
125 | #1.organizationName = Second Organization Name (eg, company) | ||
126 | #1.organizationName_default = World Wide Web Pty Ltd | ||
127 | |||
128 | organizationalUnitName = Organizational Unit Name (eg, section) | ||
129 | #organizationalUnitName_default = | ||
130 | |||
131 | commonName = Common Name (eg, YOUR name) | ||
132 | commonName_max = 64 | ||
133 | |||
134 | emailAddress = Email Address | ||
135 | emailAddress_max = 40 | ||
136 | |||
137 | # SET-ex3 = SET extension number 3 | ||
138 | |||
139 | [ req_attributes ] | ||
140 | challengePassword = A challenge password | ||
141 | challengePassword_min = 4 | ||
142 | challengePassword_max = 20 | ||
143 | |||
144 | unstructuredName = An optional company name | ||
145 | |||
146 | [ usr_cert ] | ||
147 | |||
148 | # These extensions are added when 'ca' signs a request. | ||
149 | |||
150 | # This goes against PKIX guidelines but some CAs do it and some software | ||
151 | # requires this to avoid interpreting an end user certificate as a CA. | ||
152 | |||
153 | basicConstraints=CA:FALSE | ||
154 | |||
155 | # Here are some examples of the usage of nsCertType. If it is omitted | ||
156 | # the certificate can be used for anything *except* object signing. | ||
157 | |||
158 | # This is OK for an SSL server. | ||
159 | # nsCertType = server | ||
160 | |||
161 | # For an object signing certificate this would be used. | ||
162 | # nsCertType = objsign | ||
163 | |||
164 | # For normal client use this is typical | ||
165 | # nsCertType = client, email | ||
166 | |||
167 | # and for everything including object signing: | ||
168 | # nsCertType = client, email, objsign | ||
169 | |||
170 | # This is typical in keyUsage for a client certificate. | ||
171 | # keyUsage = nonRepudiation, digitalSignature, keyEncipherment | ||
172 | |||
173 | # This will be displayed in Netscape's comment listbox. | ||
174 | nsComment = "OpenSSL Generated Certificate" | ||
175 | |||
176 | # PKIX recommendations harmless if included in all certificates. | ||
177 | subjectKeyIdentifier=hash | ||
178 | authorityKeyIdentifier=keyid,issuer:always | ||
179 | |||
180 | # This stuff is for subjectAltName and issuerAltname. | ||
181 | # Import the email address. | ||
182 | # subjectAltName=email:copy | ||
183 | |||
184 | # Copy subject details | ||
185 | # issuerAltName=issuer:copy | ||
186 | |||
187 | #nsCaRevocationUrl = http://www.domain.dom/ca-crl.pem | ||
188 | #nsBaseUrl | ||
189 | #nsRevocationUrl | ||
190 | #nsRenewalUrl | ||
191 | #nsCaPolicyUrl | ||
192 | #nsSslServerName | ||
193 | |||
194 | [ v3_req ] | ||
195 | |||
196 | # Extensions to add to a certificate request | ||
197 | |||
198 | basicConstraints = CA:FALSE | ||
199 | keyUsage = nonRepudiation, digitalSignature, keyEncipherment | ||
200 | |||
201 | [ v3_ca ] | ||
202 | |||
203 | |||
204 | # Extensions for a typical CA | ||
205 | |||
206 | |||
207 | # PKIX recommendation. | ||
208 | |||
209 | subjectKeyIdentifier=hash | ||
210 | |||
211 | authorityKeyIdentifier=keyid:always,issuer:always | ||
212 | |||
213 | # This is what PKIX recommends but some broken software chokes on critical | ||
214 | # extensions. | ||
215 | #basicConstraints = critical,CA:true | ||
216 | # So we do this instead. | ||
217 | basicConstraints = CA:true | ||
218 | |||
219 | # Key usage: this is typical for a CA certificate. However since it will | ||
220 | # prevent it being used as an test self-signed certificate it is best | ||
221 | # left out by default. | ||
222 | # keyUsage = cRLSign, keyCertSign | ||
223 | |||
224 | # Some might want this also | ||
225 | # nsCertType = sslCA, emailCA | ||
226 | |||
227 | # Include email address in subject alt name: another PKIX recommendation | ||
228 | # subjectAltName=email:copy | ||
229 | # Copy issuer details | ||
230 | # issuerAltName=issuer:copy | ||
231 | |||
232 | # DER hex encoding of an extension: beware experts only! | ||
233 | # obj=DER:02:03 | ||
234 | # Where 'obj' is a standard or added object | ||
235 | # You can even override a supported extension: | ||
236 | # basicConstraints= critical, DER:30:03:01:01:FF | ||
237 | |||
238 | [ crl_ext ] | ||
239 | |||
240 | # CRL extensions. | ||
241 | # Only issuerAltName and authorityKeyIdentifier make any sense in a CRL. | ||
242 | |||
243 | # issuerAltName=issuer:copy | ||
244 | authorityKeyIdentifier=keyid:always,issuer:always | ||
diff --git a/src/service/gns/test_gns_proxy.conf b/src/service/gns/test_gns_proxy.conf new file mode 100644 index 000000000..3dfeacafe --- /dev/null +++ b/src/service/gns/test_gns_proxy.conf | |||
@@ -0,0 +1,31 @@ | |||
1 | @INLINE@ test_gns_defaults.conf | ||
2 | |||
3 | [transport] | ||
4 | PLUGINS = tcp | ||
5 | |||
6 | [gns] | ||
7 | # PREFIX = valgrind --leak-check=full --track-origins=yes | ||
8 | START_ON_DEMAND = YES | ||
9 | AUTO_IMPORT_PKEY = YES | ||
10 | MAX_PARALLEL_BACKGROUND_QUERIES = 10 | ||
11 | DEFAULT_LOOKUP_TIMEOUT = 15 s | ||
12 | RECORD_PUT_INTERVAL = 1 h | ||
13 | ZONE_PUBLISH_TIME_WINDOW = 1 h | ||
14 | DNS_ROOT=PD67SGHF3E0447TU9HADIVU9OM7V4QHTOG0EBU69TFRI2LG63DR0 | ||
15 | |||
16 | [zonemaster-monitor] | ||
17 | IMMEDIATE_START = YES | ||
18 | START_ON_DEMAND = YES | ||
19 | |||
20 | [zonemaster] | ||
21 | IMMEDIATE_START = YES | ||
22 | START_ON_DEMAND = YES | ||
23 | |||
24 | |||
25 | |||
26 | [gns-proxy] | ||
27 | PROXY_CACERT = $GNUNET_TMP/proxy_cacert.pem | ||
28 | PROXY_UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-gns-proxy.sock | ||
29 | |||
30 | [namestore] | ||
31 | START_ON_DEMAND = YES | ||
diff --git a/src/service/gns/test_gnunet_gns.sh.in b/src/service/gns/test_gnunet_gns.sh.in deleted file mode 100755 index d0c07b4e4..000000000 --- a/src/service/gns/test_gnunet_gns.sh.in +++ /dev/null | |||
@@ -1,47 +0,0 @@ | |||
1 | #!/bin/bash | ||
2 | # This file is in the public domain. | ||
3 | # test -z being correct was a false assumption here. | ||
4 | # I have no executable 'fooble', but this will | ||
5 | # return 1: | ||
6 | # if test -z "`which fooble`"; then echo 1; fi | ||
7 | # The command builtin might not work with busybox's ash | ||
8 | # but this works for now. | ||
9 | dir=$(dirname "$0") | ||
10 | |||
11 | existence() { | ||
12 | command -v "$1" >/dev/null 2>&1 | ||
13 | } | ||
14 | |||
15 | LOCATION=`existence gnunet-config` | ||
16 | if test -z $LOCATION; then | ||
17 | LOCATION="gnunet-config" | ||
18 | fi | ||
19 | $LOCATION --version | ||
20 | if test $? != 0 | ||
21 | then | ||
22 | echo "GNUnet command line tools cannot be found, check environmental variables PATH and GNUNET_PREFIX" | ||
23 | exit 77 | ||
24 | fi | ||
25 | |||
26 | trap "gnunet-arm -e -c test_gns_lookup.conf" SIGINT | ||
27 | ME=`whoami` | ||
28 | if [ "$ME" != "root" ] | ||
29 | then | ||
30 | echo "This test only works if run as root. Skipping." | ||
31 | exit 77 | ||
32 | fi | ||
33 | export PATH=".:$PATH" | ||
34 | gnunet-service-gns -c gns.conf & | ||
35 | sleep 1 | ||
36 | LO=`nslookup alice.gnu | grep Address | tail -n1` | ||
37 | if [ "$LO" != "Address: 1.2.3.4" ] | ||
38 | then | ||
39 | echo "Fail: $LO" | ||
40 | fi | ||
41 | LO=`nslookup www.bob.gnu | grep Address | tail -n1` | ||
42 | if [ "$LO" != "Address: 4.5.6.7" ] | ||
43 | then | ||
44 | echo "Fail: $LO" | ||
45 | fi | ||
46 | # XXX: jobs. a builtin by bash, netbsd sh, maybe leave it be for now. | ||
47 | kill `jobs -p` | ||
diff --git a/src/service/gns/zonefiles/188JSUMKEF25GVU8TTV0PBNNN8JVCPUEDFV1UHJJU884JD25V0T0.zkey b/src/service/gns/zonefiles/188JSUMKEF25GVU8TTV0PBNNN8JVCPUEDFV1UHJJU884JD25V0T0.zkey deleted file mode 100644 index 895946037..000000000 --- a/src/service/gns/zonefiles/188JSUMKEF25GVU8TTV0PBNNN8JVCPUEDFV1UHJJU884JD25V0T0.zkey +++ /dev/null | |||
Binary files differ | |||
diff --git a/src/service/gns/zonefiles/J7POEUT41A8PBFS7KVVDRF88GBOU4HK8PSU5QKVLVE3R9T91E99G.zkey b/src/service/gns/zonefiles/J7POEUT41A8PBFS7KVVDRF88GBOU4HK8PSU5QKVLVE3R9T91E99G.zkey deleted file mode 100644 index 3ef49f0ac..000000000 --- a/src/service/gns/zonefiles/J7POEUT41A8PBFS7KVVDRF88GBOU4HK8PSU5QKVLVE3R9T91E99G.zkey +++ /dev/null | |||
Binary files differ | |||
diff --git a/src/service/gns/zonefiles/OEFL7A4VEF1B40QLEMTG5D8G1CN6EN16QUSG5R2DT71GRJN34LSG.zkey b/src/service/gns/zonefiles/OEFL7A4VEF1B40QLEMTG5D8G1CN6EN16QUSG5R2DT71GRJN34LSG.zkey deleted file mode 100644 index 89e0b3a0a..000000000 --- a/src/service/gns/zonefiles/OEFL7A4VEF1B40QLEMTG5D8G1CN6EN16QUSG5R2DT71GRJN34LSG.zkey +++ /dev/null | |||
Binary files differ | |||
diff --git a/src/service/gns/zonefiles/test_zonekey b/src/service/gns/zonefiles/test_zonekey deleted file mode 100644 index 870c56315..000000000 --- a/src/service/gns/zonefiles/test_zonekey +++ /dev/null | |||
Binary files differ | |||
diff --git a/src/service/namecache/test_plugin_namecache.c b/src/service/namecache/test_plugin_namecache.c deleted file mode 100644 index 141698a23..000000000 --- a/src/service/namecache/test_plugin_namecache.c +++ /dev/null | |||
@@ -1,135 +0,0 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet. | ||
3 | Copyright (C) 2012 GNUnet e.V. | ||
4 | |||
5 | GNUnet is free software: you can redistribute it and/or modify it | ||
6 | under the terms of the GNU Affero General Public License as published | ||
7 | by the Free Software Foundation, either version 3 of the License, | ||
8 | or (at your option) any later version. | ||
9 | |||
10 | GNUnet is distributed in the hope that it will be useful, but | ||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Affero General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Affero General Public License | ||
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
17 | |||
18 | SPDX-License-Identifier: AGPL3.0-or-later | ||
19 | */ | ||
20 | /* | ||
21 | * @file namecache/test_plugin_namecache.c | ||
22 | * @brief Test for the namecache plugins | ||
23 | * @author Christian Grothoff | ||
24 | */ | ||
25 | #include "platform.h" | ||
26 | #include "gnunet_util_lib.h" | ||
27 | #include "gnunet_namecache_plugin.h" | ||
28 | #include "gnunet_testing_lib.h" | ||
29 | |||
30 | |||
31 | static int ok; | ||
32 | |||
33 | /** | ||
34 | * Name of plugin under test. | ||
35 | */ | ||
36 | static const char *plugin_name; | ||
37 | |||
38 | |||
39 | /** | ||
40 | * Function called when the service shuts down. Unloads our namecache | ||
41 | * plugin. | ||
42 | * | ||
43 | * @param api api to unload | ||
44 | */ | ||
45 | static void | ||
46 | unload_plugin (struct GNUNET_NAMECACHE_PluginFunctions *api) | ||
47 | { | ||
48 | char *libname; | ||
49 | |||
50 | GNUNET_asprintf (&libname, "libgnunet_plugin_namecache_%s", plugin_name); | ||
51 | GNUNET_break (NULL == GNUNET_PLUGIN_unload (libname, api)); | ||
52 | GNUNET_free (libname); | ||
53 | } | ||
54 | |||
55 | |||
56 | /** | ||
57 | * Load the namecache plugin. | ||
58 | * | ||
59 | * @param cfg configuration to pass | ||
60 | * @return NULL on error | ||
61 | */ | ||
62 | static struct GNUNET_NAMECACHE_PluginFunctions * | ||
63 | load_plugin (const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
64 | { | ||
65 | struct GNUNET_NAMECACHE_PluginFunctions *ret; | ||
66 | char *libname; | ||
67 | |||
68 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Loading `%s' namecache plugin\n"), | ||
69 | plugin_name); | ||
70 | GNUNET_asprintf (&libname, "libgnunet_plugin_namecache_%s", plugin_name); | ||
71 | if (NULL == (ret = GNUNET_PLUGIN_load (libname, (void *) cfg))) | ||
72 | { | ||
73 | fprintf (stderr, "Failed to load plugin `%s'!\n", plugin_name); | ||
74 | GNUNET_free (libname); | ||
75 | return NULL; | ||
76 | } | ||
77 | GNUNET_free (libname); | ||
78 | return ret; | ||
79 | } | ||
80 | |||
81 | |||
82 | static void | ||
83 | run (void *cls, char *const *args, const char *cfgfile, | ||
84 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
85 | { | ||
86 | struct GNUNET_NAMECACHE_PluginFunctions *nsp; | ||
87 | |||
88 | ok = 0; | ||
89 | nsp = load_plugin (cfg); | ||
90 | if (NULL == nsp) | ||
91 | { | ||
92 | fprintf (stderr, | ||
93 | "%s", | ||
94 | "Failed to initialize namecache. Database likely not setup, skipping test.\n"); | ||
95 | return; | ||
96 | } | ||
97 | |||
98 | unload_plugin (nsp); | ||
99 | } | ||
100 | |||
101 | |||
102 | int | ||
103 | main (int argc, char *argv[]) | ||
104 | { | ||
105 | char cfg_name[PATH_MAX]; | ||
106 | char *const xargv[] = { | ||
107 | "test-plugin-namecache", | ||
108 | "-c", | ||
109 | cfg_name, | ||
110 | NULL | ||
111 | }; | ||
112 | struct GNUNET_GETOPT_CommandLineOption options[] = { | ||
113 | GNUNET_GETOPT_OPTION_END | ||
114 | }; | ||
115 | |||
116 | plugin_name = GNUNET_STRINGS_get_suffix_from_binary_name (argv[0]); | ||
117 | GNUNET_snprintf (cfg_name, sizeof(cfg_name), "test_plugin_namecache_%s.conf", | ||
118 | plugin_name); | ||
119 | |||
120 | GNUNET_DISK_purge_cfg_dir (cfg_name, "GNUNET_TEST_HOME"); | ||
121 | |||
122 | GNUNET_log_setup ("test-plugin-namecache", | ||
123 | "WARNING", | ||
124 | NULL); | ||
125 | GNUNET_PROGRAM_run ((sizeof(xargv) / sizeof(char *)) - 1, xargv, | ||
126 | "test-plugin-namecache", "nohelp", options, &run, NULL); | ||
127 | |||
128 | if (ok != 0) | ||
129 | fprintf (stderr, "Missed some testcases: %d\n", ok); | ||
130 | GNUNET_DISK_purge_cfg_dir (cfg_name, "GNUNET_TEST_HOME"); | ||
131 | return ok; | ||
132 | } | ||
133 | |||
134 | |||
135 | /* end of test_plugin_namecache.c */ | ||
diff --git a/src/service/namecache/test_plugin_namecache_flat.conf b/src/service/namecache/test_plugin_namecache_flat.conf deleted file mode 100644 index efe77e37a..000000000 --- a/src/service/namecache/test_plugin_namecache_flat.conf +++ /dev/null | |||
@@ -1,2 +0,0 @@ | |||
1 | [namecache-flat] | ||
2 | FILENAME = $GNUNET_TMP/gnunet-test-plugin-namecache-flat/flatdb | ||
diff --git a/src/service/namecache/test_plugin_namecache_postgres.conf b/src/service/namecache/test_plugin_namecache_postgres.conf deleted file mode 100644 index 8473857d5..000000000 --- a/src/service/namecache/test_plugin_namecache_postgres.conf +++ /dev/null | |||
@@ -1,3 +0,0 @@ | |||
1 | [namestore-postgres] | ||
2 | CONFIG = connect_timeout=10; dbname=gnunetcheck | ||
3 | TEMPORARY_TABLE = YES | ||
diff --git a/src/service/namecache/test_plugin_namecache_sqlite.conf b/src/service/namecache/test_plugin_namecache_sqlite.conf deleted file mode 100644 index 24eecd286..000000000 --- a/src/service/namecache/test_plugin_namecache_sqlite.conf +++ /dev/null | |||
@@ -1,2 +0,0 @@ | |||
1 | [namestore-sqlite] | ||
2 | FILENAME = $GNUNET_TMP/gnunet-test-plugin-namestore-sqlite/sqlite.db | ||
diff --git a/src/service/reclaim/pabc_helper.c b/src/service/reclaim/pabc_helper.c deleted file mode 100644 index 65a633f7b..000000000 --- a/src/service/reclaim/pabc_helper.c +++ /dev/null | |||
@@ -1,366 +0,0 @@ | |||
1 | // maximilian.kaul@aisec.fraunhofer.de | ||
2 | |||
3 | // WIP implementation of | ||
4 | // https://github.com/ontio/ontology-crypto/wiki/Anonymous-Credential | ||
5 | // using the relic library https://github.com/relic-toolkit/relic/ | ||
6 | |||
7 | #include "platform.h" | ||
8 | #include "pabc_helper.h" | ||
9 | #include <pwd.h> | ||
10 | #include <stdlib.h> | ||
11 | #include <unistd.h> | ||
12 | |||
13 | static char pabc_dir[PATH_MAX + 1]; | ||
14 | |||
15 | static const char * | ||
16 | get_homedir () | ||
17 | { | ||
18 | const char *homedir; | ||
19 | if ((homedir = getenv ("HOME")) == NULL) | ||
20 | { | ||
21 | homedir = getpwuid (getuid ())->pw_dir; | ||
22 | } | ||
23 | return homedir; | ||
24 | } | ||
25 | |||
26 | |||
27 | static enum GNUNET_GenericReturnValue | ||
28 | write_file (char const *const filename, const char *buffer) | ||
29 | { | ||
30 | struct GNUNET_DISK_FileHandle *fh; | ||
31 | fh = GNUNET_DISK_file_open (filename, | ||
32 | GNUNET_DISK_OPEN_WRITE | ||
33 | | GNUNET_DISK_OPEN_TRUNCATE | ||
34 | | GNUNET_DISK_OPEN_CREATE, | ||
35 | GNUNET_DISK_PERM_USER_WRITE | ||
36 | | GNUNET_DISK_PERM_USER_READ); | ||
37 | if (fh == NULL) | ||
38 | return GNUNET_SYSERR; | ||
39 | if (GNUNET_SYSERR == GNUNET_DISK_file_write (fh, | ||
40 | buffer, strlen (buffer) + 1)) | ||
41 | goto fail; | ||
42 | GNUNET_DISK_file_close (fh); | ||
43 | return GNUNET_OK; | ||
44 | |||
45 | fail: | ||
46 | GNUNET_DISK_file_close (fh); | ||
47 | return GNUNET_SYSERR; | ||
48 | } | ||
49 | |||
50 | |||
51 | static enum GNUNET_GenericReturnValue | ||
52 | init_pabc_dir () | ||
53 | { | ||
54 | size_t filename_size = strlen (get_homedir ()) + 1 + strlen (".local") + 1 | ||
55 | + strlen ("pabc-reclaim") + 1; | ||
56 | snprintf (pabc_dir, filename_size, "%s/%s/%s", | ||
57 | get_homedir (), ".local", "pabc-reclaim"); | ||
58 | return GNUNET_DISK_directory_create (pabc_dir); | ||
59 | } | ||
60 | |||
61 | |||
62 | static const char * | ||
63 | get_pabcdir () | ||
64 | { | ||
65 | init_pabc_dir (); | ||
66 | return pabc_dir; | ||
67 | } | ||
68 | |||
69 | |||
70 | enum GNUNET_GenericReturnValue | ||
71 | read_file (char const *const filename, char **buffer) | ||
72 | { | ||
73 | struct GNUNET_DISK_FileHandle *fh; | ||
74 | if (GNUNET_YES != GNUNET_DISK_file_test (filename)) | ||
75 | return GNUNET_SYSERR; | ||
76 | |||
77 | fh = GNUNET_DISK_file_open (filename, | ||
78 | GNUNET_DISK_OPEN_READ, | ||
79 | GNUNET_DISK_PERM_USER_READ); | ||
80 | if (fh == NULL) | ||
81 | return GNUNET_SYSERR; | ||
82 | long lSize = GNUNET_DISK_file_seek (fh, 0, GNUNET_DISK_SEEK_END); | ||
83 | if (lSize < 0) | ||
84 | goto fail; | ||
85 | GNUNET_DISK_file_seek (fh, 0, GNUNET_DISK_SEEK_SET); | ||
86 | *buffer = calloc ((size_t) lSize + 1, sizeof(char)); | ||
87 | if (*buffer == NULL) | ||
88 | goto fail; | ||
89 | |||
90 | // copy the file into the buffer: | ||
91 | size_t r = GNUNET_DISK_file_read (fh, *buffer, (size_t) lSize); | ||
92 | if (r != (size_t) lSize) | ||
93 | goto fail; | ||
94 | |||
95 | GNUNET_DISK_file_close (fh); | ||
96 | return GNUNET_OK; | ||
97 | |||
98 | fail: | ||
99 | GNUNET_DISK_file_close (fh); | ||
100 | GNUNET_free (*buffer); | ||
101 | return GNUNET_SYSERR; | ||
102 | } | ||
103 | |||
104 | |||
105 | struct pabc_public_parameters * | ||
106 | PABC_read_issuer_ppfile (const char *f, struct pabc_context *const ctx) | ||
107 | { | ||
108 | if (NULL == ctx) | ||
109 | { | ||
110 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No global context provided\n"); | ||
111 | return NULL; | ||
112 | } | ||
113 | struct pabc_public_parameters *pp; | ||
114 | char *buffer; | ||
115 | int r; | ||
116 | r = read_file (f, &buffer); | ||
117 | if (GNUNET_OK != r) | ||
118 | { | ||
119 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error reading file\n"); | ||
120 | return NULL; | ||
121 | } | ||
122 | if (PABC_OK != pabc_decode_and_new_public_parameters (ctx, &pp, buffer)) | ||
123 | { | ||
124 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
125 | "Failed to decode public parameters\n"); | ||
126 | PABC_FREE_NULL (buffer); | ||
127 | return NULL; | ||
128 | } | ||
129 | PABC_FREE_NULL (buffer); | ||
130 | return pp; | ||
131 | } | ||
132 | |||
133 | |||
134 | enum GNUNET_GenericReturnValue | ||
135 | PABC_load_public_parameters (struct pabc_context *const ctx, | ||
136 | char const *const pp_name, | ||
137 | struct pabc_public_parameters **pp) | ||
138 | { | ||
139 | char fname[PATH_MAX]; | ||
140 | char *pp_filename; | ||
141 | const char *pdir = get_pabcdir (); | ||
142 | |||
143 | if (ctx == NULL) | ||
144 | return GNUNET_SYSERR; | ||
145 | if (pp_name == NULL) | ||
146 | return GNUNET_SYSERR; | ||
147 | |||
148 | GNUNET_STRINGS_urlencode (pp_name, strlen (pp_name), &pp_filename); | ||
149 | if (GNUNET_YES != GNUNET_DISK_directory_test (pdir, GNUNET_YES)) | ||
150 | { | ||
151 | GNUNET_free (pp_filename); | ||
152 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error reading %s\n", pdir); | ||
153 | return GNUNET_SYSERR; | ||
154 | } | ||
155 | snprintf (fname, PATH_MAX, "%s/%s%s", pdir, pp_filename, PABC_PP_EXT); | ||
156 | if (GNUNET_YES != GNUNET_DISK_file_test (fname)) | ||
157 | { | ||
158 | GNUNET_free (pp_filename); | ||
159 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error testing %s\n", fname); | ||
160 | return GNUNET_SYSERR; | ||
161 | } | ||
162 | *pp = PABC_read_issuer_ppfile (fname, ctx); | ||
163 | if (*pp) | ||
164 | return GNUNET_OK; | ||
165 | else | ||
166 | return GNUNET_SYSERR; | ||
167 | } | ||
168 | |||
169 | |||
170 | enum GNUNET_GenericReturnValue | ||
171 | PABC_write_public_parameters (char const *const pp_name, | ||
172 | struct pabc_public_parameters *const pp) | ||
173 | { | ||
174 | char *json; | ||
175 | char *filename; | ||
176 | char *pp_filename; | ||
177 | enum pabc_status status; | ||
178 | struct pabc_context *ctx = NULL; | ||
179 | |||
180 | GNUNET_STRINGS_urlencode (pp_name, strlen (pp_name), &pp_filename); | ||
181 | PABC_ASSERT (pabc_new_ctx (&ctx)); | ||
182 | // store in json file | ||
183 | status = pabc_encode_public_parameters (ctx, pp, &json); | ||
184 | if (status != PABC_OK) | ||
185 | { | ||
186 | GNUNET_free (pp_filename); | ||
187 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
188 | "Failed to encode public parameters.\n"); | ||
189 | pabc_free_ctx (&ctx); | ||
190 | return GNUNET_SYSERR; | ||
191 | } | ||
192 | |||
193 | size_t filename_size = | ||
194 | strlen (get_pabcdir ()) + 1 + strlen (pp_filename) + strlen (PABC_PP_EXT) | ||
195 | + 1; | ||
196 | filename = GNUNET_malloc (filename_size); | ||
197 | if (! filename) | ||
198 | { | ||
199 | GNUNET_free (pp_filename); | ||
200 | PABC_FREE_NULL (json); | ||
201 | pabc_free_ctx (&ctx); | ||
202 | return GNUNET_SYSERR; | ||
203 | } | ||
204 | snprintf (filename, filename_size, "%s/%s%s", get_pabcdir (), pp_filename, | ||
205 | PABC_PP_EXT); | ||
206 | |||
207 | GNUNET_free (pp_filename); | ||
208 | if (GNUNET_OK != write_file (filename, json)) | ||
209 | { | ||
210 | PABC_FREE_NULL (filename); | ||
211 | PABC_FREE_NULL (json); | ||
212 | pabc_free_ctx (&ctx); | ||
213 | return GNUNET_SYSERR; | ||
214 | } | ||
215 | PABC_FREE_NULL (filename); | ||
216 | PABC_FREE_NULL (json); | ||
217 | pabc_free_ctx (&ctx); | ||
218 | return GNUNET_OK; | ||
219 | } | ||
220 | |||
221 | |||
222 | enum GNUNET_GenericReturnValue | ||
223 | PABC_write_usr_ctx (char const *const usr_name, | ||
224 | char const *const pp_name, | ||
225 | struct pabc_context const *const ctx, | ||
226 | struct pabc_public_parameters const *const pp, | ||
227 | struct pabc_user_context *const usr_ctx) | ||
228 | { | ||
229 | |||
230 | char *pp_filename; | ||
231 | char *json = NULL; | ||
232 | enum pabc_status status; | ||
233 | char *fname = NULL; | ||
234 | |||
235 | if (NULL == usr_name) | ||
236 | { | ||
237 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No issuer given.\n"); | ||
238 | return GNUNET_SYSERR; | ||
239 | } | ||
240 | if (NULL == pp_name) | ||
241 | { | ||
242 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No user given.\n"); | ||
243 | return GNUNET_SYSERR; | ||
244 | } | ||
245 | if (NULL == ctx) | ||
246 | { | ||
247 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No context given.\n"); | ||
248 | return GNUNET_SYSERR; | ||
249 | } | ||
250 | if (NULL == pp) | ||
251 | { | ||
252 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No public parameters given.\n"); | ||
253 | return GNUNET_SYSERR; | ||
254 | } | ||
255 | if (NULL == usr_ctx) | ||
256 | { | ||
257 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No user context given.\n"); | ||
258 | return GNUNET_SYSERR; | ||
259 | } | ||
260 | |||
261 | GNUNET_STRINGS_urlencode (pp_name, strlen (pp_name), &pp_filename); | ||
262 | status = pabc_encode_user_ctx (ctx, pp, usr_ctx, &json); | ||
263 | if (PABC_OK != status) | ||
264 | { | ||
265 | GNUNET_free (pp_filename); | ||
266 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to encode user context.\n"); | ||
267 | return status; | ||
268 | } | ||
269 | |||
270 | size_t fname_size = strlen (get_pabcdir ()) + 1 + strlen (usr_name) + 1 | ||
271 | + strlen (pp_filename) + strlen (PABC_USR_EXT) + 1; | ||
272 | fname = GNUNET_malloc (fname_size); | ||
273 | |||
274 | snprintf (fname, fname_size, "%s/%s_%s%s", get_pabcdir (), usr_name, | ||
275 | pp_filename, | ||
276 | PABC_USR_EXT); | ||
277 | |||
278 | GNUNET_free (pp_filename); | ||
279 | if (GNUNET_OK == write_file (fname, json)) | ||
280 | { | ||
281 | GNUNET_free (fname); | ||
282 | GNUNET_free (json); | ||
283 | return GNUNET_OK; | ||
284 | } | ||
285 | else | ||
286 | { | ||
287 | GNUNET_free (fname); | ||
288 | GNUNET_free (json); | ||
289 | return GNUNET_SYSERR; | ||
290 | } | ||
291 | } | ||
292 | |||
293 | |||
294 | enum GNUNET_GenericReturnValue | ||
295 | PABC_read_usr_ctx (char const *const usr_name, | ||
296 | char const *const pp_name, | ||
297 | struct pabc_context const *const ctx, | ||
298 | struct pabc_public_parameters const *const pp, | ||
299 | struct pabc_user_context **usr_ctx) | ||
300 | { | ||
301 | char *json = NULL; | ||
302 | char *pp_filename; | ||
303 | enum pabc_status status; | ||
304 | |||
305 | char *fname = NULL; | ||
306 | |||
307 | if (NULL == usr_name) | ||
308 | { | ||
309 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No issuer given.\n"); | ||
310 | return GNUNET_SYSERR; | ||
311 | } | ||
312 | if (NULL == pp_name) | ||
313 | { | ||
314 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No user given.\n"); | ||
315 | return GNUNET_SYSERR; | ||
316 | } | ||
317 | if (NULL == ctx) | ||
318 | { | ||
319 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No context given.\n"); | ||
320 | return GNUNET_SYSERR; | ||
321 | } | ||
322 | if (NULL == pp) | ||
323 | { | ||
324 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No public parameters given.\n"); | ||
325 | return GNUNET_SYSERR; | ||
326 | } | ||
327 | if (NULL == usr_ctx) | ||
328 | { | ||
329 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No user context given.\n"); | ||
330 | return GNUNET_SYSERR; | ||
331 | } | ||
332 | GNUNET_STRINGS_urlencode (pp_name, strlen (pp_name), &pp_filename); | ||
333 | |||
334 | size_t fname_size = strlen (get_pabcdir ()) + 1 + strlen (usr_name) + 1 | ||
335 | + strlen (pp_filename) + strlen (PABC_USR_EXT) + 1; | ||
336 | fname = GNUNET_malloc (fname_size); | ||
337 | snprintf (fname, fname_size, "%s/%s_%s%s", get_pabcdir (), usr_name, | ||
338 | pp_filename, | ||
339 | PABC_USR_EXT); | ||
340 | GNUNET_free (pp_filename); | ||
341 | if (GNUNET_OK != read_file (fname, &json)) | ||
342 | { | ||
343 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
344 | "Failed to read `%s'\n", fname); | ||
345 | PABC_FREE_NULL (fname); | ||
346 | return GNUNET_SYSERR; | ||
347 | } | ||
348 | GNUNET_free (fname); | ||
349 | |||
350 | status = pabc_new_user_context (ctx, pp, usr_ctx); | ||
351 | if (PABC_OK != status) | ||
352 | { | ||
353 | GNUNET_free (json); | ||
354 | return GNUNET_SYSERR; | ||
355 | } | ||
356 | status = pabc_decode_user_ctx (ctx, pp, *usr_ctx, json); | ||
357 | GNUNET_free (json); | ||
358 | if (PABC_OK != status) | ||
359 | { | ||
360 | pabc_free_user_context (ctx, pp, usr_ctx); | ||
361 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to encode user context.\n"); | ||
362 | return GNUNET_SYSERR; | ||
363 | } | ||
364 | |||
365 | return GNUNET_OK; | ||
366 | } | ||
diff --git a/src/service/reclaim/pabc_helper.h b/src/service/reclaim/pabc_helper.h deleted file mode 100644 index 045ad5dda..000000000 --- a/src/service/reclaim/pabc_helper.h +++ /dev/null | |||
@@ -1,41 +0,0 @@ | |||
1 | #include "platform.h" | ||
2 | #include "gnunet_util_lib.h" | ||
3 | #include <pabc/pabc.h> | ||
4 | |||
5 | #ifndef PATH_MAX | ||
6 | #define PATH_MAX 4096 | ||
7 | #endif | ||
8 | |||
9 | #define PABC_ISK_EXT ".isk" | ||
10 | |||
11 | #define PABC_PP_EXT ".pp" | ||
12 | |||
13 | #define PABC_USR_EXT ".usr" | ||
14 | |||
15 | #define PABC_ATTR_DELIM "=" | ||
16 | |||
17 | enum GNUNET_GenericReturnValue | ||
18 | PABC_write_public_parameters (char const *const pp_name, | ||
19 | struct pabc_public_parameters *const pp); | ||
20 | |||
21 | |||
22 | enum GNUNET_GenericReturnValue | ||
23 | PABC_load_public_parameters (struct pabc_context *const ctx, | ||
24 | char const *const pp_name, | ||
25 | struct pabc_public_parameters **pp); | ||
26 | |||
27 | enum GNUNET_GenericReturnValue | ||
28 | PABC_write_usr_ctx (char const *const user_name, | ||
29 | char const *const pp_name, | ||
30 | struct pabc_context const *const ctx, | ||
31 | struct pabc_public_parameters const *const | ||
32 | pp, | ||
33 | struct pabc_user_context *const usr_ctx); | ||
34 | |||
35 | enum GNUNET_GenericReturnValue | ||
36 | PABC_read_usr_ctx (char const *const user_name, | ||
37 | char const *const pp_name, | ||
38 | struct pabc_context const *const ctx, | ||
39 | struct pabc_public_parameters const *const | ||
40 | pp, | ||
41 | struct pabc_user_context **usr_ctx); | ||