← Back to branch summary

~thopiekar/zypper/libzypp-manual-import

« back to all changes in this revision

Viewing changes to zypp/target/rpm/RpmHeader.cc

  • Committer: Thomas-Karl Pietrowski
  • Date: 2014-01-29 22:44:28 UTC
  • Revision ID: thopiekar@googlemail.com-20140129224428-gpcqnsdakby362n8
first import

Show diffs side-by-side

added added

removed removed

Lines of Context:
zypp/target/rpm/RpmHeader.cc
 
1
/*---------------------------------------------------------------------\
 
2
|                          ____ _   __ __ ___                          |
 
3
|                         |__  / \ / / . \ . \                         |
 
4
|                           / / \ V /|  _/  _/                         |
 
5
|                          / /__ | | | | | |                           |
 
6
|                         /_____||_| |_| |_|                           |
 
7
|                                                                      |
 
8
\---------------------------------------------------------------------*/
 
9
/** \file zypp/target/rpm/RpmHeader.cc
 
10
 *
 
11
*/
 
12
#include "librpm.h"
 
13
#ifdef _RPM_4_4
 
14
#include <rpm/ugid.h>
 
15
#else
 
16
////////////////////////////////////////////////////////////////////
 
17
// unameToUid and gnameToGid are shamelessly stolen from rpm-4.4.
 
18
// (rpmio/ugid.c) Those functions were dropped in RPM_4_7
 
19
extern "C"
 
20
{
 
21
#include <pwd.h>
 
22
#include <grp.h>
 
23
}
 
24
/* unameToUid(), uidTouname() and the group variants are really poorly
 
25
   implemented. They really ought to use hash tables. I just made the
 
26
   guess that most files would be owned by root or the same person/group
 
27
   who owned the last file. Those two values are cached, everything else
 
28
   is looked up via getpw() and getgr() functions.  If this performs
 
29
   too poorly I'll have to implement it properly :-( */
 
30
 
 
31
int unameToUid(const char * thisUname, uid_t * uid)
 
32
{
 
33
/*@only@*/ static char * lastUname = NULL;
 
34
    static size_t lastUnameLen = 0;
 
35
    static size_t lastUnameAlloced;
 
36
    static uid_t lastUid;
 
37
    struct passwd * pwent;
 
38
    size_t thisUnameLen;
 
39
 
 
40
    if (!thisUname) {
 
41
        lastUnameLen = 0;
 
42
        return -1;
 
43
    } else if (strcmp(thisUname, "root") == 0) {
 
44
/*@-boundswrite@*/
 
45
        *uid = 0;
 
46
/*@=boundswrite@*/
 
47
        return 0;
 
48
    }
 
49
 
 
50
    thisUnameLen = strlen(thisUname);
 
51
    if (lastUname == NULL || thisUnameLen != lastUnameLen ||
 
52
        strcmp(thisUname, lastUname) != 0)
 
53
    {
 
54
        if (lastUnameAlloced < thisUnameLen + 1) {
 
55
            lastUnameAlloced = thisUnameLen + 10;
 
56
            lastUname = (char *)realloc(lastUname, lastUnameAlloced);   /* XXX memory leak */
 
57
        }
 
58
/*@-boundswrite@*/
 
59
        strcpy(lastUname, thisUname);
 
60
/*@=boundswrite@*/
 
61
 
 
62
        pwent = getpwnam(thisUname);
 
63
        if (pwent == NULL) {
 
64
            /*@-internalglobs@*/ /* FIX: shrug */
 
65
            endpwent();
 
66
            /*@=internalglobs@*/
 
67
            pwent = getpwnam(thisUname);
 
68
            if (pwent == NULL) return -1;
 
69
        }
 
70
 
 
71
        lastUid = pwent->pw_uid;
 
72
    }
 
73
 
 
74
/*@-boundswrite@*/
 
75
    *uid = lastUid;
 
76
/*@=boundswrite@*/
 
77
 
 
78
    return 0;
 
79
}
 
80
 
 
81
int gnameToGid(const char * thisGname, gid_t * gid)
 
