75                           ._blocks = std::vector<Block>(),
 
   77                           ._message = std::move(message),
 
  131        if(!zck_init_read(zck_src, src_fd)) {
 
  150          const auto srcHashType = zck_get_chunk_hash_type( 
_zchunkContext );
 
  151          const auto targetHashType = zck_get_chunk_hash_type( 
_zchunkContext );
 
  162          if ( ftruncate ( 
_targetFd, fileSize ) < 0 ) {
 
  166          if( srcHashType != targetHashType ) {
 
  168                                % zck_hash_name_from_type ( srcHashType )
 
  169                                % zck_hash_name_from_type ( targetHashType ) );
 
  172          std::vector<Block> ranges;
 
  178          auto bytesReused = fileSize;
 
  188            if ( zck_get_chunk_valid( chunk ) == 1 )
 
  192            UByteArray chksumVec = zypp::Digest::hexStringToUByteArray( std::string_view( zckDigest.
value() ) );
 
  193            std::string chksumName;
 
  194            std::optional<size_t> chksumCompareLen;
 
  196            switch ( targetHashType ) {
 
  197              case ZCK_HASH_SHA1: {
 
  201              case ZCK_HASH_SHA256: {
 
  205              case ZCK_HASH_SHA512: {
 
  209              case ZCK_HASH_SHA512_128: {
 
  213                chksumCompareLen = chksumVec.size();
 
  221            const auto s = 
static_cast<size_t>( zck_get_chunk_start( chunk ) );
 
  222            const auto l = 
static_cast<size_t>( zck_get_chunk_comp_size ( chunk ) );
 
  224            MIL_MEDIA << 
"Downloading block " << s << 
" with length " << l << 
" checksum " << zckDigest.
value() << 
" type " << chksumName << std::endl;
 
  225            ranges.push_back( 
Block {
 
  228                                ._chksumtype = chksumName,
 
  229                                ._checksum  = std::move( chksumVec ),
 
  230                                ._relevantDigestLen = std::move(chksumCompareLen)
 
  236          } 
while ( (chunk = zck_get_next_chunk( chunk )) );
 
  251        if ( res == 0 || res == -1 ) {
 
  252          if( zck_is_error(
nullptr) ) {
 
  253            std::string err = zck_get_error(NULL);
 
  254            zck_clear_error(NULL);
 
 
  327            ._blocks = std::vector<Block>(),
 
  329            ._message = std::move(message),
 
  341    if(!zck_init_read(zck_src, src_fd))
 
  352    if(!zck_init_read(zckTarget, target_fd))
 
  356    switch ( zck_find_valid_chunks(zckTarget) ) {
 
  365    const auto srcHashType = zck_get_chunk_hash_type( zckTarget );
 
  366    const auto targetHashType = zck_get_chunk_hash_type( zckTarget );
 
  368    auto _fileSize = expectedFileSize;
 
  370    const size_t fLen = zck_get_length( zckTarget );
 
  371    if ( expectedFileSize > 0 ) {
 
  373      if ( expectedFileSize != fLen ) {
 
  376              zypp::str::Format(
"Zchunk header reports a different filesize than what was expected ( Zck: %1% != Exp: %2%).") % fLen % _fileSize
 
  383    if( srcHashType != targetHashType )
 
  385                         % zck_hash_name_from_type ( srcHashType )
 
  386                         % zck_hash_name_from_type ( targetHashType ) );
 
  388    std::vector<Block> ranges;
 
  390    if(!zck_copy_chunks( zck_src, zckTarget ))
 
  394    auto bytesReused = _fileSize;
 
  396    auto chunk = zck_get_first_chunk( zckTarget );
 
  399      if ( zck_get_chunk_valid( chunk ) == 1 )
 
  403      UByteArray chksumVec = zypp::Digest::hexStringToUByteArray( std::string_view( zckDigest.
value() ) );
 
  404      std::string chksumName;
 
  405      std::optional<size_t> chksumCompareLen;
 
  407      switch ( targetHashType ) {
 
  408        case ZCK_HASH_SHA1: {
 
  412        case ZCK_HASH_SHA256: {
 
  416        case ZCK_HASH_SHA512: {
 
  420        case ZCK_HASH_SHA512_128: {
 
  424          chksumCompareLen = chksumVec.size();
 
  432      const auto s = 
static_cast<size_t>( zck_get_chunk_start( chunk ) );
 
  433      const auto l = 
static_cast<size_t>( zck_get_chunk_comp_size ( chunk ) );
 
  435      MIL_MEDIA << 
"Downloading block " << s << 
" with length " << l << 
" checksum " << zckDigest.
value() << 
" type " << chksumName << std::endl;
 
  436      ranges.push_back( 
Block {
 
  439                          ._chksumtype = chksumName,
 
  440                          ._checksum  = std::move( chksumVec ),
 
  441                          ._relevantDigestLen = std::move(chksumCompareLen)
 
  447    } 
while ( (chunk = zck_get_next_chunk( chunk )) );
 
  451          ._blocks = std::move(ranges),
 
  452          ._bytesReused = std::move(bytesReused),
 
  453          ._message = std::string()
 
 
  459    const auto &
setFailed = [&]( std::string &&err ) {
 
  460      error = std::move(err);
 
  472    if(!zck_init_read(zckTarget, target_fd))
 
  477    const auto res = zck_validate_checksums( zckTarget );
 
  478    if ( res == 0 || res == -1 ) {
 
  479      if( zck_is_error(
nullptr) ) {
 
  480        std::string err = zck_get_error(NULL);
 
  481        zck_clear_error(NULL);
 
  484      if( zck_is_error(zckTarget) )
 
  485        return setFailed( zck_get_error(zckTarget) );
 
  486      return setFailed( 
"zck_validate_checksums returned a unknown error." );