tests/lib/fakewrite.c

   1 /* $Id: fakewrite.c 5417 2002-04-15 08:40:20Z rra $ */
   2 /* Fake write and writev functions for testing xwrite and xwritev. */
   3
   4 #include "config.h"
   5
   6 #include <errno.h>
   7 #include <sys/types.h>
   8 #include <sys/uio.h>
   9
  10 #include "libinn.h"
  11
  12 ssize_t fake_write(int, const void *, size_t);
  13 ssize_t fake_pwrite(int, const void *, size_t, off_t);
  14 ssize_t fake_writev(int, const struct iovec *, int);
  15
  16 /* All the data is actually written into this buffer.  We use write_offset
  17    to track how far we've written. */
  18 char write_buffer[256];
  19 size_t write_offset = 0;
  20
  21 /* If write_interrupt is non-zero, then half of the calls to write or writev
  22    will fail, returning -1 with errno set to EINTR. */
  23 int write_interrupt = 0;
  24
  25 /* If write_fail is non-zero, all writes or writevs will return 0,
  26    indicating no progress in writing out the buffer. */
  27 int write_fail = 0;
  28
  29 /* Accept a write request and write only the first 32 bytes of it into
  30    write_buffer (or as much as will fit), returning the amount written. */
  31 ssize_t
  32 fake_write(int fd UNUSED, const void *data, size_t n)
  33 {
  34     size_t total;
  35
  36     if (write_fail)
  37         return 0;
  38     if (write_interrupt && (write_interrupt++ % 2) == 0) {
  39         errno = EINTR;
  40         return -1;
  41     }
  42     total = (n < 32) ? n : 32;
  43     if (256 - write_offset < total)
  44         total = 256 - write_offset;
  45     memcpy(write_buffer + write_offset, data, total);
  46     write_offset += total;
  47     return total;
  48 }
  49
  50 /* Accept a pwrite request and write only the first 32 bytes of it into
  51    write_buffer at the specified offset (or as much as will fit), returning
  52    the amount written. */
  53 ssize_t
  54 fake_pwrite(int fd UNUSED, const void *data, size_t n, off_t offset)
  55 {
  56     size_t total;
  57
  58     if (write_fail)
  59         return 0;
  60     if (write_interrupt && (write_interrupt++ % 2) == 0) {
  61         errno = EINTR;
  62         return -1;
  63     }
  64     total = (n < 32) ? n : 32;
  65     if (offset > 256) {
  66         errno = ENOSPC;
  67         return -1;
  68     }
  69     if ((size_t) (256 - offset) < total)
  70         total = 256 - offset;
  71     memcpy(write_buffer + offset, data, total);
  72     return total;
  73 }
  74
  75 /* Accept an xwrite request and write only the first 32 bytes of it into
  76    write_buffer (or as much as will fit), returning the amount written. */
  77 ssize_t
  78 fake_writev(int fd UNUSED, const struct iovec *iov, int iovcnt)
  79 {
  80     int total, i;
  81     size_t left, n;
  82
  83     if (write_fail)
  84         return 0;
  85     if (write_interrupt && (write_interrupt++ % 2) == 0) {
  86         errno = EINTR;
  87         return -1;
  88     }
  89     left = 256 - write_offset;
  90     if (left > 32)
  91         left = 32;
  92     total = 0;
  93     for (i = 0; i < iovcnt && left != 0; i++) {
  94         n = ((size_t) iov[i].iov_len < left) ? iov[i].iov_len : left;
  95         memcpy(write_buffer + write_offset, iov[i].iov_base, n);
  96         write_offset += n;
  97         total += n;
  98         left -= n;
  99     }
 100     return total;
 101 }