1 files changed, 131 insertions, 132 deletions
diff --git a/src/topology/friends.c b/src/topology/friends.c
index f23724444..81c7d45e9 100644
--- a/src/topology/friends.c
+++ b/src/topology/friends.c
@@ -16,7 +16,7 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
     SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
 * @file topology/friends.c
@@ -36,9 +36,9 @@
 * @return #GNUNET_OK on success, #GNUNET_SYSERR on parsing errors
 */
 int
-GNUNET_FRIENDS_parse (const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_FRIENDS_parse(const struct GNUNET_CONFIGURATION_Handle *cfg,
-                      GNUNET_FRIENDS_Callback cb,
+                     GNUNET_FRIENDS_Callback cb,
-                      void *cb_cls)
+                     void *cb_cls)
 {
  char *fn;
  char *data;
@@ -49,94 +49,94 @@ GNUNET_FRIENDS_parse (const struct GNUNET_CONFIGURATION_Handle *cfg,
  ssize_t ssize;
  if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename (cfg,
+      GNUNET_CONFIGURATION_get_value_filename(cfg,
-                                               "TOPOLOGY",
+                                              "TOPOLOGY",
-                                               "FRIENDS",
+                                              "FRIENDS",
-                                               &fn))
+                                              &fn))
-  {
+    {
-    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
-                               "topology",
+                                "topology",
-                               "FRIENDS");
+                                "FRIENDS");
-    return GNUNET_SYSERR;
+      return GNUNET_SYSERR;
-  }
+    }
  if (GNUNET_SYSERR ==
-      GNUNET_DISK_directory_create_for_file (fn))
+      GNUNET_DISK_directory_create_for_file(fn))
-  {
+    {
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING,
-                              "mkdir",
+                               "mkdir",
-                              fn);
+                               fn);
-    GNUNET_free (fn);
+      GNUNET_free(fn);
-    return GNUNET_SYSERR;
+      return GNUNET_SYSERR;
-  }
+    }
-  if ( (GNUNET_OK !=
+  if ((GNUNET_OK !=
-        GNUNET_DISK_file_test (fn)) &&
+       GNUNET_DISK_file_test(fn)) &&
-       (GNUNET_OK !=
+      (GNUNET_OK !=
-        GNUNET_DISK_fn_write (fn,
+       GNUNET_DISK_fn_write(fn,
-                              NULL,
+                            NULL,
-                              0,
+                            0,
-                              GNUNET_DISK_PERM_USER_READ |
+                            GNUNET_DISK_PERM_USER_READ |
-                              GNUNET_DISK_PERM_USER_WRITE |
+                            GNUNET_DISK_PERM_USER_WRITE |
-                              GNUNET_DISK_OPEN_CREATE)) )
+                            GNUNET_DISK_OPEN_CREATE)))
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING,
-                              "write",
+                             "write",
-                              fn);
+                             fn);
-  if ( (GNUNET_OK !=
+  if ((GNUNET_OK !=
-        GNUNET_DISK_file_size (fn,
+       GNUNET_DISK_file_size(fn,
-                               &fsize,
+                             &fsize,
-                               GNUNET_NO,
+                             GNUNET_NO,
-                               GNUNET_YES)) ||
+                             GNUNET_YES)) ||
-       (0 == fsize) )
+      (0 == fsize))
-  {
+    {
-    GNUNET_free (fn);
+      GNUNET_free(fn);
-    return GNUNET_OK;
+      return GNUNET_OK;
-  }
+    }
-  data = GNUNET_malloc_large (fsize);
+  data = GNUNET_malloc_large(fsize);
  if (NULL == data)
-  {
+    {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "malloc");
+      GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "malloc");
-    GNUNET_free (fn);
+      GNUNET_free(fn);
-    return GNUNET_SYSERR;
+      return GNUNET_SYSERR;
-  }
+    }
-  ssize = GNUNET_DISK_fn_read (fn,
+  ssize = GNUNET_DISK_fn_read(fn,
-                               data,
+                              data,
-                               fsize);
+                              fsize);
-  if ( (ssize < 0) ||
+  if ((ssize < 0) ||
-       (fsize != (uint64_t) ssize) )
+      (fsize != (uint64_t)ssize))
-  {
+    {
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
+      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR,
-                              "read",
+                               "read",
-                              "fn");
+                               "fn");
-    GNUNET_free (fn);
+      GNUNET_free(fn);
-    GNUNET_free (data);
+      GNUNET_free(data);
-    return GNUNET_SYSERR;
+      return GNUNET_SYSERR;
-  }
+    }
  start = 0;
  pos = 0;
  while (pos < fsize)
