Browse Source

* added ajs patch

tags/debian/0.7.21
Michael Vogt 15 years ago
parent
commit
cde41ae88e
10 changed files with 812 additions and 98 deletions
  1. +1
    -0
      apt-pkg/contrib/hashes.cc
  2. +3
    -1
      apt-pkg/contrib/hashes.h
  3. +421
    -0
      apt-pkg/contrib/sha256.cc
  4. +75
    -0
      apt-pkg/contrib/sha256.h
  5. +2
    -2
      apt-pkg/makefile
  6. +2
    -1
      apt-pkg/tagfile.cc
  7. +212
    -38
      ftparchive/cachedb.cc
  8. +30
    -10
      ftparchive/cachedb.h
  9. +60
    -44
      ftparchive/writer.cc
  10. +6
    -2
      ftparchive/writer.h

+ 1
- 0
apt-pkg/contrib/hashes.cc View File

@@ -36,6 +36,7 @@ bool Hashes::AddFD(int Fd,unsigned long Size)
Size -= Res;
MD5.Add(Buf,Res);
SHA1.Add(Buf,Res);
SHA256.Add(Buf,Res);
}
return true;
}


+ 3
- 1
apt-pkg/contrib/hashes.h View File

@@ -19,6 +19,7 @@

#include <apt-pkg/md5.h>
#include <apt-pkg/sha1.h>
#include <apt-pkg/sha256.h>

#include <algorithm>

@@ -30,10 +31,11 @@ class Hashes

MD5Summation MD5;
SHA1Summation SHA1;
SHA256Summation SHA256;
inline bool Add(const unsigned char *Data,unsigned long Size)
{
return MD5.Add(Data,Size) && SHA1.Add(Data,Size);
return MD5.Add(Data,Size) && SHA1.Add(Data,Size) && SHA256.Add(Data,Size);
};
inline bool Add(const char *Data) {return Add((unsigned char *)Data,strlen(Data));};
bool AddFD(int Fd,unsigned long Size);


+ 421
- 0
apt-pkg/contrib/sha256.cc View File

@@ -0,0 +1,421 @@
/*
* Cryptographic API.
*
* SHA-256, as specified in
* http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf
*
* SHA-256 code by Jean-Luc Cooke <jlcooke@certainkey.com>.
*
* Copyright (c) Jean-Luc Cooke <jlcooke@certainkey.com>
* Copyright (c) Andrew McDonald <andrew@mcdonald.org.uk>
* Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
*
* Ported from the Linux kernel to Apt by Anthony Towns <ajt@debian.org>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
*/
#define SHA256_DIGEST_SIZE 32
#define SHA256_HMAC_BLOCK_SIZE 64

#define ror32(value,bits) (((value) >> (bits)) | ((value) << (32 - (bits))))

#include <apt-pkg/sha256.h>
#include <apt-pkg/strutl.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <arpa/inet.h>

typedef uint32_t u32;
typedef uint8_t u8;

static inline u32 Ch(u32 x, u32 y, u32 z)
{
return z ^ (x & (y ^ z));
}

static inline u32 Maj(u32 x, u32 y, u32 z)
{
return (x & y) | (z & (x | y));
}

#define e0(x) (ror32(x, 2) ^ ror32(x,13) ^ ror32(x,22))
#define e1(x) (ror32(x, 6) ^ ror32(x,11) ^ ror32(x,25))
#define s0(x) (ror32(x, 7) ^ ror32(x,18) ^ (x >> 3))
#define s1(x) (ror32(x,17) ^ ror32(x,19) ^ (x >> 10))

#define H0 0x6a09e667
#define H1 0xbb67ae85
#define H2 0x3c6ef372
#define H3 0xa54ff53a
#define H4 0x510e527f
#define H5 0x9b05688c
#define H6 0x1f83d9ab
#define H7 0x5be0cd19

static inline void LOAD_OP(int I, u32 *W, const u8 *input)
{
W[I] = ntohl( ((u32*)(input))[I] );
}

static inline void BLEND_OP(int I, u32 *W)
{
W[I] = s1(W[I-2]) + W[I-7] + s0(W[I-15]) + W[I-16];
}

