← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/gnupg2/oneiric-updates

« back to all changes in this revision

Viewing changes to g10/keyring.c

  • Committer: Bazaar Package Importer
  • Author(s): Thomas Viehmann
  • Date: 2008-10-04 10:25:53 UTC
  • mfrom: (5.1.15 intrepid)
  • Revision ID: james.westby@ubuntu.com-20081004102553-fv62pp8dsitxli47
Tags: 2.0.9-3.1
http://bugs.debian.org/499569
* Non-maintainer upload.
* agent/gpg-agent.c: Deinit the threading library before exec'ing
  the command to run in --daemon mode. And because that still doesn't
  restore the sigprocmask, do that manually. Closes: #499569

Show diffs side-by-side

added added

removed removed

Lines of Context:
g10/keyring.c
1
1
/* keyring.c - keyring file handling
2
 
 * Copyright (C) 2001, 2003 Free Software Foundation, Inc.
 
2
 * Copyright (C) 2001, 2004 Free Software Foundation, Inc.
3
3
 *
4
4
 * This file is part of GnuPG.
5
5
 *
6
6
 * GnuPG is free software; you can redistribute it and/or modify
7
7
 * it under the terms of the GNU General Public License as published by
8
 
 * the Free Software Foundation; either version 2 of the License, or
 
8
 * the Free Software Foundation; either version 3 of the License, or
9
9
 * (at your option) any later version.
10
10
 *
11
11
 * GnuPG is distributed in the hope that it will be useful,
14
14
 * GNU General Public License for more details.
15
15
 *
16
16
 * You should have received a copy of the GNU General Public License
17
 
 * along with this program; if not, write to the Free Software
18
 
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 
17
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
19
18
 */
20
19
 
21
20
#include <config.h>
73
72
  int secret;             /* this is for a secret keyring */
74
73
  struct {
75
74
    CONST_KR_NAME kr;
76
 
    iobuf_t iobuf;
 
75
    IOBUF iobuf;
77
76
    int eof;
78
77
    int error;
79
78
  } current;
102
101
{
103
102
  struct off_item *k;
104
103
  
105
 
  k = xcalloc (1,sizeof *k);
 
104
  k = xmalloc_clear (sizeof *k);
106
105
  return k;
107
106
}
108
107
 
125
124
{
126
125
  struct off_item **tbl;
127
126
 
128
 
  tbl = xcalloc (2048, sizeof *tbl);
 
127
  tbl = xmalloc_clear (2048 * sizeof *tbl);
129
128
  return tbl;
130
129
}
131
130
 
207
206
 
208
207
    for (kr=kr_names; kr; kr = kr->next)
209
208
      {
210
 
        if ( !compare_filenames (kr->fname, fname) )
 
209
        if (same_file_p (kr->fname, fname))
211
210
          {
212
211
            *ptr=kr;
213
 
            return 0; /* already registered */
 
212
            return 0; /* Already registered.  */
214
213
          }
215
214
      }
216
215
 
 
216
    if (secret)
 
217
      register_secured_file (fname);
 
218
 
217
219
    kr = xmalloc (sizeof *kr + strlen (fname));
218
220
    strcpy (kr->fname, fname);
219
221
    kr->secret = !!secret;
255
257
 
256
258
  assert (resource && !resource->secret == !secret);
257
259
  
258
 
  hd = xcalloc (1,sizeof *hd);
 
260
  hd = xmalloc_clear (sizeof *hd);
259
261
  hd->resource = resource;
260
262
  hd->secret = !!secret;
261
263
  active_handles++;
304
306
                kr->lockhd = create_dotlock( kr->fname );
305
307
                if (!kr->lockhd) {
306
308
                    log_info ("can't allocate lock for `%s'\n", kr->fname );
307
 
                    rc = GPG_ERR_GENERAL;
 
309
                    rc = G10ERR_GENERAL;
308
310
                }
309
311
            }
310
312
        }
319
321
                ;