-  {
-    while ( (pos < fsize) &&
-            (! isspace ((unsigned char) data[pos])) )
-      pos++;
-    if (GNUNET_OK !=
-        GNUNET_CRYPTO_eddsa_public_key_from_string (&data[start],
-                                                    pos - start,
-                                                    &pid.public_key))
    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+      while ((pos < fsize) &&
-                  _("Syntax error in FRIENDS file at offset %llu, skipping bytes `%.*s'.\n"),
+             (!isspace((unsigned char)data[pos])))
-                  (unsigned long long) pos,
+        pos++;
-                  (int) (pos - start),
+      if (GNUNET_OK !=
-                  &data[start]);
+          GNUNET_CRYPTO_eddsa_public_key_from_string(&data[start],
+                                                     pos - start,
+                                                     &pid.public_key))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                     _("Syntax error in FRIENDS file at offset %llu, skipping bytes `%.*s'.\n"),
+                     (unsigned long long)pos,
+                     (int)(pos - start),
+                     &data[start]);
+          pos++;
+          start = pos;
+          continue;
+        }
      pos++;
      start = pos;
-      continue;
+      cb(cb_cls, &pid);
    }
-    pos++;
+  GNUNET_free(data);
-    start = pos;
+  GNUNET_free(fn);
-    cb (cb_cls, &pid);
-  }
-  GNUNET_free (data);
-  GNUNET_free (fn);
  return GNUNET_OK;
 }
@@ -144,8 +144,7 @@ GNUNET_FRIENDS_parse (const struct GNUNET_CONFIGURATION_Handle *cfg,
 /**
 * Handle for writing a friends file.
 */
-struct GNUNET_FRIENDS_Writer
+struct GNUNET_FRIENDS_Writer {
-{
  /**
   * Handle to the file.
   */
@@ -161,41 +160,41 @@ struct GNUNET_FRIENDS_Writer
 * @return NULL on error
 */
 struct GNUNET_FRIENDS_Writer *
-GNUNET_FRIENDS_write_start (const struct GNUNET_CONFIGURATION_Handle *cfg)
+GNUNET_FRIENDS_write_start(const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
  struct GNUNET_FRIENDS_Writer *w;
  char *fn;
  if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename (cfg, "TOPOLOGY", "FRIENDS", &fn))
+      GNUNET_CONFIGURATION_get_value_filename(cfg, "TOPOLOGY", "FRIENDS", &fn))
-  {
+    {
-    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
-                               "topology", "FRIENDS");
+                                "topology", "FRIENDS");
-    return NULL;
+      return NULL;
-  }
+    }
  if (GNUNET_OK !=
-      GNUNET_DISK_directory_create_for_file (fn))
+      GNUNET_DISK_directory_create_for_file(fn))
-  {
+    {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                _("Directory for file `%s' does not seem to be writable.\n"),
+                 _("Directory for file `%s' does not seem to be writable.\n"),
-                fn);
+                 fn);
-    GNUNET_free (fn);
+      GNUNET_free(fn);
-    return NULL;
+      return NULL;
-  }
+    }
-  if (GNUNET_OK == GNUNET_DISK_file_test (fn))
+  if (GNUNET_OK == GNUNET_DISK_file_test(fn))
-    GNUNET_DISK_file_backup (fn);
+    GNUNET_DISK_file_backup(fn);
-  w = GNUNET_new (struct GNUNET_FRIENDS_Writer);
+  w = GNUNET_new(struct GNUNET_FRIENDS_Writer);
-  w->fh = GNUNET_DISK_file_open  (fn,
+  w->fh = GNUNET_DISK_file_open(fn,
-                                  GNUNET_DISK_OPEN_CREATE |
+                                GNUNET_DISK_OPEN_CREATE |
-                                  GNUNET_DISK_OPEN_WRITE |
+                                GNUNET_DISK_OPEN_WRITE |
-                                  GNUNET_DISK_OPEN_FAILIFEXISTS,
+                                GNUNET_DISK_OPEN_FAILIFEXISTS,
-                                  GNUNET_DISK_PERM_USER_READ);
+                                GNUNET_DISK_PERM_USER_READ);
-  GNUNET_free (fn);
+  GNUNET_free(fn);
  if (NULL == w->fh)
