39        ._blocks = std::vector<Block>(),
 
   41        ._message = std::move(message),
 
   53    if(!zck_init_read(zck_src, src_fd))
 
   64    if(!zck_init_read(zckTarget, target_fd))
 
   68    switch ( zck_find_valid_chunks(zckTarget) ) {
 
   77    const auto srcHashType = zck_get_chunk_hash_type( zckTarget );
 
   78    const auto targetHashType = zck_get_chunk_hash_type( zckTarget );
 
   80    auto _fileSize = expectedFileSize;
 
   82    const size_t fLen = zck_get_length( zckTarget );
 
   83    if ( expectedFileSize > 0 ) {
 
   85      if ( expectedFileSize != fLen ) {
 
   88              zypp::str::Format(
"Zchunk header reports a different filesize than what was expected ( Zck: %1% != Exp: %2%).") % fLen % _fileSize
 
   95    if( srcHashType != targetHashType )
 
   97                        % zck_hash_name_from_type ( srcHashType )
 
   98                        % zck_hash_name_from_type ( targetHashType ) );
 
  100    std::vector<Block> ranges;
 
  102    if(!zck_copy_chunks( zck_src, zckTarget ))
 
  106        auto bytesReused = _fileSize;
 
  108        auto chunk = zck_get_first_chunk( zckTarget );
 
  111          if ( zck_get_chunk_valid( chunk ) == 1 )
 
  115          UByteArray chksumVec = zypp::Digest::hexStringToUByteArray( std::string_view( zckDigest.
value() ) );
 
  116          std::string chksumName;
 
  117          std::optional<size_t> chksumCompareLen;
 
  119          switch ( targetHashType ) {
 
  120            case ZCK_HASH_SHA1: {
 
  124            case ZCK_HASH_SHA256: {
 
  128            case ZCK_HASH_SHA512: {
 
  132            case ZCK_HASH_SHA512_128: {
 
  136              chksumCompareLen = chksumVec.size();
 
  144          const auto s = 
static_cast<size_t>( zck_get_chunk_start( chunk ) );
 
  145          const auto l = 
static_cast<size_t>( zck_get_chunk_comp_size ( chunk ) );
 
  147          MIL_MEDIA << 
"Downloading block " << s << 
" with length " << l << 
" checksum " << zckDigest.
value() << 
" type " << chksumName << std::endl;
 
  148          ranges.push_back( 
Block {
 
  151            ._chksumtype = chksumName,
 
  152            ._checksum  = std::move( chksumVec ),
 
  153            ._relevantDigestLen = std::move(chksumCompareLen)
 
  159        } 
while ( (chunk = zck_get_next_chunk( chunk )) );
 
  163          ._blocks = std::move(ranges),
 
  164          ._bytesReused = std::move(bytesReused),
 
  165          ._message = std::string()
 
 
  171    const auto &setFailed = [&]( std::string &&err ) {
 
  172      error = std::move(err);
 
  184    if(!zck_init_read(zckTarget, target_fd))
 
  185      return setFailed ( 
zypp::str::Format( 
"Unable to open %1%: %2%") %  file % zck_get_error(zckTarget) );
 
  189    const auto res = zck_validate_checksums( zckTarget );
 
  190    if ( res == 0 || res == -1 ) {
 
  191      if( zck_is_error(
nullptr) ) {
 
  192        std::string err = zck_get_error(NULL);
 
  193        zck_clear_error(NULL);
 
  194        return setFailed( std::move(err) );
 
  196      if( zck_is_error(zckTarget) )
 
  197        return setFailed( zck_get_error(zckTarget) );
 
  198      return setFailed( 
"zck_validate_checksums returned a unknown error." );