82
{
 
83
/*@only@*/ static char * lastGname = NULL;
 
84
    static size_t lastGnameLen = 0;
 
85
    static size_t lastGnameAlloced;
 
86
    static gid_t lastGid;
 
87
    size_t thisGnameLen;
 
88
    struct group * grent;
 
89
 
 
90
    if (thisGname == NULL) {
 
91
        lastGnameLen = 0;
 
92
        return -1;
 
93
    } else if (strcmp(thisGname, "root") == 0) {
 
94
/*@-boundswrite@*/
 
95
        *gid = 0;
 
96
/*@=boundswrite@*/
 
97
        return 0;
 
98
    }
 
99
 
 
100
    thisGnameLen = strlen(thisGname);
 
101
    if (lastGname == NULL || thisGnameLen != lastGnameLen ||
 
102
        strcmp(thisGname, lastGname) != 0)
 
103
    {
 
104
        if (lastGnameAlloced < thisGnameLen + 1) {
 
105
            lastGnameAlloced = thisGnameLen + 10;
 
106
            lastGname = (char *)realloc(lastGname, lastGnameAlloced);   /* XXX memory leak */
 
107
        }
 
108
/*@-boundswrite@*/
 
109
        strcpy(lastGname, thisGname);
 
110
/*@=boundswrite@*/
 
111
 
 
112
        grent = getgrnam(thisGname);
 
113
        if (grent == NULL) {
 
114
            /*@-internalglobs@*/ /* FIX: shrug */
 
115
            endgrent();
 
116
            /*@=internalglobs@*/
 
117
            grent = getgrnam(thisGname);
 
118
            if (grent == NULL) {
 
119
                /* XXX The filesystem package needs group/lock w/o getgrnam. */
 
120
                if (strcmp(thisGname, "lock") == 0) {
 
121
/*@-boundswrite@*/
 
122
                    *gid = lastGid = 54;
 
123
/*@=boundswrite@*/
 
124
                    return 0;
 
125
                } else
 
126
                if (strcmp(thisGname, "mail") == 0) {
 
127
/*@-boundswrite@*/
 
128
                    *gid = lastGid = 12;
 
129
/*@=boundswrite@*/
 
130
                    return 0;
 
131
                } else
 
132
                return -1;
 
133
            }
 
134
        }
 
135
        lastGid = grent->gr_gid;
 
136
    }
 
137
 
 
138
/*@-boundswrite@*/
 
139
    *gid = lastGid;
 
140
/*@=boundswrite@*/
 
141
 
 
142
    return 0;
 
143
}
 
144
////////////////////////////////////////////////////////////////////
 
145
#endif
 
146
 
 
147
#include <iostream>
 
148
#include <map>
 
149
#include <set>
 
150
#include <vector>
 
151
 
 
152
#include "zypp/base/Easy.h"
 
153
#include "zypp/base/Logger.h"
 
154
#include "zypp/base/Exception.h"
 
155
 
 
156
#include "zypp/target/rpm/librpmDb.h"
 
157
#include "zypp/target/rpm/RpmHeader.h"
 
158
#include "zypp/Package.h"
 
159
#include "zypp/PathInfo.h"
 
160
 
 
161
using std::endl;
 
162
 
 
163
namespace zypp
 