-  {
+    {
-    GNUNET_free (w);
+      GNUNET_free(w);
-    return NULL;
+      return NULL;
-  }
+    }
  return w;
 }
@@ -207,12 +206,12 @@ GNUNET_FRIENDS_write_start (const struct GNUNET_CONFIGURATION_Handle *cfg)
 * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
 */
 int
-GNUNET_FRIENDS_write_stop (struct GNUNET_FRIENDS_Writer *w)
+GNUNET_FRIENDS_write_stop(struct GNUNET_FRIENDS_Writer *w)
 {
  int ret;
-  ret = GNUNET_DISK_file_close (w->fh);
+  ret = GNUNET_DISK_file_close(w->fh);
-  GNUNET_free (w);
+  GNUNET_free(w);
  return ret;
 }
@@ -225,28 +224,28 @@ GNUNET_FRIENDS_write_stop (struct GNUNET_FRIENDS_Writer *w)
 * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
 */
 int
-GNUNET_FRIENDS_write (struct GNUNET_FRIENDS_Writer *w,
+GNUNET_FRIENDS_write(struct GNUNET_FRIENDS_Writer *w,
-                      const struct GNUNET_PeerIdentity *friend_id)
+                     const struct GNUNET_PeerIdentity *friend_id)
 {
  char *buf;
  char *ret;
  size_t slen;
-  ret = GNUNET_CRYPTO_eddsa_public_key_to_string (&friend_id->public_key);
+  ret = GNUNET_CRYPTO_eddsa_public_key_to_string(&friend_id->public_key);
-  GNUNET_asprintf (&buf,
+  GNUNET_asprintf(&buf,
-                   "%s\n",
+                  "%s\n",
-                   ret);
+                  ret);
-  GNUNET_free (ret);
+  GNUNET_free(ret);
-  slen = strlen (buf);
+  slen = strlen(buf);
  if (slen !=
-      GNUNET_DISK_file_write (w->fh,
+      GNUNET_DISK_file_write(w->fh,
-                              buf,
+                             buf,
-                              slen))
+                             slen))
-  {
+    {
-    GNUNET_free (buf);
+      GNUNET_free(buf);
-    return GNUNET_SYSERR;
+      return GNUNET_SYSERR;
-  }
+    }
-  GNUNET_free (buf);
+  GNUNET_free(buf);
  return GNUNET_OK;
 }

