← Back to branch summary

~ubuntu-branches/ubuntu/karmic/gnupg2/karmic-updates

« back to all changes in this revision

Viewing changes to scd/app.c

  • Committer: Bazaar Package Importer
  • Author(s): Eric Dorland
  • Date: 2009-03-08 22:46:47 UTC
  • mfrom: (1.1.11 upstream)
  • Revision ID: james.westby@ubuntu.com-20090308224647-gq17gatcl71lrc2k
Tags: 2.0.11-1
http://bugs.debian.org/496663
http://bugs.debian.org/496323
* New upstream release. (Closes: #496663)
* debian/control: Make the description a little more distinctive than
  gnupg v1's. Thanks Jari Aalto. (Closes: #496323)

Show diffs side-by-side

added added

removed removed

Lines of Context:
scd/app.c
22
22
#include <stdio.h>
23
23
#include <stdlib.h>
24
24
#include <string.h>
25
 
# include <pth.h>
 
25
#include <pth.h>
26
26
 
27
27
#include "scdaemon.h"
28
28
#include "app-common.h"
106
106
dump_mutex_state (pth_mutex_t *m)
107
107
{
108
108
#ifdef _W32_PTH_H
 
109
  (void)m;
109
110
  log_printf ("unknown under W32");
110
111
#else
111
112
  if (!(m->mx_state & PTH_MUTEX_INITIALIZED))
160
161
}
161
162
 
162
163
 
163
 
/* This may be called to tell this module about a removed card. */
 
164
/* This may be called to tell this module about a removed or resetted card. */
164
165
void
165
 
application_notify_card_removed (int slot)
 
166
application_notify_card_reset (int slot)
166
167
{
167
168
  app_t app;
168
169
 
186
187
}
187
188
 
188
189
 
189
 
/* This fucntion is used by the serialno command to check for an
 
190
/* This function is used by the serialno command to check for an
190
191
   application conflict which may appear if the serialno command is
191
192
   used to request a specific application and the connection has
192
193
   already done a select_application. */
220
221
  unsigned char *result = NULL;
221
222
  size_t resultlen;
222
223
 
 
224
  (void)ctrl;
 
225
 
223
226
  *r_app = NULL;
224
227
 
225
228
  err = lock_reader (slot);
240
243
 
241
244
  /* If we don't have an app, check whether we have a saved
242
245
     application for that slot.  This is useful so that a card does
243
 
     not get reset even if only one session is using the card - so the
244
 
     PIN cache and other cached data are preserved. */
 
246
     not get reset even if only one session is using the card - this
 
247
     way the PIN cache and other cached data are preserved.  */
245
248
  if (!app && lock_table[slot].initialized && lock_table[slot].last_app)
246
249
    {
247
250
      app = lock_table[slot].last_app;
349
352
    err = app_select_p15 (app);
350
353
  if (err && is_app_allowed ("dinsig") && (!name || !strcmp (name, "dinsig")))
351
354
    err = app_select_dinsig (app);
 
355
  if (err && is_app_allowed ("geldkarte")
 
356
      && (!name || !strcmp (name, "geldkarte")))
 
357
    err = app_select_geldkarte (app);
352
358
  if (err && name)
353
359
    err = gpg_error (GPG_ERR_NOT_SUPPORTED);
354
360
 
366
372
      return err;
367
373
    }
368
374
 
369
 
  app->initialized = 1;
370
375
  app->ref_count = 1;
 
376
 
371
377
  lock_table[slot].app = app;
372
378
  *r_app = app;
373
379
  unlock_reader (slot);
375
381
}
376
382
 
377
383
 
 
384
char *
 
385
get_supported_applications (void)
 
386
{
 
387
  const char *list[] = {
 
388
    "openpgp",
 
389
    "nks",
 
390
    "p15",
 
391
    "dinsig",
 
392
    "geldkarte",
 
393
    NULL
 
394
  };
 
395
  int idx;
 
396
  size_t nbytes;
 
397
  char *buffer, *p;
 
398
  
 
399
  for (nbytes=1, idx=0; list[idx]; idx++)
 
400
    nbytes += strlen (list[idx]) + 1 + 1;
 
401
  
 
402
  buffer = xtrymalloc (nbytes);
 
403
  if (!buffer)
 
404
    return NULL;
 
405
 
 
406
  for (p=buffer, idx=0; list[idx]; idx++)
 
407
    if (is_app_allowed (list[idx]))
 
408
      p = stpcpy (stpcpy (p, list[idx]), ":\n");
 
409
  *p = 0;
 
410
 
 
411
  return buffer;
 
412
}
 
