libuuu/sparse.cpp

   1 /*
   2  * Copyright 2020 NXP.
   3  *
   4  * Redistribution and use in source and binary forms, with or without modification,
   5  * are permitted provided that the following conditions are met:
   6  *
   7  * Redistributions of source code must retain the above copyright notice, this
   8  * list of conditions and the following disclaimer.
   9  *
  10  * Redistributions in binary form must reproduce the above copyright notice, this
  11  * list of conditions and the following disclaimer in the documentation and/or
  12  * other materials provided with the distribution.
  13  *
  14  * Neither the name of the NXP Semiconductor nor the names of its
  15  * contributors may be used to endorse or promote products derived from this
  16  * software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  19  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  22  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  */
  31
  32 #include "sparse.h"
  33 #include "liberror.h"
  34
  35 #include <cstddef>
  36 #include <cstring>
  37
  38
  39 int SparseFile::init_header(size_t blsz, int blcount)
  40 {
  41         sparse_header header;
  42
  43         memset(&header, 0, sizeof(header));
  44         header.magic = SPARSE_HEADER_MAGIC;
  45         header.major_version = 1;
  46         header.minor_version = 0;
  47         header.file_hdr_sz = sizeof(header);
  48         header.chunk_hdr_sz = sizeof(chunk_header);
  49         header.blk_sz = blsz;
  50         m_cur_chunk_header_pos = 0;
  51         if (blcount)
  52         {
  53                 m_data.reserve(blsz*blcount + 0x1000);
  54                 m_max_size = blsz * blcount;
  55         }
  56         m_data.clear();
  57         push(&header, sizeof(header));
  58         m_pcrc = (uint32_t*)(m_data.data() + offsetof(sparse_header, image_checksum));
  59         return 0;
  60 }
  61
  62 bool SparseFile::is_append_old_chuck(int type, void *p)
  63 {
  64         chunk_header_t *pchunk;
  65         pchunk = (chunk_header_t *)(m_data.data() + m_cur_chunk_header_pos);
  66
  67         if (m_cur_chunk_header_pos == 0)
  68                 return false;
  69
  70         if (pchunk->chunk_type != type)
  71                 return false;
  72
  73         if (type == CHUNK_TYPE_FILL)
  74         {
  75                 uint32_t a = *(uint32_t*)(pchunk + 1);
  76                 uint32_t b = *(uint32_t*)p;
  77                 if (a != b)
  78                         return false;
  79         }
  80         return true;
  81 }
  82
  83 bool SparseFile::is_same_value(void *data, size_t sz)
  84 {
  85         uint32_t *p = (uint32_t *)data;
  86         uint32_t val = *p;
  87         for (size_t i = 0; i < sz / sizeof(uint32_t); i++)
  88                 if (val != p[i])
  89                         return false;
  90         return true;
  91 }
  92
  93 bool SparseFile::is_validate_sparse_file(void *p, size_t)
  94 {
  95         sparse_header *pheader = (sparse_header*)p;
  96         if (pheader->magic == SPARSE_HEADER_MAGIC)
  97                 return true;
  98         return false;
  99 }
 100
 101 int SparseFile::push(void *p, size_t sz)
 102 {
 103         size_t pos = m_data.size();
 104         m_data.resize(pos + sz);
 105         memcpy(m_data.data() + pos, p, sz);
 106         return 0;
 107 }
 108
 109 int SparseFile::push_one_block(void *data, bool skip)
 110 {
 111         chunk_header_t *pchunk;
 112         pchunk = (chunk_header_t *)(m_data.data() + m_cur_chunk_header_pos);
 113
 114         sparse_header *pheader;
 115         pheader = (sparse_header *)m_data.data();
 116
 117         pheader->total_blks++;
 118
 119         int type = skip ? CHUNK_TYPE_DONT_CARE : CHUNK_TYPE_RAW;
 120
 121         if (!is_append_old_chuck(type, data))
 122         {
 123                 chunk_header_t header;
 124                 header.chunk_type = type;
 125                 header.chunk_sz = 1;
 126                 header.total_sz = sizeof(chunk_header_t);
 127                 if (type == CHUNK_TYPE_RAW)
 128                         header.total_sz += pheader->blk_sz;
 129                 header.reserved1 = 0;
 130
 131                 pheader->total_chunks++;
 132
 133                 m_cur_chunk_header_pos = m_data.size();
 134
 135                 push(&header, sizeof(chunk_header_t));
 136
 137                 if (type == CHUNK_TYPE_RAW)
 138                         push(data, pheader->blk_sz);
 139         }
 140         else
 141         {
 142                 pchunk->chunk_sz++;
 143                 if (type == CHUNK_TYPE_RAW)
 144                 {
 145                         push(data, pheader->blk_sz);
 146                         pchunk->total_sz += pheader->blk_sz;
 147                 }
 148         }
 149
 150         if (m_data.size() + 2 * pheader->blk_sz > m_max_size ) {
 151                 return -1;
 152         }
 153
 154         return 0;
 155 }
 156
 157 size_t SparseFile::push_one_chuck(chunk_header_t *p, void *data)
 158 {
 159         chunk_header_t cheader = *p;
 160         sparse_header *pheader;
 161         pheader = (sparse_header *)m_data.data();
 162
 163         size_t sz = p->total_sz - sizeof(chunk_header);
 164
 165         if (p->total_sz + m_data.size() > m_max_size)
 166         {
 167                 if (p->chunk_type == CHUNK_TYPE_RAW)
 168                 {
 169                         size_t blk = (m_max_size - m_data.size()) / pheader->blk_sz;
 170                         if (blk < 2)
 171                                 return 0;
 172
 173                         blk -= 2;
 174
 175                         cheader.chunk_sz = blk;
 176                         sz = blk * pheader->blk_sz;
 177                         cheader.total_sz = sizeof(chunk_header_t) + sz;
 178                 }
 179                 else
 180                         return 0;
 181         }
 182
 183         push(&cheader, sizeof(chunk_header));
 184         pheader->total_chunks ++;
 185         pheader->total_blks += cheader.chunk_sz;
 186
 187         if (data) {
 188                 push(data, sz);
 189         }
 190
 191         return sz;
 192 }
 193
 194 size_t SparseFile::push_raw_data(void *data, size_t sz)
 195 {
 196         chunk_header_t cheader;
 197         cheader.chunk_type = CHUNK_TYPE_RAW;
 198
 199         sparse_header *pheader;
 200         pheader = (sparse_header *)m_data.data();
 201
 202         cheader.chunk_sz = sz / pheader->blk_sz;
 203         cheader.total_sz = cheader.chunk_sz*pheader->blk_sz + sizeof(chunk_header_t);
 204         pheader = (sparse_header *)m_data.data();
 205
 206         return push_one_chuck(&cheader, data);
 207 }