320
322
            else if (make_dotlock (kr->lockhd, -1) ) {
321
323
                log_info ("can't lock `%s'\n", kr->fname );
322
 
                rc = GPG_ERR_GENERAL;
 
324
                rc = G10ERR_GENERAL;
323
325
            }
324
326
            else 
325
327
                kr->is_locked = 1;
356
358
    PACKET *pkt;
357
359
    int rc;
358
360
    KBNODE keyblock = NULL, node, lastnode;
359
 
    iobuf_t a;
 
361
    IOBUF a;
360
362
    int in_cert = 0;
361
363
    int pk_no = 0;
362
364
    int uid_no = 0;
369
371
        return -1; /* no successful search */
370
372
 
371
373
    a = iobuf_open (hd->found.kr->fname);
372
 
    if (!a) {
373
 
        log_error ("can't open `%s'\n", hd->found.kr->fname);
374
 
        return GPG_ERR_KEYRING_OPEN;
375
 
    }
 
374
    if (!a)
 
375
      {
 
376
        log_error(_("can't open `%s'\n"), hd->found.kr->fname);
 
377
        return G10ERR_KEYRING_OPEN;
 
378
      }
376
379
 
377
380
    if (iobuf_seek (a, hd->found.offset) ) {
378
381
        log_error ("can't seek `%s'\n", hd->found.kr->fname);
379
382
        iobuf_close(a);
380
 
        return GPG_ERR_KEYRING_OPEN;
 
383
        return G10ERR_KEYRING_OPEN;
381
384
    }
382
385
 
383
386
    pkt = xmalloc (sizeof *pkt);
387
390
    save_mode = set_packet_list_mode(0);
388
391
    while ((rc=parse_packet (a, pkt)) != -1) {
389
392
        hd->found.n_packets++;
390
 
        if (gpg_err_code (rc) == GPG_ERR_UNKNOWN_PACKET) {
 
393
        if (rc == G10ERR_UNKNOWN_PACKET) {
391
394
            free_packet (pkt);
392
395
            init_packet (pkt);
393
396
            continue;
394
397
        }
395
398
        if (rc) {  
396
399
            log_error ("keyring_get_keyblock: read error: %s\n",
397
 
                       gpg_strerror (rc) );
398
 
            rc = GPG_ERR_INV_KEYRING;
 
400
                       g10_errstr(rc) );
 
401
            rc = G10ERR_INV_KEYRING;
399
402
            break;
400
403
        }
401
404
        if (pkt->pkttype == PKT_COMPRESSED) {
478
481
    /* Make sure that future search operations fail immediately when
479
482
     * we know that we are working on a invalid keyring 
480
483
     */
481
 
    if (gpg_err_code (rc) == GPG_ERR_INV_KEYRING)
 
484
    if (rc == G10ERR_INV_KEYRING)
482
485
        hd->current.error = rc;
483
486
 
484
487
    return rc;
496
499
        /* need to know the number of packets - do a dummy get_keyblock*/
497
500
        rc = keyring_get_keyblock (hd, NULL);
498
501
        if (rc) {
499
 
            log_error ("re-reading keyblock failed: %s\n", gpg_strerror (rc));
 
502
            log_error ("re-reading keyblock failed: %s\n", g10_errstr (rc));
500
503
            return rc;
501
504
        }
502
505
        if (!hd->found.n_packets)
540
543
        fname = hd->resource? hd->resource->fname:NULL;
541
544
 
542
545
    if (!fname)
543
 
        return GPG_ERR_GENERAL; 
 
546
        return G10ERR_GENERAL; 
544
547
 
545
548
    /* close this one otherwise we will lose the position for
546
549
     * a next search.  Fixme: it would be better to adjust the position
572
575
        /* need to know the number of packets - do a dummy get_keyblock*/
573
576
        rc = keyring_get_keyblock (hd, NULL);
574
577
        if (rc) {
575
 
            log_error ("re-reading keyblock failed: %s\n", gpg_strerror (rc));
 
578
            log_error ("re-reading keyblock failed: %s\n", g10_errstr (rc));
576
579
            return rc;
577
580
        }
578
581
        if (!hd->found.n_packets)
629
632
 
630
633
    if (hd->current.kr && !hd->current.eof) {
631
634
        if ( !hd->current.iobuf )
632
 
            return GPG_ERR_GENERAL; /* position invalid after a modify */
 
635
            return G10ERR_GENERAL; /* position invalid after a modify */
633
636
        return 0; /* okay */
634
637
    }
635
638
 
654
657
 
655
658
    hd->current.eof = 0;
656
659
    hd->current.iobuf = iobuf_open (hd->current.kr->fname);
657
 
    if (!hd->current.iobuf) {
658
 
        hd->current.error = gpg_error_from_errno (errno);
659
 
        log_error ("can't open `%s'\n", hd->current.kr->fname );
 
660
    if (!hd->current.iobuf)
 
661
      {
 
662
        hd->current.error = gpg_error_from_syserror ();
 
663
        log_error(_("can't open `%s'\n"), hd->current.kr->fname );
660
664
        return hd->current.error;
661
 
    }
 
665
      }
662
666
 
663
667
    return 0;
664
668
}
776
780
    int c;
777
781
 
778
782
    /* the original length is always enough for the pattern */
779
 
    p = pattern = xmalloc (strlen(name)+1);
 
783
    p = pattern = xmalloc(strlen(name)+1);
780
784
    do {
781
785
        /* skip leading delimiters */
782
786
        while( *name && !word_match_chars[*name] )
1071
1075
              goto found;
1072
1076
            break;
1073
1077
          default: 
1074
 
            rc = GPG_ERR_INV_ARG;
 
1078
            rc = G10ERR_INV_ARG;
1075
1079
            goto found;
1076
1080
          }
1077
1081
        }
