GNUnet  0.10.x
gnunet-hello.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet
3  Copyright (C) 2012 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19 */
25 #include "platform.h"
26 #include "gnunet_protocols.h"
27 #include "gnunet_hello_lib.h"
28 
32 struct AddContext
33 {
37  char *buf;
38 
42  size_t max;
43 
47  size_t ret;
48 };
49 
50 static int address_count;
51 
52 
61 static int
62 add_to_buf (void *cls,
63  const struct GNUNET_HELLO_Address *address,
65 {
66  struct AddContext *ac = cls;
67  size_t ret;
68 
69  ret = GNUNET_HELLO_add_address (address,
71  ac->buf,
72  ac->max);
73  ac->buf += ret;
74  ac->max -= ret;
75  ac->ret += ret;
76  address_count ++;
77  return GNUNET_OK;
78 }
79 
80 
89 static ssize_t
90 add_from_hello (void *cls,
91  size_t max,
92  void *buf)
93 {
94  struct GNUNET_HELLO_Message **orig = cls;
95  struct AddContext ac;
96 
97  if (NULL == *orig)
98  return GNUNET_SYSERR; /* already done */
99  ac.buf = buf;
100  ac.max = max;
101  ac.ret = 0;
102  GNUNET_assert (NULL ==
105  &ac));
106  *orig = NULL;
107  return ac.ret;
108 }
109 
110 
111 int
112 main (int argc, char *argv[])
113 {
114  struct GNUNET_DISK_FileHandle *fh;
115  struct GNUNET_HELLO_Message *orig;
117  struct GNUNET_PeerIdentity pid;
118  uint64_t fsize;
119  address_count = 0;
120 
121  GNUNET_log_setup ("gnunet-hello", "INFO", NULL);
122  if (argc != 2)
123  {
124  FPRINTF (stderr,
125  "%s",
126  _("Call with name of HELLO file to modify.\n"));
127  return 1;
128  }
129  if (GNUNET_OK != GNUNET_DISK_file_size (argv[1], &fsize, GNUNET_YES, GNUNET_YES))
130  {
131  FPRINTF (stderr,
132  _("Error accessing file `%s': %s\n"),
133  argv[1],
134  STRERROR (errno));
135  return 1;
136  }
137  if (fsize > 65536)
138  {
139  FPRINTF (stderr,
140  _("File `%s' is too big to be a HELLO\n"),
141  argv[1]);
142  return 1;
143  }
144  if (fsize < sizeof (struct GNUNET_MessageHeader))
145  {
146  FPRINTF (stderr,
147  _("File `%s' is too small to be a HELLO\n"),
148  argv[1]);
149  return 1;
150  }
151  fh = GNUNET_DISK_file_open (argv[1],
154  if (NULL == fh)
155  {
156  FPRINTF (stderr,
157  _("Error opening file `%s': %s\n"),
158  argv[1],
159  STRERROR (errno));
160  return 1;
161  }
162  {
163  char buf[fsize] GNUNET_ALIGN;
164 
165  GNUNET_assert (fsize ==
166  GNUNET_DISK_file_read (fh, buf, fsize));
168  orig = (struct GNUNET_HELLO_Message *) buf;
169  if ( (fsize < GNUNET_HELLO_size (orig)) ||
170  (GNUNET_OK != GNUNET_HELLO_get_id (orig,
171  &pid)) )
172  {
173  FPRINTF (stderr,
174  _("Did not find well-formed HELLO in file `%s'\n"),
175  argv[1]);
176  return 1;
177  }
178  {
179  char *pids;
180 
182  fprintf (stdout,
183  "Processing HELLO for peer `%s'\n",
184  pids);
185  GNUNET_free (pids);
186  }
187  result = GNUNET_HELLO_create (&pid.public_key,
189  &orig,
191  GNUNET_assert (NULL != result);
192  fh = GNUNET_DISK_file_open (argv[1],
195  if (NULL == fh)
196  {
197  FPRINTF (stderr,
198  _("Error opening file `%s': %s\n"),
199  argv[1],
200  STRERROR (errno));
201  GNUNET_free (result);
202  return 1;
203  }
204  fsize = GNUNET_HELLO_size (result);
205  if (fsize != GNUNET_DISK_file_write (fh,
206  result,
207  fsize))
208  {
209  FPRINTF (stderr,
210  _("Error writing HELLO to file `%s': %s\n"),
211  argv[1],
212  STRERROR (errno));
213  (void) GNUNET_DISK_file_close (fh);
214  return 1;
215  }
217  }
218  FPRINTF (stderr,
219  _("Modified %u addresses, wrote %u bytes\n"),
221  (unsigned int) fsize);
222  return 0;
223 }
224 
225 /* end of gnunet-hello.c */
Open the file for reading.
int GNUNET_HELLO_get_id(const struct GNUNET_HELLO_Message *hello, struct GNUNET_PeerIdentity *peer)
Get the peer identity from a HELLO message.
Definition: hello.c:668
static ssize_t add_from_hello(void *cls, size_t max, void *buf)
Add addresses from the address list to the HELLO.
Definition: gnunet-hello.c:90
A HELLO message is used to exchange information about transports with other peers.
static char * expiration
Credential TTL.
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1817
struct GNUNET_HELLO_Message * GNUNET_HELLO_create(const struct GNUNET_CRYPTO_EddsaPublicKey *public_key, GNUNET_HELLO_GenerateAddressListCallback addrgen, void *addrgen_cls, int friend_only)
Construct a HELLO message given the public key, expiration time and an iterator that spews the transp...
Definition: hello.c:204
#define FPRINTF
Definition: plibc.h:683
ssize_t GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: disk.c:881
char * buf
Where to add.
Definition: gnunet-hello.c:37
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define STRERROR(i)
Definition: plibc.h:676
size_t max
Maximum number of bytes left.
Definition: gnunet-hello.c:42
int main(int argc, char *argv[])
Definition: gnunet-hello.c:112
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
static int add_to_buf(void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)
Add the given address with infinit expiration to the buffer.
Definition: gnunet-hello.c:62
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
struct GNUNET_HELLO_Message * GNUNET_HELLO_iterate_addresses(const struct GNUNET_HELLO_Message *msg, int return_modified, GNUNET_HELLO_AddressIterator it, void *it_cls)
Iterate over all of the addresses in the HELLO.
Definition: hello.c:254
Truncate file if it exists.
char * GNUNET_CRYPTO_eddsa_public_key_to_string(const struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Convert a public key to a string.
Definition: crypto_ecc.c:367
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:1049
static int result
Global testing status.
static int fh
Handle to the unique file.
static int address_count
Definition: gnunet-hello.c:50
size_t GNUNET_HELLO_add_address(const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration, char *target, size_t max)
Copy the given address information into the given buffer using the format of HELLOs.
Definition: hello.c:109
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
Open the file for writing.
int GNUNET_HELLO_is_friend_only(const struct GNUNET_HELLO_Message *h)
Return HELLO type.
Definition: hello.c:89
static struct GNUNET_MQ_Envelope * ac
Handle to current GNUNET_PEERINFO_add_peer() operation.
int GNUNET_DISK_file_size(const char *filename, uint64_t *size, int include_symbolic_links, int single_file_mode)
Get the size of the file (or directory) of the given file (in bytes).
Definition: disk.c:289
The identity of the host (wraps the signing key of the peer).
#define GNUNET_ALIGN
gcc-ism to force alignment; we use this to align char-arrays that may then be cast to &#39;struct&#39;s...
An address for communicating with a peer.
uint16_t GNUNET_HELLO_size(const struct GNUNET_HELLO_Message *hello)
Return the size of the given HELLO message.
Definition: hello.c:649
Closure for add_to_buf().
Definition: gnunet-hello.c:32
Header for all communications.
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:80
int GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
Setup logging.
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1673
static char * address
GNS address for this phone.
Handle used to access files (and pipes).
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_CRYPTO_EddsaPublicKey public_key
size_t ret
Number of bytes added so far.
Definition: gnunet-hello.c:47