← Back to branch summary

~thopiekar/zypper/libzypp-manual-import

« back to all changes in this revision

Viewing changes to zypp/media/MediaBlockList.h

  • 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/media/MediaBlockList.h
 
1
/*---------------------------------------------------------------------\
 
2
|                          ____ _   __ __ ___                          |
 
3
|                         |__  / \ / / . \ . \                         |
 
4
|                           / / \ V /|  _/  _/                         |
 
5
|                          / /__ | | | | | |                           |
 
6
|                         /_____||_| |_| |_|                           |
 
7
|                                                                      |
 
8
\---------------------------------------------------------------------*/
 
9
/** \file zypp/media/MediaBlockList.h
 
10
 *
 
11
*/
 
12
#ifndef ZYPP_MEDIA_MEDIABLOCKLIST_H
 
13
#define ZYPP_MEDIA_MEDIABLOCKLIST_H
 
14
 
 
15
#include <sys/types.h>
 
16
#include <vector>
 
17
 
 
18
#include "zypp/Digest.h"
 
19
 
 
20
namespace zypp {
 
21
  namespace media {
 
22
 
 
23
/**
 
24
 * a single block from the blocklist, consisting of an offset and a size
 
25
 **/
 
26
struct MediaBlock {
 
27
  MediaBlock( off_t off_r, size_t size_r )
 
28
  : off( off_r )
 
29
  , size( size_r )
 
30
  {}
 
31
  off_t off;
 
32
  size_t size;
 
33
};
 
34
 
 
35
class MediaBlockList {
 
36
public:
 
37
  MediaBlockList(off_t filesize=off_t(-1));
 
38
 
 
39
  /**
 
40
   * do we have a blocklist describing the file?
 
41
   * set to true when addBlock() is called
 
42
   **/
 
43
  inline bool haveBlocks() const {
 
44
    return haveblocks;
 
45
  }
 
46
  /**
 
47
   * add a block with offset off and size size to the block list. Note
 
48
   * that blocks must be ordered and must not overlap. returns the
 
49
   * block number.
 
50
   **/
 
51
  size_t addBlock(off_t off, size_t size);
 
52
 
 
53
  /**
 
54
   * return the offset/size of a block with number blkno
 
55
   **/
 
56
  inline MediaBlock getBlock(size_t blkno) const {
 
57
    return blocks[blkno];
 
58
  }
 
59
  /**
 
60
   * return the number of blocks in the blocklist
 
61
   **/
 
62
  inline size_t numBlocks() const {
 
63
    return blocks.size();
 
64
  }
 
65
 
 
66
  /**
 
67
   * set / return the size of the whole file
 
68
   **/
 
69
  inline void setFilesize(off_t newfilesize=off_t(-1)) {
 
70
    filesize = newfilesize;
 
71
  }
 
72
  inline off_t getFilesize() const {
 
73
    return filesize;
 
74
  }
 
75
  inline bool haveFilesize() const {
 
76
    return filesize != off_t(-1);
 
77
  }
 
78
 
 
79
  /**
 
80
   * set / verify the checksum over the whole file
 
81
   **/
 
82
  void setFileChecksum(std::string ctype, int cl, unsigned char *c);
 
83
  bool createFileDigest(Digest &digest) const;
 
84
  bool verifyFileDigest(Digest &digest) const;
 
85
  inline bool haveFileChecksum() const {
 
86
    return !fsumtype.empty() && fsum.size();
 
87
  }
 
88
 
 
89
  /**
 
90
   * set / verify the (strong) checksum over a single block
 
91
   **/
 
92
  void setChecksum(size_t blkno, std::string cstype, int csl, unsigned char *cs, size_t cspad=0);
 
93
  bool checkChecksum(size_t blkno, const unsigned char *buf, size_t bufl) const;
 
94
  bool createDigest(Digest &digest) const;
 
95
  bool verifyDigest(size_t blkno, Digest &digest) const;
 
96
  inline bool haveChecksum(size_t blkno) const {
 
97
    return chksumlen && chksums.size() >= chksumlen * (blkno + 1);
 
98
  }
 
99
 
 
100
  /**
 
101
   * set / verify the (weak) rolling checksum over a single block
 
102
   **/
 
103
  void setRsum(size_t blkno, int rsl, unsigned int rs, size_t rspad=0);
 
104
  bool checkRsum(size_t blkno, const unsigned char *buf, size_t bufl) const;
 
105
  unsigned int updateRsum(unsigned int rs, const char *bytes, size_t len) const;
 
106
  bool verifyRsum(size_t blkno, unsigned int rs) const;
 
107
  inline bool haveRsum(size_t blkno) const {
 
108
    return rsumlen && rsums.size() >= blkno + 1;
 
109
  }
 
110
 
 
111
  /**
 
112
   * scan a file for blocks from our blocklist. if we find a suitable block,
 
113
   * it is removed from the list
 
114
   **/
 
115
  void reuseBlocks(FILE *wfp, std::string filename);
 
116
 
 
117
  /**
 
118
   * return block list as string
 
119
   **/
 
120
  std::string asString() const;
 
121
 
 
122
private:
 
123
  void writeBlock(size_t blkno, FILE *fp, const unsigned char *buf, size_t bufl, size_t start, std::vector<bool> &found) const;
 
124
  bool checkChecksumRotated(size_t blkno, const unsigned char *buf, size_t bufl, size_t start) const;
 
125
 
 
126
  off_t filesize;
 
127
  std::string fsumtype;
 
128
  std::vector<unsigned char> fsum;
 
129
 
 
130
  bool haveblocks;
 
131
  std::vector<MediaBlock> blocks;
 
132
 
 
133
  std::string chksumtype;
 
134
  int chksumlen;
 
135
  size_t chksumpad;
 
136
  std::vector<unsigned char> chksums;
 
137
 
 
138
  std::string rsumtype;
 
139
  int rsumlen;
 
140
  size_t rsumpad;
 
141
  std::vector<unsigned int> rsums;
 
142
};
 
143
 
 
144
inline std::ostream & operator<<(std::ostream &str, const MediaBlockList &bl)
 
145
{ return str << bl.asString(); }
 
146
 
 
147
  } // namespace media
 
148
} // namespace zypp
 
149
 
 
150
#endif // ZYPP_MEDIA_MEDIABLOCKLIST_H
 
151