1085
1089
      for (n=any_skip?0:ndesc; n < ndesc; n++) 
1086
1090
        {
1087
1091
          if (desc[n].skipfnc
1088
 
              && desc[n].skipfnc (desc[n].skipfncvalue, aki))
 
1092
              && desc[n].skipfnc (desc[n].skipfncvalue, aki, uid))
1089
1093
            break;
1090
1094
        }
1091
1095
      if (n == ndesc)
1141
1145
 
1142
1146
static int
1143
1147
create_tmp_file (const char *template,
1144
 
                 char **r_bakfname, char **r_tmpfname, iobuf_t *r_fp)
 
1148
                 char **r_bakfname, char **r_tmpfname, IOBUF *r_fp)
1145
1149
{  
1146
1150
  char *bakfname, *tmpfname;
1147
1151
  mode_t oldmask;
1184
1188
 
1185
1189
    /* Create the temp file with limited access */
1186
1190
    oldmask=umask(077);
1187
 
    *r_fp = iobuf_create (tmpfname);
 
1191
    if (is_secured_filename (tmpfname))
 
1192
      {
 
1193
        *r_fp = NULL;
 
1194
        errno = EPERM;
 
1195
      }
 
1196
    else
 
1197
      *r_fp = iobuf_create (tmpfname);
1188
1198
    umask(oldmask);
1189
 
    if (!*r_fp) {
1190
 
        int tmperr = gpg_error_from_errno (errno);
1191
 
        log_error ("can't create `%s': %s\n", tmpfname, strerror(errno) );
 
1199
    if (!*r_fp)
 
1200
      {
 
1201
        int rc = gpg_error_from_syserror ();
 
1202
        log_error(_("can't create `%s': %s\n"), tmpfname, strerror(errno) );
1192
1203
        xfree (tmpfname);
1193
1204
        xfree (bakfname);
1194
 
        return tmperr;
1195
 
    }
 
1205
        return rc;
 
1206
      }
1196
1207
    
1197
1208
    *r_bakfname = bakfname;
1198
1209
    *r_tmpfname = tmpfname;
1219
1230
#endif
1220
1231
      if (rename (fname, bakfname) )
1221
1232
        {
1222
 
          int tmperr = gpg_error_from_errno (errno);
 
1233
          rc = gpg_error_from_syserror ();
1223
1234
          log_error ("renaming `%s' to `%s' failed: %s\n",
1224
1235
                     fname, bakfname, strerror(errno) );
1225
 
          return tmperr;
 
1236
          return rc;
1226
1237
        }
1227
1238
    }
