/*
- silcbuffer.h
+ silcbuffer.h
- Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
+ Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1998 - 2000 Pekka Riikonen
+ Copyright (C) 1998 - 2002 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
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
+ the Free Software Foundation; version 2 of the License.
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
the allocated data area. Following short description of the fields
of the buffer.
- uint32 truelen;
+ SilcUInt32 truelen;
True length of the buffer. This is set at the allocation of the
buffer and it should not be touched after that. This field should
be considered read-only.
- uint32 len;
+ SilcUInt32 len;
Length of the currently valid data area. Tells the length of the
data at the buffer. This is set to zero at the allocation of the
Currently valid data area is considered to be the main data area in
the buffer. However, the entire buffer is of course valid data and can
be used as such. Usually head section of the buffer includes different
- kind of headers or similiar. Data section includes the main data of
+ kind of headers or similar. Data section includes the main data of
the buffer. Tail section can be seen as a reserve space of the data
section. Tail section can be pulled towards end thus the data section
becomes larger.
*/
typedef struct {
- uint32 truelen;
- uint32 len;
+ SilcUInt32 truelen;
+ SilcUInt32 len;
unsigned char *head;
unsigned char *data;
unsigned char *tail;
/* Inline functions */
-extern inline
-SilcBuffer silc_buffer_alloc(uint32 len)
+static inline
+SilcBuffer silc_buffer_alloc(SilcUInt32 len)
{
SilcBuffer sb;
/* Free's a SilcBuffer */
-extern inline
+static inline
void silc_buffer_free(SilcBuffer sb)
{
if (sb) {
can be used to set the data to static buffer without needing any
memory allocations. The `data' will not be copied to the buffer. */
-extern inline
-void silc_buffer_set(SilcBuffer sb, unsigned char *data, uint32 data_len)
+static inline
+void silc_buffer_set(SilcBuffer sb, unsigned char *data, SilcUInt32 data_len)
{
sb->data = sb->head = data;
sb->tail = sb->end = data + data_len;
^
*/
-extern inline
-unsigned char *silc_buffer_pull(SilcBuffer sb, uint32 len)
+static inline
+unsigned char *silc_buffer_pull(SilcBuffer sb, SilcUInt32 len)
{
unsigned char *old_data = sb->data;
#ifdef SILC_DEBUG
- assert(len <= (sb->tail - sb->data));
+ assert(len <= (SilcUInt32)(sb->tail - sb->data));
#endif
sb->data += len;
^
*/
-extern inline
-unsigned char *silc_buffer_push(SilcBuffer sb, uint32 len)
+static inline
+unsigned char *silc_buffer_push(SilcBuffer sb, SilcUInt32 len)
{
unsigned char *old_data = sb->data;
^
*/
-extern inline
-unsigned char *silc_buffer_pull_tail(SilcBuffer sb, uint32 len)
+static inline
+unsigned char *silc_buffer_pull_tail(SilcBuffer sb, SilcUInt32 len)
{
unsigned char *old_tail = sb->tail;
#ifdef SILC_DEBUG
- assert((sb->end - sb->tail) >= len);
+ assert((SilcUInt32)(sb->end - sb->tail) >= len);
#endif
sb->tail += len;
^
*/
-extern inline
-unsigned char *silc_buffer_push_tail(SilcBuffer sb, uint32 len)
+static inline
+unsigned char *silc_buffer_push_tail(SilcBuffer sb, SilcUInt32 len)
{
unsigned char *old_tail = sb->tail;
Puts data to the head section.
*/
-extern inline
+static inline
unsigned char *silc_buffer_put_head(SilcBuffer sb,
- unsigned char *data,
- uint32 len)
+ const unsigned char *data,
+ SilcUInt32 len)
{
#ifdef SILC_DEBUG
- assert((sb->data - sb->head) >= len);
+ assert((SilcUInt32)(sb->data - sb->head) >= len);
#endif
return (unsigned char *)memcpy(sb->head, data, len);
}
Puts data to the data section.
*/
-extern inline
+static inline
unsigned char *silc_buffer_put(SilcBuffer sb,
- unsigned char *data,
- uint32 len)
+ const unsigned char *data,
+ SilcUInt32 len)
{
#ifdef SILC_DEBUG
- assert((sb->tail - sb->data) >= len);
+ assert((SilcUInt32)(sb->tail - sb->data) >= len);
#endif
return (unsigned char *)memcpy(sb->data, data, len);
}
Puts data to the tail section.
*/
-extern inline
+static inline
unsigned char *silc_buffer_put_tail(SilcBuffer sb,
- unsigned char *data,
- uint32 len)
+ const unsigned char *data,
+ SilcUInt32 len)
{
#ifdef SILC_DEBUG
- assert((sb->end - sb->tail) >= len);
+ assert((SilcUInt32)(sb->end - sb->tail) >= len);
#endif
return (unsigned char *)memcpy(sb->tail, data, len);
}
+/* Clears and initialiazes the buffer to the state as if it was just
+ allocated by silc_buffer_alloc. */
+
+static inline
+void silc_buffer_clear(SilcBuffer sb)
+{
+ memset(sb->head, 0, sb->truelen);
+ sb->data = sb->head;
+ sb->tail = sb->head;
+ sb->len = 0;
+}
+
+/* Generates copy of a SilcBuffer. This copies everything inside the
+ currently valid data area, nothing more. Use silc_buffer_clone to
+ copy entire buffer. */
+
+static inline
+SilcBuffer silc_buffer_copy(SilcBuffer sb)
+{
+ SilcBuffer sb_new;
+
+ sb_new = silc_buffer_alloc(sb->len);
+ silc_buffer_pull_tail(sb_new, SILC_BUFFER_END(sb_new));
+ silc_buffer_put(sb_new, sb->data, sb->len);
+
+ return sb_new;
+}
+
+/* Clones SilcBuffer. This generates new SilcBuffer and copies
+ everything from the source buffer. The result is exact clone of
+ the original buffer. */
+
+static inline
+SilcBuffer silc_buffer_clone(SilcBuffer sb)
+{
+ SilcBuffer sb_new;
+
+ sb_new = silc_buffer_alloc(sb->truelen);
+ silc_buffer_pull_tail(sb_new, SILC_BUFFER_END(sb_new));
+ silc_buffer_put(sb_new, sb->head, sb->truelen);
+ sb_new->data = sb_new->head + (sb->data - sb->head);
+ sb_new->tail = sb_new->data + sb->len;
+ sb_new->len = sb->len;
+
+ return sb_new;
+}
+
+/* Reallocates buffer. Old data is saved into the new buffer. Returns
+ new SilcBuffer pointer. The buffer is exact clone of the old one
+ except that there is now more space at the end of buffer. */
+
+static inline
+SilcBuffer silc_buffer_realloc(SilcBuffer sb, SilcUInt32 newsize)
+{
+ SilcBuffer sb_new;
+
+ if (!sb)
+ return silc_buffer_alloc(newsize);
+
+ if (newsize <= sb->truelen)
+ return sb;
+
+ sb_new = silc_buffer_alloc(newsize);
+ silc_buffer_pull_tail(sb_new, SILC_BUFFER_END(sb_new));
+ silc_buffer_put(sb_new, sb->head, sb->truelen);
+ sb_new->data = sb_new->head + (sb->data - sb->head);
+ sb_new->tail = sb_new->data + sb->len;
+ sb_new->len = sb->len;
+
+ silc_buffer_free(sb);
+
+ return sb_new;
+}
+
#endif
projects / silc.git / blobdiff