static void sha256_transform(u32 *state, const u8 *input)
{
u32 a, b, c, d, e, f, g, h, t1, t2;
u32 W[64];
int i;

/* load the input */
for (i = 0; i < 16; i++)
LOAD_OP(i, W, input);

/* now blend */
for (i = 16; i < 64; i++)
BLEND_OP(i, W);
/* load the state into our registers */
a=state[0]; b=state[1]; c=state[2]; d=state[3];
e=state[4]; f=state[5]; g=state[6]; h=state[7];

/* now iterate */
t1 = h + e1(e) + Ch(e,f,g) + 0x428a2f98 + W[ 0];
t2 = e0(a) + Maj(a,b,c); d+=t1; h=t1+t2;
t1 = g + e1(d) + Ch(d,e,f) + 0x71374491 + W[ 1];
t2 = e0(h) + Maj(h,a,b); c+=t1; g=t1+t2;
t1 = f + e1(c) + Ch(c,d,e) + 0xb5c0fbcf + W[ 2];
t2 = e0(g) + Maj(g,h,a); b+=t1; f=t1+t2;
t1 = e + e1(b) + Ch(b,c,d) + 0xe9b5dba5 + W[ 3];
t2 = e0(f) + Maj(f,g,h); a+=t1; e=t1+t2;
t1 = d + e1(a) + Ch(a,b,c) + 0x3956c25b + W[ 4];
t2 = e0(e) + Maj(e,f,g); h+=t1; d=t1+t2;
t1 = c + e1(h) + Ch(h,a,b) + 0x59f111f1 + W[ 5];
t2 = e0(d) + Maj(d,e,f); g+=t1; c=t1+t2;
t1 = b + e1(g) + Ch(g,h,a) + 0x923f82a4 + W[ 6];
t2 = e0(c) + Maj(c,d,e); f+=t1; b=t1+t2;
t1 = a + e1(f) + Ch(f,g,h) + 0xab1c5ed5 + W[ 7];
t2 = e0(b) + Maj(b,c,d); e+=t1; a=t1+t2;

t1 = h + e1(e) + Ch(e,f,g) + 0xd807aa98 + W[ 8];
t2 = e0(a) + Maj(a,b,c); d+=t1; h=t1+t2;
t1 = g + e1(d) + Ch(d,e,f) + 0x12835b01 + W[ 9];
t2 = e0(h) + Maj(h,a,b); c+=t1; g=t1+t2;
t1 = f + e1(c) + Ch(c,d,e) + 0x243185be + W[10];
t2 = e0(g) + Maj(g,h,a); b+=t1; f=t1+t2;
t1 = e + e1(b) + Ch(b,c,d) + 0x550c7dc3 + W[11];
t2 = e0(f) + Maj(f,g,h); a+=t1; e=t1+t2;
t1 = d + e1(a) + Ch(a,b,c) + 0x72be5d74 + W[12];
t2 = e0(e) + Maj(e,f,g); h+=t1; d=t1+t2;
t1 = c + e1(h) + Ch(h,a,b) + 0x80deb1fe + W[13];
t2 = e0(d) + Maj(d,e,f); g+=t1; c=t1+t2;
t1 = b + e1(g) + Ch(g,h,a) + 0x9bdc06a7 + W[14];
t2 = e0(c) + Maj(c,d,e); f+=t1; b=t1+t2;
t1 = a + e1(f) + Ch(f,g,h) + 0xc19bf174 + W[15];
t2 = e0(b) + Maj(b,c,d); e+=t1; a=t1+t2;

t1 = h + e1(e) + Ch(e,f,g) + 0xe49b69c1 + W[16];
t2 = e0(a) + Maj(a,b,c); d+=t1; h=t1+t2;
t1 = g + e1(d) + Ch(d,e,f) + 0xefbe4786 + W[17];
t2 = e0(h) + Maj(h,a,b); c+=t1; g=t1+t2;
t1 = f + e1(c) + Ch(c,d,e) + 0x0fc19dc6 + W[18];
t2 = e0(g) + Maj(g,h,a); b+=t1; f=t1+t2;
t1 = e + e1(b) + Ch(b,c,d) + 0x240ca1cc + W[19];
t2 = e0(f) + Maj(f,g,h); a+=t1; e=t1+t2;
t1 = d + e1(a) + Ch(a,b,c) + 0x2de92c6f + W[20];
t2 = e0(e) + Maj(e,f,g); h+=t1; d=t1+t2;
t1 = c + e1(h) + Ch(h,a,b) + 0x4a7484aa + W[21];
t2 = e0(d) + Maj(d,e,f); g+=t1; c=t1+t2;
t1 = b + e1(g) + Ch(g,h,a) + 0x5cb0a9dc + W[22];
t2 = e0(c) + Maj(c,d,e); f+=t1; b=t1+t2;
t1 = a + e1(f) + Ch(f,g,h) + 0x76f988da + W[23];
t2 = e0(b) + Maj(b,c,d); e+=t1; a=t1+t2;

t1 = h + e1(e) + Ch(e,f,g) + 0x983e5152 + W[24];
t2 = e0(a) + Maj(a,b,c); d+=t1; h=t1+t2;
t1 = g + e1(d) + Ch(d,e,f) + 0xa831c66d + W[25];
t2 = e0(h) + Maj(h,a,b); c+=t1; g=t1+t2;
t1 = f + e1(c) + Ch(c,d,e) + 0xb00327c8 + W[26];
t2 = e0(g) + Maj(g,h,a); b+=t1; f=t1+t2;
t1 = e + e1(b) + Ch(b,c,d) + 0xbf597fc7 + W[27];
t2 = e0(f) + Maj(f,g,h); a+=t1; e=t1+t2;
t1 = d + e1(a) + Ch(a,b,c) + 0xc6e00bf3 + W[28];
t2 = e0(e) + Maj(e,f,g); h+=t1; d=t1+t2;
t1 = c + e1(h) + Ch(h,a,b) + 0xd5a79147 + W[29];
t2 = e0(d) + Maj(d,e,f); g+=t1; c=t1+t2;
t1 = b + e1(g) + Ch(g,h,a) + 0x06ca6351 + W[30];
t2 = e0(c) + Maj(c,d,e); f+=t1; b=t1+t2;
t1 = a + e1(f) + Ch(f,g,h) + 0x14292967 + W[31];
t2 = e0(b) + Maj(b,c,d); e+=t1; a=t1+t2;

t1 = h + e1(e) + Ch(e,f,g) + 0x27b70a85 + W[32];
t2 = e0(a) + Maj(a,b,c); d+=t1; h=t1+t2;
t1 = g + e1(d) + Ch(d,e,f) + 0x2e1b2138 + W[33];
t2 = e0(h) + Maj(h,a,b); c+=t1; g=t1+t2;
t1 = f + e1(c) + Ch(c,d,e) + 0x4d2c6dfc + W[34];
t2 = e0(g) + Maj(g,h,a); b+=t1; f=t1+t2;
t1 = e + e1(b) + Ch(b,c,d) + 0x53380d13 + W[35];
t2 = e0(f) + Maj(f,g,h); a+=t1; e=t1+t2;
t1 = d + e1(a) + Ch(a,b,c) + 0x650a7354 + W[36];
t2 = e0(e) + Maj(e,f,g); h+=t1; d=t1+t2;
t1 = c + e1(h) + Ch(h,a,b) + 0x766a0abb + W[37];
t2 = e0(d) + Maj(d,e,f); g+=t1; c=t1+t2;
t1 = b + e1(g) + Ch(g,h,a) + 0x81c2c92e + W[38];
t2 = e0(c) + Maj(c,d,e); f+=t1; b=t1+t2;
t1 = a + e1(f) + Ch(f,g,h) + 0x92722c85 + W[39];
t2 = e0(b) + Maj(b,c,d); e+=t1; a=t1+t2;

t1 = h + e1(e) + Ch(e,f,g) + 0xa2bfe8a1 + W[40];
t2 = e0(a) + Maj(a,b,c); d+=t1; h=t1+t2;
t1 = g + e1(d) + Ch(d,e,f) + 0xa81a664b + W[41];
t2 = e0(h) + Maj(h,a,b); c+=t1; g=t1+t2;
t1 = f + e1(c) + Ch(c,d,e) + 0xc24b8b70 + W[42];
t2 = e0(g) + Maj(g,h,a); b+=t1; f=t1+t2;
t1 = e + e1(b) + Ch(b,c,d) + 0xc76c51a3 + W[43];
t2 = e0(f) + Maj(f,g,h); a+=t1; e=t1+t2;
t1 = d + e1(a) + Ch(a,b,c) + 0xd192e819 + W[44];
t2 = e0(e) + Maj(e,f,g); h+=t1; d=t1+t2;
t1 = c + e1(h) + Ch(h,a,b) + 0xd6990624 + W[45];
t2 = e0(d) + Maj(d,e,f); g+=t1; c=t1+t2;
t1 = b + e1(g) + Ch(g,h,a) + 0xf40e3585 + W[46];
t2 = e0(c) + Maj(c,d,e); f+=t1; b=t1+t2;
t1 = a + e1(f) + Ch(f,g,h) + 0x106aa070 + W[47];
t2 = e0(b) + Maj(b,c,d); e+=t1; a=t1+t2;

t1 = h + e1(e) + Ch(e,f,g) + 0x19a4c116 + W[48];
t2 = e0(a) + Maj(a,b,c); d+=t1; h=t1+t2;
t1 = g + e1(d) + Ch(d,e,f) + 0x1e376c08 + W[49];
t2 = e0(h) + Maj(h,a,b); c+=t1; g=t1+t2;
t1 = f + e1(c) + Ch(c,d,e) + 0x2748774c + W[50];
t2 = e0(g) + Maj(g,h,a); b+=t1; f=t1+t2;
t1 = e + e1(b) + Ch(b,c,d) + 0x34b0bcb5 + W[51];
t2 = e0(f) + Maj(f,g,h); a+=t1; e=t1+t2;
t1 = d + e1(a) + Ch(a,b,c) + 0x391c0cb3 + W[52];
t2 = e0(e) + Maj(e,f,g); h+=t1; d=t1+t2;
t1 = c + e1(h) + Ch(h,a,b) + 0x4ed8aa4a + W[53];
t2 = e0(d) + Maj(d,e,f); g+=t1; c=t1+t2;
t1 = b + e1(g) + Ch(g,h,a) + 0x5b9cca4f + W[54];
t2 = e0(c) + Maj(c,d,e); f+=t1; b=t1+t2;
t1 = a + e1(f) + Ch(f,g,h) + 0x682e6ff3 + W[55];
t2 = e0(b) + Maj(b,c,d); e+=t1; a=t1+t2;

t1 = h + e1(e) + Ch(e,f,g) + 0x748f82ee + W[56];
t2 = e0(a) + Maj(a,b,c); d+=t1; h=t1+t2;
t1 = g + e1(d) + Ch(d,e,f) + 0x78a5636f + W[57];
t2 = e0(h) + Maj(h,a,b); c+=t1; g=t1+t2;
t1 = f + e1(c) + Ch(c,d,e) + 0x84c87814 + W[58];
t2 = e0(g) + Maj(g,h,a); b+=t1; f=t1+t2;
t1 = e + e1(b) + Ch(b,c,d) + 0x8cc70208 + W[59];
t2 = e0(f) + Maj(f,g,h); a+=t1; e=t1+t2;
t1 = d + e1(a) + Ch(a,b,c) + 0x90befffa + W[60];
t2 = e0(e) + Maj(e,f,g); h+=t1; d=t1+t2;
t1 = c + e1(h) + Ch(h,a,b) + 0xa4506ceb + W[61];
t2 = e0(d) + Maj(d,e,f); g+=t1; c=t1+t2;
t1 = b + e1(g) + Ch(g,h,a) + 0xbef9a3f7 + W[62];
t2 = e0(c) + Maj(c,d,e); f+=t1; b=t1+t2;
t1 = a + e1(f) + Ch(f,g,h) + 0xc67178f2 + W[63];
t2 = e0(b) + Maj(b,c,d); e+=t1; a=t1+t2;

state[0] += a; state[1] += b; state[2] += c; state[3] += d;
state[4] += e; state[5] += f; state[6] += g; state[7] += h;

/* clear any sensitive info... */
a = b = c = d = e = f = g = h = t1 = t2 = 0;
memset(W, 0, 64 * sizeof(u32));
}