413
 
 
414
 
378
415
/* Deallocate the application. */
379
416
static void
380
417
deallocate_app (app_t app)
402
439
  if (!app)
403
440
    return;
404
441
 
405
 
  if (app->ref_count < 1)
 
442
  if (!app->ref_count)
406
443
    log_bug ("trying to release an already released context\n");
407
444
  if (--app->ref_count)
408
445
    return;
437
474
     FF 00 00 = For serial numbers starting with an FF
438
475
     FF 01 00 = Some german p15 cards return an empty serial number so the
439
476
                serial number from the EF(TokenInfo) is used instead.
 
477
     FF 7F 00 = No serialno.
440
478
     
441
479
     All other serial number not starting with FF are used as they are.
442
480
*/
449
487
         requires that we put our default prefix "FF0000" in front. */
450
488
      unsigned char *p = xtrymalloc (app->serialnolen + 3);
451
489
      if (!p)
452
 
        return gpg_error (gpg_err_code_from_errno (errno));
 
490
        return gpg_error_from_syserror ();
453
491
      memcpy (p, "\xff\0", 3);
454
492
      memcpy (p+3, app->serialno, app->serialnolen);
455
493
      app->serialnolen += 3;
456
494
      xfree (app->serialno);
457
495
      app->serialno = p;
458
496
    }
 
497
  else if (!app->serialnolen)
 
498
    { 
 
499
      unsigned char *p = xtrymalloc (3);
 
500
      if (!p)
 
501
        return gpg_error_from_syserror ();
 
502
      memcpy (p, "\xff\x7f", 3);
 
503
      app->serialnolen = 3;
 
504
      xfree (app->serialno);
 
505
      app->serialno = p;
 
506
    }
459
507
  return 0;
460
508
}
461
509
 
470
518
gpg_error_t 
471
519
app_get_serial_and_stamp (app_t app, char **serial, time_t *stamp)
472
520
{
473
 
  char *buf, *p;
474
 
  int i;
 
521
  char *buf;
475
522
 
476
523
  if (!app || !serial)
477
524
    return gpg_error (GPG_ERR_INV_VALUE);
480
527
  if (stamp)
481
528
    *stamp = 0; /* not available */
482
529
 
483
 
  buf = xtrymalloc (app->serialnolen * 2 + 1);
 
530
  if (!app->serialnolen)
 
531
    buf = xtrystrdup ("FF7F00");
 
532
  else
 
533
    buf = bin2hex (app->serialno, app->serialnolen, NULL);
484
534
  if (!buf)
485
535
    return gpg_error_from_syserror ();
486
 
  for (p=buf, i=0; i < app->serialnolen; p +=2, i++)
487
 
    sprintf (p, "%02X", app->serialno[i]);
488
 
  *p = 0;
 
536
 
489
537
  *serial = buf;
490
538
  return 0;
491
539
}
500
548
 
501
549
  if (!app)
502
550
    return gpg_error (GPG_ERR_INV_VALUE);
503
 
  if (!app->initialized)
 
551
  if (!app->ref_count)
504
552
    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
505
553
  if (!app->fnc.learn_status)
506
554
    return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
529
577
 
530
578
  if (!app)
531
579
    return gpg_error (GPG_ERR_INV_VALUE);
532
 
  if (!app->initialized)
 
580
  if (!app->ref_count)
533
581
    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
534
582
  if (!app->fnc.readcert)
535
583
    return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
561
609
 
562
610
  if (!app || !keyid || !pk || !pklen)
563
611
    return gpg_error (GPG_ERR_INV_VALUE);
564
 
  if (!app->initialized)
 
612
  if (!app->ref_count)
565
613
    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
566
614
  if (!app->fnc.readkey)
567
615
    return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
582
630
 
583
631
  if (!app || !name || !*name)
584
632
    return gpg_error (GPG_ERR_INV_VALUE);
585
 
  if (!app->initialized)
 
633
  if (!app->ref_count)
586
634
    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
587
635
 
588
636
  if (app->apptype && name && !strcmp (name, "APPTYPE"))
