Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1998 - 2007 Pekka Riikonen
+ Copyright (C) 1998 - 2008 Pekka Riikonen
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#define silc_buffer_data(x) (x)->data
/***/
+/****f* silcutil/SilcBufferAPI/silc_buffer_tail
+ *
+ * NAME
+ *
+ * unsigned char *silc_buffer_tail(SilcBuffer sb)
+ *
+ * DESCRIPTION
+ *
+ * Returns pointer to the tail area of the buffer.
+ *
+ * SOURCE
+ */
+#define silc_buffer_tail(x) (x)->tail
+/***/
+
/****f* silcutil/SilcBufferAPI/silc_buffer_datalen
*
* NAME
*
* DESCRIPTION
*
- * Allocates new SilcBuffer and returns it. Returns NULL on error.
+ * Allocates new SilcBuffer and returns it. Returns NULL if system is
+ * out of memory.
*
***/
*
* DESCRIPTION
*
- * Allocates new SilcBuffer and returns it.
+ * Allocates new SilcBuffer and returns it. Returns NULL if system is
+ * out of memory.
*
* This routine use SilcStack are memory source. If `stack' is NULL
* reverts back to normal allocating routine.
*
* Pulls current data area towards end. The length of the currently
* valid data area is also decremented. Returns pointer to the data
- * area before pulling. Returns NULL on error.
+ * area before pulling. Returns NULL if the pull would lead to buffer
+ * overflow or would go beyond the valid data area.
*
* EXAMPLE
*
#ifdef SILC_DIST_INPLACE
SILC_ASSERT(len <= silc_buffer_len(sb));
#endif /* SILC_DIST_INPLACE */
- if (silc_unlikely(len > silc_buffer_len(sb)))
+ if (silc_unlikely(len > silc_buffer_len(sb))) {
+ silc_set_errno(SILC_ERR_OVERFLOW);
return NULL;
+ }
sb->data += len;
return old_data;
*
* Pushes current data area towards beginning. Length of the currently
* valid data area is also incremented. Returns a pointer to the
- * data area before pushing. Returns NULL on error.
+ * data area before pushing. Returns NULL if the push would lead to
+ * go beyond the buffer boundaries or current data area.
*
* EXAMPLE
*
#ifdef SILC_DIST_INPLACE
SILC_ASSERT((sb->data - len) >= sb->head);
#endif /* SILC_DIST_INPLACE */
- if (silc_unlikely((sb->data - len) < sb->head))
+ if (silc_unlikely((sb->data - len) < sb->head)) {
+ silc_set_errno(SILC_ERR_OVERFLOW);
return NULL;
+ }
sb->data -= len;
return old_data;
*
* Pulls current tail section towards end. Length of the current valid
* data area is also incremented. Returns a pointer to the data area
- * before pulling. Returns NULL on error.
+ * before pulling. Returns NULL if the pull would lead to buffer overflow.
*
* EXAMPLE
*
#ifdef SILC_DIST_INPLACE
SILC_ASSERT(len <= silc_buffer_taillen(sb));
#endif /* SILC_DIST_INPLACE */
- if (silc_unlikely(len > silc_buffer_taillen(sb)))
+ if (silc_unlikely(len > silc_buffer_taillen(sb))) {
+ silc_set_errno(SILC_ERR_OVERFLOW);
return NULL;
+ }
sb->tail += len;
return old_tail;
*
* Pushes current tail section towards beginning. Length of the current
* valid data area is also decremented. Returns a pointer to the
- * tail section before pushing. Returns NULL on error.
+ * tail section before pushing. Returns NULL if the push would lead to
+ * go beyond buffer boundaries or current tail area.
*
* EXAMPLE
*
#ifdef SILC_DIST_INPLACE
SILC_ASSERT((sb->tail - len) >= sb->data);
#endif /* SILC_DIST_INPLACE */
- if (silc_unlikely((sb->tail - len) < sb->data))
+ if (silc_unlikely((sb->tail - len) < sb->data)) {
+ silc_set_errno(SILC_ERR_OVERFLOW);
return NULL;
+ }
sb->tail -= len;
return old_tail;
* DESCRIPTION
*
* Puts data at the head of the buffer. Returns pointer to the copied
- * data area. Returns NULL on error.
+ * data area. Returns NULL if the data is longer that the current head
+ * area.
*
* EXAMPLE
*
#ifdef SILC_DIST_INPLACE
SILC_ASSERT(len <= silc_buffer_headlen(sb));
#endif /* SILC_DIST_INPLACE */
- if (silc_unlikely(len > silc_buffer_headlen(sb)))
+ if (silc_unlikely(len > silc_buffer_headlen(sb))) {
+ silc_set_errno(SILC_ERR_OVERFLOW);
return NULL;
+ }
+
+ if (sb->head > data) {
+ if (sb->head - data <= len)
+ return (unsigned char *)memmove(sb->head, data, len);
+ } else {
+ if (data - sb->head <= len)
+ return (unsigned char *)memmove(sb->head, data, len);
+ }
return (unsigned char *)memcpy(sb->head, data, len);
}
* DESCRIPTION
*
* Puts data at the start of the valid data area. Returns a pointer
- * to the copied data area. Returns NULL on error.
+ * to the copied data area. Returns NULL if the data is longer than the
+ * current data area.
*
* EXAMPLE
*
#ifdef SILC_DIST_INPLACE
SILC_ASSERT(len <= silc_buffer_len(sb));
#endif /* SILC_DIST_INPLACE */
- if (silc_unlikely(len > silc_buffer_len(sb)))
+ if (silc_unlikely(len > silc_buffer_len(sb))) {
+ silc_set_errno(SILC_ERR_OVERFLOW);
return NULL;
+ }
+
+ if (sb->data > data) {
+ if (sb->data - data <= len)
+ return (unsigned char *)memmove(sb->data, data, len);
+ } else {
+ if (data - sb->data <= len)
+ return (unsigned char *)memmove(sb->data, data, len);
+ }
return (unsigned char *)memcpy(sb->data, data, len);
}
* DESCRIPTION
*
* Puts data at the tail of the buffer. Returns pointer to the copied
- * data area. Returns NULL on error.
+ * data area. Returns NULL if the data is longer than the current tail
+ * area.
*
* EXAMPLE
*
#ifdef SILC_DIST_INPLACE
SILC_ASSERT(len <= silc_buffer_taillen(sb));
#endif /* SILC_DIST_INPLACE */
- if (silc_unlikely(len > silc_buffer_taillen(sb)))
+ if (silc_unlikely(len > silc_buffer_taillen(sb))) {
+ silc_set_errno(SILC_ERR_OVERFLOW);
return NULL;
+ }
+
+ if (sb->tail > data) {
+ if (sb->tail - data <= len)
+ return (unsigned char *)memmove(sb->tail, data, len);
+ } else {
+ if (data - sb->tail <= len)
+ return (unsigned char *)memmove(sb->tail, data, len);
+ }
return (unsigned char *)memcpy(sb->tail, data, len);
}
*
* Allocates `len' bytes size buffer and moves the tail area automatically
* `len' bytes so that the buffer is ready to use without calling the
- * silc_buffer_pull_tail. Returns NULL on error.
+ * silc_buffer_pull_tail. Returns NULL if system is out of memory.
*
***/
*
* Allocates `len' bytes size buffer and moves the tail area automatically
* `len' bytes so that the buffer is ready to use without calling the
- * silc_buffer_pull_tail.
+ * silc_buffer_pull_tail. Returns NULL if system is out of memory.
*
* This routine use SilcStack are memory source. If `stack' is NULL
* reverts back to normal allocating routine.
*
* Generates copy of a SilcBuffer. This copies everything inside the
* currently valid data area, nothing more. Use silc_buffer_clone to
- * copy entire buffer. Returns NULL on error.
+ * copy entire buffer. Returns NULL if system is out of memory.
*
***/
*
* Generates copy of a SilcBuffer. This copies everything inside the
* currently valid data area, nothing more. Use silc_buffer_clone to
- * copy entire buffer.
+ * copy entire buffer. Returns NULL if system is out of memory.
*
* This routine use SilcStack are memory source. If `stack' is NULL
* reverts back to normal allocating routine.
*
* Clones SilcBuffer. This generates new SilcBuffer and copies
* everything from the source buffer. The result is exact clone of
- * the original buffer. Returns NULL on error.
+ * the original buffer. Returns NULL if system is out of memory.
*
***/
*
* Clones SilcBuffer. This generates new SilcBuffer and copies
* everything from the source buffer. The result is exact clone of
- * the original buffer.
+ * the original buffer. Returns NULL if system is out of memory.
*
* This routine use SilcStack are memory source. If `stack' is NULL
* reverts back to normal allocating routine.
* DESCRIPTION
*
* Reallocates buffer. Old data is saved into the new buffer. The buffer
- * is exact clone of the old one except that there is now more space
+ * is exact clone of the old one except that there is now more/less space
* at the end of buffer. This always returns the same `sb' unless `sb'
- * was NULL. Returns NULL on error.
+ * was NULL. Returns NULL if system is out of memory.
+ *
+ * If the `newsize' is shorter than the current buffer size, the data
+ * and tail area of the buffer must be set to correct position before
+ * calling this function so that buffer overflow would not occur when
+ * the buffer size is reduced.
*
***/
if (!sb)
return silc_buffer_alloc(newsize);
- if (silc_unlikely(newsize <= silc_buffer_truelen(sb)))
+ if (silc_unlikely(newsize == silc_buffer_truelen(sb)))
return sb;
hlen = silc_buffer_headlen(sb);
* DESCRIPTION
*
* Reallocates buffer. Old data is saved into the new buffer. The buffer
- * is exact clone of the old one except that there is now more space
- * at the end of buffer.
+ * is exact clone of the old one except that there is now more/less space
+ * at the end of buffer. Returns NULL if system is out of memory. This
+ * always returns `sb' unless `sb' was NULL.
+ *
+ * If the `newsize' is shorter than the current buffer size, the data
+ * and tail area of the buffer must be set to correct position before
+ * calling this function so that buffer overflow would not occur when
+ * the buffer size is reduced.
*
* This routine use SilcStack are memory source. If `stack' is NULL
* reverts back to normal allocating routine.
if (!sb)
return silc_buffer_salloc(stack, newsize);
- if (newsize <= silc_buffer_truelen(sb))
+ if (newsize == silc_buffer_truelen(sb))
return sb;
hlen = silc_buffer_headlen(sb);
dlen = silc_buffer_len(sb);
h = (unsigned char *)silc_srealloc(stack, silc_buffer_truelen(sb),
sb->head, newsize);
- if (!h) {
- /* Do slow and stack wasting realloc. The old sb->head is lost and
- is freed eventually. */
- h = (unsigned char *)silc_smalloc(stack, newsize);
- if (silc_unlikely(!h))
- return NULL;
- memcpy(h, sb->head, silc_buffer_truelen(sb));
- }
+ if (!h)
+ return NULL;
sb->head = h;
sb->data = sb->head + hlen;
*
* Same as silc_buffer_realloc but moves moves the tail area
* automatically so that the buffer is ready to use without calling the
- * silc_buffer_pull_tail. Returns NULL on error.
+ * silc_buffer_pull_tail. Returns NULL if system is out of memory.
*
***/
*
* Same as silc_buffer_srealloc but moves moves the tail area
* automatically so that the buffer is ready to use without calling the
- * silc_buffer_pull_tail.
+ * silc_buffer_pull_tail. Returns NULL if system is out of memory.
*
* This routine use SilcStack are memory source. If `stack' is NULL
* reverts back to normal allocating routine.
* is at least the size of `size'. If there is more space than `size'
* in the data area this does not do anything. If there is enough
* space in the tail area this merely moves the tail area to reveal
- * the extra space. Returns FALSE on error.
+ * the extra space. Returns FALSE if system is out of memory.
*
***/
* is at least the size of `size'. If there is more space than `size'
* in the data area this does not do anything. If there is enough
* space in the tail area this merely moves the tail area to reveal
- * the extra space. Returns FALSE on error.
+ * the extra space. Returns FALSE if system is out of memory.
*
* This routine use SilcStack are memory source. If `stack' is NULL
* reverts back to normal allocating routine.
return TRUE;
}
+/****f* silcutil/SilcBufferAPI/silc_buffer_append
+ *
+ * SYNOPSIS
+ *
+ * static inline
+ * SilcBuffer silc_buffer_append(SilcBuffer sb, SilcUInt32 size);
+ *
+ * DESCRIPTION
+ *
+ * Appends the current data area by the amount of `size'. The tail area
+ * of the buffer remains intact and contains the same data than the old
+ * tail area (the data is copied to the new tail area). After appending
+ * there is now `size' bytes more free area in the data area. Returns
+ * FALSE if system is out of memory.
+ *
+ * EXAMPLE
+ *
+ * Before appending:
+ * ---------------------------------
+ * | head | data | tail |
+ * ---------------------------------
+ *
+ * After appending:
+ * ------------------------------------
+ * | head | data | tail |
+ * -------------------------------------
+ *
+ * silc_buffer_append(sb, 5);
+ *
+ ***/
+
+static inline
+SilcBool silc_buffer_append(SilcBuffer sb, SilcUInt32 size)
+{
+ if (silc_unlikely(!silc_buffer_realloc(sb, silc_buffer_truelen(sb) + size)))
+ return FALSE;
+
+ /* Enlarge data area */
+ silc_buffer_pull_tail(sb, size);
+
+ /* Copy old tail area to new tail area */
+ silc_buffer_put_tail(sb, sb->tail - size, silc_buffer_taillen(sb));
+
+ return TRUE;
+}
+
+/****f* silcutil/SilcBufferAPI/silc_buffer_append
+ *
+ * SYNOPSIS
+ *
+ * static inline
+ * SilcBool silc_buffer_sappend(SilcStack stack, SilcBuffer sb,
+ * SilcUInt32 size)
+ *
+ * DESCRIPTION
+ *
+ * Appends the current data area by the amount of `size'. The tail area
+ * of the buffer remains intact and contains the same data than the old
+ * tail area (the data is copied to the new tail area). After appending
+ * there is now `size' bytes more free area in the data area. Returns
+ * FALSE if system is out of memory.
+ *
+ * This routine use SilcStack are memory source. If `stack' is NULL
+ * reverts back to normal allocating routine.
+ *
+ * Note that this call consumes the `stack'. The caller should push the
+ * stack before calling the function and pop it later.
+ *
+ * EXAMPLE
+ *
+ * Before appending:
+ * ---------------------------------
+ * | head | data | tail |
+ * ---------------------------------
+ *
+ * After appending:
+ * ------------------------------------
+ * | head | data | tail |
+ * -------------------------------------
+ *
+ * silc_buffer_append(sb, 5);
+ *
+ ***/
+
+static inline
+SilcBool silc_buffer_sappend(SilcStack stack, SilcBuffer sb, SilcUInt32 size)
+{
+ if (silc_unlikely(!silc_buffer_srealloc(stack, sb,
+ silc_buffer_truelen(sb) + size)))
+ return FALSE;
+
+ /* Enlarge data area */
+ silc_buffer_pull_tail(sb, size);
+
+ /* Copy old tail area to new tail area */
+ silc_buffer_put_tail(sb, sb->tail - size, silc_buffer_taillen(sb));
+
+ return TRUE;
+}
+
/****f* silcutil/SilcBufferAPI/silc_buffer_strchr
*
* SYNOPSIS
return NULL;
}
+/****f* silcutil/SilcBufferAPI/silc_buffer_equal
+ *
+ * SYNOPSIS
+ *
+ * static inline
+ * SilcBool silc_buffer_equal(SilcBuffer sb1, SilcBuffer sb2)
+ *
+ * DESCRIPTION
+ *
+ * Compares if the data area of the buffer `sb1' and `sb2' are identical.
+ * Returns TRUE if they match and FALSE if they differ.
+ *
+ ***/
+
+static inline
+SilcBool silc_buffer_equal(SilcBuffer sb1, SilcBuffer sb2)
+{
+ if (silc_buffer_len(sb1) != silc_buffer_len(sb2))
+ return FALSE;
+ return memcmp(sb1->data, sb2->data, silc_buffer_len(sb1)) == 0;
+}
+
+/****f* silcutil/SilcBufferAPI/silc_buffer_memcmp
+ *
+ * SYNOPSIS
+ *
+ * static inline
+ * SilcBool silc_buffer_memcmp(SilcBuffer buffer,
+ * const unsigned char *data,
+ * SilcUInt32 data_len)
+ *
+ * DESCRIPTION
+ *
+ * Compares the data area of the buffer with the `data'. Returns TRUE
+ * if the data area is identical to `data' or FALSE if they differ.
+ *
+ ***/
+
+static inline
+SilcBool silc_buffer_memcmp(SilcBuffer buffer, const unsigned char *data,
+ SilcUInt32 data_len)
+{
+ if (silc_buffer_len(buffer) != data_len)
+ return FALSE;
+ return memcmp(buffer->data, data, data_len) == 0;
+}
+
+/****f* silcutil/SilcBufferAPI/silc_buffer_printf
+ *
+ * SYNOPSIS
+ *
+ * static inline
+ * void silc_buffer_printf(SilcBuffer sb, SilcBool newline);
+ *
+ * DESCRIPTION
+ *
+ * Prints the current data area of `sb' into stdout. If `newline' is
+ * TRUE prints '\n' after the data in the buffer.
+ *
+ ***/
+
+static inline
+void silc_buffer_printf(SilcBuffer sb, SilcBool newline)
+{
+ silc_file_write(1, silc_buffer_data(sb), silc_buffer_len(sb));
+ if (newline)
+ printf("\n");
+ fflush(stdout);
+}
+
#endif /* SILCBUFFER_H */
projects / silc.git / blobdiff