SHA256Summation::SHA256Summation()
{
Sum.state[0] = H0;
Sum.state[1] = H1;
Sum.state[2] = H2;
Sum.state[3] = H3;
Sum.state[4] = H4;
Sum.state[5] = H5;
Sum.state[6] = H6;
Sum.state[7] = H7;
Sum.count[0] = Sum.count[1] = 0;
memset(Sum.buf, 0, sizeof(Sum.buf));
Done = false;
}

bool SHA256Summation::Add(const u8 *data, unsigned long len)
{
struct sha256_ctx *sctx = &Sum;
unsigned int i, index, part_len;

if (Done) return false;

/* Compute number of bytes mod 128 */
index = (unsigned int)((sctx->count[0] >> 3) & 0x3f);

/* Update number of bits */
if ((sctx->count[0] += (len << 3)) < (len << 3)) {
sctx->count[1]++;
sctx->count[1] += (len >> 29);
}

part_len = 64 - index;

/* Transform as many times as possible. */
if (len >= part_len) {
memcpy(&sctx->buf[index], data, part_len);
sha256_transform(sctx->state, sctx->buf);

for (i = part_len; i + 63 < len; i += 64)
sha256_transform(sctx->state, &data[i]);
index = 0;
} else {
i = 0;
}

/* Buffer remaining input */
memcpy(&sctx->buf[index], &data[i], len-i);

return true;
}

SHA256SumValue SHA256Summation::Result()
{
struct sha256_ctx *sctx = &Sum;
if (!Done) {
u8 bits[8];
unsigned int index, pad_len, t;
static const u8 padding[64] = { 0x80, };

/* Save number of bits */
t = sctx->count[0];
bits[7] = t; t >>= 8;
bits[6] = t; t >>= 8;
bits[5] = t; t >>= 8;
bits[4] = t;
t = sctx->count[1];
bits[3] = t; t >>= 8;
bits[2] = t; t >>= 8;
bits[1] = t; t >>= 8;
bits[0] = t;

/* Pad out to 56 mod 64. */
index = (sctx->count[0] >> 3) & 0x3f;
pad_len = (index < 56) ? (56 - index) : ((64+56) - index);
Add(padding, pad_len);

/* Append length (before padding) */
Add(bits, 8);
}

Done = true;

/* Store state in digest */

SHA256SumValue res;
u8 *out = res.Sum;

int i, j;
unsigned int t;
for (i = j = 0; i < 8; i++, j += 4) {
t = sctx->state[i];
out[j+3] = t; t >>= 8;
out[j+2] = t; t >>= 8;
out[j+1] = t; t >>= 8;
out[j ] = t;
}

return res;
}

