GNUnet  0.11.x
gnunet-gns-import.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2012-2013 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  */
26 #include "platform.h"
27 #include <gnunet_util_lib.h>
28 #include <gnunet_gnsrecord_lib.h>
31 
35 static const struct GNUNET_CONFIGURATION_Handle *cfg;
36 
40 static struct GNUNET_IDENTITY_Handle *sh;
41 
46 
50 static struct GNUNET_NAMESTORE_Handle *ns;
51 
55 static char *master_zone_pkey;
56 
61 
65 static char *private_zone_pkey;
66 
70 static char *pin_zone_pkey =
71  "72QC35CO20UJN1E91KPJFNT9TG4CLKAPB4VK9S3Q758S9MLBRKOG";
72 
77 
81 static int found_pin_rec = GNUNET_NO;
82 
86 static int ret;
87 
88 
89 static int
90 run_process_and_wait (int pipe_control,
91  enum GNUNET_OS_InheritStdioFlags std_inheritance,
92  struct GNUNET_DISK_PipeHandle *pipe_stdin,
93  struct GNUNET_DISK_PipeHandle *pipe_stdout,
95  unsigned long *code,
96  const char *filename, ...)
97 {
98  static struct GNUNET_OS_Process *p;
99  int arglen;
100  char *arg;
101  char *args;
102  char *argp;
103  va_list ap, apc1, apc2;
104 
105  va_start (ap, filename);
106  va_copy (apc1, ap);
107  va_copy (apc2, ap);
108  arglen = 0;
109  while (NULL != (arg = va_arg (apc1, char *)))
110  arglen += strlen (arg) + 1;
111  va_end (apc1);
112  args = argp = GNUNET_malloc (arglen);
113  while (NULL != (arg = va_arg (apc2, char *)))
114  {
115  strcpy (argp, arg);
116  argp += strlen (arg);
117  *argp = ' ';
118  argp += 1;
119  }
120  va_end (apc2);
121  if (arglen > 0)
122  argp[-1] = '\0';
123  p = GNUNET_OS_start_process_va (pipe_control, std_inheritance,
124  pipe_stdin,
125  pipe_stdout,
126  NULL,
127  filename, ap);
128  va_end (ap);
129  if (NULL == p)
130  {
131  ret = 3;
132  fprintf (stderr, "Failed to run `%s'\n", args);
133  GNUNET_free (args);
134  return 1;
135  }
136 
138  {
139  ret = 4;
140  fprintf (stderr, "Failed to wait for `%s'\n", args);
141  GNUNET_free (args);
142  return 1;
143  }
144 
145  switch (GNUNET_OS_process_status (p, st, code))
146  {
147  case GNUNET_OK:
148  break;
149 
150  case GNUNET_NO:
151  ret = 5;
152  fprintf (stderr, "`%s' is still running\n", args);
153  GNUNET_free (args);
154  return 1;
155 
156  default:
157  case GNUNET_SYSERR:
158  ret = 6;
159  fprintf (stderr, "Failed to check the status of `%s'\n", args);
160  GNUNET_free (args);
161  return 1;
162  }
163  return 0;
164 }
165 
166 
167 static void
168 check_pkey (unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd,
169  char *pk, int *found_rec)
170 {
171  int i;
172 
173  for (i = 0; i < rd_len; i++)
174  {
175  char *s;
176  if ((GNUNET_GNSRECORD_TYPE_PKEY != rd[i].record_type) ||
177  (rd[i].data_size != sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)) )
178  continue;
179  s = GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
180  rd[i].data,
181  rd[i].data_size);
182  if (NULL == s)
183  continue;
184  if (0 == strcmp (s, pk))
185  *found_rec = GNUNET_YES;
186  GNUNET_free (s);
187  }
188 }
189 
190 
200 static void
201 zone_iterator (void *cls,
202  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
203  const char *rname, unsigned int rd_len,
204  const struct GNUNET_GNSRECORD_Data *rd)
205 {
206  if (NULL != rname)
207  {
208  if (0 == strcmp (rname, "private"))
210  else if (0 == strcmp (rname, "pin"))
211  check_pkey (rd_len, rd, pin_zone_pkey, &found_pin_rec);
212  }
214 }
215 
216 
217 static void
219 {
221  unsigned long code;
222 
223  if (! found_private_rec)
224  {
226  NULL, NULL, &st, &code,
227  "gnunet-namestore",
228  "gnunet-namestore", "-z", "master-zone",
229  "-a", "-e", "never", "-n", "private", "-p",
230  "-t", "PKEY", "-V",
231  private_zone_pkey, NULL))
232  {
233  ret = 8;
234  return;
235  }
236  }
237  if (! found_pin_rec)
238  {
240  NULL, NULL, &st, &code,
241  "gnunet-namestore",
242  "gnunet-namestore", "-z", "master-zone",
243  "-a", "-e", "never", "-n", "pin", "-p", "-t",
244  "PKEY", "-V", pin_zone_pkey,
245  NULL))
246  {
247  ret = 10;
248  return;
249  }
250  }
251  list_it = NULL;
253 }
254 
255 
256 static void
258 {
259 }
260 
261 
295 static void
296 get_ego (void *cls,
297  struct GNUNET_IDENTITY_Ego *ego,
298  void **ctx,
299  const char *identifier)
300 {
301  static struct GNUNET_CRYPTO_EcdsaPublicKey pk;
302 
303  if (NULL == ego)
304  {
305  if ((NULL == master_zone_pkey) ||
306  (NULL == private_zone_pkey) )
307  {
308  ret = 11;
310  return;
311  }
313  &master_pk,
315  NULL, &zone_iterator, NULL,
317  NULL);
318  if (NULL == list_it)
319  {
320  ret = 12;
322  }
323  return;
324  }
326  if (NULL != identifier)
327  {
328  if ((NULL == master_zone_pkey) && (0 == strcmp ("master-zone",
329  identifier)) )
330  {
333  }
334  else if ((NULL == private_zone_pkey) && (0 == strcmp ("private-zone",
335  identifier)) )
337  }
338 }
339 
340 
346 static void
347 shutdown_task (void *cls)
348 {
350  master_zone_pkey = NULL;
352  private_zone_pkey = NULL;
353  if (NULL != list_it)
354  {
356  list_it = NULL;
357  }
358  if (NULL != ns)
359  {
361  ns = NULL;
362  }
363  if (NULL != sh)
364  {
366  sh = NULL;
367  }
368 }
369 
370 
379 static void
380 run (void *cls, char *const *args, const char *cfgfile,
381  const struct GNUNET_CONFIGURATION_Handle *c)
382 {
384  unsigned long code;
385 
386  cfg = c;
387 
388  if (0 != run_process_and_wait (GNUNET_NO, 0, NULL, NULL, &st, &code,
389  "gnunet-arm",
390  "gnunet-arm", "-I", NULL))
391  {
392  if (7 == ret)
393  fprintf (stderr,
394  "GNUnet is not running, please start GNUnet before running import\n");
395  return;
396  }
397 
399  NULL, NULL, &st, &code,
400  "gnunet-identity",
401  "gnunet-identity", "-C", "master-zone", NULL))
402  return;
403 
405  NULL, NULL, &st, &code,
406  "gnunet-identity",
407  "gnunet-identity", "-C", "private-zone", NULL))
408  return;
409 
411  NULL, NULL, &st, &code,
412  "gnunet-identity",
413  "gnunet-identity", "-C", "sks-zone", NULL))
414  return;
415 
417  NULL, NULL, &st, &code,
418  "gnunet-identity",
419  "gnunet-identity", "-e", "master-zone", "-s",
420  "gns-master", NULL))
421  return;
422 
424  NULL, NULL, &st, &code,
425  "gnunet-identity",
426  "gnunet-identity", "-e", "master-zone", "-s",
427  "namestore", NULL))
428  return;
429 
431  NULL, NULL, &st, &code,
432  "gnunet-identity",
433  "gnunet-identity", "-e", "master-zone", "-s",
434  "gns-proxy", NULL))
435  return;
436 
438  NULL, NULL, &st, &code,
439  "gnunet-identity",
440  "gnunet-identity", "-e", "master-zone", "-s",
441  "gns-intercept", NULL))
442  return;
443 
445  NULL, NULL, &st, &code,
446  "gnunet-identity",
447  "gnunet-identity", "-e", "private-zone", "-s",
448  "gns-private", NULL))
449  return;
450 
452  NULL, NULL, &st, &code,
453  "gnunet-identity",
454  "gnunet-identity", "-e", "sks-zone", "-s",
455  "fs-sks", NULL))
456  return;
457 
458  ns = GNUNET_NAMESTORE_connect (cfg);
459  sh = GNUNET_IDENTITY_connect (cfg, &get_ego, NULL);
461 }
462 
463 
471 int
472 main (int argc, char *const *argv)
473 {
474  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
476  };
477  int r;
478 
479  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
480  return 2;
481 
482  GNUNET_log_setup ("gnunet-gns-import", "WARNING", NULL);
483  ret = 0;
484  r = GNUNET_PROGRAM_run (argc, argv, "gnunet-gns-import",
485  _ (
486  "This program will import some GNS authorities into your GNS namestore."),
487  options,
488  &run, NULL);
489  GNUNET_free ((void*) argv);
490  return GNUNET_OK == r ? ret : 1;
491 }
492 
493 
494 /* end of gnunet-gns-import.c */
struct GNUNET_IDENTITY_Handle * GNUNET_IDENTITY_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_IDENTITY_Callback cb, void *cb_cls)
Connect to the identity service.
Definition: identity_api.c:527
GNUNET_OS_InheritStdioFlags
Flags that determine which of the standard streams should be inherited by the child process...
Definition: gnunet_os_lib.h:68
static struct GNUNET_CRYPTO_EddsaPrivateKey * pk
Private key of this peer.
static char * pin_zone_pkey
String version of PKEY for pin-zone.
static char * private_zone_pkey
String version of PKEY for private-zone.
int main(int argc, char *const *argv)
The main function for gnunet-gns.
int GNUNET_OS_process_status(struct GNUNET_OS_Process *proc, enum GNUNET_OS_ProcessStatusType *type, unsigned long *code)
Retrieve the status of a process, waiting on it if dead.
Definition: os_priority.c:963
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1300
struct GNUNET_NAMESTORE_ZoneIterator * GNUNET_NAMESTORE_zone_iteration_start(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor proc, void *proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls)
Starts a new zone iteration (used to periodically PUT all of our records into our DHT)...
struct GNUNET_NAMESTORE_ZoneIterator * list_it
Zone iterator for master zone.
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1438
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:555
static struct GNUNET_CRYPTO_EcdsaPrivateKey master_pk
Binary version of PKEY for master-zone.
#define GNUNET_NO
Definition: gnunet_common.h:78
static int run_process_and_wait(int pipe_control, enum GNUNET_OS_InheritStdioFlags std_inheritance, struct GNUNET_DISK_PipeHandle *pipe_stdin, struct GNUNET_DISK_PipeHandle *pipe_stdout, enum GNUNET_OS_ProcessStatusType *st, unsigned long *code, const char *filename,...)
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
Definition of a command line option.
void GNUNET_NAMESTORE_zone_iterator_next(struct GNUNET_NAMESTORE_ZoneIterator *it, uint64_t limit)
Calls the record processor specified in GNUNET_NAMESTORE_zone_iteration_start for the next record...
Private ECC key encoded for transmission.
struct GNUNET_OS_Process * GNUNET_OS_start_process_va(int pipe_control, enum GNUNET_OS_InheritStdioFlags std_inheritance, struct GNUNET_DISK_PipeHandle *pipe_stdin, struct GNUNET_DISK_PipeHandle *pipe_stdout, struct GNUNET_DISK_PipeHandle *pipe_stderr, const char *filename, va_list va)
Start a process.
Definition: os_priority.c:639
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static void zone_iteration_finished(void *cls)
void GNUNET_NAMESTORE_disconnect(struct GNUNET_NAMESTORE_Handle *h)
Disconnect from the namestore service (and free associated resources).
Handle for a zone iterator operation.
Handle for an ego.
Definition: identity.h:245
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
#define GNUNET_GNSRECORD_TYPE_PKEY
Record type for GNS zone transfer ("PKEY").
Connection to the NAMESTORE service.
Handle for the service.
Definition: identity_api.c:95
GNUNET_OS_ProcessStatusType
Process status types.
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
Main function that will be run.
static char * filename
void GNUNET_IDENTITY_disconnect(struct GNUNET_IDENTITY_Handle *h)
Disconnect from identity service.
Definition: identity_api.c:837
static int found_pin_rec
Set to GNUNET_YES if pin record was found;.
void GNUNET_NAMESTORE_zone_iteration_stop(struct GNUNET_NAMESTORE_ZoneIterator *it)
Stops iteration and releases the namestore handle for further calls.
When these flags are set, the child process will inherit stdout and stderr of the parent...
Definition: gnunet_os_lib.h:97
char * GNUNET_CRYPTO_ecdsa_public_key_to_string(const struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Convert a public key to a string.
Definition: crypto_ecc.c:332
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct GNUNET_NAMESTORE_Handle * GNUNET_NAMESTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the namestore service.
static int found_private_rec
Set to GNUNET_YES if private record was found;.
static int ret
Exit code.
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
void GNUNET_IDENTITY_ego_get_public_key(const struct GNUNET_IDENTITY_Ego *ego, struct GNUNET_CRYPTO_EcdsaPublicKey *pk)
Get the identifier (public key) of an ego.
Definition: identity_api.c:568
static void get_ego(void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *identifier)
Get master-zone and private-zone keys.
static char * master_zone_pkey
String version of PKEY for master-zone.
static void shutdown_task(void *cls)
Task run on shutdown.
int GNUNET_OS_process_wait(struct GNUNET_OS_Process *proc)
Wait for a process to terminate.
Definition: os_priority.c:1000
configuration data
Definition: configuration.c:85
static void check_pkey(unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd, char *pk, int *found_rec)
static void zone_iterator(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
Process a record that was stored in the namestore.
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
int GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration, parse options).
Definition: program.c:367
#define GNUNET_YES
Definition: gnunet_common.h:77
static struct GNUNET_IDENTITY_Handle * sh
Handle to IDENTITY service.
int GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
Setup logging.
static struct GNUNET_SCHEDULER_Task * st
The shutdown task.
uint32_t data
The data value.
char * GNUNET_GNSRECORD_value_to_string(uint32_t type, const void *data, size_t data_size)
Convert the &#39;value&#39; of a record to a string.
Definition: gnsrecord.c:143
Handle used to manage a pipe.
Definition: disk.c:68
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
static void zone_iteration_error(void *cls)