include/membuff.h

   1 /* SPDX-License-Identifier: GPL-2.0+ */
   2 /*
   3  * Copyright (c) 2015 Google, Inc
   4  * Written by Simon Glass <sjg@chromium.org>
   5  *
   6  * Copyright (c) 1992 Simon Glass
   7  */
   8
   9 #ifndef _MEMBUFF_H
  10 #define _MEMBUFF_H
  11
  12 /**
  13  * @struct membuff: holds the state of a membuff - it is used for input and
  14  * output buffers. The buffer extends from @start to (@start + @size - 1).
  15  * Data in the buffer extends from @tail to @head: it is written in at
  16  * @head and read out from @tail. The membuff is empty when @head == @tail
  17  * and full when adding another character would make @head == @tail. We
  18  * therefore waste one character in the membuff to avoid having an extra flag
  19  * to determine whether (when @head == @tail) the membuff is empty or full.
  20  *
  21  * xxxxxx  data
  22  * ......  empty
  23  *
  24  * .............xxxxxxxxxxxxxxxx.........................
  25  *              ^               ^
  26  *              tail            head
  27  *
  28  * xxxxxxxxxxxxx................xxxxxxxxxxxxxxxxxxxxxxxxx
  29  *              ^               ^
  30  *              head            tail
  31  */
  32 struct membuff {
  33         char *start;            /** the start of the buffer */
  34         char *end;              /** the end of the buffer (start + length) */
  35         char *head;             /** current buffer head */
  36         char *tail;             /** current buffer tail */
  37 };
  38
  39 /**
  40  * membuff_purge() - reset a membuff to the empty state
  41  *
  42  * Initialise head and tail pointers so that the membuff becomes empty.
  43  *
  44  * @mb: membuff to purge
  45  */
  46 void membuff_purge(struct membuff *mb);
  47
  48 /**
  49  * membuff_putraw() - find out where bytes can be written
  50  *
  51  * Work out where in the membuff some data could be written. Return a pointer
  52  * to the address and the number of bytes which can be written there. If
  53  * @update is true, the caller must then write the data immediately, since
  54  * the membuff is updated as if the write has been done,
  55  *
  56  * Note that because the spare space in a membuff may not be contiguous, this
  57  * function may not return @maxlen even if there is enough space in the
  58  * membuff. However, by calling this function twice (with @update == true),
  59  * you will get access to all the spare space.
  60  *
  61  * @mb: membuff to adjust
  62  * @maxlen: the number of bytes we want to write
  63  * @update: true to update the membuff as if the write happened, false to not
  64  * @data: the address data can be written to
  65  * @return number of bytes which can be written
  66  */
  67 int membuff_putraw(struct membuff *mb, int maxlen, bool update, char **data);
  68
  69 /**
  70  * membuff_getraw() - find and return a pointer to available bytes
  71  *
  72  * Returns a pointer to any valid input data in the given membuff and
  73  * optionally marks it as read. Note that not all input data may not be
  74  * returned, since data is not necessarily contiguous in the membuff. However,
  75  * if you call this function twice (with @update == true) you are guaranteed
  76  * to get all available data, in at most two installments.
  77  *
  78  * @mb: membuff to adjust
  79  * @maxlen: maximum number of bytes to get
  80  * @update: true to update the membuff as if the bytes have been read (use
  81  * false to check bytes without reading them)
  82  * @data: returns address of data in input membuff
  83  * @return the number of bytes available at *@data
  84  */
  85 int membuff_getraw(struct membuff *mb, int maxlen, bool update, char **data);
  86
  87 /**
  88  * membuff_putbyte() - Writes a byte to a membuff
  89  *
  90  * @mb: membuff to adjust
  91  * @ch: byte to write
  92  * @return true on success, false if membuff is full
  93  */
  94 bool membuff_putbyte(struct membuff *mb, int ch);
  95
  96 /**
  97  * @mb: membuff to adjust
  98  * membuff_getbyte() - Read a byte from the membuff
  99  * @return the byte read, or -1 if the membuff is empty
 100  */
 101 int membuff_getbyte(struct membuff *mb);
 102
 103 /**
 104  * membuff_peekbyte() - check the next available byte
 105  *
 106  * Return the next byte which membuff_getbyte() would return, without
 107  * removing it from the membuff.
 108  *
 109  * @mb: membuff to adjust
 110  * @return the byte peeked, or -1 if the membuff is empty
 111  */
 112 int membuff_peekbyte(struct membuff *mb);
 113
 114 /**
 115  * membuff_get() - get data from a membuff
 116  *
 117  * Copies any available data (up to @maxlen bytes) to @buff and removes it
 118  * from the membuff.
 119  *
 120  * @mb: membuff to adjust
 121  * @Buff: address of membuff to transfer bytes to
 122  * @maxlen: maximum number of bytes to read
 123  * @return the number of bytes read
 124  */
 125 int membuff_get(struct membuff *mb, char *buff, int maxlen);
 126
 127 /**
 128  * membuff_put() - write data to a membuff
 129  *
 130  * Writes some data to a membuff. Returns the number of bytes added. If this
 131  * is less than @lnehgt, then the membuff got full
 132  *
 133  * @mb: membuff to adjust
 134  * @data: the data to write
 135  * @length: number of bytes to write from 'data'
 136  * @return the number of bytes added
 137  */
 138 int membuff_put(struct membuff *mb, const char *buff, int length);
 139
 140 /**
 141  * membuff_isempty() - check if a membuff is empty
 142  *
 143  * @mb: membuff to check
 144  * @return true if empty, else false
 145  */
 146 bool membuff_isempty(struct membuff *mb);
 147
 148 /**
 149  * membuff_avail() - check available data in a membuff
 150  *
 151  * @mb: membuff to check
 152  * @return number of bytes of data available
 153  */
 154 int membuff_avail(struct membuff *mb);
 155
 156 /**
 157  * membuff_size() - get the size of a membuff
 158  *
 159  * Note that a membuff can only old data up to one byte less than its size.
 160  *
 161  * @mb: membuff to check
 162  * @return total size
 163  */
 164 int membuff_size(struct membuff *mb);
 165
 166 /**
 167  * membuff_makecontig() - adjust all membuff data to be contiguous
 168  *
 169  * This places all data in a membuff into a single contiguous lump, if
 170  * possible
 171  *
 172  * @mb: membuff to adjust
 173  * @return true on success
 174  */
 175 bool membuff_makecontig(struct membuff *mb);
 176
 177 /**
 178  * membuff_free() - find the number of bytes that can be written to a membuff
 179  *
 180  * @mb: membuff to check
 181  * @return returns the number of bytes free in a membuff
 182  */
 183 int membuff_free(struct membuff *mb);
 184
 185 /**
 186  * membuff_readline() - read a line of text from a membuff
 187  *
 188  * Reads a line of text of up to 'maxlen' characters from a membuff and puts
 189  * it in @str. Any character less than @minch is assumed to be the end of
 190  * line character
 191  *
 192  * @mb: membuff to adjust
 193  * @str: Place to put the line
 194  * @maxlen: Maximum line length (excluding terminator)
 195  * @return number of bytes read (including terminator) if a line has been
 196  *         read, 0 if nothing was there
 197  */
 198 int membuff_readline(struct membuff *mb, char *str, int maxlen, int minch);
 199
 200 /**
 201  * membuff_extend_by() - expand a membuff
 202  *
 203  * Extends a membuff by the given number of bytes
 204  *
 205  * @mb: membuff to adjust
 206  * @by: Number of bytes to increase the size by
 207  * @max: Maximum size to allow
 208  * @return 0 if the expand succeeded, -ENOMEM if not enough memory, -E2BIG
 209  * if the the size would exceed @max
 210  */
 211 int membuff_extend_by(struct membuff *mb, int by, int max);
 212
 213 /**
 214  * membuff_init() - set up a new membuff using an existing membuff
 215  *
 216  * @mb: membuff to set up
 217  * @buff: Address of buffer
 218  * @size: Size of buffer
 219  */
 220 void membuff_init(struct membuff *mb, char *buff, int size);
 221
 222 /**
 223  * membuff_uninit() - clear a membuff so it can no longer be used
 224  *
 225  * @mb: membuff to uninit
 226  */
 227 void membuff_uninit(struct membuff *mb);
 228
 229 /**
 230  * membuff_new() - create a new membuff
 231  *
 232  * @mb: membuff to init
 233  * @size: size of membuff to create
 234  * @return 0 if OK, -ENOMEM if out of memory
 235  */
 236 int membuff_new(struct membuff *mb, int size);
 237
 238 /**
 239  * membuff_dispose() - free memory allocated to a membuff and uninit it
 240  *
 241  * @mb: membuff to dispose
 242  */
 243 void membuff_dispose(struct membuff *mb);
 244
 245 #endif