// SHA256SumValue::SHA256SumValue - Constructs the sum from a string /*{{{*/
// ---------------------------------------------------------------------
/* The string form of a SHA256 is a 64 character hex number */
SHA256SumValue::SHA256SumValue(string Str)
{
memset(Sum,0,sizeof(Sum));
Set(Str);
}

/*}}}*/
// SHA256SumValue::SHA256SumValue - Default constructor /*{{{*/
// ---------------------------------------------------------------------
/* Sets the value to 0 */
SHA256SumValue::SHA256SumValue()
{
memset(Sum,0,sizeof(Sum));
}

/*}}}*/
// SHA256SumValue::Set - Set the sum from a string /*{{{*/
// ---------------------------------------------------------------------
/* Converts the hex string into a set of chars */
bool SHA256SumValue::Set(string Str)
{
return Hex2Num(Str,Sum,sizeof(Sum));
}
/*}}}*/
// SHA256SumValue::Value - Convert the number into a string /*{{{*/
// ---------------------------------------------------------------------
/* Converts the set of chars into a hex string in lower case */
string SHA256SumValue::Value() const
{
char Conv[16] =
{ '0','1','2','3','4','5','6','7','8','9','a','b',
'c','d','e','f'
};
char Result[65];
Result[64] = 0;

// Convert each char into two letters
int J = 0;
int I = 0;
for (; I != 64; J++,I += 2)
{
Result[I] = Conv[Sum[J] >> 4];
Result[I + 1] = Conv[Sum[J] & 0xF];
}

return string(Result);
}



// SHA256SumValue::operator == - Comparator /*{{{*/
// ---------------------------------------------------------------------
/* Call memcmp on the buffer */
bool SHA256SumValue::operator == (const SHA256SumValue & rhs) const
{
return memcmp(Sum,rhs.Sum,sizeof(Sum)) == 0;
}
/*}}}*/


// SHA256Summation::AddFD - Add content of file into the checksum /*{{{*/
// ---------------------------------------------------------------------
/* */
bool SHA256Summation::AddFD(int Fd,unsigned long Size)
{
unsigned char Buf[64 * 64];
int Res = 0;
int ToEOF = (Size == 0);
while (Size != 0 || ToEOF)
{
unsigned n = sizeof(Buf);
if (!ToEOF) n = min(Size,(unsigned long)n);
Res = read(Fd,Buf,n);
if (Res < 0 || (!ToEOF && (unsigned) Res != n)) // error, or short read
return false;
if (ToEOF && Res == 0) // EOF
break;
Size -= Res;
Add(Buf,Res);
}
return true;
}
/*}}}*/


+ 75
- 0
apt-pkg/contrib/sha256.h View File

@@ -0,0 +1,75 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: sha1.h,v 1.3 2001/05/07 05:05:47 jgg Exp $
/* ######################################################################

SHA256SumValue - Storage for a SHA-256 hash.
SHA256Summation - SHA-256 Secure Hash Algorithm.
This is a C++ interface to a set of SHA256Sum functions, that mirrors
the equivalent MD5 & SHA1 classes.

##################################################################### */
/*}}}*/
#ifndef APTPKG_SHA256_H
#define APTPKG_SHA256_H

#ifdef __GNUG__
#pragma interface "apt-pkg/sha256.h"
#endif

#include <string>
#include <algorithm>
#include <stdint.h>

using std::string;
using std::min;

class SHA256Summation;

class SHA256SumValue
{
friend class SHA256Summation;
unsigned char Sum[32];
public:

// Accessors
bool operator ==(const SHA256SumValue &rhs) const;
string Value() const;
inline void Value(unsigned char S[32])
{for (int I = 0; I != sizeof(Sum); I++) S[I] = Sum[I];};
inline operator string() const {return Value();};
bool Set(string Str);
inline void Set(unsigned char S[32])
{for (int I = 0; I != sizeof(Sum); I++) Sum[I] = S[I];};

SHA256SumValue(string Str);
SHA256SumValue();
};

struct sha256_ctx {
uint32_t count[2];
uint32_t state[8];
uint8_t buf[128];
};

class SHA256Summation
{
struct sha256_ctx Sum;

bool Done;

public:

bool Add(const unsigned char *inbuf,unsigned long inlen);
inline bool Add(const char *Data) {return Add((unsigned char *)Data,strlen(Data));};
bool AddFD(int Fd,unsigned long Size);
inline bool Add(const unsigned char *Beg,const unsigned char *End)
{return Add(Beg,End-Beg);};
SHA256SumValue Result();
SHA256Summation();
};

#endif

+ 2
- 2
apt-pkg/makefile View File

@@ -21,11 +21,11 @@ APT_DOMAIN:=libapt-pkg$(MAJOR)
# Source code for the contributed non-core things
SOURCE = contrib/mmap.cc contrib/error.cc contrib/strutl.cc \
contrib/configuration.cc contrib/progress.cc contrib/cmndline.cc \
contrib/md5.cc contrib/sha1.cc contrib/hashes.cc \
contrib/md5.cc contrib/sha1.cc contrib/sha256.cc contrib/hashes.cc \
contrib/cdromutl.cc contrib/crc-16.cc \
contrib/fileutl.cc
HEADERS = mmap.h error.h configuration.h fileutl.h cmndline.h \
md5.h crc-16.h cdromutl.h strutl.h sptr.h sha1.h hashes.h
md5.h crc-16.h cdromutl.h strutl.h sptr.h sha1.h sha256.h hashes.h

# Source code for the core main library
SOURCE+= pkgcache.cc version.cc depcache.cc \


+ 2
- 1
apt-pkg/tagfile.cc View File

@@ -394,7 +394,8 @@ static const char *iTFRewritePackageOrder[] = {
"Filename",
"Size",
"MD5Sum",
"SHA1Sum",
"SHA1",
"SHA256",
"MSDOS-Filename", // Obsolete
"Description",
0};


+ 212
- 38
ftparchive/cachedb.cc View File

@@ -19,6 +19,8 @@
#include <apti18n.h>
#include <apt-pkg/error.h>
#include <apt-pkg/md5.h>
#include <apt-pkg/sha1.h>
#include <apt-pkg/sha256.h>
#include <apt-pkg/strutl.h>
#include <apt-pkg/configuration.h>
@@ -54,7 +56,7 @@ bool CacheDB::ReadyDB(string DB)
return true;

