← Back to branch summary

~ubuntu-branches/ubuntu/feisty/gnupg2/feisty

« back to all changes in this revision

Viewing changes to sm/call-dirmngr.c

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2006-11-24 18:48:23 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20061124184823-17ir9m46tl09n9k4
Tags: 2.0.0-4ubuntu1
* Synchronize to Debian, reapply remaining Ubuntu changes to pristine Debian
  version:
  - Remove libpcsclite-dev, libopensc2-dev build dependencies (they are in
    universe).

Show diffs side-by-side

added added

removed removed

Lines of Context:
sm/call-dirmngr.c
48
48
 
49
49
 
50
50
 
51
 
static ASSUAN_CONTEXT dirmngr_ctx = NULL;
 
51
static assuan_context_t dirmngr_ctx = NULL;
52
52
static int force_pipe_server = 0;
53
53
 
54
54
struct inq_certificate_parm_s {
55
 
  ASSUAN_CONTEXT ctx;
 
55
  assuan_context_t ctx;
56
56
  ksba_cert_t cert;
57
57
  ksba_cert_t issuer_cert;
58
58
};
59
59
 
60
60
struct isvalid_status_parm_s {
61
 
  CTRL ctrl;
 
61
  ctrl_t ctrl;
62
62
  int seen;
63
63
  unsigned char fpr[20];
64
64
};
65
65
 
66
66
 
67
67
struct lookup_parm_s {
68
 
  CTRL ctrl;
69
 
  ASSUAN_CONTEXT ctx;
 
68
  ctrl_t ctrl;
 
69
  assuan_context_t ctx;
70
70
  void (*cb)(void *, ksba_cert_t);
71
71
  void *cb_value;
72
72
  struct membuf data;
74
74
};
75
75
 
76
76
struct run_command_parm_s {
77
 
  ASSUAN_CONTEXT ctx;
 
77
  assuan_context_t ctx;
78
78
};
79
79
 
80
80
 