1228
1239
  
1230
1241
#if defined(HAVE_DOSISH_SYSTEM) || defined(__riscos__)
1231
1242
  remove( fname );
1232
1243
#endif
 
1244
  if (secret)
 
1245
    unregister_secured_file (fname);
1233
1246
  if (rename (tmpfname, fname) )
1234
1247
    {
1235
 
      rc = gpg_error_from_errno (errno);
1236
 
      log_error ("renaming `%s' to `%s' failed: %s\n",
 
1248
      rc = gpg_error_from_syserror ();
 
1249
      log_error (_("renaming `%s' to `%s' failed: %s\n"),
1237
1250
                 tmpfname, fname, strerror(errno) );
 
1251
      register_secured_file (fname);
1238
1252
      if (secret)
1239
1253
        {
1240
1254
          log_info(_("WARNING: 2 files with confidential"
1269
1283
 
1270
1284
 
1271
1285
static int
1272
 
write_keyblock (iobuf_t fp, KBNODE keyblock)
 
1286
write_keyblock (IOBUF fp, KBNODE keyblock)
1273
1287
{
1274
1288
  KBNODE kbctx = NULL, node;
1275
1289
  int rc;
1282
1296
      if ( (rc = build_packet (fp, node->pkt) ))
1283
1297
        {
1284
1298
          log_error ("build_packet(%d) failed: %s\n",
1285
 
                     node->pkt->pkttype, gpg_strerror (rc) );
 
1299
                     node->pkt->pkttype, g10_errstr(rc) );
1286
1300
          return rc;
1287
1301
        }
1288
1302
      if (node->pkt->pkttype == PKT_SIGNATURE) 
1299
1313
          iobuf_put (fp, 0xb0); /* old style packet 12, 1 byte len*/
1300
1314
          iobuf_put (fp, 2);    /* 2 bytes */
1301
1315
          iobuf_put (fp, 0);    /* unused */
1302
 
          if (iobuf_put (fp, cacheval)) {
1303
 
            int tmperr = gpg_error_from_errno (errno);
1304
 
            log_error ("writing sigcache packet failed\n");
1305
 
            return tmperr;
1306
 
          }
 
1316
          if (iobuf_put (fp, cacheval)) 
 
1317
            {
 
1318
              rc = gpg_error_from_syserror ();
 
1319
              log_error ("writing sigcache packet failed\n");
 
1320
              return rc;
 
1321
            }
1307
1322
        }
1308
1323
    }
1309
1324
  return 0;
1315
1330
 * This is only done for the public keyrings.
1316
1331
 */
1317
1332
int
1318
 
keyring_rebuild_cache (void *token)
 
1333
keyring_rebuild_cache (void *token,int noisy)
1319
1334
{
1320
1335
  KEYRING_HANDLE hd;
1321
1336
  KEYDB_SEARCH_DESC desc;
1322
1337
  KBNODE keyblock = NULL, node;
1323
1338
  const char *lastresname = NULL, *resname;
1324
 
  iobuf_t tmpfp = NULL;
 
1339
  IOBUF tmpfp = NULL;
1325
1340
  char *tmpfilename = NULL;
1326
1341
  char *bakfilename = NULL;
1327
1342
  int rc;
1345
1360
            {
1346
1361
              if (iobuf_close (tmpfp))
1347
1362
                {
1348
 
                  rc = gpg_error_from_errno (errno);
 
1363
                  rc = gpg_error_from_syserror ();
1349
1364
                  log_error ("error closing `%s': %s\n",
1350
1365
                             tmpfilename, strerror (errno));
1351
1366
                  goto leave;
1361
1376
          if (rc)
1362
1377
            goto leave;
1363
1378
          lastresname = resname;
1364
 
          if (!opt.quiet)
1365
 
            log_info (_("checking keyring `%s'\n"), resname);
 
1379
          if (noisy && !opt.quiet)
 
1380
            log_info (_("caching keyring `%s'\n"), resname);
1366
1381
          rc = create_tmp_file (resname, &bakfilename, &tmpfilename, &tmpfp);
1367
1382
          if (rc)
1368
1383
            goto leave;
1372
1387
      rc = keyring_get_keyblock (hd, &keyblock);
1373
1388
      if (rc) 
1374
1389
        {
1375
 
          log_error ("keyring_get_keyblock failed: %s\n", gpg_strerror (rc));
 
1390
          log_error ("keyring_get_keyblock failed: %s\n", g10_errstr(rc));
1376
1391
          goto leave;
1377
1392
        }
1378
1393
      assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
1380
1395
      /* check all signature to set the signature's cache flags */
1381
1396
      for (node=keyblock; node; node=node->next)
1382
1397
        {
 
1398
          /* Note that this doesn't cache the result of a revocation
 
1399
             issued by a designated revoker.  This is because the pk
 
1400
             in question does not carry the revkeys as we haven't
 
1401
             merged the key and selfsigs.  It is questionable whether
 
1402
             this matters very much since there are very very few
 
1403
             designated revoker revocation packets out there. */
 
1404
 
1383
1405
          if (node->pkt->pkttype == PKT_SIGNATURE)
1384
1406
            {
1385
 
              /* Note that this doesn't cache the result of a
1386
 
                 revocation issued by a designated revoker.  This is
1387
 
                 because the pk in question does not carry the revkeys
1388
 
                 as we haven't merged the key and selfsigs.  It is
1389
 
                 questionable whether this matters very much since
1390
 
                 there are very very few designated revoker revocation
1391
 
                 packets out there. */
1392
 
              check_key_signature (keyblock, node, NULL);
 
1407
              PKT_signature *sig=node->pkt->pkt.signature;
 
1408
 
 
1409
              if(!opt.no_sig_cache && sig->flags.checked && sig->flags.valid
 
1410
                 && (openpgp_md_test_algo(sig->digest_algo)
 
1411
                     || openpgp_pk_test_algo(sig->pubkey_algo)))
 
1412
                sig->flags.checked=sig->flags.valid=0;
 
1413
              else
 
1414
                check_key_signature (keyblock, node, NULL);
 
1415
 
1393
1416
              sigcount++;
1394
1417
            }
1395
1418
        }
1399
1422
      if (rc)
1400
1423
        goto leave;
1401
1424
 
1402
 
      if ( !(++count % 50) && !opt.quiet)
1403
 
        log_info(_("%lu keys checked so far (%lu signatures)\n"),
 
1425
      if ( !(++count % 50) && noisy && !opt.quiet)
 
1426
        log_info(_("%lu keys cached so far (%lu signatures)\n"),
1404
1427
                 count, sigcount );
1405
1428
 
1406
1429
    } /* end main loop */ 
1408
1431
    rc = 0;
1409
1432
  if (rc) 
1410
1433
    {
1411
 
      log_error ("keyring_search failed: %s\n", gpg_strerror (rc));
 
1434
      log_error ("keyring_search failed: %s\n", g10_errstr(rc));
1412
1435
      goto leave;
1413
1436
    }
1414
 
  log_info(_("%lu keys checked (%lu signatures)\n"), count, sigcount );
 
1437
  if(noisy || opt.verbose)
 
1438
    log_info(_("%lu keys cached (%lu signatures)\n"), count, sigcount );
1415
1439
  if (tmpfp)
1416
1440
    {
1417
1441
      if (iobuf_close (tmpfp))
1418
1442
        {
1419
 
          rc = gpg_error_from_errno (errno);
 
1443
          rc = gpg_error_from_syserror ();
1420
1444
          log_error ("error closing `%s': %s\n",
1421
1445
                     tmpfilename, strerror (errno));
1422
1446
          goto leave;
1452
1476
do_copy (int mode, const char *fname, KBNODE root, int secret,
1453
1477
         off_t start_offset, unsigned int n_packets )
1454
1478
{
1455
 
    iobuf_t fp, newfp;
 
1479
    IOBUF fp, newfp;
1456
1480
    int rc=0;
1457
1481
    char *bakfname = NULL;
1458
1482
    char *tmpfname = NULL;
1459
1483
 
1460
 
    /* Open the source file. Because we do a rname, we have to check the 
 
1484
    /* Open the source file. Because we do a rename, we have to check the 
1461
1485
       permissions of the file */
1462
1486
    if (access (fname, W_OK))
1463
 
      return gpg_error_from_errno (errno);
1464
 
 
 
1487
      return gpg_error_from_syserror ();
1465
1488
 
1466
1489
    fp = iobuf_open (fname);
1467
1490
    if (mode == 1 && !fp && errno == ENOENT) { 
1470
1493
        mode_t oldmask;
1471
1494
 
1472
1495
        oldmask=umask(077);
1473
 
        newfp = iobuf_create (fname);
 
1496
        if (!secret && is_secured_filename (fname)) {
 
1497
            newfp = NULL;
 
1498
            errno = EPERM;
 
1499
        }
 
1500
        else
 
1501
            newfp = iobuf_create (fname);
1474
1502
        umask(oldmask);
1475
 
        if( !newfp ) {
1476
 
            int tmperr = gpg_error_from_errno (errno);
1477
 
            log_error (_("%s: can't create: %s\n"),
1478
 
                       fname, strerror(errno));
1479
 
            return tmperr;
1480
 
        }
 
1503
        if( !newfp )
 
1504
          {
 
1505
            rc = gpg_error_from_syserror ();
 
1506
            log_error (_("can't create `%s': %s\n"), fname, strerror(errno));
 
1507
            return rc;
 
1508
          }
1481
1509
        if( !opt.quiet )
1482
1510
            log_info(_("%s: keyring created\n"), fname );
1483
1511
 
1485
1513
        while ( (node = walk_kbnode( root, &kbctx, 0 )) ) {
1486
1514
            if( (rc = build_packet( newfp, node->pkt )) ) {
1487
1515
                log_error("build_packet(%d) failed: %s\n",
1488
 
                            node->pkt->pkttype, gpg_strerror (rc) );
 
1516
                            node->pkt->pkttype, g10_errstr(rc) );
1489
1517
                iobuf_cancel(newfp);
1490
1518
                return rc;
1491
1519
            }
1492
1520
        }
1493
 
        if (iobuf_close(newfp)) {
1494
 
            int tmperr = gpg_error_from_errno (errno);
 
1521
        if( iobuf_close(newfp) ) {
 
1522
            rc = gpg_error_from_syserror ();
1495
1523
            log_error ("%s: close failed: %s\n", fname, strerror(errno));
1496
 
            return tmperr;
 
1524
            return rc;
1497
1525
        }
1498
1526
        return 0; /* ready */
1499
1527
    }
1500
1528
 
1501
 
    if( !fp ) {
1502
 
        rc = gpg_error_from_errno (errno);
1503
 
        log_error ("%s: can't open: %s\n", fname, strerror(errno) );
 
1529
    if( !fp )
 
1530
      {
 
1531
        rc = gpg_error_from_syserror ();
 
1532
        log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
1504
1533
        goto leave;
1505
 
    }
 
1534
      }
1506
1535
 
1507
 
    /* create the new file */
 
1536
    /* Create the new file.  */
1508
1537
    rc = create_tmp_file (fname, &bakfname, &tmpfname, &newfp);
1509
1538
    if (rc) {
1510
1539
        iobuf_close(fp);
1511
1540
        goto leave;
1512
1541
    }
 
1542
    if (secret)
 
1543
      register_secured_file (tmpfname);
 
1544
 
1513
1545
    if( mode == 1 ) { /* insert */
1514
1546
        /* copy everything to the new file */
1515
1547
        rc = copy_all_packets (fp, newfp);
1516
1548
        if( rc != -1 ) {
1517
1549
            log_error("%s: copy to `%s' failed: %s\n",
1518
 
                      fname, tmpfname, gpg_strerror (rc) );
 
1550
                      fname, tmpfname, g10_errstr(rc) );
1519
1551
            iobuf_close(fp);
 
1552
            if (secret)
 
1553
              unregister_secured_file (tmpfname);
1520
1554
            iobuf_cancel(newfp);
1521
1555
            goto leave;
1522
1556
        }
1528
1562
        rc = copy_some_packets( fp, newfp, start_offset );
1529
1563
        if( rc ) { /* should never get EOF here */
1530
1564
            log_error ("%s: copy to `%s' failed: %s\n",
1531
 
                       fname, tmpfname, gpg_strerror (rc) );
 
1565
                       fname, tmpfname, g10_errstr(rc) );
1532
1566
            iobuf_close(fp);
 
1567
            if (secret)
 
1568
              unregister_secured_file (tmpfname);
1533
1569
            iobuf_cancel(newfp);
1534
1570
            goto leave;
1535
1571
        }
1538
1574
        rc = skip_some_packets( fp, n_packets );
1539
1575
        if( rc ) {
1540
1576
            log_error("%s: skipping %u packets failed: %s\n",
1541
 
                            fname, n_packets, gpg_strerror (rc));
 
1577
                            fname, n_packets, g10_errstr(rc));
1542
1578
            iobuf_close(fp);
 
1579
            if (secret)
 
1580
              unregister_secured_file (tmpfname);
1543
1581
            iobuf_cancel(newfp);
1544
1582
            goto leave;
1545
1583
        }
1549
1587
        rc = write_keyblock (newfp, root);
1550
1588
        if (rc) {
1551
1589
          iobuf_close(fp);
 
1590
          if (secret)
 
1591
            unregister_secured_file (tmpfname);
1552
1592
          iobuf_cancel(newfp);
1553
1593
          goto leave;
1554
1594
        }
1559
1599
        rc = copy_all_packets( fp, newfp );
1560
1600
        if( rc != -1 ) {
1561
1601
            log_error("%s: copy to `%s' failed: %s\n",
1562
 
                      fname, tmpfname, gpg_strerror (rc) );
 
1602
                      fname, tmpfname, g10_errstr(rc) );
1563
1603
            iobuf_close(fp);
 
1604
            if (secret)
 
1605
              unregister_secured_file (tmpfname);
1564
1606
            iobuf_cancel(newfp);
1565
1607
            goto leave;
1566
1608
        }
1569
1611
 
1570
1612
    /* close both files */
1571
1613
    if( iobuf_close(fp) ) {
1572
 
        rc = gpg_error_from_errno (errno);
 
1614
        rc = gpg_error_from_syserror ();
1573
1615
        log_error("%s: close failed: %s\n", fname, strerror(errno) );
1574
1616
        goto leave;
1575
1617
    }
1576
1618
    if( iobuf_close(newfp) ) {
1577
 
        rc = gpg_error_from_errno (errno);
 
1619
        rc = gpg_error_from_syserror ();
1578
1620
        log_error("%s: close failed: %s\n", tmpfname, strerror(errno) );
1579
1621
        goto leave;
1580
1622
    }
1582
1624
    rc = rename_tmp_file (bakfname, tmpfname, fname, secret);
1583
1625
 
1584
1626
  leave:
1585
 
    xfree (bakfname);
1586
 
    xfree (tmpfname);
 
1627
    xfree(bakfname);
 
1628
    xfree(tmpfname);
1587
1629
    return rc;
1588
1630
}