db_create(&Dbp, NULL, 0);
if ((err = Dbp->open(Dbp, NULL, DB.c_str(), NULL, DB_HASH,
if ((err = Dbp->open(Dbp, NULL, DB.c_str(), NULL, DB_BTREE,
(ReadOnly?DB_RDONLY:DB_CREATE),
0644)) != 0)
{
@@ -79,48 +81,123 @@ bool CacheDB::ReadyDB(string DB)
return true;
}
/*}}}*/
// CacheDB::SetFile - Select a file to be working with /*{{{*/
// CacheDB::OpenFile - Open the filei /*{{{*/
// ---------------------------------------------------------------------
/* All future actions will be performed against this file */
bool CacheDB::SetFile(string FileName,struct stat St,FileFd *Fd)
/* */
bool CacheDB::OpenFile()
{
Fd = new FileFd(FileName,FileFd::ReadOnly);
if (_error->PendingError() == true)
{
delete Fd;
Fd = NULL;
return false;
}
return true;
}
/*}}}*/
// CacheDB::GetFileStat - Get stats from the file /*{{{*/
// ---------------------------------------------------------------------
/* This gets the size from the database if it's there. If we need
* to look at the file, also get the mtime from the file. */
bool CacheDB::GetFileStat()
{
if ((CurStat.Flags & FlSize) == FlSize)
{
/* Already worked out the file size */
}
else
{
/* Get it from the file. */
if (Fd == NULL && OpenFile() == false)
{
return false;
}
// Stat the file
struct stat St;
if (fstat(Fd->Fd(),&St) != 0)
{
return _error->Errno("fstat",
_("Failed to stat %s"),FileName.c_str());
}
CurStat.FileSize = St.st_size;
CurStat.mtime = htonl(St.st_mtime);
CurStat.Flags |= FlSize;
}
return true;
}
/*}}}*/
// CacheDB::GetCurStat - Set the CurStat variable. /*{{{*/
// ---------------------------------------------------------------------
/* Sets the CurStat variable. Either to 0 if no database is used
* or to the value in the database if one is used */
bool CacheDB::GetCurStat()
{
delete DebFile;
DebFile = 0;
this->FileName = FileName;
this->Fd = Fd;
this->FileStat = St;
FileStat = St;
memset(&CurStat,0,sizeof(CurStat));
Stats.Bytes += St.st_size;
Stats.Packages++;
if (DBLoaded == false)
return true;
if (DBLoaded)
{
/* First see if thre is anything about it
in the database */

/* Get the flags (and mtime) */
InitQuery("st");
// Ensure alignment of the returned structure
Data.data = &CurStat;
Data.ulen = sizeof(CurStat);
Data.flags = DB_DBT_USERMEM;
// Lookup the stat info and confirm the file is unchanged
if (Get() == true)
{
if (CurStat.mtime != htonl(St.st_mtime))
if (Get() == false)
{
CurStat.mtime = htonl(St.st_mtime);
CurStat.Flags = 0;
_error->Warning(_("File date has changed %s"),FileName.c_str());
}
CurStat.Flags = ntohl(CurStat.Flags);
CurStat.FileSize = ntohl(CurStat.FileSize);
}
else
return true;
}
/*}}}*/
// CacheDB::GetFileInfo - Get all the info about the file /*{{{*/
// ---------------------------------------------------------------------
bool CacheDB::GetFileInfo(string FileName, bool DoControl, bool DoContents,
bool GenContentsOnly,
bool DoMD5, bool DoSHA1, bool DoSHA256)
{
this->FileName = FileName;

if (GetCurStat() == false)
{
CurStat.mtime = htonl(St.st_mtime);
CurStat.Flags = 0;
return false;
}
CurStat.Flags = ntohl(CurStat.Flags);
OldStat = CurStat;
if (GetFileStat() == false)
{
delete Fd;
Fd = NULL;
return false;
}

Stats.Bytes += CurStat.FileSize;
Stats.Packages++;

if (DoControl && LoadControl() == false
|| DoContents && LoadContents(GenContentsOnly) == false
|| DoMD5 && GetMD5(false) == false
|| DoSHA1 && GetSHA1(false) == false
|| DoSHA256 && GetSHA256(false) == false)
{
delete Fd;
Fd = NULL;
delete DebFile;
DebFile = NULL;
return false;
}

delete Fd;
Fd = NULL;
delete DebFile;
DebFile = NULL;

return true;
}
/*}}}*/
@@ -139,6 +216,10 @@ bool CacheDB::LoadControl()
CurStat.Flags &= ~FlControl;
}
if (Fd == NULL && OpenFile() == false)
{
return false;
}
// Create a deb instance to read the archive
if (DebFile == 0)
{
@@ -183,6 +264,10 @@ bool CacheDB::LoadContents(bool GenOnly)
CurStat.Flags &= ~FlContents;
}
if (Fd == NULL && OpenFile() == false)
{
return false;
}
// Create a deb instance to read the archive
if (DebFile == 0)
{
@@ -201,10 +286,37 @@ bool CacheDB::LoadContents(bool GenOnly)
return true;
}
/*}}}*/

static string bytes2hex(uint8_t *bytes, size_t length) {
char space[65];
if (length * 2 > sizeof(space) - 1) length = (sizeof(space) - 1) / 2;
for (size_t i = 0; i < length; i++)
snprintf(&space[i*2], 3, "%02x", bytes[i]);
return string(space);
}

static inline unsigned char xdig2num(char dig) {
if (isdigit(dig)) return dig - '0';
if ('a' <= dig && dig <= 'f') return dig - 'a' + 10;
if ('A' <= dig && dig <= 'F') return dig - 'A' + 10;
return 0;
}

static void hex2bytes(uint8_t *bytes, const char *hex, int length) {
while (length-- > 0) {
*bytes = 0;
if (isxdigit(hex[0]) && isxdigit(hex[1])) {
*bytes = xdig2num(hex[0]) * 16 + xdig2num(hex[1]);
hex += 2;
}
bytes++;
}
}

// CacheDB::GetMD5 - Get the MD5 hash /*{{{*/
// ---------------------------------------------------------------------
/* */
bool CacheDB::GetMD5(string &MD5Res,bool GenOnly)
bool CacheDB::GetMD5(bool GenOnly)
{
// Try to read the control information out of the DB.
if ((CurStat.Flags & FlMD5) == FlMD5)
@@ -212,28 +324,88 @@ bool CacheDB::GetMD5(string &MD5Res,bool GenOnly)
if (GenOnly == true)
return true;
InitQuery("m5");
if (Get() == true)
{
MD5Res = string((char *)Data.data,Data.size);
MD5Res = bytes2hex(CurStat.MD5, sizeof(CurStat.MD5));
return true;
}
CurStat.Flags &= ~FlMD5;
}
Stats.MD5Bytes += FileStat.st_size;
Stats.MD5Bytes += CurStat.FileSize;
if (Fd == NULL && OpenFile() == false)
{
return false;
}
MD5Summation MD5;
if (Fd->Seek(0) == false || MD5.AddFD(Fd->Fd(),FileStat.st_size) == false)
if (Fd->Seek(0) == false || MD5.AddFD(Fd->Fd(),CurStat.FileSize) == false)
return false;
MD5Res = MD5.Result();
InitQuery("m5");
if (Put(MD5Res.c_str(),MD5Res.length()) == true)
hex2bytes(CurStat.MD5, MD5Res.data(), sizeof(CurStat.MD5));
CurStat.Flags |= FlMD5;
return true;
}
/*}}}*/
// CacheDB::GetSHA1 - Get the SHA1 hash /*{{{*/
// ---------------------------------------------------------------------
/* */
bool CacheDB::GetSHA1(bool GenOnly)
{
// Try to read the control information out of the DB.
if ((CurStat.Flags & FlSHA1) == FlSHA1)
{
if (GenOnly == true)
return true;

SHA1Res = bytes2hex(CurStat.SHA1, sizeof(CurStat.SHA1));
return true;
}
Stats.SHA1Bytes += CurStat.FileSize;
if (Fd == NULL && OpenFile() == false)
{
return false;
}
SHA1Summation SHA1;
if (Fd->Seek(0) == false || SHA1.AddFD(Fd->Fd(),CurStat.FileSize) == false)
return false;
SHA1Res = SHA1.Result();
hex2bytes(CurStat.SHA1, SHA1Res.data(), sizeof(CurStat.SHA1));
CurStat.Flags |= FlSHA1;
return true;
}
/*}}}*/
// CacheDB::GetSHA256 - Get the SHA256 hash /*{{{*/
// ---------------------------------------------------------------------
/* */
bool CacheDB::GetSHA256(bool GenOnly)
{
// Try to read the control information out of the DB.
if ((CurStat.Flags & FlSHA256) == FlSHA256)
{
if (GenOnly == true)
return true;

SHA256Res = bytes2hex(CurStat.SHA256, sizeof(CurStat.SHA256));
return true;
}
Stats.SHA256Bytes += CurStat.FileSize;
if (Fd == NULL && OpenFile() == false)
{
return false;
}
SHA256Summation SHA256;
if (Fd->Seek(0) == false || SHA256.AddFD(Fd->Fd(),CurStat.FileSize) == false)
return false;
SHA256Res = SHA256.Result();
hex2bytes(CurStat.SHA256, SHA256Res.data(), sizeof(CurStat.SHA256));
CurStat.Flags |= FlSHA256;
return true;
}
/*}}}*/
// CacheDB::Finish - Write back the cache structure /*{{{*/
// ---------------------------------------------------------------------
/* */
@@ -246,9 +418,12 @@ bool CacheDB::Finish()
// Write the stat information
CurStat.Flags = htonl(CurStat.Flags);
CurStat.FileSize = htonl(CurStat.FileSize);
InitQuery("st");
Put(&CurStat,sizeof(CurStat));
CurStat.Flags = ntohl(CurStat.Flags);
CurStat.FileSize = ntohl(CurStat.FileSize);

return true;
}
/*}}}*/
@@ -278,7 +453,6 @@ bool CacheDB::Clean()
{
if (stringcmp((char *)Key.data,Colon,"st") == 0 ||
stringcmp((char *)Key.data,Colon,"cn") == 0 ||
stringcmp((char *)Key.data,Colon,"m5") == 0 ||
stringcmp((char *)Key.data,Colon,"cl") == 0)
{
if (FileExists(string(Colon+1,(const char *)Key.data+Key.size)) == true)


+ 30
- 10
ftparchive/cachedb.h View File

@@ -44,7 +44,7 @@ class CacheDB
memset(&Key,0,sizeof(Key));
memset(&Data,0,sizeof(Data));
Key.data = TmpKey;
Key.size = snprintf(TmpKey,sizeof(TmpKey),"%s:%s",Type,FileName.c_str());
Key.size = snprintf(TmpKey,sizeof(TmpKey),"%s:%s",FileName.c_str(), Type);
}
inline bool Get()
@@ -64,19 +64,31 @@ class CacheDB
}
return true;
}
bool OpenFile();
bool GetFileStat();
bool GetCurStat();
bool LoadControl();
bool LoadContents(bool GenOnly);
bool GetMD5(bool GenOnly);
bool GetSHA1(bool GenOnly);
bool GetSHA256(bool GenOnly);
// Stat info stored in the DB, Fixed types since it is written to disk.
enum FlagList {FlControl = (1<<0),FlMD5=(1<<1),FlContents=(1<<2)};
enum FlagList {FlControl = (1<<0),FlMD5=(1<<1),FlContents=(1<<2),
FlSize=(1<<3), FlSHA1=(1<<4), FlSHA256=(1<<5)};
struct StatStore
{
time_t mtime;
uint32_t Flags;
uint32_t mtime;
uint32_t FileSize;
uint8_t MD5[16];
uint8_t SHA1[20];
uint8_t SHA256[32];
} CurStat;
struct StatStore OldStat;
// 'set' state
string FileName;
struct stat FileStat;
FileFd *Fd;
debDebFile *DebFile;
@@ -85,34 +97,42 @@ class CacheDB
// Data collection helpers
debDebFile::MemControlExtract Control;
ContentsExtract Contents;
string MD5Res;
string SHA1Res;
string SHA256Res;
// Runtime statistics
struct Stats
{
double Bytes;
double MD5Bytes;
double SHA1Bytes;
double SHA256Bytes;
unsigned long Packages;
unsigned long Misses;
unsigned long DeLinkBytes;
inline void Add(const Stats &S) {Bytes += S.Bytes; MD5Bytes += S.MD5Bytes;
inline void Add(const Stats &S) {
Bytes += S.Bytes; MD5Bytes += S.MD5Bytes; SHA1Bytes += S.SHA1Bytes;
SHA256Bytes += S.SHA256Bytes;
Packages += S.Packages; Misses += S.Misses; DeLinkBytes += S.DeLinkBytes;};
Stats() : Bytes(0), MD5Bytes(0), Packages(0), Misses(0), DeLinkBytes(0) {};
Stats() : Bytes(0), MD5Bytes(0), SHA1Bytes(0), SHA256Bytes(0), Packages(0), Misses(0), DeLinkBytes(0) {};
} Stats;
bool ReadyDB(string DB);
inline bool DBFailed() {return Dbp != 0 && DBLoaded == false;};
inline bool Loaded() {return DBLoaded == true;};
inline off_t GetFileSize(void) {return CurStat.FileSize;}
bool SetFile(string FileName,struct stat St,FileFd *Fd);
bool LoadControl();
bool LoadContents(bool GenOnly);
bool GetMD5(string &MD5Res,bool GenOnly);
bool GetFileInfo(string FileName, bool DoControl, bool DoContents,
bool GenContentsOnly, bool DoMD5, bool DoSHA1, bool DoSHA256);
bool Finish();
bool Clean();
CacheDB(string DB) : Dbp(0), DebFile(0) {ReadyDB(DB);};
CacheDB(string DB) : Dbp(0), Fd(NULL), DebFile(0) {ReadyDB(DB);};
~CacheDB() {ReadyDB(string()); delete DebFile;};
};