diff --git a/src/topology/friends.c b/src/topology/friends.c index f23724444..81c7d45e9 100644 --- a/src/topology/friends.c +++ b/src/topology/friends.c
@@ -16,7 +16,7 @@
16	along with this program. If not, see <http://www.gnu.org/licenses/>.	16	along with this program. If not, see <http://www.gnu.org/licenses/>.
17		17
18	SPDX-License-Identifier: AGPL3.0-or-later	18	SPDX-License-Identifier: AGPL3.0-or-later
19	*/	19	*/
20		20
21	/**	21	/**
22	* @file topology/friends.c	22	* @file topology/friends.c
@@ -36,9 +36,9 @@
36	* @return #GNUNET_OK on success, #GNUNET_SYSERR on parsing errors	36	* @return #GNUNET_OK on success, #GNUNET_SYSERR on parsing errors
37	*/	37	*/
38	int	38	int
39	GNUNET_FRIENDS_parse (const struct GNUNET_CONFIGURATION_Handle *cfg,	39	GNUNET_FRIENDS_parse(const struct GNUNET_CONFIGURATION_Handle *cfg,
40	GNUNET_FRIENDS_Callback cb,	40	GNUNET_FRIENDS_Callback cb,
41	void *cb_cls)	41	void *cb_cls)
42	{	42	{
43	char *fn;	43	char *fn;
44	char *data;	44	char *data;
@@ -49,94 +49,94 @@ GNUNET_FRIENDS_parse (const struct GNUNET_CONFIGURATION_Handle *cfg,
49	ssize_t ssize;	49	ssize_t ssize;
50		50
51	if (GNUNET_OK !=	51	if (GNUNET_OK !=
52	GNUNET_CONFIGURATION_get_value_filename (cfg,	52	GNUNET_CONFIGURATION_get_value_filename(cfg,
53	"TOPOLOGY",	53	"TOPOLOGY",
54	"FRIENDS",	54	"FRIENDS",
55	&fn))	55	&fn))
56	{	56	{
57	GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,	57	GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
58	"topology",	58	"topology",
59	"FRIENDS");	59	"FRIENDS");
60	return GNUNET_SYSERR;	60	return GNUNET_SYSERR;
61	}	61	}
62	if (GNUNET_SYSERR ==	62	if (GNUNET_SYSERR ==
63	GNUNET_DISK_directory_create_for_file (fn))	63	GNUNET_DISK_directory_create_for_file(fn))
64	{	64	{
65	GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,	65	GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING,
66	"mkdir",	66	"mkdir",
67	fn);	67	fn);
68	GNUNET_free (fn);	68	GNUNET_free(fn);
69	return GNUNET_SYSERR;	69	return GNUNET_SYSERR;
70	}	70	}
71	if ( (GNUNET_OK !=	71	if ((GNUNET_OK !=
72	GNUNET_DISK_file_test (fn)) &&	72	GNUNET_DISK_file_test(fn)) &&
73	(GNUNET_OK !=	73	(GNUNET_OK !=
74	GNUNET_DISK_fn_write (fn,	74	GNUNET_DISK_fn_write(fn,
75	NULL,	75	NULL,
76	0,	76	0,
77	GNUNET_DISK_PERM_USER_READ \|	77	GNUNET_DISK_PERM_USER_READ \|
78	GNUNET_DISK_PERM_USER_WRITE \|	78	GNUNET_DISK_PERM_USER_WRITE \|
79	GNUNET_DISK_OPEN_CREATE)) )	79	GNUNET_DISK_OPEN_CREATE)))
80	GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,	80	GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING,
81	"write",	81	"write",
82	fn);	82	fn);
83	if ( (GNUNET_OK !=	83	if ((GNUNET_OK !=
84	GNUNET_DISK_file_size (fn,	84	GNUNET_DISK_file_size(fn,
85	&fsize,	85	&fsize,
86	GNUNET_NO,	86	GNUNET_NO,
87	GNUNET_YES)) \|\|	87	GNUNET_YES)) \|\|
88	(0 == fsize) )	88	(0 == fsize))
89	{	89	{
90	GNUNET_free (fn);	90	GNUNET_free(fn);
91	return GNUNET_OK;	91	return GNUNET_OK;
92	}	92	}
93	data = GNUNET_malloc_large (fsize);	93	data = GNUNET_malloc_large(fsize);
94	if (NULL == data)	94	if (NULL == data)
95	{	95	{
96	GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "malloc");	96	GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "malloc");
97	GNUNET_free (fn);	97	GNUNET_free(fn);
98	return GNUNET_SYSERR;	98	return GNUNET_SYSERR;
99	}	99	}
100	ssize = GNUNET_DISK_fn_read (fn,	100	ssize = GNUNET_DISK_fn_read(fn,
101	data,	101	data,
102	fsize);	102	fsize);
103	if ( (ssize < 0) \|\|	103	if ((ssize < 0) \|\|
104	(fsize != (uint64_t) ssize) )	104	(fsize != (uint64_t)ssize))
105	{	105	{
106	GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,	106	GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR,
107	"read",	107	"read",
108	"fn");	108	"fn");
109	GNUNET_free (fn);	109	GNUNET_free(fn);
110	GNUNET_free (data);	110	GNUNET_free(data);
111	return GNUNET_SYSERR;	111	return GNUNET_SYSERR;
112	}	112	}
113	start = 0;	113	start = 0;
114	pos = 0;	114	pos = 0;
115	while (pos < fsize)	115	while (pos < fsize)
116	{
117	while ( (pos < fsize) &&
118	(! isspace ((unsigned char) data[pos])) )
119	pos++;
120	if (GNUNET_OK !=
121	GNUNET_CRYPTO_eddsa_public_key_from_string (&data[start],
122	pos - start,
123	&pid.public_key))
124	{	116	{
125	GNUNET_log (GNUNET_ERROR_TYPE_WARNING,	117	while ((pos < fsize) &&
126	_("Syntax error in FRIENDS file at offset %llu, skipping bytes `%.*s'.\n"),	118	(!isspace((unsigned char)data[pos])))
127	(unsigned long long) pos,	119	pos++;
128	(int) (pos - start),	120	if (GNUNET_OK !=
129	&data[start]);	121	GNUNET_CRYPTO_eddsa_public_key_from_string(&data[start],
		122	pos - start,
		123	&pid.public_key))
		124	{
		125	GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
		126	_("Syntax error in FRIENDS file at offset %llu, skipping bytes `%.*s'.\n"),
		127	(unsigned long long)pos,
		128	(int)(pos - start),
		129	&data[start]);
		130	pos++;
		131	start = pos;
		132	continue;
		133	}
130	pos++;	134	pos++;
131	start = pos;	135	start = pos;
132	continue;	136	cb(cb_cls, &pid);
133	}	137	}
134	pos++;	138	GNUNET_free(data);
135	start = pos;	139	GNUNET_free(fn);
136	cb (cb_cls, &pid);
137	}
138	GNUNET_free (data);
139	GNUNET_free (fn);
140	return GNUNET_OK;	140	return GNUNET_OK;
141	}	141	}
142		142
@@ -144,8 +144,7 @@ GNUNET_FRIENDS_parse (const struct GNUNET_CONFIGURATION_Handle *cfg,
144	/**	144	/**
145	* Handle for writing a friends file.	145	* Handle for writing a friends file.
146	*/	146	*/
147	struct GNUNET_FRIENDS_Writer	147	struct GNUNET_FRIENDS_Writer {
148	{
149	/**	148	/**
150	* Handle to the file.	149	* Handle to the file.
151	*/	150	*/
@@ -161,41 +160,41 @@ struct GNUNET_FRIENDS_Writer
161	* @return NULL on error	160	* @return NULL on error
162	*/	161	*/
163	struct GNUNET_FRIENDS_Writer *	162	struct GNUNET_FRIENDS_Writer *
164	GNUNET_FRIENDS_write_start (const struct GNUNET_CONFIGURATION_Handle *cfg)	163	GNUNET_FRIENDS_write_start(const struct GNUNET_CONFIGURATION_Handle *cfg)
165	{	164	{
166	struct GNUNET_FRIENDS_Writer *w;	165	struct GNUNET_FRIENDS_Writer *w;
167	char *fn;	166	char *fn;
168		167
169	if (GNUNET_OK !=	168	if (GNUNET_OK !=
170	GNUNET_CONFIGURATION_get_value_filename (cfg, "TOPOLOGY", "FRIENDS", &fn))	169	GNUNET_CONFIGURATION_get_value_filename(cfg, "TOPOLOGY", "FRIENDS", &fn))
171	{	170	{
172	GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,	171	GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
173	"topology", "FRIENDS");	172	"topology", "FRIENDS");
174	return NULL;	173	return NULL;
175	}	174	}
176	if (GNUNET_OK !=	175	if (GNUNET_OK !=
177	GNUNET_DISK_directory_create_for_file (fn))	176	GNUNET_DISK_directory_create_for_file(fn))
178	{	177	{
179	GNUNET_log (GNUNET_ERROR_TYPE_WARNING,	178	GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
180	_("Directory for file `%s' does not seem to be writable.\n"),	179	_("Directory for file `%s' does not seem to be writable.\n"),
181	fn);	180	fn);
182	GNUNET_free (fn);	181	GNUNET_free(fn);
183	return NULL;	182	return NULL;
184	}	183	}
185	if (GNUNET_OK == GNUNET_DISK_file_test (fn))	184	if (GNUNET_OK == GNUNET_DISK_file_test(fn))
186	GNUNET_DISK_file_backup (fn);	185	GNUNET_DISK_file_backup(fn);
187	w = GNUNET_new (struct GNUNET_FRIENDS_Writer);	186	w = GNUNET_new(struct GNUNET_FRIENDS_Writer);
188	w->fh = GNUNET_DISK_file_open (fn,	187	w->fh = GNUNET_DISK_file_open(fn,
189	GNUNET_DISK_OPEN_CREATE \|	188	GNUNET_DISK_OPEN_CREATE \|
190	GNUNET_DISK_OPEN_WRITE \|	189	GNUNET_DISK_OPEN_WRITE \|
191	GNUNET_DISK_OPEN_FAILIFEXISTS,	190	GNUNET_DISK_OPEN_FAILIFEXISTS,
192	GNUNET_DISK_PERM_USER_READ);	191	GNUNET_DISK_PERM_USER_READ);
193	GNUNET_free (fn);	192	GNUNET_free(fn);
194	if (NULL == w->fh)	193	if (NULL == w->fh)
195	{	194	{
196	GNUNET_free (w);	195	GNUNET_free(w);
197	return NULL;	196	return NULL;
198	}	197	}
199	return w;	198	return w;
200	}	199	}
201		200
@@ -207,12 +206,12 @@ GNUNET_FRIENDS_write_start (const struct GNUNET_CONFIGURATION_Handle *cfg)
207	* @return #GNUNET_OK on success, #GNUNET_SYSERR on error	206	* @return #GNUNET_OK on success, #GNUNET_SYSERR on error
208	*/	207	*/
209	int	208	int
210	GNUNET_FRIENDS_write_stop (struct GNUNET_FRIENDS_Writer *w)	209	GNUNET_FRIENDS_write_stop(struct GNUNET_FRIENDS_Writer *w)
211	{	210	{
212	int ret;	211	int ret;
213		212
214	ret = GNUNET_DISK_file_close (w->fh);	213	ret = GNUNET_DISK_file_close(w->fh);
215	GNUNET_free (w);	214	GNUNET_free(w);
216	return ret;	215	return ret;
217	}	216	}
218		217
@@ -225,28 +224,28 @@ GNUNET_FRIENDS_write_stop (struct GNUNET_FRIENDS_Writer *w)
225	* @return #GNUNET_OK on success, #GNUNET_SYSERR on error	224	* @return #GNUNET_OK on success, #GNUNET_SYSERR on error
226	*/	225	*/
227	int	226	int
228	GNUNET_FRIENDS_write (struct GNUNET_FRIENDS_Writer *w,	227	GNUNET_FRIENDS_write(struct GNUNET_FRIENDS_Writer *w,
229	const struct GNUNET_PeerIdentity *friend_id)	228	const struct GNUNET_PeerIdentity *friend_id)
230	{	229	{
231	char *buf;	230	char *buf;
232	char *ret;	231	char *ret;
233	size_t slen;	232	size_t slen;
234		233
235	ret = GNUNET_CRYPTO_eddsa_public_key_to_string (&friend_id->public_key);	234	ret = GNUNET_CRYPTO_eddsa_public_key_to_string(&friend_id->public_key);
236	GNUNET_asprintf (&buf,	235	GNUNET_asprintf(&buf,
237	"%s\n",	236	"%s\n",
238	ret);	237	ret);
239	GNUNET_free (ret);	238	GNUNET_free(ret);
240	slen = strlen (buf);	239	slen = strlen(buf);
241	if (slen !=	240	if (slen !=
242	GNUNET_DISK_file_write (w->fh,	241	GNUNET_DISK_file_write(w->fh,
243	buf,	242	buf,
244	slen))	243	slen))
245	{	244	{
246	GNUNET_free (buf);	245	GNUNET_free(buf);
247	return GNUNET_SYSERR;	246	return GNUNET_SYSERR;
248	}	247	}
249	GNUNET_free (buf);	248	GNUNET_free(buf);
250	return GNUNET_OK;	249	return GNUNET_OK;
251	}	250	}
252		251