626
674
 
627
675
  if (!app || !name || !*name || !value)
628
676
    return gpg_error (GPG_ERR_INV_VALUE);
629
 
  if (!app->initialized)
 
677
  if (!app->ref_count)
630
678
    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
631
679
  if (!app->fnc.setattr)
632
680
    return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
652
700
 
653
701
  if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
654
702
    return gpg_error (GPG_ERR_INV_VALUE);
655
 
  if (!app->initialized)
 
703
  if (!app->ref_count)
656
704
    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
657
705
  if (!app->fnc.sign)
658
706
    return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
684
732
 
685
733
  if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
686
734
    return gpg_error (GPG_ERR_INV_VALUE);
687
 
  if (!app->initialized)
 
735
  if (!app->ref_count)
688
736
    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
689
737
  if (!app->fnc.auth)
690
738
    return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
716
764
 
717
765
  if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
718
766
    return gpg_error (GPG_ERR_INV_VALUE);
719
 
  if (!app->initialized)
 
767
  if (!app->ref_count)
720
768
    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
721
769
  if (!app->fnc.decipher)
722
770
    return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
734
782
}
735
783
 
736
784
 
 
785
/* Perform the WRITECERT operation.  */
 
786
gpg_error_t
 
787
app_writecert (app_t app, ctrl_t ctrl,
 
788
              const char *certidstr,
 
789
              gpg_error_t (*pincb)(void*, const char *, char **),
 
790
              void *pincb_arg,
 
791
              const unsigned char *data, size_t datalen)
 
792
{
 
793
  gpg_error_t err;
 
794
 
 
795
  if (!app || !certidstr || !*certidstr || !pincb)
 
796
    return gpg_error (GPG_ERR_INV_VALUE);
 
797
  if (!app->ref_count)
 
798
    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
 
799
  if (!app->fnc.writecert)
 
800
    return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
 
801
  err = lock_reader (app->slot);
 
802
  if (err)
 
803
    return err;
 
804
  err = app->fnc.writecert (app, ctrl, certidstr,
 
805
                            pincb, pincb_arg, data, datalen);
 
806
  unlock_reader (app->slot);
 
807
  if (opt.verbose)
 
808
    log_info ("operation writecert result: %s\n", gpg_strerror (err));
 
809
  return err;
 
810
}
 
811
 
 
812
 
737
813
/* Perform the WRITEKEY operation.  */
738
814
gpg_error_t
739
815
app_writekey (app_t app, ctrl_t ctrl,
746
822
 
747
823
  if (!app || !keyidstr || !*keyidstr || !pincb)
748
824
    return gpg_error (GPG_ERR_INV_VALUE);
749
 
  if (!app->initialized)
 
825
  if (!app->ref_count)
750
826
    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
751
827
  if (!app->fnc.writekey)
752
828
    return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
759
835
  if (opt.verbose)
760
836
    log_info ("operation writekey result: %s\n", gpg_strerror (err));
761
837
  return err;
762
 
 
763
838
}
764
839
 
765
840
 
774
849
 
775
850
  if (!app || !keynostr || !*keynostr || !pincb)
776
851
    return gpg_error (GPG_ERR_INV_VALUE);
777
 
  if (!app->initialized)
 
852
  if (!app->ref_count)
778
853
    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
779
854
  if (!app->fnc.genkey)
780
855
    return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
800
875
 
801
876
  if (!app || !nbytes || !buffer)
802
877
    return gpg_error (GPG_ERR_INV_VALUE);
803
 
  if (!app->initialized)
 
878
  if (!app->ref_count)
804
879
    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
805
880
  err = lock_reader (app->slot);
806
881
  if (err)
822
897
 
823
898
  if (!app || !chvnostr || !*chvnostr || !pincb)
824
899
    return gpg_error (GPG_ERR_INV_VALUE);
825
 
  if (!app->initialized)
 
900
  if (!app->ref_count)
826
901
    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
827
902
  if (!app->fnc.change_pin)
828
903
    return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
850
925
 
851
926
  if (!app || !keyidstr || !*keyidstr || !pincb)
852
927
    return gpg_error (GPG_ERR_INV_VALUE);
853
 
  if (!app->initialized)
 
928
  if (!app->ref_count)
854
929
    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
855
930
  if (!app->fnc.check_pin)
856
931
    return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);