diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
commit | c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch) | |
tree | cac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/hello | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) | |
download | gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/hello')
-rw-r--r-- | src/hello/address.c | 66 | ||||
-rw-r--r-- | src/hello/gnunet-hello.c | 179 | ||||
-rw-r--r-- | src/hello/hello-ng.c | 141 | ||||
-rw-r--r-- | src/hello/hello.c | 843 | ||||
-rw-r--r-- | src/hello/test_friend_hello.c | 196 | ||||
-rw-r--r-- | src/hello/test_hello.c | 284 |
6 files changed, 862 insertions, 847 deletions
diff --git a/src/hello/address.c b/src/hello/address.c index 3936a0133..e22f3850f 100644 --- a/src/hello/address.c +++ b/src/hello/address.c | |||
@@ -36,8 +36,8 @@ | |||
36 | * @return #GNUNET_YES or #GNUNET_NO | 36 | * @return #GNUNET_YES or #GNUNET_NO |
37 | */ | 37 | */ |
38 | int | 38 | int |
39 | GNUNET_HELLO_address_check_option(const struct GNUNET_HELLO_Address * address, | 39 | GNUNET_HELLO_address_check_option (const struct GNUNET_HELLO_Address *address, |
40 | enum GNUNET_HELLO_AddressInfo option) | 40 | enum GNUNET_HELLO_AddressInfo option) |
41 | { | 41 | { |
42 | if (option == (address->local_info & option)) | 42 | if (option == (address->local_info & option)) |
43 | return GNUNET_YES; | 43 | return GNUNET_YES; |
@@ -52,10 +52,10 @@ GNUNET_HELLO_address_check_option(const struct GNUNET_HELLO_Address * address, | |||
52 | * @return the size | 52 | * @return the size |
53 | */ | 53 | */ |
54 | size_t | 54 | size_t |
55 | GNUNET_HELLO_address_get_size(const struct GNUNET_HELLO_Address * address) | 55 | GNUNET_HELLO_address_get_size (const struct GNUNET_HELLO_Address *address) |
56 | { | 56 | { |
57 | return sizeof(struct GNUNET_HELLO_Address) + address->address_length + | 57 | return sizeof(struct GNUNET_HELLO_Address) + address->address_length |
58 | strlen(address->transport_name) + 1; | 58 | + strlen (address->transport_name) + 1; |
59 | } | 59 | } |
60 | 60 | ||
61 | 61 | ||
@@ -70,31 +70,31 @@ GNUNET_HELLO_address_get_size(const struct GNUNET_HELLO_Address * address) | |||
70 | * @return the address struct | 70 | * @return the address struct |
71 | */ | 71 | */ |
72 | struct GNUNET_HELLO_Address * | 72 | struct GNUNET_HELLO_Address * |
73 | GNUNET_HELLO_address_allocate(const struct GNUNET_PeerIdentity *peer, | 73 | GNUNET_HELLO_address_allocate (const struct GNUNET_PeerIdentity *peer, |
74 | const char *transport_name, | 74 | const char *transport_name, |
75 | const void *address, | 75 | const void *address, |
76 | size_t address_length, | 76 | size_t address_length, |
77 | enum GNUNET_HELLO_AddressInfo local_info) | 77 | enum GNUNET_HELLO_AddressInfo local_info) |
78 | { | 78 | { |
79 | struct GNUNET_HELLO_Address *addr; | 79 | struct GNUNET_HELLO_Address *addr; |
80 | size_t slen; | 80 | size_t slen; |
81 | char *end; | 81 | char *end; |
82 | 82 | ||
83 | slen = strlen(transport_name) + 1; | 83 | slen = strlen (transport_name) + 1; |
84 | addr = GNUNET_malloc(sizeof(struct GNUNET_HELLO_Address) + | 84 | addr = GNUNET_malloc (sizeof(struct GNUNET_HELLO_Address) |
85 | address_length + slen); | 85 | + address_length + slen); |
86 | addr->peer = *peer; | 86 | addr->peer = *peer; |
87 | addr->address = &addr[1]; | 87 | addr->address = &addr[1]; |
88 | addr->address_length = address_length; | 88 | addr->address_length = address_length; |
89 | addr->local_info = local_info; | 89 | addr->local_info = local_info; |
90 | end = (char *)&addr[1]; | 90 | end = (char *) &addr[1]; |
91 | addr->transport_name = &end[address_length]; | 91 | addr->transport_name = &end[address_length]; |
92 | GNUNET_memcpy(end, | 92 | GNUNET_memcpy (end, |
93 | address, | 93 | address, |
94 | address_length); | 94 | address_length); |
95 | GNUNET_memcpy(&end[address_length], | 95 | GNUNET_memcpy (&end[address_length], |
96 | transport_name, | 96 | transport_name, |
97 | slen); | 97 | slen); |
98 | return addr; | 98 | return addr; |
99 | } | 99 | } |
100 | 100 | ||
@@ -106,15 +106,15 @@ GNUNET_HELLO_address_allocate(const struct GNUNET_PeerIdentity *peer, | |||
106 | * @return a copy of the address struct | 106 | * @return a copy of the address struct |
107 | */ | 107 | */ |
108 | struct GNUNET_HELLO_Address * | 108 | struct GNUNET_HELLO_Address * |
109 | GNUNET_HELLO_address_copy(const struct GNUNET_HELLO_Address *address) | 109 | GNUNET_HELLO_address_copy (const struct GNUNET_HELLO_Address *address) |
110 | { | 110 | { |
111 | if (NULL == address) | 111 | if (NULL == address) |
112 | return NULL; | 112 | return NULL; |
113 | return GNUNET_HELLO_address_allocate(&address->peer, | 113 | return GNUNET_HELLO_address_allocate (&address->peer, |
114 | address->transport_name, | 114 | address->transport_name, |
115 | address->address, | 115 | address->address, |
116 | address->address_length, | 116 | address->address_length, |
117 | address->local_info); | 117 | address->local_info); |
118 | } | 118 | } |
119 | 119 | ||
120 | 120 | ||
@@ -127,8 +127,8 @@ GNUNET_HELLO_address_copy(const struct GNUNET_HELLO_Address *address) | |||
127 | * @return 0 if the addresses are equal, -1 if a1<a2, 1 if a1>a2. | 127 | * @return 0 if the addresses are equal, -1 if a1<a2, 1 if a1>a2. |
128 | */ | 128 | */ |
129 | int | 129 | int |
130 | GNUNET_HELLO_address_cmp(const struct GNUNET_HELLO_Address *a1, | 130 | GNUNET_HELLO_address_cmp (const struct GNUNET_HELLO_Address *a1, |
131 | const struct GNUNET_HELLO_Address *a2) | 131 | const struct GNUNET_HELLO_Address *a2) |
132 | { | 132 | { |
133 | int ret; | 133 | int ret; |
134 | 134 | ||
@@ -139,18 +139,18 @@ GNUNET_HELLO_address_cmp(const struct GNUNET_HELLO_Address *a1, | |||
139 | return 1; | 139 | return 1; |
140 | if (NULL == a2) | 140 | if (NULL == a2) |
141 | return -1; | 141 | return -1; |
142 | ret = strcmp(a1->transport_name, a2->transport_name); | 142 | ret = strcmp (a1->transport_name, a2->transport_name); |
143 | if (0 != ret) | 143 | if (0 != ret) |
144 | return ret; | 144 | return ret; |
145 | if (a1->local_info != a2->local_info) | 145 | if (a1->local_info != a2->local_info) |
146 | return (((int)a1->local_info) < ((int)a2->local_info)) ? -1 : 1; | 146 | return (((int) a1->local_info) < ((int) a2->local_info)) ? -1 : 1; |
147 | if (a1->address_length < a2->address_length) | 147 | if (a1->address_length < a2->address_length) |
148 | return -1; | 148 | return -1; |
149 | if (a1->address_length > a2->address_length) | 149 | if (a1->address_length > a2->address_length) |
150 | return 1; | 150 | return 1; |
151 | return memcmp(a1->address, | 151 | return memcmp (a1->address, |
152 | a2->address, | 152 | a2->address, |
153 | a1->address_length); | 153 | a1->address_length); |
154 | } | 154 | } |
155 | 155 | ||
156 | 156 | ||
diff --git a/src/hello/gnunet-hello.c b/src/hello/gnunet-hello.c index 1b572b904..9f277de4a 100644 --- a/src/hello/gnunet-hello.c +++ b/src/hello/gnunet-hello.c | |||
@@ -29,7 +29,8 @@ | |||
29 | /** | 29 | /** |
30 | * Closure for #add_to_buf(). | 30 | * Closure for #add_to_buf(). |
31 | */ | 31 | */ |
32 | struct AddContext { | 32 | struct AddContext |
33 | { | ||
33 | /** | 34 | /** |
34 | * Where to add. | 35 | * Where to add. |
35 | */ | 36 | */ |
@@ -58,17 +59,17 @@ static int address_count; | |||
58 | * @return #GNUNET_OK keep iterating | 59 | * @return #GNUNET_OK keep iterating |
59 | */ | 60 | */ |
60 | static int | 61 | static int |
61 | add_to_buf(void *cls, | 62 | add_to_buf (void *cls, |
62 | const struct GNUNET_HELLO_Address *address, | 63 | const struct GNUNET_HELLO_Address *address, |
63 | struct GNUNET_TIME_Absolute expiration) | 64 | struct GNUNET_TIME_Absolute expiration) |
64 | { | 65 | { |
65 | struct AddContext *ac = cls; | 66 | struct AddContext *ac = cls; |
66 | size_t ret; | 67 | size_t ret; |
67 | 68 | ||
68 | ret = GNUNET_HELLO_add_address(address, | 69 | ret = GNUNET_HELLO_add_address (address, |
69 | GNUNET_TIME_UNIT_FOREVER_ABS, | 70 | GNUNET_TIME_UNIT_FOREVER_ABS, |
70 | ac->buf, | 71 | ac->buf, |
71 | ac->max); | 72 | ac->max); |
72 | ac->buf += ret; | 73 | ac->buf += ret; |
73 | ac->max -= ret; | 74 | ac->max -= ret; |
74 | ac->ret += ret; | 75 | ac->ret += ret; |
@@ -86,7 +87,7 @@ add_to_buf(void *cls, | |||
86 | * @return number of bytes added, 0 to terminate | 87 | * @return number of bytes added, 0 to terminate |
87 | */ | 88 | */ |
88 | static ssize_t | 89 | static ssize_t |
89 | add_from_hello(void *cls, size_t max, void *buf) | 90 | add_from_hello (void *cls, size_t max, void *buf) |
90 | { | 91 | { |
91 | struct GNUNET_HELLO_Message **orig = cls; | 92 | struct GNUNET_HELLO_Message **orig = cls; |
92 | struct AddContext ac; | 93 | struct AddContext ac; |
@@ -96,16 +97,16 @@ add_from_hello(void *cls, size_t max, void *buf) | |||
96 | ac.buf = buf; | 97 | ac.buf = buf; |
97 | ac.max = max; | 98 | ac.max = max; |
98 | ac.ret = 0; | 99 | ac.ret = 0; |
99 | GNUNET_assert( | 100 | GNUNET_assert ( |
100 | NULL == | 101 | NULL == |
101 | GNUNET_HELLO_iterate_addresses(*orig, GNUNET_NO, &add_to_buf, &ac)); | 102 | GNUNET_HELLO_iterate_addresses (*orig, GNUNET_NO, &add_to_buf, &ac)); |
102 | *orig = NULL; | 103 | *orig = NULL; |
103 | return ac.ret; | 104 | return ac.ret; |
104 | } | 105 | } |
105 | 106 | ||
106 | 107 | ||
107 | int | 108 | int |
108 | main(int argc, char *argv[]) | 109 | main (int argc, char *argv[]) |
109 | { | 110 | { |
110 | struct GNUNET_DISK_FileHandle *fh; | 111 | struct GNUNET_DISK_FileHandle *fh; |
111 | struct GNUNET_HELLO_Message *orig; | 112 | struct GNUNET_HELLO_Message *orig; |
@@ -115,98 +116,98 @@ main(int argc, char *argv[]) | |||
115 | 116 | ||
116 | address_count = 0; | 117 | address_count = 0; |
117 | 118 | ||
118 | GNUNET_log_setup("gnunet-hello", "INFO", NULL); | 119 | GNUNET_log_setup ("gnunet-hello", "INFO", NULL); |
119 | if (argc != 2) | 120 | if (argc != 2) |
120 | { | 121 | { |
121 | fprintf(stderr, "%s", _("Call with name of HELLO file to modify.\n")); | 122 | fprintf (stderr, "%s", _ ("Call with name of HELLO file to modify.\n")); |
122 | return 1; | 123 | return 1; |
123 | } | 124 | } |
124 | if (GNUNET_OK != | 125 | if (GNUNET_OK != |
125 | GNUNET_DISK_file_size(argv[1], &fsize, GNUNET_YES, GNUNET_YES)) | 126 | GNUNET_DISK_file_size (argv[1], &fsize, GNUNET_YES, GNUNET_YES)) |
126 | { | 127 | { |
127 | fprintf(stderr, | 128 | fprintf (stderr, |
128 | _("Error accessing file `%s': %s\n"), | 129 | _ ("Error accessing file `%s': %s\n"), |
129 | argv[1], | 130 | argv[1], |
130 | strerror(errno)); | 131 | strerror (errno)); |
131 | return 1; | 132 | return 1; |
132 | } | 133 | } |
133 | if (fsize > 65536) | 134 | if (fsize > 65536) |
134 | { | 135 | { |
135 | fprintf(stderr, _("File `%s' is too big to be a HELLO\n"), argv[1]); | 136 | fprintf (stderr, _ ("File `%s' is too big to be a HELLO\n"), argv[1]); |
136 | return 1; | 137 | return 1; |
137 | } | 138 | } |
138 | if (fsize < sizeof(struct GNUNET_MessageHeader)) | 139 | if (fsize < sizeof(struct GNUNET_MessageHeader)) |
139 | { | 140 | { |
140 | fprintf(stderr, _("File `%s' is too small to be a HELLO\n"), argv[1]); | 141 | fprintf (stderr, _ ("File `%s' is too small to be a HELLO\n"), argv[1]); |
141 | return 1; | 142 | return 1; |
142 | } | 143 | } |
143 | fh = GNUNET_DISK_file_open(argv[1], | 144 | fh = GNUNET_DISK_file_open (argv[1], |
144 | GNUNET_DISK_OPEN_READ, | 145 | GNUNET_DISK_OPEN_READ, |
145 | GNUNET_DISK_PERM_USER_READ); | 146 | GNUNET_DISK_PERM_USER_READ); |
146 | if (NULL == fh) | 147 | if (NULL == fh) |
147 | { | 148 | { |
148 | fprintf(stderr, | 149 | fprintf (stderr, |
149 | _("Error opening file `%s': %s\n"), | 150 | _ ("Error opening file `%s': %s\n"), |
150 | argv[1], | 151 | argv[1], |
151 | strerror(errno)); | 152 | strerror (errno)); |
152 | return 1; | 153 | return 1; |
153 | } | 154 | } |
154 | { | 155 | { |
155 | char buf[fsize] GNUNET_ALIGN; | 156 | char buf[fsize] GNUNET_ALIGN; |
156 | 157 | ||
157 | GNUNET_assert(fsize == GNUNET_DISK_file_read(fh, buf, fsize)); | 158 | GNUNET_assert (fsize == GNUNET_DISK_file_read (fh, buf, fsize)); |
158 | GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fh)); | 159 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh)); |
159 | orig = (struct GNUNET_HELLO_Message *)buf; | 160 | orig = (struct GNUNET_HELLO_Message *) buf; |
160 | if ((fsize < GNUNET_HELLO_size(orig)) || | 161 | if ((fsize < GNUNET_HELLO_size (orig)) || |
161 | (GNUNET_OK != GNUNET_HELLO_get_id(orig, &pid))) | 162 | (GNUNET_OK != GNUNET_HELLO_get_id (orig, &pid))) |
162 | { | 163 | { |
163 | fprintf(stderr, | 164 | fprintf (stderr, |
164 | _("Did not find well-formed HELLO in file `%s'\n"), | 165 | _ ("Did not find well-formed HELLO in file `%s'\n"), |
165 | argv[1]); | 166 | argv[1]); |
166 | return 1; | 167 | return 1; |
167 | } | 168 | } |
168 | { | 169 | { |
169 | char *pids; | 170 | char *pids; |
170 | 171 | ||
171 | pids = GNUNET_CRYPTO_eddsa_public_key_to_string(&pid.public_key); | 172 | pids = GNUNET_CRYPTO_eddsa_public_key_to_string (&pid.public_key); |
172 | fprintf(stdout, "Processing HELLO for peer `%s'\n", pids); | 173 | fprintf (stdout, "Processing HELLO for peer `%s'\n", pids); |
173 | GNUNET_free(pids); | 174 | GNUNET_free (pids); |
174 | } | 175 | } |
175 | result = GNUNET_HELLO_create(&pid.public_key, | 176 | result = GNUNET_HELLO_create (&pid.public_key, |
176 | &add_from_hello, | 177 | &add_from_hello, |
177 | &orig, | 178 | &orig, |
178 | GNUNET_HELLO_is_friend_only(orig)); | 179 | GNUNET_HELLO_is_friend_only (orig)); |
179 | GNUNET_assert(NULL != result); | 180 | GNUNET_assert (NULL != result); |
180 | fh = | 181 | fh = |
181 | GNUNET_DISK_file_open(argv[1], | 182 | GNUNET_DISK_file_open (argv[1], |
182 | GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_TRUNCATE, | 183 | GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_TRUNCATE, |
183 | GNUNET_DISK_PERM_USER_READ | | 184 | GNUNET_DISK_PERM_USER_READ |
184 | GNUNET_DISK_PERM_USER_WRITE); | 185 | | GNUNET_DISK_PERM_USER_WRITE); |
185 | if (NULL == fh) | 186 | if (NULL == fh) |
186 | { | 187 | { |
187 | fprintf(stderr, | 188 | fprintf (stderr, |
188 | _("Error opening file `%s': %s\n"), | 189 | _ ("Error opening file `%s': %s\n"), |
189 | argv[1], | 190 | argv[1], |
190 | strerror(errno)); | 191 | strerror (errno)); |
191 | GNUNET_free(result); | 192 | GNUNET_free (result); |
192 | return 1; | 193 | return 1; |
193 | } | 194 | } |
194 | fsize = GNUNET_HELLO_size(result); | 195 | fsize = GNUNET_HELLO_size (result); |
195 | if (fsize != GNUNET_DISK_file_write(fh, result, fsize)) | 196 | if (fsize != GNUNET_DISK_file_write (fh, result, fsize)) |
196 | { | 197 | { |
197 | fprintf(stderr, | 198 | fprintf (stderr, |
198 | _("Error writing HELLO to file `%s': %s\n"), | 199 | _ ("Error writing HELLO to file `%s': %s\n"), |
199 | argv[1], | 200 | argv[1], |
200 | strerror(errno)); | 201 | strerror (errno)); |
201 | (void)GNUNET_DISK_file_close(fh); | 202 | (void) GNUNET_DISK_file_close (fh); |
202 | return 1; | 203 | return 1; |
203 | } | 204 | } |
204 | GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fh)); | 205 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh)); |
205 | } | 206 | } |
206 | fprintf(stderr, | 207 | fprintf (stderr, |
207 | _("Modified %u addresses, wrote %u bytes\n"), | 208 | _ ("Modified %u addresses, wrote %u bytes\n"), |
208 | address_count, | 209 | address_count, |
209 | (unsigned int)fsize); | 210 | (unsigned int) fsize); |
210 | return 0; | 211 | return 0; |
211 | } | 212 | } |
212 | 213 | ||
diff --git a/src/hello/hello-ng.c b/src/hello/hello-ng.c index f44fff032..8dea616b9 100644 --- a/src/hello/hello-ng.c +++ b/src/hello/hello-ng.c | |||
@@ -33,7 +33,8 @@ | |||
33 | /** | 33 | /** |
34 | * Binary block we sign when we sign an address. | 34 | * Binary block we sign when we sign an address. |
35 | */ | 35 | */ |
36 | struct SignedAddress { | 36 | struct SignedAddress |
37 | { | ||
37 | /** | 38 | /** |
38 | * Purpose must be #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS | 39 | * Purpose must be #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS |
39 | */ | 40 | */ |
@@ -62,7 +63,7 @@ struct SignedAddress { | |||
62 | * @param result_size[out] set to size of @a result | 63 | * @param result_size[out] set to size of @a result |
63 | */ | 64 | */ |
64 | void | 65 | void |
65 | GNUNET_HELLO_sign_address( | 66 | GNUNET_HELLO_sign_address ( |
66 | const char *address, | 67 | const char *address, |
67 | enum GNUNET_NetworkType nt, | 68 | enum GNUNET_NetworkType nt, |
68 | struct GNUNET_TIME_Absolute mono_time, | 69 | struct GNUNET_TIME_Absolute mono_time, |
@@ -74,22 +75,22 @@ GNUNET_HELLO_sign_address( | |||
74 | struct GNUNET_CRYPTO_EddsaSignature sig; | 75 | struct GNUNET_CRYPTO_EddsaSignature sig; |
75 | char *sig_str; | 76 | char *sig_str; |
76 | 77 | ||
77 | sa.purpose.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS); | 78 | sa.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS); |
78 | sa.purpose.size = htonl(sizeof(sa)); | 79 | sa.purpose.size = htonl (sizeof(sa)); |
79 | sa.mono_time = GNUNET_TIME_absolute_hton(mono_time); | 80 | sa.mono_time = GNUNET_TIME_absolute_hton (mono_time); |
80 | GNUNET_CRYPTO_hash(address, strlen(address), &sa.h_addr); | 81 | GNUNET_CRYPTO_hash (address, strlen (address), &sa.h_addr); |
81 | GNUNET_assert(GNUNET_YES == | 82 | GNUNET_assert (GNUNET_YES == |
82 | GNUNET_CRYPTO_eddsa_sign(private_key, &sa.purpose, &sig)); | 83 | GNUNET_CRYPTO_eddsa_sign (private_key, &sa.purpose, &sig)); |
83 | sig_str = NULL; | 84 | sig_str = NULL; |
84 | (void)GNUNET_STRINGS_base64_encode(&sig, sizeof(sig), &sig_str); | 85 | (void) GNUNET_STRINGS_base64_encode (&sig, sizeof(sig), &sig_str); |
85 | *result_size = | 86 | *result_size = |
86 | 1 + GNUNET_asprintf((char **)result, | 87 | 1 + GNUNET_asprintf ((char **) result, |
87 | "%s;%llu;%u;%s", | 88 | "%s;%llu;%u;%s", |
88 | sig_str, | 89 | sig_str, |
89 | (unsigned long long)mono_time.abs_value_us, | 90 | (unsigned long long) mono_time.abs_value_us, |
90 | (unsigned int)nt, | 91 | (unsigned int) nt, |
91 | address); | 92 | address); |
92 | GNUNET_free(sig_str); | 93 | GNUNET_free (sig_str); |
93 | } | 94 | } |
94 | 95 | ||
95 | 96 | ||
@@ -104,11 +105,11 @@ GNUNET_HELLO_sign_address( | |||
104 | * @return NULL on error, otherwise the address | 105 | * @return NULL on error, otherwise the address |
105 | */ | 106 | */ |
106 | char * | 107 | char * |
107 | GNUNET_HELLO_extract_address(const void *raw, | 108 | GNUNET_HELLO_extract_address (const void *raw, |
108 | size_t raw_size, | 109 | size_t raw_size, |
109 | const struct GNUNET_PeerIdentity *pid, | 110 | const struct GNUNET_PeerIdentity *pid, |
110 | enum GNUNET_NetworkType *nt, | 111 | enum GNUNET_NetworkType *nt, |
111 | struct GNUNET_TIME_Absolute *mono_time) | 112 | struct GNUNET_TIME_Absolute *mono_time) |
112 | { | 113 | { |
113 | const struct GNUNET_CRYPTO_EddsaPublicKey *public_key = &pid->public_key; | 114 | const struct GNUNET_CRYPTO_EddsaPublicKey *public_key = &pid->public_key; |
114 | const char *raws = raw; | 115 | const char *raws = raw; |
@@ -123,59 +124,59 @@ GNUNET_HELLO_extract_address(const void *raw, | |||
123 | struct GNUNET_CRYPTO_EddsaSignature *sig; | 124 | struct GNUNET_CRYPTO_EddsaSignature *sig; |
124 | 125 | ||
125 | if ('\0' != raws[raw_size]) | 126 | if ('\0' != raws[raw_size]) |
126 | { | 127 | { |
127 | GNUNET_break_op(0); | 128 | GNUNET_break_op (0); |
128 | return NULL; | 129 | return NULL; |
129 | } | 130 | } |
130 | if (NULL == (sc = strchr(raws, ';'))) | 131 | if (NULL == (sc = strchr (raws, ';'))) |
131 | { | 132 | { |
132 | GNUNET_break_op(0); | 133 | GNUNET_break_op (0); |
133 | return NULL; | 134 | return NULL; |
134 | } | 135 | } |
135 | if (NULL == (sc2 = strchr(sc + 1, ';'))) | 136 | if (NULL == (sc2 = strchr (sc + 1, ';'))) |
136 | { | 137 | { |
137 | GNUNET_break_op(0); | 138 | GNUNET_break_op (0); |
138 | return NULL; | 139 | return NULL; |
139 | } | 140 | } |
140 | if (NULL == (sc3 = strchr(sc2 + 1, ';'))) | 141 | if (NULL == (sc3 = strchr (sc2 + 1, ';'))) |
141 | { | 142 | { |
142 | GNUNET_break_op(0); | 143 | GNUNET_break_op (0); |
143 | return NULL; | 144 | return NULL; |
144 | } | 145 | } |
145 | if (1 != sscanf(sc + 1, "%llu;%u;", &raw_us, &raw_nt)) | 146 | if (1 != sscanf (sc + 1, "%llu;%u;", &raw_us, &raw_nt)) |
146 | { | 147 | { |
147 | GNUNET_break_op(0); | 148 | GNUNET_break_op (0); |
148 | return NULL; | 149 | return NULL; |
149 | } | 150 | } |
150 | raw_mono_time.abs_value_us = raw_us; | 151 | raw_mono_time.abs_value_us = raw_us; |
151 | sig = NULL; | 152 | sig = NULL; |
152 | if (sizeof(struct GNUNET_CRYPTO_EddsaSignature) != | 153 | if (sizeof(struct GNUNET_CRYPTO_EddsaSignature) != |
153 | GNUNET_STRINGS_base64_decode(raws, sc - raws, (void **)&sig)) | 154 | GNUNET_STRINGS_base64_decode (raws, sc - raws, (void **) &sig)) |
154 | { | 155 | { |
155 | GNUNET_break_op(0); | 156 | GNUNET_break_op (0); |
156 | GNUNET_free_non_null(sig); | 157 | GNUNET_free_non_null (sig); |
157 | return NULL; | 158 | return NULL; |
158 | } | 159 | } |
159 | raw_addr = sc3 + 1; | 160 | raw_addr = sc3 + 1; |
160 | 161 | ||
161 | sa.purpose.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS); | 162 | sa.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS); |
162 | sa.purpose.size = htonl(sizeof(sa)); | 163 | sa.purpose.size = htonl (sizeof(sa)); |
163 | sa.mono_time = GNUNET_TIME_absolute_hton(raw_mono_time); | 164 | sa.mono_time = GNUNET_TIME_absolute_hton (raw_mono_time); |
164 | GNUNET_CRYPTO_hash(raw_addr, strlen(raw_addr), &sa.h_addr); | 165 | GNUNET_CRYPTO_hash (raw_addr, strlen (raw_addr), &sa.h_addr); |
165 | if (GNUNET_YES != | 166 | if (GNUNET_YES != |
166 | GNUNET_CRYPTO_eddsa_verify(GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS, | 167 | GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS, |
167 | &sa.purpose, | 168 | &sa.purpose, |
168 | sig, | 169 | sig, |
169 | public_key)) | 170 | public_key)) |
170 | { | 171 | { |
171 | GNUNET_break_op(0); | 172 | GNUNET_break_op (0); |
172 | GNUNET_free(sig); | 173 | GNUNET_free (sig); |
173 | return NULL; | 174 | return NULL; |
174 | } | 175 | } |
175 | GNUNET_free(sig); | 176 | GNUNET_free (sig); |
176 | *mono_time = raw_mono_time; | 177 | *mono_time = raw_mono_time; |
177 | *nt = (enum GNUNET_NetworkType)raw_nt; | 178 | *nt = (enum GNUNET_NetworkType) raw_nt; |
178 | return GNUNET_strdup(raw_addr); | 179 | return GNUNET_strdup (raw_addr); |
179 | } | 180 | } |
180 | 181 | ||
181 | 182 | ||
@@ -187,12 +188,12 @@ GNUNET_HELLO_extract_address(const void *raw, | |||
187 | * @return NULL if the address is mal-formed, otherwise the prefix | 188 | * @return NULL if the address is mal-formed, otherwise the prefix |
188 | */ | 189 | */ |
189 | char * | 190 | char * |
190 | GNUNET_HELLO_address_to_prefix(const char *address) | 191 | GNUNET_HELLO_address_to_prefix (const char *address) |
191 | { | 192 | { |
192 | const char *dash; | 193 | const char *dash; |
193 | 194 | ||
194 | dash = strchr(address, '-'); | 195 | dash = strchr (address, '-'); |
195 | if (NULL == dash) | 196 | if (NULL == dash) |
196 | return NULL; | 197 | return NULL; |
197 | return GNUNET_strndup(address, dash - address); | 198 | return GNUNET_strndup (address, dash - address); |
198 | } | 199 | } |
diff --git a/src/hello/hello.c b/src/hello/hello.c index 021451a08..e701e1f17 100644 --- a/src/hello/hello.c +++ b/src/hello/hello.c | |||
@@ -33,7 +33,8 @@ | |||
33 | /** | 33 | /** |
34 | * Context used for building our own URI. | 34 | * Context used for building our own URI. |
35 | */ | 35 | */ |
36 | struct GNUNET_HELLO_ComposeUriContext { | 36 | struct GNUNET_HELLO_ComposeUriContext |
37 | { | ||
37 | /** | 38 | /** |
38 | * Final URI. | 39 | * Final URI. |
39 | */ | 40 | */ |
@@ -49,7 +50,8 @@ struct GNUNET_HELLO_ComposeUriContext { | |||
49 | /** | 50 | /** |
50 | * Context for #add_address_to_hello(). | 51 | * Context for #add_address_to_hello(). |
51 | */ | 52 | */ |
52 | struct GNUNET_HELLO_ParseUriContext { | 53 | struct GNUNET_HELLO_ParseUriContext |
54 | { | ||
53 | /** | 55 | /** |
54 | * Position in the URI with the next address to parse. | 56 | * Position in the URI with the next address to parse. |
55 | */ | 57 | */ |
@@ -84,9 +86,9 @@ struct GNUNET_HELLO_ParseUriContext { | |||
84 | * @return #GNUNET_YES for friend-only or #GNUNET_NO otherwise | 86 | * @return #GNUNET_YES for friend-only or #GNUNET_NO otherwise |
85 | */ | 87 | */ |
86 | int | 88 | int |
87 | GNUNET_HELLO_is_friend_only(const struct GNUNET_HELLO_Message *h) | 89 | GNUNET_HELLO_is_friend_only (const struct GNUNET_HELLO_Message *h) |
88 | { | 90 | { |
89 | if (GNUNET_YES == ntohl(h->friend_only)) | 91 | if (GNUNET_YES == ntohl (h->friend_only)) |
90 | return GNUNET_YES; | 92 | return GNUNET_YES; |
91 | return GNUNET_NO; | 93 | return GNUNET_NO; |
92 | } | 94 | } |
@@ -104,27 +106,27 @@ GNUNET_HELLO_is_friend_only(const struct GNUNET_HELLO_Message *h) | |||
104 | * the target buffer was not big enough. | 106 | * the target buffer was not big enough. |
105 | */ | 107 | */ |
106 | size_t | 108 | size_t |
107 | GNUNET_HELLO_add_address(const struct GNUNET_HELLO_Address *address, | 109 | GNUNET_HELLO_add_address (const struct GNUNET_HELLO_Address *address, |
108 | struct GNUNET_TIME_Absolute expiration, | 110 | struct GNUNET_TIME_Absolute expiration, |
109 | char *target, | 111 | char *target, |
110 | size_t max) | 112 | size_t max) |
111 | { | 113 | { |
112 | uint16_t alen; | 114 | uint16_t alen; |
113 | size_t slen; | 115 | size_t slen; |
114 | struct GNUNET_TIME_AbsoluteNBO exp; | 116 | struct GNUNET_TIME_AbsoluteNBO exp; |
115 | 117 | ||
116 | slen = strlen(address->transport_name) + 1; | 118 | slen = strlen (address->transport_name) + 1; |
117 | if (slen + sizeof(uint16_t) + sizeof(struct GNUNET_TIME_AbsoluteNBO) + | 119 | if (slen + sizeof(uint16_t) + sizeof(struct GNUNET_TIME_AbsoluteNBO) |
118 | address->address_length > max) | 120 | + address->address_length > max) |
119 | return 0; | 121 | return 0; |
120 | exp = GNUNET_TIME_absolute_hton(expiration); | 122 | exp = GNUNET_TIME_absolute_hton (expiration); |
121 | alen = htons((uint16_t)address->address_length); | 123 | alen = htons ((uint16_t) address->address_length); |
122 | GNUNET_memcpy(target, address->transport_name, slen); | 124 | GNUNET_memcpy (target, address->transport_name, slen); |
123 | GNUNET_memcpy(&target[slen], &alen, sizeof(uint16_t)); | 125 | GNUNET_memcpy (&target[slen], &alen, sizeof(uint16_t)); |
124 | slen += sizeof(uint16_t); | 126 | slen += sizeof(uint16_t); |
125 | GNUNET_memcpy(&target[slen], &exp, sizeof(struct GNUNET_TIME_AbsoluteNBO)); | 127 | GNUNET_memcpy (&target[slen], &exp, sizeof(struct GNUNET_TIME_AbsoluteNBO)); |
126 | slen += sizeof(struct GNUNET_TIME_AbsoluteNBO); | 128 | slen += sizeof(struct GNUNET_TIME_AbsoluteNBO); |
127 | GNUNET_memcpy(&target[slen], address->address, address->address_length); | 129 | GNUNET_memcpy (&target[slen], address->address, address->address_length); |
128 | slen += address->address_length; | 130 | slen += address->address_length; |
129 | return slen; | 131 | return slen; |
130 | } | 132 | } |
@@ -139,9 +141,9 @@ GNUNET_HELLO_add_address(const struct GNUNET_HELLO_Address *address, | |||
139 | * @return size of the entry, or 0 if @a max is not large enough | 141 | * @return size of the entry, or 0 if @a max is not large enough |
140 | */ | 142 | */ |
141 | static size_t | 143 | static size_t |
142 | get_hello_address_size(const char *buf, | 144 | get_hello_address_size (const char *buf, |
143 | size_t max, | 145 | size_t max, |
144 | uint16_t *ralen) | 146 | uint16_t *ralen) |
145 | { | 147 | { |
146 | const char *pos; | 148 | const char *pos; |
147 | uint16_t alen; | 149 | uint16_t alen; |
@@ -152,34 +154,34 @@ get_hello_address_size(const char *buf, | |||
152 | pos = buf; | 154 | pos = buf; |
153 | slen = 1; | 155 | slen = 1; |
154 | while ((left > 0) && ('\0' != *pos)) | 156 | while ((left > 0) && ('\0' != *pos)) |
155 | { | 157 | { |
156 | left--; | 158 | left--; |
157 | pos++; | 159 | pos++; |
158 | slen++; | 160 | slen++; |
159 | } | 161 | } |
160 | if (0 == left) | 162 | if (0 == left) |
161 | { | 163 | { |
162 | /* 0-termination not found */ | 164 | /* 0-termination not found */ |
163 | GNUNET_break_op(0); | 165 | GNUNET_break_op (0); |
164 | return 0; | 166 | return 0; |
165 | } | 167 | } |
166 | pos++; | 168 | pos++; |
167 | if (left < sizeof(uint16_t) + sizeof(struct GNUNET_TIME_AbsoluteNBO)) | 169 | if (left < sizeof(uint16_t) + sizeof(struct GNUNET_TIME_AbsoluteNBO)) |
168 | { | 170 | { |
169 | /* not enough space for addrlen */ | 171 | /* not enough space for addrlen */ |
170 | GNUNET_break_op(0); | 172 | GNUNET_break_op (0); |
171 | return 0; | 173 | return 0; |
172 | } | 174 | } |
173 | GNUNET_memcpy(&alen, pos, sizeof(uint16_t)); | 175 | GNUNET_memcpy (&alen, pos, sizeof(uint16_t)); |
174 | alen = ntohs(alen); | 176 | alen = ntohs (alen); |
175 | *ralen = alen; | 177 | *ralen = alen; |
176 | slen += alen + sizeof(uint16_t) + sizeof(struct GNUNET_TIME_AbsoluteNBO); | 178 | slen += alen + sizeof(uint16_t) + sizeof(struct GNUNET_TIME_AbsoluteNBO); |
177 | if (max < slen) | 179 | if (max < slen) |
178 | { | 180 | { |
179 | /* not enough space for addr */ | 181 | /* not enough space for addr */ |
180 | GNUNET_break_op(0); | 182 | GNUNET_break_op (0); |
181 | return 0; | 183 | return 0; |
182 | } | 184 | } |
183 | return slen; | 185 | return slen; |
184 | } | 186 | } |
185 | 187 | ||
@@ -199,41 +201,41 @@ get_hello_address_size(const char *buf, | |||
199 | * @return the hello message | 201 | * @return the hello message |
200 | */ | 202 | */ |
201 | struct GNUNET_HELLO_Message * | 203 | struct GNUNET_HELLO_Message * |
202 | GNUNET_HELLO_create(const struct GNUNET_CRYPTO_EddsaPublicKey *public_key, | 204 | GNUNET_HELLO_create (const struct GNUNET_CRYPTO_EddsaPublicKey *public_key, |
203 | GNUNET_HELLO_GenerateAddressListCallback addrgen, | 205 | GNUNET_HELLO_GenerateAddressListCallback addrgen, |
204 | void *addrgen_cls, | 206 | void *addrgen_cls, |
205 | int friend_only) | 207 | int friend_only) |
206 | { | 208 | { |
207 | char buffer[GNUNET_MAX_MESSAGE_SIZE - 1 - 256 - | 209 | char buffer[GNUNET_MAX_MESSAGE_SIZE - 1 - 256 |
208 | sizeof(struct GNUNET_HELLO_Message)]; | 210 | - sizeof(struct GNUNET_HELLO_Message)]; |
209 | size_t max; | 211 | size_t max; |
210 | size_t used; | 212 | size_t used; |
211 | size_t ret; | 213 | size_t ret; |
212 | struct GNUNET_HELLO_Message *hello; | 214 | struct GNUNET_HELLO_Message *hello; |
213 | 215 | ||
214 | GNUNET_assert(NULL != public_key); | 216 | GNUNET_assert (NULL != public_key); |
215 | GNUNET_assert((GNUNET_YES == friend_only) || | 217 | GNUNET_assert ((GNUNET_YES == friend_only) || |
216 | (GNUNET_NO == friend_only)); | 218 | (GNUNET_NO == friend_only)); |
217 | max = sizeof(buffer); | 219 | max = sizeof(buffer); |
218 | used = 0; | 220 | used = 0; |
219 | if (NULL != addrgen) | 221 | if (NULL != addrgen) |
222 | { | ||
223 | while (GNUNET_SYSERR != (ret = addrgen (addrgen_cls, | ||
224 | max, | ||
225 | &buffer[used]))) | ||
220 | { | 226 | { |
221 | while (GNUNET_SYSERR != (ret = addrgen(addrgen_cls, | 227 | max -= ret; |
222 | max, | 228 | used += ret; |
223 | &buffer[used]))) | ||
224 | { | ||
225 | max -= ret; | ||
226 | used += ret; | ||
227 | } | ||
228 | } | 229 | } |
229 | hello = GNUNET_malloc(sizeof(struct GNUNET_HELLO_Message) + used); | 230 | } |
230 | hello->header.type = htons(GNUNET_MESSAGE_TYPE_HELLO); | 231 | hello = GNUNET_malloc (sizeof(struct GNUNET_HELLO_Message) + used); |
231 | hello->header.size = htons(sizeof(struct GNUNET_HELLO_Message) + used); | 232 | hello->header.type = htons (GNUNET_MESSAGE_TYPE_HELLO); |
232 | hello->friend_only = htonl(friend_only); | 233 | hello->header.size = htons (sizeof(struct GNUNET_HELLO_Message) + used); |
234 | hello->friend_only = htonl (friend_only); | ||
233 | hello->publicKey = *public_key; | 235 | hello->publicKey = *public_key; |
234 | GNUNET_memcpy(&hello[1], | 236 | GNUNET_memcpy (&hello[1], |
235 | buffer, | 237 | buffer, |
236 | used); | 238 | used); |
237 | return hello; | 239 | return hello; |
238 | } | 240 | } |
239 | 241 | ||
@@ -249,10 +251,10 @@ GNUNET_HELLO_create(const struct GNUNET_CRYPTO_EddsaPublicKey *public_key, | |||
249 | * @return modified HELLO message | 251 | * @return modified HELLO message |
250 | */ | 252 | */ |
251 | struct GNUNET_HELLO_Message * | 253 | struct GNUNET_HELLO_Message * |
252 | GNUNET_HELLO_iterate_addresses(const struct GNUNET_HELLO_Message *msg, | 254 | GNUNET_HELLO_iterate_addresses (const struct GNUNET_HELLO_Message *msg, |
253 | int return_modified, | 255 | int return_modified, |
254 | GNUNET_HELLO_AddressIterator it, | 256 | GNUNET_HELLO_AddressIterator it, |
255 | void *it_cls) | 257 | void *it_cls) |
256 | { | 258 | { |
257 | struct GNUNET_HELLO_Address address; | 259 | struct GNUNET_HELLO_Address address; |
258 | uint16_t msize; | 260 | uint16_t msize; |
@@ -266,69 +268,70 @@ GNUNET_HELLO_iterate_addresses(const struct GNUNET_HELLO_Message *msg, | |||
266 | struct GNUNET_TIME_AbsoluteNBO expire; | 268 | struct GNUNET_TIME_AbsoluteNBO expire; |
267 | int iret; | 269 | int iret; |
268 | 270 | ||
269 | msize = GNUNET_HELLO_size(msg); | 271 | msize = GNUNET_HELLO_size (msg); |
270 | if ((msize < sizeof(struct GNUNET_HELLO_Message)) || | 272 | if ((msize < sizeof(struct GNUNET_HELLO_Message)) || |
271 | (ntohs(msg->header.type) != GNUNET_MESSAGE_TYPE_HELLO)) | 273 | (ntohs (msg->header.type) != GNUNET_MESSAGE_TYPE_HELLO)) |
272 | { | 274 | { |
273 | GNUNET_break_op(0); | 275 | GNUNET_break_op (0); |
274 | return NULL; | 276 | return NULL; |
275 | } | 277 | } |
276 | ret = NULL; | 278 | ret = NULL; |
277 | if (return_modified) | 279 | if (return_modified) |
278 | { | 280 | { |
279 | ret = GNUNET_malloc(msize); | 281 | ret = GNUNET_malloc (msize); |
280 | GNUNET_memcpy(ret, | 282 | GNUNET_memcpy (ret, |
281 | msg, | 283 | msg, |
282 | msize); | 284 | msize); |
283 | } | 285 | } |
284 | inptr = (const char *)&msg[1]; | 286 | inptr = (const char *) &msg[1]; |
285 | insize = msize - sizeof(struct GNUNET_HELLO_Message); | 287 | insize = msize - sizeof(struct GNUNET_HELLO_Message); |
286 | wpos = 0; | 288 | wpos = 0; |
287 | woff = (NULL != ret) ? (char *)&ret[1] : NULL; | 289 | woff = (NULL != ret) ? (char *) &ret[1] : NULL; |
288 | address.peer.public_key = msg->publicKey; | 290 | address.peer.public_key = msg->publicKey; |
289 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 291 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
290 | "HELLO has %u bytes of address data\n", | 292 | "HELLO has %u bytes of address data\n", |
291 | (unsigned int)insize); | 293 | (unsigned int) insize); |
292 | 294 | ||
293 | while (insize > 0) | 295 | while (insize > 0) |
296 | { | ||
297 | esize = get_hello_address_size (inptr, | ||
298 | insize, | ||
299 | &alen); | ||
300 | if (0 == esize) | ||
294 | { | 301 | { |
295 | esize = get_hello_address_size(inptr, | 302 | GNUNET_break (0); |
296 | insize, | 303 | GNUNET_free_non_null (ret); |
297 | &alen); | 304 | return NULL; |
298 | if (0 == esize) | ||
299 | { | ||
300 | GNUNET_break(0); | ||
301 | GNUNET_free_non_null(ret); | ||
302 | return NULL; | ||
303 | } | ||
304 | /* need GNUNET_memcpy() due to possibility of misalignment */ | ||
305 | GNUNET_memcpy(&expire, | ||
306 | &inptr[esize - alen - sizeof(struct GNUNET_TIME_AbsoluteNBO)], | ||
307 | sizeof(struct GNUNET_TIME_AbsoluteNBO)); | ||
308 | address.address = &inptr[esize - alen]; | ||
309 | address.address_length = alen; | ||
310 | address.transport_name = inptr; | ||
311 | address.local_info = GNUNET_HELLO_ADDRESS_INFO_NONE; | ||
312 | iret = it(it_cls, | ||
313 | &address, | ||
314 | GNUNET_TIME_absolute_ntoh(expire)); | ||
315 | if (GNUNET_SYSERR == iret) | ||
316 | break; | ||
317 | if ((GNUNET_OK == iret) && | ||
318 | (NULL != ret)) | ||
319 | { | ||
320 | /* copy address over */ | ||
321 | GNUNET_memcpy(woff, | ||
322 | inptr, | ||
323 | esize); | ||
324 | woff += esize; | ||
325 | wpos += esize; | ||
326 | } | ||
327 | insize -= esize; | ||
328 | inptr += esize; | ||
329 | } | 305 | } |
306 | /* need GNUNET_memcpy() due to possibility of misalignment */ | ||
307 | GNUNET_memcpy (&expire, | ||
308 | &inptr[esize - alen - sizeof(struct | ||
309 | GNUNET_TIME_AbsoluteNBO)], | ||
310 | sizeof(struct GNUNET_TIME_AbsoluteNBO)); | ||
311 | address.address = &inptr[esize - alen]; | ||
312 | address.address_length = alen; | ||
313 | address.transport_name = inptr; | ||
314 | address.local_info = GNUNET_HELLO_ADDRESS_INFO_NONE; | ||
315 | iret = it (it_cls, | ||
316 | &address, | ||
317 | GNUNET_TIME_absolute_ntoh (expire)); | ||
318 | if (GNUNET_SYSERR == iret) | ||
319 | break; | ||
320 | if ((GNUNET_OK == iret) && | ||
321 | (NULL != ret)) | ||
322 | { | ||
323 | /* copy address over */ | ||
324 | GNUNET_memcpy (woff, | ||
325 | inptr, | ||
326 | esize); | ||
327 | woff += esize; | ||
328 | wpos += esize; | ||
329 | } | ||
330 | insize -= esize; | ||
331 | inptr += esize; | ||
332 | } | ||
330 | if (NULL != ret) | 333 | if (NULL != ret) |
331 | ret->header.size = ntohs(sizeof(struct GNUNET_HELLO_Message) + wpos); | 334 | ret->header.size = ntohs (sizeof(struct GNUNET_HELLO_Message) + wpos); |
332 | return ret; | 335 | return ret; |
333 | } | 336 | } |
334 | 337 | ||
@@ -336,7 +339,8 @@ GNUNET_HELLO_iterate_addresses(const struct GNUNET_HELLO_Message *msg, | |||
336 | /** | 339 | /** |
337 | * Closure for #get_match_exp(). | 340 | * Closure for #get_match_exp(). |
338 | */ | 341 | */ |
339 | struct ExpireContext { | 342 | struct ExpireContext |
343 | { | ||
340 | /** | 344 | /** |
341 | * Address we are looking for. | 345 | * Address we are looking for. |
342 | */ | 346 | */ |
@@ -363,14 +367,14 @@ struct ExpireContext { | |||
363 | * @return #GNUNET_SYSERR if we found a matching address, #GNUNET_OK otherwise | 367 | * @return #GNUNET_SYSERR if we found a matching address, #GNUNET_OK otherwise |
364 | */ | 368 | */ |
365 | static int | 369 | static int |
366 | get_match_exp(void *cls, | 370 | get_match_exp (void *cls, |
367 | const struct GNUNET_HELLO_Address *address, | 371 | const struct GNUNET_HELLO_Address *address, |
368 | struct GNUNET_TIME_Absolute expiration) | 372 | struct GNUNET_TIME_Absolute expiration) |
369 | { | 373 | { |
370 | struct ExpireContext *ec = cls; | 374 | struct ExpireContext *ec = cls; |
371 | 375 | ||
372 | if (0 != GNUNET_HELLO_address_cmp(address, | 376 | if (0 != GNUNET_HELLO_address_cmp (address, |
373 | ec->address)) | 377 | ec->address)) |
374 | return GNUNET_OK; | 378 | return GNUNET_OK; |
375 | ec->found = GNUNET_YES; | 379 | ec->found = GNUNET_YES; |
376 | ec->expiration = expiration; | 380 | ec->expiration = expiration; |
@@ -381,7 +385,8 @@ get_match_exp(void *cls, | |||
381 | /** | 385 | /** |
382 | * Context for a #GNUNET_HELLO_Merge operation. | 386 | * Context for a #GNUNET_HELLO_Merge operation. |
383 | */ | 387 | */ |
384 | struct MergeContext { | 388 | struct MergeContext |
389 | { | ||
385 | /** | 390 | /** |
386 | * First HELLO we are merging. | 391 | * First HELLO we are merging. |
387 | */ | 392 | */ |
@@ -434,9 +439,9 @@ struct MergeContext { | |||
434 | * @return always #GNUNET_OK | 439 | * @return always #GNUNET_OK |
435 | */ | 440 | */ |
436 | static int | 441 | static int |
437 | copy_latest(void *cls, | 442 | copy_latest (void *cls, |
438 | const struct GNUNET_HELLO_Address *address, | 443 | const struct GNUNET_HELLO_Address *address, |
439 | struct GNUNET_TIME_Absolute expiration) | 444 | struct GNUNET_TIME_Absolute expiration) |
440 | { | 445 | { |
441 | struct MergeContext *mc = cls; | 446 | struct MergeContext *mc = cls; |
442 | struct ExpireContext ec; | 447 | struct ExpireContext ec; |
@@ -444,22 +449,22 @@ copy_latest(void *cls, | |||
444 | ec.address = address; | 449 | ec.address = address; |
445 | ec.found = GNUNET_NO; | 450 | ec.found = GNUNET_NO; |
446 | /* check if address exists in other */ | 451 | /* check if address exists in other */ |
447 | GNUNET_HELLO_iterate_addresses(mc->other, | 452 | GNUNET_HELLO_iterate_addresses (mc->other, |
448 | GNUNET_NO, | 453 | GNUNET_NO, |
449 | &get_match_exp, | 454 | &get_match_exp, |
450 | &ec); | 455 | &ec); |
451 | if ((GNUNET_NO == ec.found) || | 456 | if ((GNUNET_NO == ec.found) || |
452 | (ec.expiration.abs_value_us < expiration.abs_value_us) || | 457 | (ec.expiration.abs_value_us < expiration.abs_value_us) || |
453 | ((ec.expiration.abs_value_us == expiration.abs_value_us) && | 458 | ((ec.expiration.abs_value_us == expiration.abs_value_us) && |
454 | (GNUNET_YES == mc->take_equal))) | 459 | (GNUNET_YES == mc->take_equal))) |
455 | { | 460 | { |
456 | /* copy address to buffer */ | 461 | /* copy address to buffer */ |
457 | mc->ret += | 462 | mc->ret += |
458 | GNUNET_HELLO_add_address(address, | 463 | GNUNET_HELLO_add_address (address, |
459 | expiration, | 464 | expiration, |
460 | &mc->buf[mc->ret], | 465 | &mc->buf[mc->ret], |
461 | mc->max - mc->ret); | 466 | mc->max - mc->ret); |
462 | } | 467 | } |
463 | return GNUNET_OK; | 468 | return GNUNET_OK; |
464 | } | 469 | } |
465 | 470 | ||
@@ -475,9 +480,9 @@ copy_latest(void *cls, | |||
475 | * @return #GNUNET_SYSERR to end iteration, otherwise number of bytes written to @a buf | 480 | * @return #GNUNET_SYSERR to end iteration, otherwise number of bytes written to @a buf |
476 | */ | 481 | */ |
477 | static ssize_t | 482 | static ssize_t |
478 | merge_addr(void *cls, | 483 | merge_addr (void *cls, |
479 | size_t max, | 484 | size_t max, |
480 | void *buf) | 485 | void *buf) |
481 | { | 486 | { |
482 | struct MergeContext *mc = cls; | 487 | struct MergeContext *mc = cls; |
483 | 488 | ||
@@ -489,17 +494,17 @@ merge_addr(void *cls, | |||
489 | mc->take_equal = GNUNET_NO; | 494 | mc->take_equal = GNUNET_NO; |
490 | mc->other = mc->h2; | 495 | mc->other = mc->h2; |
491 | /* copy addresses from h1, if strictly larger expiration than h2 */ | 496 | /* copy addresses from h1, if strictly larger expiration than h2 */ |
492 | GNUNET_HELLO_iterate_addresses(mc->h1, | 497 | GNUNET_HELLO_iterate_addresses (mc->h1, |
493 | GNUNET_NO, | 498 | GNUNET_NO, |
494 | ©_latest, | 499 | ©_latest, |
495 | mc); | 500 | mc); |
496 | mc->take_equal = GNUNET_YES; | 501 | mc->take_equal = GNUNET_YES; |
497 | mc->other = mc->h1; | 502 | mc->other = mc->h1; |
498 | /* copy addresses from h2, if larger or equal expiration than h1 */ | 503 | /* copy addresses from h2, if larger or equal expiration than h1 */ |
499 | GNUNET_HELLO_iterate_addresses(mc->h2, | 504 | GNUNET_HELLO_iterate_addresses (mc->h2, |
500 | GNUNET_NO, | 505 | GNUNET_NO, |
501 | ©_latest, | 506 | ©_latest, |
502 | mc); | 507 | mc); |
503 | /* set marker to stop iteration */ | 508 | /* set marker to stop iteration */ |
504 | mc->h1 = NULL; | 509 | mc->h1 = NULL; |
505 | return mc->ret; | 510 | return mc->ret; |
@@ -516,8 +521,8 @@ merge_addr(void *cls, | |||
516 | * @return the combined HELLO message | 521 | * @return the combined HELLO message |
517 | */ | 522 | */ |
518 | struct GNUNET_HELLO_Message * | 523 | struct GNUNET_HELLO_Message * |
519 | GNUNET_HELLO_merge(const struct GNUNET_HELLO_Message *h1, | 524 | GNUNET_HELLO_merge (const struct GNUNET_HELLO_Message *h1, |
520 | const struct GNUNET_HELLO_Message *h2) | 525 | const struct GNUNET_HELLO_Message *h2) |
521 | { | 526 | { |
522 | struct MergeContext mc = { h1, h2, NULL, NULL, 0, 0, 0 }; | 527 | struct MergeContext mc = { h1, h2, NULL, NULL, 0, 0, 0 }; |
523 | int friend_only; | 528 | int friend_only; |
@@ -525,12 +530,12 @@ GNUNET_HELLO_merge(const struct GNUNET_HELLO_Message *h1, | |||
525 | if (h1->friend_only != h2->friend_only) | 530 | if (h1->friend_only != h2->friend_only) |
526 | friend_only = GNUNET_YES; /* One of the HELLOs is friend only */ | 531 | friend_only = GNUNET_YES; /* One of the HELLOs is friend only */ |
527 | else | 532 | else |
528 | friend_only = ntohl(h1->friend_only); /* Both HELLO's have the same type */ | 533 | friend_only = ntohl (h1->friend_only); /* Both HELLO's have the same type */ |
529 | 534 | ||
530 | return GNUNET_HELLO_create(&h1->publicKey, | 535 | return GNUNET_HELLO_create (&h1->publicKey, |
531 | &merge_addr, | 536 | &merge_addr, |
532 | &mc, | 537 | &mc, |
533 | friend_only); | 538 | friend_only); |
534 | } | 539 | } |
535 | 540 | ||
536 | 541 | ||
@@ -538,7 +543,8 @@ GNUNET_HELLO_merge(const struct GNUNET_HELLO_Message *h1, | |||
538 | * Context used in #GNUNET_HELLO_iterate_new_addresses() to | 543 | * Context used in #GNUNET_HELLO_iterate_new_addresses() to |
539 | * figure out which addresses are in fact 'new'. | 544 | * figure out which addresses are in fact 'new'. |
540 | */ | 545 | */ |
541 | struct DeltaContext { | 546 | struct DeltaContext |
547 | { | ||
542 | /** | 548 | /** |
543 | * We should ignore addresses that expire before this time. | 549 | * We should ignore addresses that expire before this time. |
544 | */ | 550 | */ |
@@ -575,9 +581,9 @@ struct DeltaContext { | |||
575 | * whatever the iterator returned. | 581 | * whatever the iterator returned. |
576 | */ | 582 | */ |
577 | static int | 583 | static int |
578 | delta_match(void *cls, | 584 | delta_match (void *cls, |
579 | const struct GNUNET_HELLO_Address *address, | 585 | const struct GNUNET_HELLO_Address *address, |
580 | struct GNUNET_TIME_Absolute expiration) | 586 | struct GNUNET_TIME_Absolute expiration) |
581 | { | 587 | { |
582 | struct DeltaContext *dc = cls; | 588 | struct DeltaContext *dc = cls; |
583 | int ret; | 589 | int ret; |
@@ -585,17 +591,17 @@ delta_match(void *cls, | |||
585 | 591 | ||
586 | ec.address = address; | 592 | ec.address = address; |
587 | ec.found = GNUNET_NO; | 593 | ec.found = GNUNET_NO; |
588 | GNUNET_HELLO_iterate_addresses(dc->old_hello, | 594 | GNUNET_HELLO_iterate_addresses (dc->old_hello, |
589 | GNUNET_NO, | 595 | GNUNET_NO, |
590 | &get_match_exp, | 596 | &get_match_exp, |
591 | &ec); | 597 | &ec); |
592 | if ((GNUNET_YES == ec.found) && | 598 | if ((GNUNET_YES == ec.found) && |
593 | ((ec.expiration.abs_value_us > expiration.abs_value_us) || | 599 | ((ec.expiration.abs_value_us > expiration.abs_value_us) || |
594 | (ec.expiration.abs_value_us >= dc->expiration_limit.abs_value_us))) | 600 | (ec.expiration.abs_value_us >= dc->expiration_limit.abs_value_us))) |
595 | return GNUNET_YES; /* skip: found and boring */ | 601 | return GNUNET_YES; /* skip: found and boring */ |
596 | ret = dc->it(dc->it_cls, | 602 | ret = dc->it (dc->it_cls, |
597 | address, | 603 | address, |
598 | expiration); | 604 | expiration); |
599 | return ret; | 605 | return ret; |
600 | } | 606 | } |
601 | 607 | ||
@@ -614,11 +620,14 @@ delta_match(void *cls, | |||
614 | * @param it_cls closure for @a it | 620 | * @param it_cls closure for @a it |
615 | */ | 621 | */ |
616 | void | 622 | void |
617 | GNUNET_HELLO_iterate_new_addresses(const struct GNUNET_HELLO_Message *new_hello, | 623 | GNUNET_HELLO_iterate_new_addresses (const struct |
618 | const struct GNUNET_HELLO_Message *old_hello, | 624 | GNUNET_HELLO_Message *new_hello, |
619 | struct GNUNET_TIME_Absolute expiration_limit, | 625 | const struct |
620 | GNUNET_HELLO_AddressIterator it, | 626 | GNUNET_HELLO_Message *old_hello, |
621 | void *it_cls) | 627 | struct GNUNET_TIME_Absolute |
628 | expiration_limit, | ||
629 | GNUNET_HELLO_AddressIterator it, | ||
630 | void *it_cls) | ||
622 | { | 631 | { |
623 | struct DeltaContext dc; | 632 | struct DeltaContext dc; |
624 | 633 | ||
@@ -626,11 +635,11 @@ GNUNET_HELLO_iterate_new_addresses(const struct GNUNET_HELLO_Message *new_hello, | |||
626 | dc.it = it; | 635 | dc.it = it; |
627 | dc.it_cls = it_cls; | 636 | dc.it_cls = it_cls; |
628 | dc.old_hello = old_hello; | 637 | dc.old_hello = old_hello; |
629 | GNUNET_assert(NULL == | 638 | GNUNET_assert (NULL == |
630 | GNUNET_HELLO_iterate_addresses(new_hello, | 639 | GNUNET_HELLO_iterate_addresses (new_hello, |
631 | GNUNET_NO, | 640 | GNUNET_NO, |
632 | &delta_match, | 641 | &delta_match, |
633 | &dc)); | 642 | &dc)); |
634 | } | 643 | } |
635 | 644 | ||
636 | 645 | ||
@@ -640,12 +649,12 @@ GNUNET_HELLO_iterate_new_addresses(const struct GNUNET_HELLO_Message *new_hello, | |||
640 | * @return the size, 0 if HELLO is invalid | 649 | * @return the size, 0 if HELLO is invalid |
641 | */ | 650 | */ |
642 | uint16_t | 651 | uint16_t |
643 | GNUNET_HELLO_size(const struct GNUNET_HELLO_Message *hello) | 652 | GNUNET_HELLO_size (const struct GNUNET_HELLO_Message *hello) |
644 | { | 653 | { |
645 | uint16_t ret = ntohs(hello->header.size); | 654 | uint16_t ret = ntohs (hello->header.size); |
646 | 655 | ||
647 | if ((ret < sizeof(struct GNUNET_HELLO_Message)) || | 656 | if ((ret < sizeof(struct GNUNET_HELLO_Message)) || |
648 | (ntohs(hello->header.type) != GNUNET_MESSAGE_TYPE_HELLO)) | 657 | (ntohs (hello->header.type) != GNUNET_MESSAGE_TYPE_HELLO)) |
649 | return 0; | 658 | return 0; |
650 | return ret; | 659 | return ret; |
651 | } | 660 | } |
@@ -659,13 +668,13 @@ GNUNET_HELLO_size(const struct GNUNET_HELLO_Message *hello) | |||
659 | * @return #GNUNET_SYSERR if the HELLO was malformed | 668 | * @return #GNUNET_SYSERR if the HELLO was malformed |
660 | */ | 669 | */ |
661 | int | 670 | int |
662 | GNUNET_HELLO_get_id(const struct GNUNET_HELLO_Message *hello, | 671 | GNUNET_HELLO_get_id (const struct GNUNET_HELLO_Message *hello, |
663 | struct GNUNET_PeerIdentity *peer) | 672 | struct GNUNET_PeerIdentity *peer) |
664 | { | 673 | { |
665 | uint16_t ret = ntohs(hello->header.size); | 674 | uint16_t ret = ntohs (hello->header.size); |
666 | 675 | ||
667 | if ((ret < sizeof(struct GNUNET_HELLO_Message)) || | 676 | if ((ret < sizeof(struct GNUNET_HELLO_Message)) || |
668 | (ntohs(hello->header.type) != GNUNET_MESSAGE_TYPE_HELLO)) | 677 | (ntohs (hello->header.type) != GNUNET_MESSAGE_TYPE_HELLO)) |
669 | return GNUNET_SYSERR; | 678 | return GNUNET_SYSERR; |
670 | peer->public_key = hello->publicKey; | 679 | peer->public_key = hello->publicKey; |
671 | return GNUNET_OK; | 680 | return GNUNET_OK; |
@@ -681,12 +690,12 @@ GNUNET_HELLO_get_id(const struct GNUNET_HELLO_Message *hello, | |||
681 | * @return header or NULL if the HELLO was malformed | 690 | * @return header or NULL if the HELLO was malformed |
682 | */ | 691 | */ |
683 | struct GNUNET_MessageHeader * | 692 | struct GNUNET_MessageHeader * |
684 | GNUNET_HELLO_get_header(struct GNUNET_HELLO_Message *hello) | 693 | GNUNET_HELLO_get_header (struct GNUNET_HELLO_Message *hello) |
685 | { | 694 | { |
686 | uint16_t ret = ntohs(hello->header.size); | 695 | uint16_t ret = ntohs (hello->header.size); |
687 | 696 | ||
688 | if ((ret < sizeof(struct GNUNET_HELLO_Message)) || | 697 | if ((ret < sizeof(struct GNUNET_HELLO_Message)) || |
689 | (ntohs(hello->header.type) != GNUNET_MESSAGE_TYPE_HELLO)) | 698 | (ntohs (hello->header.type) != GNUNET_MESSAGE_TYPE_HELLO)) |
690 | return NULL; | 699 | return NULL; |
691 | 700 | ||
692 | return &hello->header; | 701 | return &hello->header; |
@@ -696,7 +705,8 @@ GNUNET_HELLO_get_header(struct GNUNET_HELLO_Message *hello) | |||
696 | /** | 705 | /** |
697 | * Context used for comparing HELLOs in #GNUNET_HELLO_equals(). | 706 | * Context used for comparing HELLOs in #GNUNET_HELLO_equals(). |
698 | */ | 707 | */ |
699 | struct EqualsContext { | 708 | struct EqualsContext |
709 | { | ||
700 | /** | 710 | /** |
701 | * Addresses that expired before this date are ignored for | 711 | * Addresses that expired before this date are ignored for |
702 | * the comparisson. | 712 | * the comparisson. |
@@ -746,22 +756,22 @@ struct EqualsContext { | |||
746 | * #GNUNET_SYSERR if the address does match. | 756 | * #GNUNET_SYSERR if the address does match. |
747 | */ | 757 | */ |
748 | static int | 758 | static int |
749 | find_other_matching(void *cls, | 759 | find_other_matching (void *cls, |
750 | const struct GNUNET_HELLO_Address *address, | 760 | const struct GNUNET_HELLO_Address *address, |
751 | struct GNUNET_TIME_Absolute expiration) | 761 | struct GNUNET_TIME_Absolute expiration) |
752 | { | 762 | { |
753 | struct EqualsContext *ec = cls; | 763 | struct EqualsContext *ec = cls; |
754 | 764 | ||
755 | if (expiration.abs_value_us < ec->expiration_limit.abs_value_us) | 765 | if (expiration.abs_value_us < ec->expiration_limit.abs_value_us) |
756 | return GNUNET_YES; | 766 | return GNUNET_YES; |
757 | if (0 == GNUNET_HELLO_address_cmp(address, ec->address)) | 767 | if (0 == GNUNET_HELLO_address_cmp (address, ec->address)) |
758 | { | 768 | { |
759 | ec->found = GNUNET_YES; | 769 | ec->found = GNUNET_YES; |
760 | if (expiration.abs_value_us < ec->expiration.abs_value_us) | 770 | if (expiration.abs_value_us < ec->expiration.abs_value_us) |
761 | ec->result = GNUNET_TIME_absolute_min(expiration, | 771 | ec->result = GNUNET_TIME_absolute_min (expiration, |
762 | ec->result); | 772 | ec->result); |
763 | return GNUNET_SYSERR; | 773 | return GNUNET_SYSERR; |
764 | } | 774 | } |
765 | return GNUNET_YES; | 775 | return GNUNET_YES; |
766 | } | 776 | } |
767 | 777 | ||
@@ -779,9 +789,9 @@ find_other_matching(void *cls, | |||
779 | * #GNUNET_SYSERR if it was not found | 789 | * #GNUNET_SYSERR if it was not found |
780 | */ | 790 | */ |
781 | static int | 791 | static int |
782 | find_matching(void *cls, | 792 | find_matching (void *cls, |
783 | const struct GNUNET_HELLO_Address *address, | 793 | const struct GNUNET_HELLO_Address *address, |
784 | struct GNUNET_TIME_Absolute expiration) | 794 | struct GNUNET_TIME_Absolute expiration) |
785 | { | 795 | { |
786 | struct EqualsContext *ec = cls; | 796 | struct EqualsContext *ec = cls; |
787 | 797 | ||
@@ -790,16 +800,16 @@ find_matching(void *cls, | |||
790 | ec->address = address; | 800 | ec->address = address; |
791 | ec->expiration = expiration; | 801 | ec->expiration = expiration; |
792 | ec->found = GNUNET_NO; | 802 | ec->found = GNUNET_NO; |
793 | GNUNET_HELLO_iterate_addresses(ec->ref, | 803 | GNUNET_HELLO_iterate_addresses (ec->ref, |
794 | GNUNET_NO, | 804 | GNUNET_NO, |
795 | &find_other_matching, | 805 | &find_other_matching, |
796 | ec); | 806 | ec); |
797 | if (GNUNET_NO == ec->found) | 807 | if (GNUNET_NO == ec->found) |
798 | { | 808 | { |
799 | /* not found, we differ *now* */ | 809 | /* not found, we differ *now* */ |
800 | ec->result = GNUNET_TIME_UNIT_ZERO_ABS; | 810 | ec->result = GNUNET_TIME_UNIT_ZERO_ABS; |
801 | return GNUNET_SYSERR; | 811 | return GNUNET_SYSERR; |
802 | } | 812 | } |
803 | return GNUNET_OK; | 813 | return GNUNET_OK; |
804 | } | 814 | } |
805 | 815 | ||
@@ -821,32 +831,32 @@ find_matching(void *cls, | |||
821 | * do not match at all | 831 | * do not match at all |
822 | */ | 832 | */ |
823 | struct GNUNET_TIME_Absolute | 833 | struct GNUNET_TIME_Absolute |
824 | GNUNET_HELLO_equals(const struct GNUNET_HELLO_Message *h1, | 834 | GNUNET_HELLO_equals (const struct GNUNET_HELLO_Message *h1, |
825 | const struct GNUNET_HELLO_Message *h2, | 835 | const struct GNUNET_HELLO_Message *h2, |
826 | struct GNUNET_TIME_Absolute now) | 836 | struct GNUNET_TIME_Absolute now) |
827 | { | 837 | { |
828 | struct EqualsContext ec; | 838 | struct EqualsContext ec; |
829 | 839 | ||
830 | if (h1->header.type != h2->header.type) | 840 | if (h1->header.type != h2->header.type) |
831 | return GNUNET_TIME_UNIT_ZERO_ABS; | 841 | return GNUNET_TIME_UNIT_ZERO_ABS; |
832 | if (0 != | 842 | if (0 != |
833 | GNUNET_memcmp(&h1->publicKey, | 843 | GNUNET_memcmp (&h1->publicKey, |
834 | &h2->publicKey)) | 844 | &h2->publicKey)) |
835 | return GNUNET_TIME_UNIT_ZERO_ABS; | 845 | return GNUNET_TIME_UNIT_ZERO_ABS; |
836 | ec.expiration_limit = now; | 846 | ec.expiration_limit = now; |
837 | ec.result = GNUNET_TIME_UNIT_FOREVER_ABS; | 847 | ec.result = GNUNET_TIME_UNIT_FOREVER_ABS; |
838 | ec.ref = h2; | 848 | ec.ref = h2; |
839 | GNUNET_HELLO_iterate_addresses(h1, | 849 | GNUNET_HELLO_iterate_addresses (h1, |
840 | GNUNET_NO, | 850 | GNUNET_NO, |
841 | &find_matching, | 851 | &find_matching, |
842 | &ec); | 852 | &ec); |
843 | if (ec.result.abs_value_us == GNUNET_TIME_UNIT_ZERO.rel_value_us) | 853 | if (ec.result.abs_value_us == GNUNET_TIME_UNIT_ZERO.rel_value_us) |
844 | return ec.result; | 854 | return ec.result; |
845 | ec.ref = h1; | 855 | ec.ref = h1; |
846 | GNUNET_HELLO_iterate_addresses(h2, | 856 | GNUNET_HELLO_iterate_addresses (h2, |
847 | GNUNET_NO, | 857 | GNUNET_NO, |
848 | &find_matching, | 858 | &find_matching, |
849 | &ec); | 859 | &ec); |
850 | return ec.result; | 860 | return ec.result; |
851 | } | 861 | } |
852 | 862 | ||
@@ -861,13 +871,13 @@ GNUNET_HELLO_equals(const struct GNUNET_HELLO_Message *h1, | |||
861 | * @return #GNUNET_OK (always) | 871 | * @return #GNUNET_OK (always) |
862 | */ | 872 | */ |
863 | static int | 873 | static int |
864 | find_max_expire(void *cls, | 874 | find_max_expire (void *cls, |
865 | const struct GNUNET_HELLO_Address *address, | 875 | const struct GNUNET_HELLO_Address *address, |
866 | struct GNUNET_TIME_Absolute expiration) | 876 | struct GNUNET_TIME_Absolute expiration) |
867 | { | 877 | { |
868 | struct GNUNET_TIME_Absolute *max = cls; | 878 | struct GNUNET_TIME_Absolute *max = cls; |
869 | 879 | ||
870 | *max = GNUNET_TIME_absolute_max(*max, expiration); | 880 | *max = GNUNET_TIME_absolute_max (*max, expiration); |
871 | return GNUNET_OK; | 881 | return GNUNET_OK; |
872 | } | 882 | } |
873 | 883 | ||
@@ -879,15 +889,15 @@ find_max_expire(void *cls, | |||
879 | * @return time the last address expires, 0 if there are no addresses in the HELLO | 889 | * @return time the last address expires, 0 if there are no addresses in the HELLO |
880 | */ | 890 | */ |
881 | struct GNUNET_TIME_Absolute | 891 | struct GNUNET_TIME_Absolute |
882 | GNUNET_HELLO_get_last_expiration(const struct GNUNET_HELLO_Message *msg) | 892 | GNUNET_HELLO_get_last_expiration (const struct GNUNET_HELLO_Message *msg) |
883 | { | 893 | { |
884 | struct GNUNET_TIME_Absolute ret; | 894 | struct GNUNET_TIME_Absolute ret; |
885 | 895 | ||
886 | ret = GNUNET_TIME_UNIT_ZERO_ABS; | 896 | ret = GNUNET_TIME_UNIT_ZERO_ABS; |
887 | GNUNET_HELLO_iterate_addresses(msg, | 897 | GNUNET_HELLO_iterate_addresses (msg, |
888 | GNUNET_NO, | 898 | GNUNET_NO, |
889 | &find_max_expire, | 899 | &find_max_expire, |
890 | &ret); | 900 | &ret); |
891 | return ret; | 901 | return ret; |
892 | } | 902 | } |
893 | 903 | ||
@@ -946,9 +956,9 @@ GNUNET_HELLO_get_last_expiration(const struct GNUNET_HELLO_Message *msg) | |||
946 | * @return #GNUNET_OK (continue iteration). | 956 | * @return #GNUNET_OK (continue iteration). |
947 | */ | 957 | */ |
948 | static int | 958 | static int |
949 | add_address_to_uri(void *cls, | 959 | add_address_to_uri (void *cls, |
950 | const struct GNUNET_HELLO_Address *address, | 960 | const struct GNUNET_HELLO_Address *address, |
951 | struct GNUNET_TIME_Absolute expiration) | 961 | struct GNUNET_TIME_Absolute expiration) |
952 | { | 962 | { |
953 | struct GNUNET_HELLO_ComposeUriContext *ctx = cls; | 963 | struct GNUNET_HELLO_ComposeUriContext *ctx = cls; |
954 | struct GNUNET_TRANSPORT_PluginFunctions *papi; | 964 | struct GNUNET_TRANSPORT_PluginFunctions *papi; |
@@ -961,49 +971,49 @@ add_address_to_uri(void *cls, | |||
961 | struct tm *t; | 971 | struct tm *t; |
962 | time_t seconds; | 972 | time_t seconds; |
963 | 973 | ||
964 | papi = ctx->plugins_find(address->transport_name); | 974 | papi = ctx->plugins_find (address->transport_name); |
965 | if (NULL == papi) | 975 | if (NULL == papi) |
966 | { | 976 | { |
967 | /* Not an error - we might just not have the right plugin. */ | 977 | /* Not an error - we might just not have the right plugin. */ |
968 | return GNUNET_OK; | 978 | return GNUNET_OK; |
969 | } | 979 | } |
970 | if (NULL == papi->address_to_string) | 980 | if (NULL == papi->address_to_string) |
971 | { | 981 | { |
972 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 982 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
973 | "URI conversion not implemented for plugin `%s'\n", | 983 | "URI conversion not implemented for plugin `%s'\n", |
974 | address->transport_name); | 984 | address->transport_name); |
975 | return GNUNET_OK; | 985 | return GNUNET_OK; |
976 | } | 986 | } |
977 | addr = papi->address_to_string(papi->cls, | 987 | addr = papi->address_to_string (papi->cls, |
978 | address->address, | 988 | address->address, |
979 | address->address_length); | 989 | address->address_length); |
980 | if ((NULL == addr) || | 990 | if ((NULL == addr) || |
981 | (0 == strlen(addr))) | 991 | (0 == strlen (addr))) |
982 | return GNUNET_OK; | 992 | return GNUNET_OK; |
983 | 993 | ||
984 | addr_dup = GNUNET_strdup(addr); | 994 | addr_dup = GNUNET_strdup (addr); |
985 | if (NULL != (pos = strstr(addr_dup, "_server"))) | 995 | if (NULL != (pos = strstr (addr_dup, "_server"))) |
986 | GNUNET_memcpy(pos, | 996 | GNUNET_memcpy (pos, |
987 | client_str, | 997 | client_str, |
988 | strlen(client_str)); /* Replace all server addresses with client addresses */ | 998 | strlen (client_str)); /* Replace all server addresses with client addresses */ |
989 | 999 | ||
990 | seconds = expiration.abs_value_us / 1000LL / 1000LL; | 1000 | seconds = expiration.abs_value_us / 1000LL / 1000LL; |
991 | t = gmtime(&seconds); | 1001 | t = gmtime (&seconds); |
992 | 1002 | ||
993 | GNUNET_asprintf(&ret, | 1003 | GNUNET_asprintf (&ret, |
994 | "%s%c%s%c%s%c%s", | 1004 | "%s%c%s%c%s%c%s", |
995 | ctx->uri, | 1005 | ctx->uri, |
996 | GNUNET_HELLO_URI_SEP, | 1006 | GNUNET_HELLO_URI_SEP, |
997 | strftime(tbuf, | 1007 | strftime (tbuf, |
998 | sizeof(tbuf), | 1008 | sizeof(tbuf), |
999 | "%Y%m%d%H%M%S", | 1009 | "%Y%m%d%H%M%S", |
1000 | t) ? tbuf : "0", | 1010 | t) ? tbuf : "0", |
1001 | GNUNET_HELLO_URI_SEP, | 1011 | GNUNET_HELLO_URI_SEP, |
1002 | address->transport_name, | 1012 | address->transport_name, |
1003 | GNUNET_HELLO_URI_SEP, | 1013 | GNUNET_HELLO_URI_SEP, |
1004 | addr_dup); | 1014 | addr_dup); |
1005 | GNUNET_free(addr_dup); | 1015 | GNUNET_free (addr_dup); |
1006 | GNUNET_free(ctx->uri); | 1016 | GNUNET_free (ctx->uri); |
1007 | ctx->uri = ret; | 1017 | ctx->uri = ret; |
1008 | return GNUNET_OK; | 1018 | return GNUNET_OK; |
1009 | } | 1019 | } |
@@ -1017,25 +1027,25 @@ add_address_to_uri(void *cls, | |||
1017 | * @return Hello URI string | 1027 | * @return Hello URI string |
1018 | */ | 1028 | */ |
1019 | char * | 1029 | char * |
1020 | GNUNET_HELLO_compose_uri(const struct GNUNET_HELLO_Message *hello, | 1030 | GNUNET_HELLO_compose_uri (const struct GNUNET_HELLO_Message *hello, |
1021 | GNUNET_HELLO_TransportPluginsFind plugins_find) | 1031 | GNUNET_HELLO_TransportPluginsFind plugins_find) |
1022 | { | 1032 | { |
1023 | struct GNUNET_HELLO_ComposeUriContext ctx; | 1033 | struct GNUNET_HELLO_ComposeUriContext ctx; |
1024 | char *pkey; | 1034 | char *pkey; |
1025 | 1035 | ||
1026 | ctx.plugins_find = plugins_find; | 1036 | ctx.plugins_find = plugins_find; |
1027 | pkey = GNUNET_CRYPTO_eddsa_public_key_to_string(&hello->publicKey); | 1037 | pkey = GNUNET_CRYPTO_eddsa_public_key_to_string (&hello->publicKey); |
1028 | GNUNET_asprintf(&ctx.uri, | 1038 | GNUNET_asprintf (&ctx.uri, |
1029 | "%s%s", | 1039 | "%s%s", |
1030 | (GNUNET_YES == GNUNET_HELLO_is_friend_only(hello)) | 1040 | (GNUNET_YES == GNUNET_HELLO_is_friend_only (hello)) |
1031 | ? GNUNET_FRIEND_HELLO_URI_PREFIX | 1041 | ? GNUNET_FRIEND_HELLO_URI_PREFIX |
1032 | : GNUNET_HELLO_URI_PREFIX, | 1042 | : GNUNET_HELLO_URI_PREFIX, |
1033 | pkey); | 1043 | pkey); |
1034 | GNUNET_free(pkey); | 1044 | GNUNET_free (pkey); |
1035 | GNUNET_HELLO_iterate_addresses(hello, | 1045 | GNUNET_HELLO_iterate_addresses (hello, |
1036 | GNUNET_NO, | 1046 | GNUNET_NO, |
1037 | &add_address_to_uri, | 1047 | &add_address_to_uri, |
1038 | &ctx); | 1048 | &ctx); |
1039 | return ctx.uri; | 1049 | return ctx.uri; |
1040 | } | 1050 | } |
1041 | 1051 | ||
@@ -1053,9 +1063,9 @@ GNUNET_HELLO_compose_uri(const struct GNUNET_HELLO_Message *hello, | |||
1053 | * @return number of bytes added to buffer, #GNUNET_SYSERR on error | 1063 | * @return number of bytes added to buffer, #GNUNET_SYSERR on error |
1054 | */ | 1064 | */ |
1055 | static ssize_t | 1065 | static ssize_t |
1056 | add_address_to_hello(void *cls, | 1066 | add_address_to_hello (void *cls, |
1057 | size_t max, | 1067 | size_t max, |
1058 | void *buffer) | 1068 | void *buffer) |
1059 | { | 1069 | { |
1060 | struct GNUNET_HELLO_ParseUriContext *ctx = cls; | 1070 | struct GNUNET_HELLO_ParseUriContext *ctx = cls; |
1061 | const char *tname; | 1071 | const char *tname; |
@@ -1075,119 +1085,122 @@ add_address_to_hello(void *cls, | |||
1075 | if (NULL == ctx->pos) | 1085 | if (NULL == ctx->pos) |
1076 | return GNUNET_SYSERR; | 1086 | return GNUNET_SYSERR; |
1077 | if (GNUNET_HELLO_URI_SEP != ctx->pos[0]) | 1087 | if (GNUNET_HELLO_URI_SEP != ctx->pos[0]) |
1078 | { | 1088 | { |
1079 | ctx->ret = GNUNET_SYSERR; | 1089 | ctx->ret = GNUNET_SYSERR; |
1080 | GNUNET_break(0); | 1090 | GNUNET_break (0); |
1081 | return GNUNET_SYSERR; | 1091 | return GNUNET_SYSERR; |
1082 | } | 1092 | } |
1083 | ctx->pos++; | 1093 | ctx->pos++; |
1084 | 1094 | ||
1085 | if (('0' == ctx->pos[0]) && | 1095 | if (('0' == ctx->pos[0]) && |
1086 | (GNUNET_HELLO_URI_SEP == ctx->pos[1])) | 1096 | (GNUNET_HELLO_URI_SEP == ctx->pos[1])) |
1087 | { | 1097 | { |
1088 | expire = GNUNET_TIME_UNIT_FOREVER_ABS; | 1098 | expire = GNUNET_TIME_UNIT_FOREVER_ABS; |
1089 | tname = ctx->pos + 1; | 1099 | tname = ctx->pos + 1; |
1090 | } | 1100 | } |
1091 | else | 1101 | else |
1102 | { | ||
1103 | memset (&expiration_time, 0, sizeof(expiration_time)); | ||
1104 | tname = strptime (ctx->pos, | ||
1105 | "%Y%m%d%H%M%S", | ||
1106 | &expiration_time); | ||
1107 | if (NULL == tname) | ||
1092 | { | 1108 | { |
1093 | memset(&expiration_time, 0, sizeof(expiration_time)); | ||
1094 | tname = strptime(ctx->pos, | ||
1095 | "%Y%m%d%H%M%S", | ||
1096 | &expiration_time); | ||
1097 | if (NULL == tname) | ||
1098 | { | ||
1099 | ctx->ret = GNUNET_SYSERR; | ||
1100 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | ||
1101 | _("Failed to parse HELLO message: missing expiration time\n")); | ||
1102 | GNUNET_break(0); | ||
1103 | return GNUNET_SYSERR; | ||
1104 | } | ||
1105 | |||
1106 | expiration_seconds = mktime(&expiration_time); | ||
1107 | if (expiration_seconds == (time_t)-1) | ||
1108 | { | ||
1109 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | ||
1110 | _("Failed to parse HELLO message: invalid expiration time\n")); | ||
1111 | ctx->ret = GNUNET_SYSERR; | ||
1112 | GNUNET_break(0); | ||
1113 | return GNUNET_SYSERR; | ||
1114 | } | ||
1115 | expire.abs_value_us = expiration_seconds * 1000LL * 1000LL; | ||
1116 | } | ||
1117 | if (GNUNET_HELLO_URI_SEP != tname[0]) | ||
1118 | { | ||
1119 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | ||
1120 | _("Failed to parse HELLO message: malformed\n")); | ||
1121 | ctx->ret = GNUNET_SYSERR; | 1109 | ctx->ret = GNUNET_SYSERR; |
1122 | GNUNET_break(0); | 1110 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1111 | _ ( | ||
1112 | "Failed to parse HELLO message: missing expiration time\n")); | ||
1113 | GNUNET_break (0); | ||
1123 | return GNUNET_SYSERR; | 1114 | return GNUNET_SYSERR; |
1124 | } | 1115 | } |
1125 | tname++; | 1116 | |
1126 | address = strchr(tname, | 1117 | expiration_seconds = mktime (&expiration_time); |
1127 | (int)GNUNET_HELLO_URI_SEP); | 1118 | if (expiration_seconds == (time_t) -1) |
1128 | if (NULL == address) | ||
1129 | { | 1119 | { |
1130 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 1120 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1131 | _("Failed to parse HELLO message: missing transport plugin\n")); | 1121 | _ ( |
1122 | "Failed to parse HELLO message: invalid expiration time\n")); | ||
1132 | ctx->ret = GNUNET_SYSERR; | 1123 | ctx->ret = GNUNET_SYSERR; |
1133 | GNUNET_break(0); | 1124 | GNUNET_break (0); |
1134 | return GNUNET_SYSERR; | 1125 | return GNUNET_SYSERR; |
1135 | } | 1126 | } |
1127 | expire.abs_value_us = expiration_seconds * 1000LL * 1000LL; | ||
1128 | } | ||
1129 | if (GNUNET_HELLO_URI_SEP != tname[0]) | ||
1130 | { | ||
1131 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
1132 | _ ("Failed to parse HELLO message: malformed\n")); | ||
1133 | ctx->ret = GNUNET_SYSERR; | ||
1134 | GNUNET_break (0); | ||
1135 | return GNUNET_SYSERR; | ||
1136 | } | ||
1137 | tname++; | ||
1138 | address = strchr (tname, | ||
1139 | (int) GNUNET_HELLO_URI_SEP); | ||
1140 | if (NULL == address) | ||
1141 | { | ||
1142 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
1143 | _ ( | ||
1144 | "Failed to parse HELLO message: missing transport plugin\n")); | ||
1145 | ctx->ret = GNUNET_SYSERR; | ||
1146 | GNUNET_break (0); | ||
1147 | return GNUNET_SYSERR; | ||
1148 | } | ||
1136 | address++; | 1149 | address++; |
1137 | end = strchr(address, (int)GNUNET_HELLO_URI_SEP); | 1150 | end = strchr (address, (int) GNUNET_HELLO_URI_SEP); |
1138 | ctx->pos = end; | 1151 | ctx->pos = end; |
1139 | ctx->counter_total++; | 1152 | ctx->counter_total++; |
1140 | plugin_name = GNUNET_strndup(tname, address - (tname + 1)); | 1153 | plugin_name = GNUNET_strndup (tname, address - (tname + 1)); |
1141 | papi = ctx->plugins_find(plugin_name); | 1154 | papi = ctx->plugins_find (plugin_name); |
1142 | if (NULL == papi) | 1155 | if (NULL == papi) |
1143 | { | 1156 | { |
1144 | /* Not an error - we might just not have the right plugin. | 1157 | /* Not an error - we might just not have the right plugin. |
1145 | * Skip this part, advance to the next one and recurse. | 1158 | * Skip this part, advance to the next one and recurse. |
1146 | * But only if this is not the end of string. | 1159 | * But only if this is not the end of string. |
1147 | */ | 1160 | */ |
1148 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 1161 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1149 | _("Plugin `%s' not found, skipping address\n"), | 1162 | _ ("Plugin `%s' not found, skipping address\n"), |
1150 | plugin_name); | 1163 | plugin_name); |
1151 | GNUNET_free(plugin_name); | 1164 | GNUNET_free (plugin_name); |
1152 | return 0; | 1165 | return 0; |
1153 | } | 1166 | } |
1154 | if (NULL == papi->string_to_address) | 1167 | if (NULL == papi->string_to_address) |
1155 | { | 1168 | { |
1156 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 1169 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1157 | _("Plugin `%s' does not support URIs yet\n"), | 1170 | _ ("Plugin `%s' does not support URIs yet\n"), |
1158 | plugin_name); | 1171 | plugin_name); |
1159 | GNUNET_free(plugin_name); | 1172 | GNUNET_free (plugin_name); |
1160 | GNUNET_break(0); | 1173 | GNUNET_break (0); |
1161 | return 0; | 1174 | return 0; |
1162 | } | 1175 | } |
1163 | uri_address = GNUNET_strndup(address, end - address); | 1176 | uri_address = GNUNET_strndup (address, end - address); |
1164 | if (GNUNET_OK != | 1177 | if (GNUNET_OK != |
1165 | papi->string_to_address(papi->cls, | 1178 | papi->string_to_address (papi->cls, |
1166 | uri_address, | 1179 | uri_address, |
1167 | strlen(uri_address) + 1, | 1180 | strlen (uri_address) + 1, |
1168 | &addr, | 1181 | &addr, |
1169 | &addr_len)) | 1182 | &addr_len)) |
1170 | { | 1183 | { |
1171 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 1184 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1172 | _("Failed to parse `%s' as an address for plugin `%s'\n"), | 1185 | _ ("Failed to parse `%s' as an address for plugin `%s'\n"), |
1173 | uri_address, | 1186 | uri_address, |
1174 | plugin_name); | 1187 | plugin_name); |
1175 | GNUNET_free(plugin_name); | 1188 | GNUNET_free (plugin_name); |
1176 | GNUNET_free(uri_address); | 1189 | GNUNET_free (uri_address); |
1177 | return 0; | 1190 | return 0; |
1178 | } | 1191 | } |
1179 | GNUNET_free(uri_address); | 1192 | GNUNET_free (uri_address); |
1180 | /* address.peer is unset - not used by add_address() */ | 1193 | /* address.peer is unset - not used by add_address() */ |
1181 | haddr.address_length = addr_len; | 1194 | haddr.address_length = addr_len; |
1182 | haddr.address = addr; | 1195 | haddr.address = addr; |
1183 | haddr.transport_name = plugin_name; | 1196 | haddr.transport_name = plugin_name; |
1184 | ret = GNUNET_HELLO_add_address(&haddr, | 1197 | ret = GNUNET_HELLO_add_address (&haddr, |
1185 | expire, | 1198 | expire, |
1186 | buffer, | 1199 | buffer, |
1187 | max); | 1200 | max); |
1188 | ctx->counter_added++; | 1201 | ctx->counter_added++; |
1189 | GNUNET_free(addr); | 1202 | GNUNET_free (addr); |
1190 | GNUNET_free(plugin_name); | 1203 | GNUNET_free (plugin_name); |
1191 | return ret; | 1204 | return ret; |
1192 | } | 1205 | } |
1193 | 1206 | ||
@@ -1202,39 +1215,39 @@ add_address_to_hello(void *cls, | |||
1202 | * @return #GNUNET_OK on success, #GNUNET_SYSERR if the URI was invalid, #GNUNET_NO on other errors | 1215 | * @return #GNUNET_OK on success, #GNUNET_SYSERR if the URI was invalid, #GNUNET_NO on other errors |
1203 | */ | 1216 | */ |
1204 | int | 1217 | int |
1205 | GNUNET_HELLO_parse_uri(const char *uri, | 1218 | GNUNET_HELLO_parse_uri (const char *uri, |
1206 | struct GNUNET_CRYPTO_EddsaPublicKey *pubkey, | 1219 | struct GNUNET_CRYPTO_EddsaPublicKey *pubkey, |
1207 | struct GNUNET_HELLO_Message **hello, | 1220 | struct GNUNET_HELLO_Message **hello, |
1208 | GNUNET_HELLO_TransportPluginsFind plugins_find) | 1221 | GNUNET_HELLO_TransportPluginsFind plugins_find) |
1209 | { | 1222 | { |
1210 | const char *pks; | 1223 | const char *pks; |
1211 | const char *exc; | 1224 | const char *exc; |
1212 | int friend_only; | 1225 | int friend_only; |
1213 | struct GNUNET_HELLO_ParseUriContext ctx; | 1226 | struct GNUNET_HELLO_ParseUriContext ctx; |
1214 | 1227 | ||
1215 | if (0 == strncmp(uri, | 1228 | if (0 == strncmp (uri, |
1216 | GNUNET_HELLO_URI_PREFIX, | 1229 | GNUNET_HELLO_URI_PREFIX, |
1217 | strlen(GNUNET_HELLO_URI_PREFIX))) | 1230 | strlen (GNUNET_HELLO_URI_PREFIX))) |
1218 | { | 1231 | { |
1219 | pks = &uri[strlen(GNUNET_HELLO_URI_PREFIX)]; | 1232 | pks = &uri[strlen (GNUNET_HELLO_URI_PREFIX)]; |
1220 | friend_only = GNUNET_NO; | 1233 | friend_only = GNUNET_NO; |
1221 | } | 1234 | } |
1222 | else if (0 == strncmp(uri, | 1235 | else if (0 == strncmp (uri, |
1223 | GNUNET_FRIEND_HELLO_URI_PREFIX, | 1236 | GNUNET_FRIEND_HELLO_URI_PREFIX, |
1224 | strlen(GNUNET_FRIEND_HELLO_URI_PREFIX))) | 1237 | strlen (GNUNET_FRIEND_HELLO_URI_PREFIX))) |
1225 | { | 1238 | { |
1226 | pks = &uri[strlen(GNUNET_FRIEND_HELLO_URI_PREFIX)]; | 1239 | pks = &uri[strlen (GNUNET_FRIEND_HELLO_URI_PREFIX)]; |
1227 | friend_only = GNUNET_YES; | 1240 | friend_only = GNUNET_YES; |
1228 | } | 1241 | } |
1229 | else | 1242 | else |
1230 | return GNUNET_SYSERR; | 1243 | return GNUNET_SYSERR; |
1231 | exc = strchr(pks, GNUNET_HELLO_URI_SEP); | 1244 | exc = strchr (pks, GNUNET_HELLO_URI_SEP); |
1232 | 1245 | ||
1233 | if (GNUNET_OK != | 1246 | if (GNUNET_OK != |
1234 | GNUNET_STRINGS_string_to_data(pks, | 1247 | GNUNET_STRINGS_string_to_data (pks, |
1235 | (NULL == exc) ? strlen(pks) : (exc - pks), | 1248 | (NULL == exc) ? strlen (pks) : (exc - pks), |
1236 | (unsigned char *)pubkey, | 1249 | (unsigned char *) pubkey, |
1237 | sizeof(*pubkey))) | 1250 | sizeof(*pubkey))) |
1238 | return GNUNET_SYSERR; | 1251 | return GNUNET_SYSERR; |
1239 | 1252 | ||
1240 | ctx.pos = exc; | 1253 | ctx.pos = exc; |
@@ -1242,15 +1255,15 @@ GNUNET_HELLO_parse_uri(const char *uri, | |||
1242 | ctx.counter_total = 0; | 1255 | ctx.counter_total = 0; |
1243 | ctx.counter_added = 0; | 1256 | ctx.counter_added = 0; |
1244 | ctx.plugins_find = plugins_find; | 1257 | ctx.plugins_find = plugins_find; |
1245 | *hello = GNUNET_HELLO_create(pubkey, | 1258 | *hello = GNUNET_HELLO_create (pubkey, |
1246 | &add_address_to_hello, | 1259 | &add_address_to_hello, |
1247 | &ctx, | 1260 | &ctx, |
1248 | friend_only); | 1261 | friend_only); |
1249 | 1262 | ||
1250 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1263 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1251 | "HELLO URI contained %u addresses, added %u addresses\n", | 1264 | "HELLO URI contained %u addresses, added %u addresses\n", |
1252 | ctx.counter_total, | 1265 | ctx.counter_total, |
1253 | ctx.counter_added); | 1266 | ctx.counter_added); |
1254 | 1267 | ||
1255 | return ctx.ret; | 1268 | return ctx.ret; |
1256 | } | 1269 | } |
diff --git a/src/hello/test_friend_hello.c b/src/hello/test_friend_hello.c index 7cbb019c6..1b092c0b8 100644 --- a/src/hello/test_friend_hello.c +++ b/src/hello/test_friend_hello.c | |||
@@ -27,73 +27,73 @@ | |||
27 | 27 | ||
28 | 28 | ||
29 | static ssize_t | 29 | static ssize_t |
30 | my_addr_gen(void *cls, | 30 | my_addr_gen (void *cls, |
31 | size_t max, | 31 | size_t max, |
32 | void *buf) | 32 | void *buf) |
33 | { | 33 | { |
34 | unsigned int *i = cls; | 34 | unsigned int *i = cls; |
35 | size_t ret; | 35 | size_t ret; |
36 | struct GNUNET_HELLO_Address address; | 36 | struct GNUNET_HELLO_Address address; |
37 | 37 | ||
38 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 38 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
39 | "DEBUG: my_addr_gen called with i = %d\n", *i); | 39 | "DEBUG: my_addr_gen called with i = %d\n", *i); |
40 | if (0 == *i) | 40 | if (0 == *i) |
41 | return GNUNET_SYSERR; /* Stop iteration */ | 41 | return GNUNET_SYSERR; /* Stop iteration */ |
42 | memset(&address.peer, 0, sizeof(struct GNUNET_PeerIdentity)); | 42 | memset (&address.peer, 0, sizeof(struct GNUNET_PeerIdentity)); |
43 | address.address = "address_information"; | 43 | address.address = "address_information"; |
44 | address.transport_name = "test"; | 44 | address.transport_name = "test"; |
45 | address.address_length = *i; | 45 | address.address_length = *i; |
46 | ret = | 46 | ret = |
47 | GNUNET_HELLO_add_address(&address, GNUNET_TIME_absolute_get(), buf, | 47 | GNUNET_HELLO_add_address (&address, GNUNET_TIME_absolute_get (), buf, |
48 | max); | 48 | max); |
49 | (*i)--; | 49 | (*i)--; |
50 | return ret; | 50 | return ret; |
51 | } | 51 | } |
52 | 52 | ||
53 | 53 | ||
54 | static int | 54 | static int |
55 | check_addr(void *cls, | 55 | check_addr (void *cls, |
56 | const struct GNUNET_HELLO_Address *address, | 56 | const struct GNUNET_HELLO_Address *address, |
57 | struct GNUNET_TIME_Absolute expiration) | 57 | struct GNUNET_TIME_Absolute expiration) |
58 | { | 58 | { |
59 | unsigned int *i = cls; | 59 | unsigned int *i = cls; |
60 | 60 | ||
61 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 61 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
62 | "DEBUG: check_addr called with i = %d and addrlen = %u\n", | 62 | "DEBUG: check_addr called with i = %d and addrlen = %u\n", |
63 | *i, (unsigned int)address->address_length); | 63 | *i, (unsigned int) address->address_length); |
64 | GNUNET_assert(address->address_length > 0); | 64 | GNUNET_assert (address->address_length > 0); |
65 | GNUNET_assert(*i & (1 << (address->address_length - 1))); | 65 | GNUNET_assert (*i & (1 << (address->address_length - 1))); |
66 | *i -= (1 << (address->address_length - 1)); | 66 | *i -= (1 << (address->address_length - 1)); |
67 | GNUNET_assert(0 == | 67 | GNUNET_assert (0 == |
68 | strncmp("address_information", address->address, | 68 | strncmp ("address_information", address->address, |
69 | address->address_length)); | 69 | address->address_length)); |
70 | GNUNET_assert(0 == strcmp("test", address->transport_name)); | 70 | GNUNET_assert (0 == strcmp ("test", address->transport_name)); |
71 | return GNUNET_OK; | 71 | return GNUNET_OK; |
72 | } | 72 | } |
73 | 73 | ||
74 | 74 | ||
75 | static int | 75 | static int |
76 | remove_some(void *cls, | 76 | remove_some (void *cls, |
77 | const struct GNUNET_HELLO_Address *address, | 77 | const struct GNUNET_HELLO_Address *address, |
78 | struct GNUNET_TIME_Absolute expiration) | 78 | struct GNUNET_TIME_Absolute expiration) |
79 | { | 79 | { |
80 | unsigned int *i = cls; | 80 | unsigned int *i = cls; |
81 | 81 | ||
82 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 82 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
83 | "DEBUG: remove_some called with i = %d and addrlen = %u\n", | 83 | "DEBUG: remove_some called with i = %d and addrlen = %u\n", |
84 | *i, (unsigned int)address->address_length); | 84 | *i, (unsigned int) address->address_length); |
85 | GNUNET_assert(address->address_length > 0); | 85 | GNUNET_assert (address->address_length > 0); |
86 | if (*i & (1 << (address->address_length - 1))) | 86 | if (*i & (1 << (address->address_length - 1))) |
87 | { | 87 | { |
88 | *i -= (1 << (address->address_length - 1)); | 88 | *i -= (1 << (address->address_length - 1)); |
89 | return GNUNET_NO; | 89 | return GNUNET_NO; |
90 | } | 90 | } |
91 | return GNUNET_OK; | 91 | return GNUNET_OK; |
92 | } | 92 | } |
93 | 93 | ||
94 | 94 | ||
95 | int | 95 | int |
96 | main(int argc, char *argv[]) | 96 | main (int argc, char *argv[]) |
97 | { | 97 | { |
98 | struct GNUNET_HELLO_Message *msg1; | 98 | struct GNUNET_HELLO_Message *msg1; |
99 | struct GNUNET_HELLO_Message *msg2; | 99 | struct GNUNET_HELLO_Message *msg2; |
@@ -102,84 +102,84 @@ main(int argc, char *argv[]) | |||
102 | struct GNUNET_TIME_Absolute startup_time; | 102 | struct GNUNET_TIME_Absolute startup_time; |
103 | unsigned int i; | 103 | unsigned int i; |
104 | 104 | ||
105 | GNUNET_log_setup("test-hello", "DEBUG", NULL); | 105 | GNUNET_log_setup ("test-hello", "DEBUG", NULL); |
106 | startup_time = GNUNET_TIME_absolute_get(); | 106 | startup_time = GNUNET_TIME_absolute_get (); |
107 | memset(&publicKey, 42, sizeof(publicKey)); | 107 | memset (&publicKey, 42, sizeof(publicKey)); |
108 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 108 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
109 | "Testing HELLO creation (without addresses)...\n"); | 109 | "Testing HELLO creation (without addresses)...\n"); |
110 | i = 0; | 110 | i = 0; |
111 | msg1 = GNUNET_HELLO_create(&publicKey, &my_addr_gen, &i, GNUNET_YES); | 111 | msg1 = GNUNET_HELLO_create (&publicKey, &my_addr_gen, &i, GNUNET_YES); |
112 | GNUNET_assert(msg1 != NULL); | 112 | GNUNET_assert (msg1 != NULL); |
113 | GNUNET_assert(0 < GNUNET_HELLO_size(msg1)); | 113 | GNUNET_assert (0 < GNUNET_HELLO_size (msg1)); |
114 | 114 | ||
115 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 115 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
116 | "Testing address iteration (empty set)...\n"); | 116 | "Testing address iteration (empty set)...\n"); |
117 | GNUNET_assert(NULL == | 117 | GNUNET_assert (NULL == |
118 | GNUNET_HELLO_iterate_addresses(msg1, GNUNET_NO, &check_addr, | 118 | GNUNET_HELLO_iterate_addresses (msg1, GNUNET_NO, &check_addr, |
119 | &i)); | 119 | &i)); |
120 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 120 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
121 | "Testing HELLO creation (with one address)...\n"); | 121 | "Testing HELLO creation (with one address)...\n"); |
122 | i = 1; | 122 | i = 1; |
123 | msg2 = GNUNET_HELLO_create(&publicKey, &my_addr_gen, &i, GNUNET_YES); | 123 | msg2 = GNUNET_HELLO_create (&publicKey, &my_addr_gen, &i, GNUNET_YES); |
124 | GNUNET_assert(msg2 != NULL); | 124 | GNUNET_assert (msg2 != NULL); |
125 | GNUNET_assert(GNUNET_HELLO_size(msg1) < GNUNET_HELLO_size(msg2)); | 125 | GNUNET_assert (GNUNET_HELLO_size (msg1) < GNUNET_HELLO_size (msg2)); |
126 | 126 | ||
127 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 127 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
128 | "Testing address iteration (one address)...\n"); | 128 | "Testing address iteration (one address)...\n"); |
129 | i = 1; | 129 | i = 1; |
130 | GNUNET_assert(NULL == | 130 | GNUNET_assert (NULL == |
131 | GNUNET_HELLO_iterate_addresses(msg2, GNUNET_NO, &check_addr, | 131 | GNUNET_HELLO_iterate_addresses (msg2, GNUNET_NO, &check_addr, |
132 | &i)); | 132 | &i)); |
133 | GNUNET_assert(i == 0); | 133 | GNUNET_assert (i == 0); |
134 | GNUNET_free(msg1); | 134 | GNUNET_free (msg1); |
135 | 135 | ||
136 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 136 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
137 | "Testing HELLO creation (with two addresses)...\n"); | 137 | "Testing HELLO creation (with two addresses)...\n"); |
138 | i = 2; | 138 | i = 2; |
139 | msg3 = GNUNET_HELLO_create(&publicKey, &my_addr_gen, &i, GNUNET_YES); | 139 | msg3 = GNUNET_HELLO_create (&publicKey, &my_addr_gen, &i, GNUNET_YES); |
140 | GNUNET_assert(msg3 != NULL); | 140 | GNUNET_assert (msg3 != NULL); |
141 | GNUNET_assert(GNUNET_HELLO_size(msg2) < GNUNET_HELLO_size(msg3)); | 141 | GNUNET_assert (GNUNET_HELLO_size (msg2) < GNUNET_HELLO_size (msg3)); |
142 | 142 | ||
143 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 143 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
144 | "Testing address iteration (two addresses)...\n"); | 144 | "Testing address iteration (two addresses)...\n"); |
145 | i = 3; | 145 | i = 3; |
146 | GNUNET_assert(NULL == | 146 | GNUNET_assert (NULL == |
147 | GNUNET_HELLO_iterate_addresses(msg3, GNUNET_NO, &check_addr, | 147 | GNUNET_HELLO_iterate_addresses (msg3, GNUNET_NO, &check_addr, |
148 | &i)); | 148 | &i)); |
149 | GNUNET_assert(i == 0); | 149 | GNUNET_assert (i == 0); |
150 | 150 | ||
151 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 151 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
152 | "Testing HELLO merge...\n"); | 152 | "Testing HELLO merge...\n"); |
153 | msg1 = GNUNET_HELLO_merge(msg2, msg3); | 153 | msg1 = GNUNET_HELLO_merge (msg2, msg3); |
154 | GNUNET_assert(GNUNET_HELLO_size(msg1) == GNUNET_HELLO_size(msg3)); | 154 | GNUNET_assert (GNUNET_HELLO_size (msg1) == GNUNET_HELLO_size (msg3)); |
155 | 155 | ||
156 | i = 3; | 156 | i = 3; |
157 | GNUNET_assert(NULL == | 157 | GNUNET_assert (NULL == |
158 | GNUNET_HELLO_iterate_addresses(msg1, GNUNET_NO, &check_addr, | 158 | GNUNET_HELLO_iterate_addresses (msg1, GNUNET_NO, &check_addr, |
159 | &i)); | 159 | &i)); |
160 | GNUNET_assert(i == 0); | 160 | GNUNET_assert (i == 0); |
161 | GNUNET_free(msg1); | 161 | GNUNET_free (msg1); |
162 | 162 | ||
163 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 163 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
164 | "Testing address iteration to copy HELLO...\n"); | 164 | "Testing address iteration to copy HELLO...\n"); |
165 | i = 2; | 165 | i = 2; |
166 | msg1 = GNUNET_HELLO_iterate_addresses(msg3, GNUNET_YES, &remove_some, &i); | 166 | msg1 = GNUNET_HELLO_iterate_addresses (msg3, GNUNET_YES, &remove_some, &i); |
167 | GNUNET_assert(msg1 != NULL); | 167 | GNUNET_assert (msg1 != NULL); |
168 | GNUNET_assert(i == 0); | 168 | GNUNET_assert (i == 0); |
169 | i = 1; | 169 | i = 1; |
170 | GNUNET_assert(NULL == | 170 | GNUNET_assert (NULL == |
171 | GNUNET_HELLO_iterate_addresses(msg1, GNUNET_NO, &check_addr, | 171 | GNUNET_HELLO_iterate_addresses (msg1, GNUNET_NO, &check_addr, |
172 | &i)); | 172 | &i)); |
173 | GNUNET_assert(i == 0); | 173 | GNUNET_assert (i == 0); |
174 | GNUNET_free(msg1); | 174 | GNUNET_free (msg1); |
175 | 175 | ||
176 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 176 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
177 | "Testing delta address iteration...\n"); | 177 | "Testing delta address iteration...\n"); |
178 | i = 2; | 178 | i = 2; |
179 | GNUNET_HELLO_iterate_new_addresses(msg3, msg2, startup_time, &check_addr, | 179 | GNUNET_HELLO_iterate_new_addresses (msg3, msg2, startup_time, &check_addr, |
180 | &i); | 180 | &i); |
181 | GNUNET_assert(i == 0); | 181 | GNUNET_assert (i == 0); |
182 | GNUNET_free(msg2); | 182 | GNUNET_free (msg2); |
183 | GNUNET_free(msg3); | 183 | GNUNET_free (msg3); |
184 | return 0; /* testcase passed */ | 184 | return 0; /* testcase passed */ |
185 | } | 185 | } |
diff --git a/src/hello/test_hello.c b/src/hello/test_hello.c index f3134a7ad..1580dcc55 100644 --- a/src/hello/test_hello.c +++ b/src/hello/test_hello.c | |||
@@ -35,27 +35,27 @@ | |||
35 | * @return | 35 | * @return |
36 | */ | 36 | */ |
37 | static ssize_t | 37 | static ssize_t |
38 | my_addr_gen(void *cls, | 38 | my_addr_gen (void *cls, |
39 | size_t max, | 39 | size_t max, |
40 | void *buf) | 40 | void *buf) |
41 | { | 41 | { |
42 | unsigned int *i = cls; | 42 | unsigned int *i = cls; |
43 | size_t ret; | 43 | size_t ret; |
44 | struct GNUNET_HELLO_Address address; | 44 | struct GNUNET_HELLO_Address address; |
45 | 45 | ||
46 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 46 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
47 | "DEBUG: my_addr_gen called with i = %d\n", | 47 | "DEBUG: my_addr_gen called with i = %d\n", |
48 | *i); | 48 | *i); |
49 | if (0 == *i) | 49 | if (0 == *i) |
50 | return GNUNET_SYSERR; | 50 | return GNUNET_SYSERR; |
51 | memset(&address.peer, 0, sizeof(struct GNUNET_PeerIdentity)); | 51 | memset (&address.peer, 0, sizeof(struct GNUNET_PeerIdentity)); |
52 | address.address = "address_information"; | 52 | address.address = "address_information"; |
53 | address.transport_name = "test"; | 53 | address.transport_name = "test"; |
54 | address.address_length = *i; | 54 | address.address_length = *i; |
55 | ret = GNUNET_HELLO_add_address(&address, | 55 | ret = GNUNET_HELLO_add_address (&address, |
56 | GNUNET_TIME_absolute_get(), | 56 | GNUNET_TIME_absolute_get (), |
57 | buf, | 57 | buf, |
58 | max); | 58 | max); |
59 | (*i)--; | 59 | (*i)--; |
60 | return ret; | 60 | return ret; |
61 | } | 61 | } |
@@ -70,25 +70,25 @@ my_addr_gen(void *cls, | |||
70 | * @return | 70 | * @return |
71 | */ | 71 | */ |
72 | static int | 72 | static int |
73 | check_addr(void *cls, | 73 | check_addr (void *cls, |
74 | const struct GNUNET_HELLO_Address *address, | 74 | const struct GNUNET_HELLO_Address *address, |
75 | struct GNUNET_TIME_Absolute expiration) | 75 | struct GNUNET_TIME_Absolute expiration) |
76 | { | 76 | { |
77 | unsigned int *i = cls; | 77 | unsigned int *i = cls; |
78 | 78 | ||
79 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 79 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
80 | "DEBUG: check_addr called with i = %d and addrlen = %u\n", | 80 | "DEBUG: check_addr called with i = %d and addrlen = %u\n", |
81 | *i, | 81 | *i, |
82 | (unsigned int)address->address_length); | 82 | (unsigned int) address->address_length); |
83 | GNUNET_assert(address->address_length > 0); | 83 | GNUNET_assert (address->address_length > 0); |
84 | GNUNET_assert(*i & (1 << (address->address_length - 1))); | 84 | GNUNET_assert (*i & (1 << (address->address_length - 1))); |
85 | *i -= (1 << (address->address_length - 1)); | 85 | *i -= (1 << (address->address_length - 1)); |
86 | GNUNET_assert(0 == | 86 | GNUNET_assert (0 == |
87 | strncmp("address_information", | 87 | strncmp ("address_information", |
88 | address->address, | 88 | address->address, |
89 | address->address_length)); | 89 | address->address_length)); |
90 | GNUNET_assert(0 == strcmp("test", | 90 | GNUNET_assert (0 == strcmp ("test", |
91 | address->transport_name)); | 91 | address->transport_name)); |
92 | return GNUNET_OK; | 92 | return GNUNET_OK; |
93 | } | 93 | } |
94 | 94 | ||
@@ -102,29 +102,29 @@ check_addr(void *cls, | |||
102 | * @return | 102 | * @return |
103 | */ | 103 | */ |
104 | static int | 104 | static int |
105 | remove_some(void *cls, | 105 | remove_some (void *cls, |
106 | const struct GNUNET_HELLO_Address *address, | 106 | const struct GNUNET_HELLO_Address *address, |
107 | struct GNUNET_TIME_Absolute expiration) | 107 | struct GNUNET_TIME_Absolute expiration) |
108 | { | 108 | { |
109 | unsigned int *i = cls; | 109 | unsigned int *i = cls; |
110 | 110 | ||
111 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 111 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
112 | "DEBUG: remove_some called with i = %d and addrlen = %u\n", | 112 | "DEBUG: remove_some called with i = %d and addrlen = %u\n", |
113 | *i, | 113 | *i, |
114 | (unsigned int)address->address_length); | 114 | (unsigned int) address->address_length); |
115 | GNUNET_assert(address->address_length > 0); | 115 | GNUNET_assert (address->address_length > 0); |
116 | if (*i & (1 << (address->address_length - 1))) | 116 | if (*i & (1 << (address->address_length - 1))) |
117 | { | 117 | { |
118 | *i -= (1 << (address->address_length - 1)); | 118 | *i -= (1 << (address->address_length - 1)); |
119 | return GNUNET_NO; | 119 | return GNUNET_NO; |
120 | } | 120 | } |
121 | return GNUNET_OK; | 121 | return GNUNET_OK; |
122 | } | 122 | } |
123 | 123 | ||
124 | 124 | ||
125 | int | 125 | int |
126 | main(int argc, | 126 | main (int argc, |
127 | char *argv[]) | 127 | char *argv[]) |
128 | { | 128 | { |
129 | struct GNUNET_HELLO_Message *msg1; | 129 | struct GNUNET_HELLO_Message *msg1; |
130 | struct GNUNET_HELLO_Message *msg2; | 130 | struct GNUNET_HELLO_Message *msg2; |
@@ -134,118 +134,118 @@ main(int argc, | |||
134 | struct GNUNET_TIME_Absolute startup_time; | 134 | struct GNUNET_TIME_Absolute startup_time; |
135 | unsigned int i; | 135 | unsigned int i; |
136 | 136 | ||
137 | GNUNET_log_setup("test-hello", | 137 | GNUNET_log_setup ("test-hello", |
138 | "DEBUG", | 138 | "DEBUG", |
139 | NULL); | 139 | NULL); |
140 | startup_time = GNUNET_TIME_absolute_get(); | 140 | startup_time = GNUNET_TIME_absolute_get (); |
141 | memset(&publicKey, 42, sizeof(publicKey)); | 141 | memset (&publicKey, 42, sizeof(publicKey)); |
142 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 142 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
143 | "Testing HELLO creation (without addresses)...\n"); | 143 | "Testing HELLO creation (without addresses)...\n"); |
144 | i = 0; | 144 | i = 0; |
145 | msg1 = GNUNET_HELLO_create(&publicKey, | 145 | msg1 = GNUNET_HELLO_create (&publicKey, |
146 | &my_addr_gen, | 146 | &my_addr_gen, |
147 | &i, | 147 | &i, |
148 | GNUNET_NO); | 148 | GNUNET_NO); |
149 | GNUNET_assert(msg1 != NULL); | 149 | GNUNET_assert (msg1 != NULL); |
150 | GNUNET_assert(0 < GNUNET_HELLO_size(msg1)); | 150 | GNUNET_assert (0 < GNUNET_HELLO_size (msg1)); |
151 | 151 | ||
152 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 152 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
153 | "Testing address iteration (empty set)...\n"); | 153 | "Testing address iteration (empty set)...\n"); |
154 | GNUNET_assert(NULL == | 154 | GNUNET_assert (NULL == |
155 | GNUNET_HELLO_iterate_addresses(msg1, | 155 | GNUNET_HELLO_iterate_addresses (msg1, |
156 | GNUNET_NO, | 156 | GNUNET_NO, |
157 | &check_addr, | 157 | &check_addr, |
158 | &i)); | 158 | &i)); |
159 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 159 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
160 | "Testing HELLO creation (with one address)...\n"); | 160 | "Testing HELLO creation (with one address)...\n"); |
161 | i = 1; | 161 | i = 1; |
162 | msg2 = GNUNET_HELLO_create(&publicKey, | 162 | msg2 = GNUNET_HELLO_create (&publicKey, |
163 | &my_addr_gen, | 163 | &my_addr_gen, |
164 | &i, | 164 | &i, |
165 | GNUNET_NO); | 165 | GNUNET_NO); |
166 | GNUNET_assert(msg2 != NULL); | 166 | GNUNET_assert (msg2 != NULL); |
167 | GNUNET_assert(GNUNET_HELLO_size(msg1) < GNUNET_HELLO_size(msg2)); | 167 | GNUNET_assert (GNUNET_HELLO_size (msg1) < GNUNET_HELLO_size (msg2)); |
168 | 168 | ||
169 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 169 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
170 | "Testing address iteration (one address)...\n"); | 170 | "Testing address iteration (one address)...\n"); |
171 | i = 1; | 171 | i = 1; |
172 | GNUNET_assert(NULL == | 172 | GNUNET_assert (NULL == |
173 | GNUNET_HELLO_iterate_addresses(msg2, | 173 | GNUNET_HELLO_iterate_addresses (msg2, |
174 | GNUNET_NO, | 174 | GNUNET_NO, |
175 | &check_addr, | 175 | &check_addr, |
176 | &i)); | 176 | &i)); |
177 | GNUNET_assert(i == 0); | 177 | GNUNET_assert (i == 0); |
178 | 178 | ||
179 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 179 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
180 | "Testing get_key from HELLO...\n"); | 180 | "Testing get_key from HELLO...\n"); |
181 | GNUNET_assert(GNUNET_OK == GNUNET_HELLO_get_id(msg2, &pid)); | 181 | GNUNET_assert (GNUNET_OK == GNUNET_HELLO_get_id (msg2, &pid)); |
182 | GNUNET_assert(0 == GNUNET_memcmp(&publicKey, | 182 | GNUNET_assert (0 == GNUNET_memcmp (&publicKey, |
183 | &pid.public_key)); | 183 | &pid.public_key)); |
184 | GNUNET_free(msg1); | 184 | GNUNET_free (msg1); |
185 | 185 | ||
186 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 186 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
187 | "Testing HELLO creation (with two addresses)...\n"); | 187 | "Testing HELLO creation (with two addresses)...\n"); |
188 | i = 2; | 188 | i = 2; |
189 | msg3 = GNUNET_HELLO_create(&publicKey, | 189 | msg3 = GNUNET_HELLO_create (&publicKey, |
190 | &my_addr_gen, | 190 | &my_addr_gen, |
191 | &i, | 191 | &i, |
192 | GNUNET_NO); | 192 | GNUNET_NO); |
193 | GNUNET_assert(msg3 != NULL); | 193 | GNUNET_assert (msg3 != NULL); |
194 | GNUNET_assert(GNUNET_HELLO_size(msg2) < GNUNET_HELLO_size(msg3)); | 194 | GNUNET_assert (GNUNET_HELLO_size (msg2) < GNUNET_HELLO_size (msg3)); |
195 | 195 | ||
196 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 196 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
197 | "Testing address iteration (two addresses)...\n"); | 197 | "Testing address iteration (two addresses)...\n"); |
198 | i = 3; | 198 | i = 3; |
199 | GNUNET_assert(NULL == | 199 | GNUNET_assert (NULL == |
200 | GNUNET_HELLO_iterate_addresses(msg3, | 200 | GNUNET_HELLO_iterate_addresses (msg3, |
201 | GNUNET_NO, | 201 | GNUNET_NO, |
202 | &check_addr, | 202 | &check_addr, |
203 | &i)); | 203 | &i)); |
204 | GNUNET_assert(i == 0); | 204 | GNUNET_assert (i == 0); |
205 | 205 | ||
206 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 206 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
207 | "Testing HELLO merge...\n"); | 207 | "Testing HELLO merge...\n"); |
208 | msg1 = GNUNET_HELLO_merge(msg2, msg3); | 208 | msg1 = GNUNET_HELLO_merge (msg2, msg3); |
209 | GNUNET_assert(GNUNET_HELLO_size(msg1) == GNUNET_HELLO_size(msg3)); | 209 | GNUNET_assert (GNUNET_HELLO_size (msg1) == GNUNET_HELLO_size (msg3)); |
210 | 210 | ||
211 | i = 3; | 211 | i = 3; |
212 | GNUNET_assert(NULL == | 212 | GNUNET_assert (NULL == |
213 | GNUNET_HELLO_iterate_addresses(msg1, | 213 | GNUNET_HELLO_iterate_addresses (msg1, |
214 | GNUNET_NO, | 214 | GNUNET_NO, |
215 | &check_addr, | 215 | &check_addr, |
216 | &i)); | 216 | &i)); |
217 | GNUNET_assert(i == 0); | 217 | GNUNET_assert (i == 0); |
218 | GNUNET_free(msg1); | 218 | GNUNET_free (msg1); |
219 | 219 | ||
220 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 220 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
221 | "Testing address iteration to copy HELLO...\n"); | 221 | "Testing address iteration to copy HELLO...\n"); |
222 | i = 2; | 222 | i = 2; |
223 | msg1 = GNUNET_HELLO_iterate_addresses(msg3, | 223 | msg1 = GNUNET_HELLO_iterate_addresses (msg3, |
224 | GNUNET_YES, | 224 | GNUNET_YES, |
225 | &remove_some, | 225 | &remove_some, |
226 | &i); | 226 | &i); |
227 | GNUNET_assert(msg1 != NULL); | 227 | GNUNET_assert (msg1 != NULL); |
228 | GNUNET_assert(i == 0); | 228 | GNUNET_assert (i == 0); |
229 | i = 1; | 229 | i = 1; |
230 | GNUNET_assert(NULL == | 230 | GNUNET_assert (NULL == |
231 | GNUNET_HELLO_iterate_addresses(msg1, | 231 | GNUNET_HELLO_iterate_addresses (msg1, |
232 | GNUNET_NO, | 232 | GNUNET_NO, |
233 | &check_addr, | 233 | &check_addr, |
234 | &i)); | 234 | &i)); |
235 | GNUNET_assert(i == 0); | 235 | GNUNET_assert (i == 0); |
236 | GNUNET_free(msg1); | 236 | GNUNET_free (msg1); |
237 | 237 | ||
238 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 238 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
239 | "Testing delta address iteration...\n"); | 239 | "Testing delta address iteration...\n"); |
240 | i = 2; | 240 | i = 2; |
241 | GNUNET_HELLO_iterate_new_addresses(msg3, | 241 | GNUNET_HELLO_iterate_new_addresses (msg3, |
242 | msg2, | 242 | msg2, |
243 | startup_time, | 243 | startup_time, |
244 | &check_addr, | 244 | &check_addr, |
245 | &i); | 245 | &i); |
246 | GNUNET_assert(i == 0); | 246 | GNUNET_assert (i == 0); |
247 | GNUNET_free(msg2); | 247 | GNUNET_free (msg2); |
248 | GNUNET_free(msg3); | 248 | GNUNET_free (msg3); |
249 | return 0; /* testcase passed */ | 249 | return 0; /* testcase passed */ |
250 | } | 250 | } |
251 | 251 | ||