+ 60
- 44
ftparchive/writer.cc View File

@@ -23,6 +23,7 @@
#include <apt-pkg/configuration.h>
#include <apt-pkg/md5.h>
#include <apt-pkg/sha1.h>
#include <apt-pkg/sha256.h>
#include <apt-pkg/deblistparser.h>

#include <sys/types.h>
@@ -70,7 +71,7 @@ FTWScanner::FTWScanner()
// ---------------------------------------------------------------------
/* This is the FTW scanner, it processes each directory element in the
directory tree. */
int FTWScanner::Scanner(const char *File,const struct stat *sb,int Flag)
int FTWScanner::ScannerFTW(const char *File,const struct stat *sb,int Flag)
{
if (Flag == FTW_DNR)
{
@@ -85,6 +86,14 @@ int FTWScanner::Scanner(const char *File,const struct stat *sb,int Flag)
if (Flag != FTW_F)
return 0;

return ScannerFile(File, true);
}
/*}}}*/
// FTWScanner::ScannerFile - File Scanner /*{{{*/
// ---------------------------------------------------------------------
/* */
int FTWScanner::ScannerFile(const char *File, bool ReadLink)
{
const char *LastComponent = strrchr(File, '/');
if (LastComponent == NULL)
LastComponent = File;
@@ -105,7 +114,8 @@ int FTWScanner::Scanner(const char *File,const struct stat *sb,int Flag)
given are not links themselves. */
char Jnk[2];
Owner->OriginalPath = File;
if (Owner->RealPath != 0 && readlink(File,Jnk,sizeof(Jnk)) != -1 &&
if (ReadLink && Owner->RealPath != 0 &&
readlink(File,Jnk,sizeof(Jnk)) != -1 &&
realpath(File,Owner->RealPath) != 0)
Owner->DoPackage(Owner->RealPath);
else
@@ -154,7 +164,7 @@ bool FTWScanner::RecursiveScan(string Dir)
// Do recursive directory searching
Owner = this;
int Res = ftw(Dir.c_str(),Scanner,30);
int Res = ftw(Dir.c_str(),ScannerFTW,30);
// Error treewalking?
if (Res != 0)
@@ -209,12 +219,14 @@ bool FTWScanner::LoadFileList(string Dir,string File)
FileName = Line;
}
#if 0
struct stat St;
int Flag = FTW_F;
if (stat(FileName,&St) != 0)
Flag = FTW_NS;
#endif

if (Scanner(FileName,&St,Flag) != 0)
if (ScannerFile(FileName, false) != 0)
break;
}
@@ -227,7 +239,7 @@ bool FTWScanner::LoadFileList(string Dir,string File)
/* */
bool FTWScanner::Delink(string &FileName,const char *OriginalPath,
unsigned long &DeLinkBytes,
struct stat &St)
off_t FileSize)
{
// See if this isn't an internaly prefix'd file name.
if (InternalPrefix.empty() == false &&
@@ -243,7 +255,7 @@ bool FTWScanner::Delink(string &FileName,const char *OriginalPath,
NewLine(1);
ioprintf(c1out, _(" DeLink %s [%s]\n"), (OriginalPath + InternalPrefix.length()),
SizeToStr(St.st_size).c_str());
SizeToStr(FileSize).c_str());
c1out << flush;
if (NoLinkAct == false)
@@ -269,7 +281,7 @@ bool FTWScanner::Delink(string &FileName,const char *OriginalPath,
}
}
DeLinkBytes += St.st_size;
DeLinkBytes += FileSize;
if (DeLinkBytes/1024 >= DeLinkLimit)
ioprintf(c1out, _(" DeLink limit of %sB hit.\n"), SizeToStr(DeLinkBytes).c_str());
}
@@ -295,6 +307,8 @@ PackagesWriter::PackagesWriter(string DB,string Overrides,string ExtOverrides,
// Process the command line options
DoMD5 = _config->FindB("APT::FTPArchive::MD5",true);
DoSHA1 = _config->FindB("APT::FTPArchive::SHA1",true);
DoSHA256 = _config->FindB("APT::FTPArchive::SHA256",true);
DoContents = _config->FindB("APT::FTPArchive::Contents",true);
NoOverride = _config->FindB("APT::FTPArchive::NoOverrideMsg",false);

@@ -343,29 +357,19 @@ bool FTWScanner::SetExts(string Vals)
// PackagesWriter::DoPackage - Process a single package /*{{{*/
// ---------------------------------------------------------------------
/* This method takes a package and gets its control information and
MD5 then writes out a control record with the proper fields rewritten
and the path/size/hash appended. */
MD5, SHA1 and SHA256 then writes out a control record with the proper fields
rewritten and the path/size/hash appended. */
bool PackagesWriter::DoPackage(string FileName)
{
// Open the archive
FileFd F(FileName,FileFd::ReadOnly);
if (_error->PendingError() == true)
return false;
// Stat the file for later
struct stat St;
if (fstat(F.Fd(),&St) != 0)
return _error->Errno("fstat",_("Failed to stat %s"),FileName.c_str());

// Pull all the data we need form the DB
string MD5Res;
if (Db.SetFile(FileName,St,&F) == false ||
Db.LoadControl() == false ||
(DoContents == true && Db.LoadContents(true) == false) ||
(DoMD5 == true && Db.GetMD5(MD5Res,false) == false))
if (Db.GetFileInfo(FileName, true, DoContents, true, DoMD5, DoSHA1, DoSHA256)
== false)
{
return false;
}

if (Delink(FileName,OriginalPath,Stats.DeLinkBytes,St) == false)
off_t FileSize = Db.GetFileSize();
if (Delink(FileName,OriginalPath,Stats.DeLinkBytes,FileSize) == false)
return false;
// Lookup the overide information
@@ -400,7 +404,7 @@ bool PackagesWriter::DoPackage(string FileName)
}

char Size[40];
sprintf(Size,"%lu",St.st_size);
sprintf(Size,"%lu", (unsigned long) FileSize);
// Strip the DirStrip prefix from the FileName and add the PathPrefix
string NewFileName;
@@ -420,7 +424,9 @@ bool PackagesWriter::DoPackage(string FileName)

unsigned int End = 0;
SetTFRewriteData(Changes[End++], "Size", Size);
SetTFRewriteData(Changes[End++], "MD5sum", MD5Res.c_str());
SetTFRewriteData(Changes[End++], "MD5sum", Db.MD5Res.c_str());
SetTFRewriteData(Changes[End++], "SHA1", Db.SHA1Res.c_str());
SetTFRewriteData(Changes[End++], "SHA256", Db.SHA256Res.c_str());
SetTFRewriteData(Changes[End++], "Filename", NewFileName.c_str());
SetTFRewriteData(Changes[End++], "Priority", OverItem->Priority.c_str());
SetTFRewriteData(Changes[End++], "Status", 0);
@@ -491,6 +497,10 @@ SourcesWriter::SourcesWriter(string BOverrides,string SOverrides,
else
NoOverride = true;

// WTF?? The logic above: if we can't read binary overrides, don't even try
// reading source overrides. if we can read binary overrides, then say there
// are no overrides. THIS MAKES NO SENSE! -- ajt@d.o, 2006/02/28

if (ExtOverrides.empty() == false)
SOver.ReadExtraOverride(ExtOverrides);
@@ -607,12 +617,14 @@ bool SourcesWriter::DoPackage(string FileName)
}
auto_ptr<Override::Item> SOverItem(SOver.GetItem(Tags.FindS("Source")));
const auto_ptr<Override::Item> autoSOverItem(SOverItem);
// const auto_ptr<Override::Item> autoSOverItem(SOverItem);
if (SOverItem.get() == 0)
{
ioprintf(c1out, _(" %s has no source override entry\n"), Tags.FindS("Source").c_str());
SOverItem = auto_ptr<Override::Item>(BOver.GetItem(Tags.FindS("Source")));
if (SOverItem.get() == 0)
{
ioprintf(c1out, _(" %s has no binary override entry either\n"), Tags.FindS("Source").c_str());
SOverItem = auto_ptr<Override::Item>(new Override::Item);
*SOverItem = *OverItem;
}
@@ -657,7 +669,7 @@ bool SourcesWriter::DoPackage(string FileName)
realpath(OriginalPath.c_str(),RealPath) != 0)
{
string RP = RealPath;
if (Delink(RP,OriginalPath.c_str(),Stats.DeLinkBytes,St) == false)
if (Delink(RP,OriginalPath.c_str(),Stats.DeLinkBytes,St.st_size) == false)
return false;
}
}
@@ -727,26 +739,14 @@ ContentsWriter::ContentsWriter(string DB) :
determine what the package name is. */
bool ContentsWriter::DoPackage(string FileName,string Package)
{
// Open the archive
FileFd F(FileName,FileFd::ReadOnly);
if (_error->PendingError() == true)
return false;
// Stat the file for later
struct stat St;
if (fstat(F.Fd(),&St) != 0)
return _error->Errno("fstat","Failed too stat %s",FileName.c_str());

// Ready the DB
if (Db.SetFile(FileName,St,&F) == false ||
Db.LoadContents(false) == false)
if (!Db.GetFileInfo(FileName, Package.empty(), true, false, false, false, false))
{
return false;
}

// Parse the package name
if (Package.empty() == true)
{
if (Db.LoadControl() == false)
return false;
Package = Db.Control.Section.FindS("Package");
}

@@ -896,6 +896,11 @@ bool ReleaseWriter::DoPackage(string FileName)
SHA1.AddFD(fd.Fd(), fd.Size());
CheckSums[NewFileName].SHA1 = SHA1.Result();

fd.Seek(0);
SHA256Summation SHA256;
SHA256.AddFD(fd.Fd(), fd.Size());
CheckSums[NewFileName].SHA256 = SHA256.Result();

fd.Close();
return true;
@@ -927,5 +932,16 @@ void ReleaseWriter::Finish()
(*I).second.size,
(*I).first.c_str());
}