164
{
 
165
namespace target
 
166
{
 
167
namespace rpm
 
168
{
 
169
 
 
170
///////////////////////////////////////////////////////////////////
 
171
 
 
172
///////////////////////////////////////////////////////////////////
 
173
//
 
174
//
 
175
//        METHOD NAME : RpmHeader::RpmHeader
 
176
//        METHOD TYPE : Constructor
 
177
//
 
178
//        DESCRIPTION :
 
179
//
 
180
RpmHeader::RpmHeader( Header h_r )
 
181
    : BinHeader( h_r )
 
182
{}
 
183
 
 
184
///////////////////////////////////////////////////////////////////
 
185
//
 
186
//
 
187
//        METHOD NAME : RpmHeader::RpmHeader
 
188
//        METHOD TYPE : Constructor
 
189
//
 
190
RpmHeader::RpmHeader( BinHeader::Ptr & rhs )
 
191
    : BinHeader( rhs )
 
192
{}
 
193
 
 
194
///////////////////////////////////////////////////////////////////
 
195
//
 
196
//
 
197
//        METHOD NAME : RpmHeader::~RpmHeader
 
198
//        METHOD TYPE : Destructor
 
199
//
 
200
//        DESCRIPTION :
 
201
//
 
202
RpmHeader::~RpmHeader()
 
203
{}
 
204
 
 
205
///////////////////////////////////////////////////////////////////
 
206
//
 
207
//
 
208
//        METHOD NAME : RpmHeader::readPackage
 
209
//        METHOD TYPE : constRpmHeaderPtr
 
210
//
 
211
RpmHeader::constPtr RpmHeader::readPackage( const Pathname & path_r,
 
212
                                            VERIFICATION verification_r )
 
213
{
 
214
  PathInfo file( path_r );
 
215
  if ( ! file.isFile() )
 
216
  {
 
217
    ERR << "Not a file: " << file << endl;
 
218
    return (RpmHeader*)0;
 
219
  }
 
220
 
 
221
  FD_t fd = ::Fopen( file.asString().c_str(), "r.ufdio" );
 
222
  if ( fd == 0 || ::Ferror(fd) )
 
223
  {
 
224
    ERR << "Can't open file for reading: " << file << " (" << ::Fstrerror(fd) << ")" << endl;
 
225
    if ( fd )
 
226
      ::Fclose( fd );
 
227
    return (RpmHeader*)0;
 
228
  }
 
229
 
 
230
  librpmDb::globalInit();
 
231
  rpmts ts = ::rpmtsCreate();
 
232
  unsigned vsflag = RPMVSF_DEFAULT;
 
233
  if ( verification_r & NODIGEST )
 
234
    vsflag |= _RPMVSF_NODIGESTS;
 
235
  if ( verification_r & NOSIGNATURE )
 
236
    vsflag |= _RPMVSF_NOSIGNATURES;
 
237
  ::rpmtsSetVSFlags( ts, rpmVSFlags(vsflag) );
 
238
 
 
239
  Header nh = 0;
 
240
  int res = ::rpmReadPackageFile( ts, fd, path_r.asString().c_str(), &nh );
 
241
 
 
242
  ts = rpmtsFree(ts);
 
243
 
 
244
  ::Fclose( fd );
 
245
 
 
246
  if ( ! nh )
 
247
  {
 
248
    WAR << "Error reading header from " << path_r << " error(" << res << ")" << endl;
 
249
    return (RpmHeader*)0;
 
250
  }
 
251
 
 
252
  RpmHeader::constPtr h( new RpmHeader( nh ) );
 
253
  headerFree( nh ); // clear the reference set in ReadPackageFile
 
254
 
 
255
  MIL << h << " from " << path_r << endl;
 
256
  return h;
 
257
}
 
258
 
 
259
///////////////////////////////////////////////////////////////////
 
260
//
 
261
//
 
262
//        METHOD NAME : RpmHeader::dumpOn
 
263
//        METHOD TYPE : std::ostream &
 
264
//
 
265
//        DESCRIPTION :
 
266
//
 
267
std::ostream & RpmHeader::dumpOn( std::ostream & str ) const
 
268
{
 
269
  return BinHeader::dumpOn( str ) << '{' << tag_name() << "-"
 
270
         << (tag_epoch()==0?"":(tag_epoch()+":"))
 
271
         << tag_version()
 
272
         << (tag_release().empty()?"":(std::string("-")+tag_release()))
 
273
         << ( isSrc() ? ".src}" : "}");
 
274
}
 
275
 
 
276
 
 
277
///////////////////////////////////////////////////////////////////
 
278
//
 
279
//
 
280
//        METHOD NAME : RpmHeader::isSrc
 
281
//        METHOD TYPE : bool
 
282
//
 
283
bool RpmHeader::isSrc() const
 
284
{
 
285
  return has_tag( RPMTAG_SOURCEPACKAGE );
 
286
}
 
287
 
 
288
bool RpmHeader::isNosrc() const
 
289
{
 
290
  return has_tag( RPMTAG_SOURCEPACKAGE ) && ( has_tag( RPMTAG_NOSOURCE ) || has_tag( RPMTAG_NOPATCH ) );
 
291
}
 
292
 
 
293
///////////////////////////////////////////////////////////////////
 
294
//
 
295
//
 
296
//        METHOD NAME : RpmHeader::tag_name
 
297
//        METHOD TYPE : std::string
 
298
//
 
299
//        DESCRIPTION :
 
300
//
 
301
std::string RpmHeader::tag_name() const
 
302
{
 
303
  return string_val( RPMTAG_NAME );
 
304
}
 
305
 
 
306
///////////////////////////////////////////////////////////////////
 
307
//
 
308
//
 
309
//        METHOD NAME : RpmHeader::tag_epoch
 
310
//        METHOD TYPE : Edition::epoch_t
 
311
//
 
312
//        DESCRIPTION :
 
313
//
 
314
Edition::epoch_t RpmHeader::tag_epoch() const
 
315
{
 
316
  return int_val ( RPMTAG_EPOCH );
 
317
}
 
318
 
 
319
///////////////////////////////////////////////////////////////////
 
320
//
 
321
//
 
322
//        METHOD NAME : RpmHeader::tag_version
 
323
//        METHOD TYPE : std::string
 
324
//
 
325
//        DESCRIPTION :
 
326
//
 
327
std::string RpmHeader::tag_version() const
 
328
{
 
329
  return string_val ( RPMTAG_VERSION );
 
330
}
 
331
 
 
332
///////////////////////////////////////////////////////////////////
 
333
//
 
334
//
 
335
//        METHOD NAME : RpmHeader::tag_release
 
336
//        METHOD TYPE : std::string
 
337
//
 
338
//        DESCRIPTION :
 
339
//
 
340
std::string RpmHeader::tag_release() const
 
341
{
 
342
  return string_val( RPMTAG_RELEASE );
 
343
}
 
344
 
 
345
///////////////////////////////////////////////////////////////////
 
346
//
 
347
//
 
348
//        METHOD NAME : RpmHeader::tag_edition
 
349
//        METHOD TYPE : Edition
 
350
//
 
351
//        DESCRIPTION :
 
352
//
 
353
Edition RpmHeader::tag_edition () const
 
354
{
 
355
  return Edition( tag_version(), tag_release(), tag_epoch() );
 
356
}
 
357
 
 
358
///////////////////////////////////////////////////////////////////
 
359
//
 
360
//
 
361
//        METHOD NAME : RpmHeader::tag_arch
 
362
//        METHOD TYPE : Arch
 
363
//
 
364
//        DESCRIPTION :
 
365
//
 
366
Arch RpmHeader::tag_arch() const
 
367
{
 
368
  return Arch( string_val( RPMTAG_ARCH ) );
 
369
}
 
370
 
 
371
///////////////////////////////////////////////////////////////////
 
372
//
 
373
//
 
374
//        METHOD NAME : RpmHeader::tag_installtime
 
375
//        METHOD TYPE : Date
 
376
//
 
377
//        DESCRIPTION :
 
378
//
 
379
Date RpmHeader::tag_installtime() const
 
380
{
 
381
  return int_val( RPMTAG_INSTALLTIME );
 
382
}
 
383
 
 
384
///////////////////////////////////////////////////////////////////
 
385
//
 
386
//
 
387
//        METHOD NAME : RpmHeader::tag_buildtime
 
388
//        METHOD TYPE : Date
 
389
//
 
390
//        DESCRIPTION :
 
391
//
 
392
Date RpmHeader::tag_buildtime() const
 
393
{
 
394
  return int_val( RPMTAG_BUILDTIME );
 
395
}
 
396
#warning CHECK IF FILE REQUIRES HANDLING IS OBSOLETE
 
397
///////////////////////////////////////////////////////////////////
 
398
//
 
399
//
 
400
//        METHOD NAME : RpmHeader::PkgRelList_val
 
401
//        METHOD TYPE : CapabilitySet
 
402
//
 
403
//        DESCRIPTION :
 
404
//
 
405
CapabilitySet RpmHeader::PkgRelList_val( tag tag_r, bool pre, std::set<std::string> * freq_r ) const
 
406
  {
 
407
    CapabilitySet ret;
 
408
 
 
409
    rpmTag  kindFlags   = rpmTag(0);
 
410
    rpmTag  kindVersion = rpmTag(0);
 
411
 
 
412
    switch ( tag_r )
 
413
    {
 
414
    case RPMTAG_REQUIRENAME:
 
415
      kindFlags   = RPMTAG_REQUIREFLAGS;
 
416
      kindVersion = RPMTAG_REQUIREVERSION;
 
417
      break;
 
418
    case RPMTAG_PROVIDENAME:
 
419
      kindFlags   = RPMTAG_PROVIDEFLAGS;
 
420
      kindVersion = RPMTAG_PROVIDEVERSION;
 
421
      break;
 
422
    case RPMTAG_OBSOLETENAME:
 
423
      kindFlags   = RPMTAG_OBSOLETEFLAGS;
 
424
      kindVersion = RPMTAG_OBSOLETEVERSION;
 
425
      break;
 
426
    case RPMTAG_CONFLICTNAME:
 
427
      kindFlags   = RPMTAG_CONFLICTFLAGS;
 
428
      kindVersion = RPMTAG_CONFLICTVERSION;
 
429
      break;
 
430
    case RPMTAG_ENHANCESNAME:
 
431
      kindFlags   = RPMTAG_ENHANCESFLAGS;
 
432
      kindVersion = RPMTAG_ENHANCESVERSION;
 
433
      break;
 
434
    case RPMTAG_SUGGESTSNAME:
 
435
      kindFlags   = RPMTAG_SUGGESTSFLAGS;
 
436
      kindVersion = RPMTAG_SUGGESTSVERSION;
 
437
      break;
 
438
    default:
 
439
      INT << "Illegal RPMTAG_dependencyNAME " << tag_r << endl;
 
440
      return ret;
 
441
      break;
 
442
    }
 
443
 
 
444
    stringList names;
 
445
    unsigned count = string_list( tag_r, names );
 
446
    if ( !count )
 
447
      return ret;
 
448
 
 
449
    intList  flags;
 
450
    int_list( kindFlags, flags );
 
451
 
 
452
    stringList versions;
 
453
    string_list( kindVersion, versions );
 
454
 
 
455
    for ( unsigned i = 0; i < count; ++i )
 
456
    {
 
457
 
 
458
      std::string n( names[i] );
 
459
 
 
460
      Rel op = Rel::ANY;
 
461
      int32_t f = flags[i];
 
462
      std::string v = versions[i];
 
463
 
 
464
      if ( n[0] == '/' )
 
465
      {
 
466
        if ( freq_r )
 
467
        {
 
468
          freq_r->insert( n );
 
469
        }
 
470
      }
 
471
      else
 
472
      {
 
473
        if ( v.size() )
 
474
        {
 
475
          switch ( f & RPMSENSE_SENSEMASK )
 
476
          {
 
477
          case RPMSENSE_LESS:
 
478
            op = Rel::LT;
 
479
            break;
 
480
          case RPMSENSE_LESS|RPMSENSE_EQUAL:
 
481
            op = Rel::LE;
 
482
            break;
 
483
          case RPMSENSE_GREATER:
 
484
            op = Rel::GT;
 
485
            break;
 
486
          case RPMSENSE_GREATER|RPMSENSE_EQUAL:
 
487
            op = Rel::GE;
 
488
            break;
 
489
          case RPMSENSE_EQUAL:
 
490
            op = Rel::EQ;
 
491
            break;
 
492
          }
 
493
        }
 
494
      }
 
495
      if ((pre && (f & RPMSENSE_PREREQ))
 
496
          || ((! pre) && !(f & RPMSENSE_PREREQ)))
 
497
      {
 
498
        try
 
499
        {
 
500
          ret.insert( Capability( n, op, Edition(v) ) );
 
501
        }
 
502
        catch (Exception & excpt_r)
 
503
        {
 
504
          ZYPP_CAUGHT(excpt_r);
 
505
          WAR << "Invalid capability: " << n << " " << op << " "
 
506
          << v << endl;
 
507
        }
 
508
      }
 
509
    }
 
510
 
 
511
    return ret;
 
512
  }
 
513
 
 
514
///////////////////////////////////////////////////////////////////
 
515
//
 
516
//
 
517
//        METHOD NAME : RpmHeader::tag_provides
 
518
//        METHOD TYPE : CapabilitySet
 
519
//
 
520
//        DESCRIPTION :
 
521
//
 
522
CapabilitySet RpmHeader::tag_provides( std::set<std::string> * freq_r ) const
 
523
  {
 
524
    return PkgRelList_val( RPMTAG_PROVIDENAME, false, freq_r );
 
525
  }
 
526
 
 
527
///////////////////////////////////////////////////////////////////
 
528
//
 
529
//
 
530
//        METHOD NAME : RpmHeader::tag_requires
 
531
//        METHOD TYPE : CapabilitySet
 
532
//
 
533
//        DESCRIPTION :
 
534
//
 
535
CapabilitySet RpmHeader::tag_requires( std::set<std::string> * freq_r ) const
 
536
  {
 
537
    return PkgRelList_val( RPMTAG_REQUIRENAME, false, freq_r );
 
538
  }
 
539
 
 
540
///////////////////////////////////////////////////////////////////
 
541
//
 
542
//
 
543
//        METHOD NAME : RpmHeader::tag_requires
 
544
//        METHOD TYPE : CapabilitySet
 
545
//
 
546
//        DESCRIPTION :
 
547
//
 
548
CapabilitySet RpmHeader::tag_prerequires( std::set<std::string> * freq_r ) const
 
549
  {
 
550
    return PkgRelList_val( RPMTAG_REQUIRENAME, true, freq_r );
 
551
  }
 
552
 
 
553
///////////////////////////////////////////////////////////////////
 
554
//
 
555
//
 
556
//        METHOD NAME : RpmHeader::tag_conflicts
 
557
//        METHOD TYPE : CapabilitySet
 
558
//
 
559
//        DESCRIPTION :
 
560
//
 
561
CapabilitySet RpmHeader::tag_conflicts( std::set<std::string> * freq_r ) const
 
562
  {
 
563
    return PkgRelList_val( RPMTAG_CONFLICTNAME, false, freq_r );
 
564
  }
 
565
 
 
566
///////////////////////////////////////////////////////////////////
 
567
//
 
568
//
 
569
//        METHOD NAME : RpmHeader::tag_obsoletes
 
570
//        METHOD TYPE : CapabilitySet
 
571
//
 
572
//        DESCRIPTION :
 
573
//
 
574
CapabilitySet RpmHeader::tag_obsoletes( std::set<std::string> * freq_r ) const
 
575
  {
 
576
    return PkgRelList_val( RPMTAG_OBSOLETENAME, false, freq_r );
 
577
  }
 
578
 
 
579
///////////////////////////////////////////////////////////////////
 
580
//
 
581
//
 
582
//        METHOD NAME : RpmHeader::tag_enhances
 
583
//        METHOD TYPE : CapabilitySet
 
584
//
 
585
//        DESCRIPTION :
 
586
//
 
587
CapabilitySet RpmHeader::tag_enhances( std::set<std::string> * freq_r ) const
 
588
  {
 
589
    return PkgRelList_val( RPMTAG_ENHANCESNAME, false, freq_r );
 
590
  }
 
591
 
 
592
///////////////////////////////////////////////////////////////////
 
593
//
 
594
//
 
595
//        METHOD NAME : RpmHeader::tag_suggests
 
596
//        METHOD TYPE : CapabilitySet
 
597
//
 
598
//        DESCRIPTION :
 
599
//
 
600
CapabilitySet RpmHeader::tag_suggests( std::set<std::string> * freq_r ) const
 
601
  {
 
602
    return PkgRelList_val( RPMTAG_SUGGESTSNAME, false, freq_r );
 
603
  }
 
604
 
 
605
///////////////////////////////////////////////////////////////////
 
606
//
 
607
//
 
608
//        METHOD NAME : RpmHeader::tag_size
 
609
//        METHOD TYPE : ByteCount
 
610
//
 
611
//        DESCRIPTION :
 
612
//
 
613
ByteCount RpmHeader::tag_size() const
 
614
{
 
615
  return int_val( RPMTAG_SIZE );
 
616
}
 
617
 
 
618
///////////////////////////////////////////////////////////////////
 
619
//
 
620
//
 
621
//        METHOD NAME : RpmHeader::tag_archivesize
 
622
//        METHOD TYPE : ByteCount
 
623
//
 
624
//        DESCRIPTION :
 
625
//
 
626
ByteCount RpmHeader::tag_archivesize() const
 
627
{
 
628
  return int_val( RPMTAG_ARCHIVESIZE );
 
629
}
 
630
 
 
631
///////////////////////////////////////////////////////////////////
 
632
//
 
633
//
 
634
//        METHOD NAME : RpmHeader::tag_summary
 
635
//        METHOD TYPE : std::string
 
636
//
 
637
//        DESCRIPTION :
 
638
//
 
639
std::string RpmHeader::tag_summary() const
 
640
{
 
641
  return string_val( RPMTAG_SUMMARY );
 
642
}
 
643
 
 
644
///////////////////////////////////////////////////////////////////
 
645
//
 
646
//
 
647
//        METHOD NAME : RpmHeader::tag_description
 
648
//        METHOD TYPE : std::string
 
649
//
 
650
//        DESCRIPTION :
 
651
//
 
652
std::string RpmHeader::tag_description() const
 
653
{
 
654
  return string_val( RPMTAG_DESCRIPTION );
 
655
}
 
656
 
 
657
///////////////////////////////////////////////////////////////////
 
658
//
 
659
//
 
660
//        METHOD NAME : RpmHeader::tag_group
 
661
//        METHOD TYPE : std::string
 
662
//
 
663
//        DESCRIPTION :
 
664
//
 
665
std::string RpmHeader::tag_group() const
 
666
{
 
667
  return string_val( RPMTAG_GROUP );
 
668
}
 
669
 
 
670
///////////////////////////////////////////////////////////////////
 
671
//
 
672
//
 
673
//        METHOD NAME : RpmHeader::tag_vendor
 
674
//        METHOD TYPE : std::string
 
675
//
 
676
//        DESCRIPTION :
 
677
//
 
678
std::string RpmHeader::tag_vendor() const
 
679
{
 
680
  return string_val( RPMTAG_VENDOR );
 
681
}
 
682
 
 
683
///////////////////////////////////////////////////////////////////
 
684
//
 
685
//
 
686
//        METHOD NAME : RpmHeader::tag_distribution
 
687
//        METHOD TYPE : std::string
 
688
//
 
689
//        DESCRIPTION :
 
690
//
 
691
std::string RpmHeader::tag_distribution() const
 
692
{
 
693
  return string_val( RPMTAG_DISTRIBUTION );
 
694
}
 
695
 
 
696
///////////////////////////////////////////////////////////////////
 
697
//
 
698
//
 
699
//        METHOD NAME : RpmHeader::tag_license
 
700
//        METHOD TYPE : std::string
 
701
//
 
702
//        DESCRIPTION :
 
703
//
 
704
std::string RpmHeader::tag_license() const
 
705
{
 
706
  return string_val( RPMTAG_LICENSE );
 
707
}
 
708
 
 
709
///////////////////////////////////////////////////////////////////
 
710
//
 
711
//
 
712
//        METHOD NAME : RpmHeader::tag_buildhost
 
713
//        METHOD TYPE : std::string
 
714
//
 
715
//        DESCRIPTION :
 
716
//
 
717
std::string RpmHeader::tag_buildhost() const
 
718
{
 
719
  return string_val( RPMTAG_BUILDHOST );
 
720
}
 
721
 
 
722
///////////////////////////////////////////////////////////////////
 
723
//
 
724
//
 
725
//        METHOD NAME : RpmHeader::tag_packager
 
726
//        METHOD TYPE : std::string
 
727
//
 
728
//        DESCRIPTION :
 
729
//
 
730
std::string RpmHeader::tag_packager() const
 
731
{
 
732
  return string_val( RPMTAG_PACKAGER );
 
733
}
 
734
 
 
735
///////////////////////////////////////////////////////////////////
 
736
//
 
737
//
 
738
//        METHOD NAME : RpmHeader::tag_url
 
739
//        METHOD TYPE : std::string
 
740
//
 
741
//        DESCRIPTION :
 
742
//
 
743
std::string RpmHeader::tag_url() const
 
744
{
 
745
  return string_val( RPMTAG_URL );
 
746
}
 
747
 
 
748
///////////////////////////////////////////////////////////////////
 
749
//
 
750
//
 
751
//        METHOD NAME : RpmHeader::tag_os
 
752
//        METHOD TYPE : std::string
 
753
//
 
754
//        DESCRIPTION :
 
755
//
 
756
std::string RpmHeader::tag_os() const
 
757
{
 
758
  return string_val( RPMTAG_OS );
 
759
 
 
760
}
 
761
 
 
762
std::string RpmHeader::tag_prein() const
 
763
{ return string_val( RPMTAG_PREIN ); }
 
764
 
 
765
std::string RpmHeader::tag_preinprog() const
 
766
{ return string_val( RPMTAG_PREINPROG ); }
 
767
 
 
768
std::string RpmHeader::tag_postin() const
 
769
{ return string_val( RPMTAG_POSTIN ); }
 
770
 
 
771
std::string RpmHeader::tag_postinprog() const
 
772
{ return string_val( RPMTAG_POSTINPROG ); }
 
773
 
 
774
std::string RpmHeader::tag_preun() const
 
775
{ return string_val( RPMTAG_PREUN ); }
 
776
 
 
777
std::string RpmHeader::tag_preunprog() const
 
778
{ return string_val( RPMTAG_PREUNPROG ); }
 
779
 
 
780
std::string RpmHeader::tag_postun() const
 
781
{ return string_val( RPMTAG_POSTUN ); }
 
782
 
 
783
std::string RpmHeader::tag_postunprog() const
 
784
{ return string_val( RPMTAG_POSTUNPROG ); }
 
785
 
 
786
std::string RpmHeader::tag_pretrans() const
 
787
{ return string_val( RPMTAG_PRETRANS ); }
 
788
 
 
789
std::string RpmHeader::tag_pretransprog() const
 
790
{ return string_val( RPMTAG_PRETRANSPROG ); }
 
791
 
 
792
std::string RpmHeader::tag_posttrans() const
 
793
{ return string_val( RPMTAG_POSTTRANS ); }
 
794
 
 
795
std::string RpmHeader::tag_posttransprog() const
 
796
{ return string_val( RPMTAG_POSTTRANSPROG ); }
 
797
 
 
798
///////////////////////////////////////////////////////////////////
 
799
//
 
800
//
 
801
//        METHOD NAME : RpmHeader::tag_sourcerpm
 
802
//        METHOD TYPE : std::string
 
803
//
 
804
//        DESCRIPTION :
 
805
//
 
806
std::string RpmHeader::tag_sourcerpm() const
 
807
{
 
808
  return string_val( RPMTAG_SOURCERPM );
 
809
}
 
810
 
 
811
///////////////////////////////////////////////////////////////////
 
812
//
 
813
//
 
814
//        METHOD NAME : RpmHeader::tag_filenames
 
815
//        METHOD TYPE : std::list<std::string>
 
816
//
 
817
//        DESCRIPTION :
 
818
//
 
819
std::list<std::string> RpmHeader::tag_filenames() const
 
820
{
 
821
  std::list<std::string> ret;
 
822
 
 
823
  stringList basenames;
 
824
  if ( string_list( RPMTAG_BASENAMES, basenames ) )
 
825
  {
 
826
    stringList dirnames;
 
827
    string_list( RPMTAG_DIRNAMES, dirnames );
 
828
    intList  dirindexes;
 
829
    int_list( RPMTAG_DIRINDEXES, dirindexes );
 
830
    for ( unsigned i = 0; i < basenames.size(); ++ i )
 
831
    {
 
832
      ret.push_back( dirnames[dirindexes[i]] + basenames[i] );
 
833
    }
 
834
  }
 
835
 
 
836
  return ret;
 
837
}
 
838
 
 
839
///////////////////////////////////////////////////////////////////
 
840
//
 
841
//
 
842
//        METHOD NAME : RpmHeader::tag_fileinfos
 
843
//        METHOD TYPE : std::list<FileInfo>
 
844
//
 
845
//        DESCRIPTION :
 
846
//
 
847
std::list<FileInfo> RpmHeader::tag_fileinfos() const
 
848
{
 
849
  std::list<FileInfo> ret;
 
850
 
 
851
  stringList basenames;
 
852
  if ( string_list( RPMTAG_BASENAMES, basenames ) )
 
853
  {
 
854
    stringList dirnames;
 
855
    string_list( RPMTAG_DIRNAMES, dirnames );
 
856
    intList  dirindexes;
 
857
    int_list( RPMTAG_DIRINDEXES, dirindexes );
 
858
    intList filesizes;
 
859
    int_list( RPMTAG_FILESIZES, filesizes );
 
860
    stringList md5sums;
 
861
    string_list( RPMTAG_FILEMD5S, md5sums );
 
862
    stringList usernames;
 
863
    string_list( RPMTAG_FILEUSERNAME, usernames );
 
864
    stringList groupnames;
 
865
    string_list( RPMTAG_FILEGROUPNAME, groupnames );
 
866
    intList uids;
 
867
    int_list( RPMTAG_FILEUIDS, uids );
 
868
    intList gids;
 
869
    int_list( RPMTAG_FILEGIDS, gids );
 
870
    intList filemodes;
 
871
    int_list( RPMTAG_FILEMODES, filemodes );
 
872
    intList filemtimes;
 
873
    int_list( RPMTAG_FILEMTIMES, filemtimes );
 
874
    intList fileflags;
 
875
    int_list( RPMTAG_FILEFLAGS, fileflags );
 
876
    stringList filelinks;
 
877
    string_list( RPMTAG_FILELINKTOS, filelinks );
 
878
 
 
879
    for ( unsigned i = 0; i < basenames.size(); ++ i )
 
880
    {
 
881
      uid_t uid;
 
882
      if (uids.empty())
 
883
      {
 
884
        uid = unameToUid( usernames[i].c_str(), &uid );
 
885
      }
 
886
      else
 
887
      {
 
888
        uid =uids[i];
 
889
      }
 
890
 
 
891
      gid_t gid;
 
892
      if (gids.empty())
 
893
      {
 
894
        gid = gnameToGid( groupnames[i].c_str(), &gid );
 
895
      }
 
896
      else
 
897
      {
 
898
        gid = gids[i];
 
899
      }
 
900
 
 
901
      FileInfo info = {
 
902
                        dirnames[dirindexes[i]] + basenames[i],
 
903
                        filesizes[i],
 
904
                        md5sums[i],
 
905
                        uid,
 
906
                        gid,
 
907
                        mode_t(filemodes[i]),
 
908
                        filemtimes[i],
 
909
                        bool(fileflags[i] & RPMFILE_GHOST),
 
910
                        filelinks[i]
 
911
                      };
 
912
 
 
913
      ret.push_back( info );
 
914
    }
 
915
  }
 
916
 
 
917
  return ret;
 
918
}
 
919
 
 
920
///////////////////////////////////////////////////////////////////
 
921
//
 
922
//
 
923
//        METHOD NAME : RpmHeader::tag_changelog
 
924
//        METHOD TYPE : Changelog
 
925
//
 
926
//        DESCRIPTION :
 
927
//
 
928
Changelog RpmHeader::tag_changelog() const
 
929
{
 
930
  Changelog ret;
 
931
 
 
932
  intList times;
 
933
  if ( int_list( RPMTAG_CHANGELOGTIME, times ) )
 
934
  {
 
935
    stringList names;
 
936
    string_list( RPMTAG_CHANGELOGNAME, names );
 
937
    stringList texts;
 
938
    string_list( RPMTAG_CHANGELOGTEXT, texts );
 
939
    for ( unsigned i = 0; i < times.size(); ++ i )
 
940
    {
 
941
      ret.push_back( ChangelogEntry( times[i], names[i], texts[i] ) );
 
942
    }
 
943
  }
 
944
 
 
945
  return ret;
 
946
}
 
947
 
 
948
} // namespace rpm
 
949
} // namespace target
 
950
} // namespace zypp