lib/utils_io.c

   1 /*
   2  * utils - miscellaneous I/O utilities for cryptsetup
   3  *
   4  * Copyright (C) 2004 Jana Saout <jana@saout.de>
   5  * Copyright (C) 2004-2007 Clemens Fruhwirth <clemens@endorphin.org>
   6  * Copyright (C) 2009-2020 Red Hat, Inc. All rights reserved.
   7  * Copyright (C) 2009-2020 Milan Broz
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License
  11  * as published by the Free Software Foundation; either version 2
  12  * of the License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  22  */
  23
  24 #include <errno.h>
  25 #include <string.h>
  26 #include <stdlib.h>
  27 #include <stdint.h>
  28 #include <unistd.h>
  29 #include <sys/types.h>
  30
  31 #include "utils_io.h"
  32
  33 static ssize_t _read_buffer(int fd, void *buf, size_t length, volatile int *quit)
  34 {
  35         size_t read_size = 0;
  36         ssize_t r;
  37
  38         if (fd < 0 || !buf)
  39                 return -EINVAL;
  40
  41         do {
  42                 r = read(fd, buf, length - read_size);
  43                 if (r == -1 && errno != EINTR)
  44                         return r;
  45                 if (r > 0) {
  46                         read_size += (size_t)r;
  47                         buf = (uint8_t*)buf + r;
  48                 }
  49                 if (r == 0 || (quit && *quit))
  50                         return (ssize_t)read_size;
  51         } while (read_size != length);
  52
  53         return (ssize_t)length;
  54 }
  55
  56 ssize_t read_buffer(int fd, void *buf, size_t length)
  57 {
  58         return _read_buffer(fd, buf, length, NULL);
  59 }
  60
  61 ssize_t read_buffer_intr(int fd, void *buf, size_t length, volatile int *quit)
  62 {
  63         return _read_buffer(fd, buf, length, quit);
  64 }
  65
  66 static ssize_t _write_buffer(int fd, const void *buf, size_t length, volatile int *quit)
  67 {
  68         size_t write_size = 0;
  69         ssize_t w;
  70
  71         if (fd < 0 || !buf || !length)
  72                 return -EINVAL;
  73
  74         do {
  75                 w = write(fd, buf, length - write_size);
  76                 if (w < 0 && errno != EINTR)
  77                         return w;
  78                 if (w > 0) {
  79                         write_size += (size_t) w;
  80                         buf = (const uint8_t*)buf + w;
  81                 }
  82                 if (w == 0 || (quit && *quit))
  83                         return (ssize_t)write_size;
  84         } while (write_size != length);
  85
  86         return (ssize_t)write_size;
  87 }
  88
  89 ssize_t write_buffer(int fd, const void *buf, size_t length)
  90 {
  91         return _write_buffer(fd, buf, length, NULL);
  92 }
  93
  94 ssize_t write_buffer_intr(int fd, const void *buf, size_t length, volatile int *quit)
  95 {
  96         return _write_buffer(fd, buf, length, quit);
  97 }
  98
  99 ssize_t write_blockwise(int fd, size_t bsize, size_t alignment,
 100                         void *orig_buf, size_t length)
 101 {
 102         void *hangover_buf = NULL, *buf = NULL;
 103         size_t hangover, solid;
 104         ssize_t r, ret = -1;
 105
 106         if (fd == -1 || !orig_buf || !bsize || !alignment)
 107                 return -1;
 108
 109         hangover = length % bsize;
 110         solid = length - hangover;
 111
 112         if ((size_t)orig_buf & (alignment - 1)) {
 113                 if (posix_memalign(&buf, alignment, length))
 114                         return -1;
 115                 memcpy(buf, orig_buf, length);
 116         } else
 117                 buf = orig_buf;
 118
 119         if (solid) {
 120                 r = write_buffer(fd, buf, solid);
 121                 if (r < 0 || r != (ssize_t)solid)
 122                         goto out;
 123         }
 124
 125         if (hangover) {
 126                 if (posix_memalign(&hangover_buf, alignment, bsize))
 127                         goto out;
 128                 memset(hangover_buf, 0, bsize);
 129
 130                 r = read_buffer(fd, hangover_buf, bsize);
 131                 if (r < 0)
 132                         goto out;
 133
 134                 if (lseek(fd, -(off_t)r, SEEK_CUR) < 0)
 135                         goto out;
 136
 137                 memcpy(hangover_buf, (char*)buf + solid, hangover);
 138
 139                 r = write_buffer(fd, hangover_buf, bsize);
 140                 if (r < 0 || r < (ssize_t)hangover)
 141                         goto out;
 142         }
 143         ret = length;
 144 out:
 145         free(hangover_buf);
 146         if (buf != orig_buf)
 147                 free(buf);
 148         return ret;
 149 }
 150
 151 ssize_t read_blockwise(int fd, size_t bsize, size_t alignment,
 152                        void *orig_buf, size_t length)
 153 {
 154         void *hangover_buf = NULL, *buf = NULL;
 155         size_t hangover, solid;
 156         ssize_t r, ret = -1;
 157
 158         if (fd == -1 || !orig_buf || !bsize || !alignment)
 159                 return -1;
 160
 161         hangover = length % bsize;
 162         solid = length - hangover;
 163
 164         if ((size_t)orig_buf & (alignment - 1)) {
 165                 if (posix_memalign(&buf, alignment, length))
 166                         return -1;
 167         } else
 168                 buf = orig_buf;
 169
 170         r = read_buffer(fd, buf, solid);
 171         if (r < 0 || r != (ssize_t)solid)
 172                 goto out;
 173
 174         if (hangover) {
 175                 if (posix_memalign(&hangover_buf, alignment, bsize))
 176                         goto out;
 177                 r = read_buffer(fd, hangover_buf, bsize);
 178                 if (r <  0 || r < (ssize_t)hangover)
 179                         goto out;
 180
 181                 memcpy((char *)buf + solid, hangover_buf, hangover);
 182         }
 183         ret = length;
 184 out:
 185         free(hangover_buf);
 186         if (buf != orig_buf) {
 187                 if (ret != -1)
 188                         memcpy(orig_buf, buf, length);
 189                 free(buf);
 190         }
 191         return ret;
 192 }
 193
 194 /*
 195  * Combines llseek with blockwise write. write_blockwise can already deal with short writes
 196  * but we also need a function to deal with short writes at the start. But this information
 197  * is implicitly included in the read/write offset, which can not be set to non-aligned
 198  * boundaries. Hence, we combine llseek with write.
 199  */
 200 ssize_t write_lseek_blockwise(int fd, size_t bsize, size_t alignment,
 201                               void *buf, size_t length, off_t offset)
 202 {
 203         void *frontPadBuf = NULL;
 204         size_t frontHang, innerCount = 0;
 205         ssize_t r, ret = -1;
 206
 207         if (fd == -1 || !buf || !bsize || !alignment)
 208                 return -1;
 209
 210         if (offset < 0)
 211                 offset = lseek(fd, offset, SEEK_END);
 212
 213         if (offset < 0)
 214                 return -1;
 215
 216         frontHang = offset % bsize;
 217
 218         if (lseek(fd, offset - frontHang, SEEK_SET) < 0)
 219                 return -1;
 220
 221         if (frontHang && length) {
 222                 if (posix_memalign(&frontPadBuf, alignment, bsize))
 223                         return -1;
 224
 225                 innerCount = bsize - frontHang;
 226                 if (innerCount > length)
 227                         innerCount = length;
 228
 229                 r = read_buffer(fd, frontPadBuf, bsize);
 230                 if (r < 0 || r < (ssize_t)(frontHang + innerCount))
 231                         goto out;
 232
 233                 memcpy((char*)frontPadBuf + frontHang, buf, innerCount);
 234
 235                 if (lseek(fd, offset - frontHang, SEEK_SET) < 0)
 236                         goto out;
 237
 238                 r = write_buffer(fd, frontPadBuf, bsize);
 239                 if (r < 0 || r != (ssize_t)bsize)
 240                         goto out;
 241
 242                 buf = (char*)buf + innerCount;
 243                 length -= innerCount;
 244         }
 245
 246         ret = length ? write_blockwise(fd, bsize, alignment, buf, length) : 0;
 247         if (ret >= 0)
 248                 ret += innerCount;
 249 out:
 250         free(frontPadBuf);
 251         return ret;
 252 }
 253
 254 ssize_t read_lseek_blockwise(int fd, size_t bsize, size_t alignment,
 255                              void *buf, size_t length, off_t offset)
 256 {
 257         void *frontPadBuf = NULL;
 258         size_t frontHang, innerCount = 0;
 259         ssize_t r, ret = -1;
 260
 261         if (fd == -1 || !buf || bsize <= 0)
 262                 return -1;
 263
 264         if (offset < 0)
 265                 offset = lseek(fd, offset, SEEK_END);
 266
 267         if (offset < 0)
 268                 return -1;
 269
 270         frontHang = offset % bsize;
 271
 272         if (lseek(fd, offset - frontHang, SEEK_SET) < 0)
 273                 return -1;
 274
 275         if (frontHang && length) {
 276                 if (posix_memalign(&frontPadBuf, alignment, bsize))
 277                         return -1;
 278
 279                 innerCount = bsize - frontHang;
 280                 if (innerCount > length)
 281                         innerCount = length;
 282
 283                 r = read_buffer(fd, frontPadBuf, bsize);
 284                 if (r < 0 || r < (ssize_t)(frontHang + innerCount))
 285                         goto out;
 286
 287                 memcpy(buf, (char*)frontPadBuf + frontHang, innerCount);
 288
 289                 buf = (char*)buf + innerCount;
 290                 length -= innerCount;
 291         }
 292
 293         ret = read_blockwise(fd, bsize, alignment, buf, length);
 294         if (ret >= 0)
 295                 ret += innerCount;
 296 out:
 297         free(frontPadBuf);
 298         return ret;
 299 }