fprintf(Output, "SHA256:\n");
for(map<string,struct CheckSum>::iterator I = CheckSums.begin();
I != CheckSums.end();
++I)
{
fprintf(Output, " %s %16ld %s\n",
(*I).second.SHA256.c_str(),
(*I).second.size,
(*I).first.c_str());
}
}


+ 6
- 2
ftparchive/writer.h View File

@@ -45,10 +45,11 @@ class FTWScanner
bool NoLinkAct;
static FTWScanner *Owner;
static int Scanner(const char *File,const struct stat *sb,int Flag);
static int ScannerFTW(const char *File,const struct stat *sb,int Flag);
static int ScannerFile(const char *File, bool ReadLink);

bool Delink(string &FileName,const char *OriginalPath,
unsigned long &Bytes,struct stat &St);
unsigned long &Bytes,off_t FileSize);

inline void NewLine(unsigned Priority)
{
@@ -84,6 +85,8 @@ class PackagesWriter : public FTWScanner

// Some flags
bool DoMD5;
bool DoSHA1;
bool DoSHA256;
bool NoOverride;
bool DoContents;

@@ -170,6 +173,7 @@ protected:
{
string MD5;
string SHA1;
string SHA256;
// Limited by FileFd::Size()
unsigned long size;
~CheckSum() {};


Loading…
Cancel
Save