148
148
{
149
149
  int rc;
150
150
  char *infostr, *p;
151
 
  ASSUAN_CONTEXT ctx;
 
151
  assuan_context_t ctx;
152
152
  int try_default = 0;
153
153
 
154
154
  if (dirmngr_ctx)
200
200
      no_close_list[i] = -1;
201
201
 
202
202
      /* connect to the agent and perform initial handshaking */
203
 
      rc = assuan_pipe_connect (&ctx, opt.dirmngr_program, (char**)argv,
 
203
      rc = assuan_pipe_connect (&ctx, opt.dirmngr_program, argv,
204
204
                                no_close_list);
205
205
    }
206
206
  else
237
237
 
238
238
      rc = assuan_socket_connect (&ctx, infostr, pid);
239
239
      xfree (infostr);
240
 
      if (rc == ASSUAN_Connect_Failed)
 
240
      if (gpg_err_code (rc) == GPG_ERR_ASS_CONNECT_FAILED)
241
241
        {
242
242
          log_error (_("can't connect to the dirmngr - trying fall back\n"));
243
243
          force_pipe_server = 1;
247
247
 
248
248
  if (rc)
249
249
    {
250
 
      log_error ("can't connect to the dirmngr: %s\n", assuan_strerror (rc));
 
250
      log_error ("can't connect to the dirmngr: %s\n", gpg_strerror (rc));
251
251
      return gpg_error (GPG_ERR_NO_DIRMNGR);
252
252
    }
253
253
  dirmngr_ctx = ctx;
260
260
 
261
261
 
262
262
/* Handle a SENDCERT inquiry. */
263
 
static AssuanError
 
263
static int
264
264
inq_certificate (void *opaque, const char *line)
265
265
{
266
266
  struct inq_certificate_parm_s *parm = opaque;
267
 
  AssuanError rc;
 
267
  int rc;
268
268
  const unsigned char *der;
269
269
  size_t derlen;
270
270
  int issuer_mode = 0;
296
296
  else
297
297
    {
298
298
      log_error ("unsupported inquiry `%s'\n", line);
299
 
      return ASSUAN_Inquire_Unknown;
 
299
      return gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
300
300
    }
301
301
 
302
302
  if (!*line)
304
304
      der = ksba_cert_get_image (issuer_mode? parm->issuer_cert : parm->cert,
305
305
                                 &derlen);
306
306
      if (!der)
307
 
        rc = ASSUAN_Inquire_Error;
 
307
        rc = gpg_error (GPG_ERR_INV_CERT_OBJ);
308
308
      else
309
309
        rc = assuan_send_data (parm->ctx, der, derlen);
310
310
    }
312
312
    {
313
313
      log_error ("sending specific issuer certificate back "
314
314
                 "is not yet implemented\n");
315
 
      rc = ASSUAN_Inquire_Error;
 
315
      rc = gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
316
316
    }
317
317
  else 
318
318
    { /* Send the given certificate. */
324
324
      if (err)
325
325
        {
326
326
          log_error ("certificate not found: %s\n", gpg_strerror (err));
327
 
          rc = ASSUAN_Inquire_Error;
 
327
          rc = gpg_error (GPG_ERR_NOT_FOUND);
328
328
        }
329
329
      else
330
330
        {
331
331
          der = ksba_cert_get_image (cert, &derlen);
332
332
          if (!der)
333
 
            rc = ASSUAN_Inquire_Error;
 
333
            rc = gpg_error (GPG_ERR_INV_CERT_OBJ);
334
334
          else
335
335
            rc = assuan_send_data (parm->ctx, der, derlen);
336
336
          ksba_cert_release (cert);
373
373
          for (line += 8; *line == ' '; line++)
374
374
            ;
375
375
          if (gpgsm_status (parm->ctrl, STATUS_PROGRESS, line))
376
 
            return ASSUAN_Canceled;
 
376
            return gpg_error (GPG_ERR_ASS_CANCELED);
377
377
        }
378
378
    }
379
379
  else if (!strncmp (line, "ONLY_VALID_IF_CERT_VALID", 24)
466
466
                        inq_certificate, &parm,
467
467
                        isvalid_status_cb, &stparm);
468
468
  if (opt.verbose > 1)
469
 
    log_info ("response of dirmngr: %s\n", rc? assuan_strerror (rc): "okay");
470
 
  rc = map_assuan_err (rc);
 
469
    log_info ("response of dirmngr: %s\n", rc? gpg_strerror (rc): "okay");
 
470
  rc = rc;
471
471
 
472
472
  if (!rc && stparm.seen)
473
473
    {
526
526
 
527
527
 
528
528
/* Lookup helpers*/
529
 
static AssuanError
 
529
static int
530
530
lookup_cb (void *opaque, const void *buffer, size_t length)
531
531
{
532
532
  struct lookup_parm_s *parm = opaque;
575
575
/* Return a properly escaped pattern from NAMES.  The only error
576
576
   return is NULL to indicate a malloc failure. */
577
577
static char *
578
 
pattern_from_strlist (STRLIST names)
 
578
pattern_from_strlist (strlist_t names)
579
579
{
580
 
  STRLIST sl;
 
580
  strlist_t sl;
581
581
  int n;
582
582
  const char *s;
583
583
  char *pattern, *p;
632
632
  return pattern;
633
633
}
634
634
 
635
 
static AssuanError
 
635
static int
636
636
lookup_status_cb (void *opaque, const char *line)
637
637
{
638
638
  struct lookup_parm_s *parm = opaque;
644
644
          for (line += 8; *line == ' '; line++)
645
645
            ;
646
646
          if (gpgsm_status (parm->ctrl, STATUS_PROGRESS, line))
647
 
            return ASSUAN_Canceled;
 
647
            return gpg_error (GPG_ERR_ASS_CANCELED);
648
648
        }
649
649
    }
650
650
  else if (!strncmp (line, "TRUNCATED", 9) && (line[9]==' ' || !line[9]))
665
665
   the callback CB which will be passed cert by cert.  Note that CTRL
666
666
   is optional. */
667
667
int 
668
 
gpgsm_dirmngr_lookup (CTRL ctrl, STRLIST names,
 
668
gpgsm_dirmngr_lookup (ctrl_t ctrl, strlist_t names,
669
669
                      void (*cb)(void*, ksba_cert_t), void *cb_value)
670
670
{ 
671
671
  int rc;
680
680
 
681
681
  pattern = pattern_from_strlist (names);
682
682
  if (!pattern)
683
 
    return OUT_OF_CORE (errno);
 
683
    return out_of_core ();
684
684
  snprintf (line, DIM(line)-1, "LOOKUP %s", pattern);
685
685
  line[DIM(line)-1] = 0;
686
686
  xfree (pattern);
696
696
                        NULL, NULL, lookup_status_cb, &parm);
697
697
  xfree (get_membuf (&parm.data, &len));
698
698
  if (rc)
699
 
    return map_assuan_err (rc);
 
699
    return rc;
700
700
  return parm.error;
701
701
}
702
702
 
705
705
/* Run Command helpers*/
706
706
 
707
707
/* Fairly simple callback to write all output of dirmngr to stdout. */
708
 
static AssuanError
 
708
static int
709
709
run_command_cb (void *opaque, const void *buffer, size_t length)
710
710
{
711
711
  if (buffer)
717
717
}
718
718
 
719
719
/* Handle inquiries from the dirmngr COMMAND. */
720
 
static AssuanError
 
720
static int
721
721
run_command_inq_cb (void *opaque, const char *line)
722
722
{
723
723
  struct run_command_parm_s *parm = opaque;
724
 
  AssuanError rc = 0;
 
724
  int rc = 0;
725
725
 
726
726
  if ( !strncmp (line, "SENDCERT", 8) && (line[8] == ' ' || !line[8]) )
727
727
    { /* send the given certificate */
732
732
 
733
733
      line += 8;
734
734
      if (!*line)
735
 
        return ASSUAN_Inquire_Error;
 
735
        return gpg_error (GPG_ERR_ASS_PARAMETER);
736
736
 
737
737
      err = gpgsm_find_cert (line, NULL, &cert);
738
738
      if (err)
739
739
        {
740
740
          log_error ("certificate not found: %s\n", gpg_strerror (err));
741
 
          rc = ASSUAN_Inquire_Error;
 
741
          rc = gpg_error (GPG_ERR_NOT_FOUND);
742
742
        }
743
743
      else
744
744
        {
745
745
          der = ksba_cert_get_image (cert, &derlen);
746
746
          if (!der)
747
 
            rc = ASSUAN_Inquire_Error;
 
747
            rc = gpg_error (GPG_ERR_INV_CERT_OBJ);
748
748
          else
749
749
            rc = assuan_send_data (parm->ctx, der, derlen);
750
750
          ksba_cert_release (cert);
758
758
  else
759
759
    {
760
760
      log_error ("unsupported inquiry `%s'\n", line);
761
 
      rc = ASSUAN_Inquire_Unknown;
 
761
      rc = gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
762
762
    }
763
763
 
764
764
  return rc; 
765
765
}
766
766
 
767
 
static AssuanError
 
767
static int
768
768
run_command_status_cb (void *opaque, const char *line)
769
769
{
770
770
  ctrl_t ctrl = opaque;
780
780
          for (line += 8; *line == ' '; line++)
781
781
            ;
782
782
          if (gpgsm_status (ctrl, STATUS_PROGRESS, line))
783
 
            return ASSUAN_Canceled;
 
783
            return gpg_error (GPG_ERR_ASS_CANCELED);
784
784
        }
785
785
    }
786
786
  return 0;
794
794
   percent characters within the argument strings are percent escaped
795
795
   so that blanks can act as delimiters. */
796
796
int
797
 
gpgsm_dirmngr_run_command (CTRL ctrl, const char *command,
 
797
gpgsm_dirmngr_run_command (ctrl_t ctrl, const char *command,
798
798
                           int argc, char **argv)
799
799
{ 
800
800
  int rc;
815
815
    len += 1 + 3*strlen (argv[i]); /* enough space for percent escaping */
816
816
  line = xtrymalloc (len);
817
817
  if (!line)
818
 
    return OUT_OF_CORE (errno);
 
818
    return out_of_core ();
819
819
 
820
820
  p = stpcpy (line, command);
821
821
  for (i=0; i < argc; i++)
843
843
                        run_command_inq_cb, &parm,
844
844
                        run_command_status_cb, ctrl);
845
845
  xfree (line);
846
 
  log_info ("response of dirmngr: %s\n", rc? assuan_strerror (rc): "okay");
847
 
  return map_assuan_err (rc);
 
846
  log_info ("response of dirmngr: %s\n", rc? gpg_strerror (rc): "okay");
 
847
  return rc;
848
848
}