ReactOS  0.4.13-dev-544-gede3fdd
pbuf.h File Reference
#include "lwip/opt.h"
#include "lwip/err.h"
Include dependency graph for pbuf.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  pbuf
 

Macros

#define LWIP_SUPPORT_CUSTOM_PBUF   (IP_FRAG && !IP_FRAG_USES_STATIC_BUF && !LWIP_NETIF_TX_SINGLE_PBUF)
 
#define PBUF_TRANSPORT_HLEN   20
 
#define PBUF_IP_HLEN   20
 
#define PBUF_FLAG_PUSH   0x01U
 
#define PBUF_FLAG_IS_CUSTOM   0x02U
 
#define PBUF_FLAG_MCASTLOOP   0x04U
 
#define PBUF_FLAG_LLBCAST   0x08U
 
#define PBUF_FLAG_LLMCAST   0x10U
 
#define PBUF_FLAG_TCP_FIN   0x20U
 
#define pbuf_init()
 

Enumerations

enum  pbuf_layer { PBUF_TRANSPORT, PBUF_IP, PBUF_LINK, PBUF_RAW }
 
enum  pbuf_type { PBUF_RAM, PBUF_ROM, PBUF_REF, PBUF_POOL }
 

Functions

struct pbufpbuf_alloc (pbuf_layer l, u16_t length, pbuf_type type)
 
void pbuf_realloc (struct pbuf *p, u16_t size)
 
u8_t pbuf_header (struct pbuf *p, s16_t header_size)
 
void pbuf_ref (struct pbuf *p)
 
u8_t pbuf_free (struct pbuf *p)
 
u8_t pbuf_clen (struct pbuf *p)
 
void pbuf_cat (struct pbuf *head, struct pbuf *tail)
 
void pbuf_chain (struct pbuf *head, struct pbuf *tail)
 
struct pbufpbuf_dechain (struct pbuf *p)
 
err_t pbuf_copy (struct pbuf *p_to, struct pbuf *p_from)
 
u16_t pbuf_copy_partial (struct pbuf *p, void *dataptr, u16_t len, u16_t offset)
 
err_t pbuf_take (struct pbuf *buf, const void *dataptr, u16_t len)
 
struct pbufpbuf_coalesce (struct pbuf *p, pbuf_layer layer)
 
u8_t pbuf_get_at (struct pbuf *p, u16_t offset)
 
u16_t pbuf_memcmp (struct pbuf *p, u16_t offset, const void *s2, u16_t n)
 
u16_t pbuf_memfind (struct pbuf *p, const void *mem, u16_t mem_len, u16_t start_offset)
 
u16_t pbuf_strstr (struct pbuf *p, const char *substr)
 

Macro Definition Documentation

◆ LWIP_SUPPORT_CUSTOM_PBUF

#define LWIP_SUPPORT_CUSTOM_PBUF   (IP_FRAG && !IP_FRAG_USES_STATIC_BUF && !LWIP_NETIF_TX_SINGLE_PBUF)

Currently, the pbuf_custom code is only needed for one specific configuration of IP_FRAG

Definition at line 45 of file pbuf.h.

◆ PBUF_FLAG_IS_CUSTOM

#define PBUF_FLAG_IS_CUSTOM   0x02U

indicates this is a custom pbuf: pbuf_free and pbuf_header handle such a a pbuf differently

Definition at line 69 of file pbuf.h.

◆ PBUF_FLAG_LLBCAST

#define PBUF_FLAG_LLBCAST   0x08U

indicates this pbuf was received as link-level broadcast

Definition at line 73 of file pbuf.h.

◆ PBUF_FLAG_LLMCAST

#define PBUF_FLAG_LLMCAST   0x10U

indicates this pbuf was received as link-level multicast

Definition at line 75 of file pbuf.h.

◆ PBUF_FLAG_MCASTLOOP

#define PBUF_FLAG_MCASTLOOP   0x04U

indicates this pbuf is UDP multicast to be looped back

Definition at line 71 of file pbuf.h.

◆ PBUF_FLAG_PUSH

#define PBUF_FLAG_PUSH   0x01U

indicates this packet's data should be immediately passed to the application

Definition at line 66 of file pbuf.h.

◆ PBUF_FLAG_TCP_FIN

#define PBUF_FLAG_TCP_FIN   0x20U

indicates this pbuf includes a TCP FIN flag

Definition at line 77 of file pbuf.h.

◆ pbuf_init

#define pbuf_init ( )

Definition at line 144 of file pbuf.h.

◆ PBUF_IP_HLEN

#define PBUF_IP_HLEN   20

Definition at line 48 of file pbuf.h.

◆ PBUF_TRANSPORT_HLEN

#define PBUF_TRANSPORT_HLEN   20

Definition at line 47 of file pbuf.h.

Enumeration Type Documentation

◆ pbuf_layer

Enumerator
PBUF_TRANSPORT 
PBUF_IP 
PBUF_LINK 
PBUF_RAW 

Definition at line 50 of file pbuf.h.

50  {
52  PBUF_IP,
53  PBUF_LINK,
54  PBUF_RAW
55 } pbuf_layer;
Definition: pbuf.h:53
Definition: pbuf.h:54
Definition: pbuf.h:52
pbuf_layer
Definition: pbuf.h:50

◆ pbuf_type

Enumerator
PBUF_RAM 
PBUF_ROM 
PBUF_REF 
PBUF_POOL 

Definition at line 57 of file pbuf.h.

57  {
58  PBUF_RAM, /* pbuf data is stored in RAM */
59  PBUF_ROM, /* pbuf data is stored in ROM */
60  PBUF_REF, /* pbuf comes from the pbuf pool */
61  PBUF_POOL /* pbuf payload refers to RAM */
62 } pbuf_type;
Definition: pbuf.h:58
Definition: pbuf.h:61
Definition: pbuf.h:59
pbuf_type
Definition: pbuf.h:57
Definition: pbuf.h:60

Function Documentation

◆ pbuf_alloc()

struct pbuf* pbuf_alloc ( pbuf_layer  layer,
u16_t  length,
pbuf_type  type 
)

Allocates a pbuf of the given type (possibly a chain for PBUF_POOL type).

The actual memory allocated for the pbuf is determined by the layer at which the pbuf is allocated and the requested size (from the size parameter).

Parameters
layerflag to define header size
lengthsize of the pbuf's payload
typethis parameter decides how and where the pbuf should be allocated as follows:
  • PBUF_RAM: buffer memory for pbuf is allocated as one large chunk. This includes protocol headers as well.
  • PBUF_ROM: no buffer memory is allocated for the pbuf, even for protocol headers. Additional headers must be prepended by allocating another pbuf and chain in to the front of the ROM pbuf. It is assumed that the memory used is really similar to ROM in that it is immutable and will not be changed. Memory which is dynamic should generally not be attached to PBUF_ROM pbufs. Use PBUF_REF instead.
  • PBUF_REF: no buffer memory is allocated for the pbuf, even for protocol headers. It is assumed that the pbuf is only being used in a single thread. If the pbuf gets queued, then pbuf_take should be called to copy the buffer.
  • PBUF_POOL: the pbuf is allocated as a pbuf chain, with pbufs from the pbuf pool that is allocated during pbuf_init().
Returns
the allocated pbuf. If multiple pbufs where allocated, this is the first pbuf of a pbuf chain.

Definition at line 207 of file pbuf.c.

208 {
209  struct pbuf *p, *q, *r;
210  u16_t offset;
211  s32_t rem_len; /* remaining length */
212  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_alloc(length=%"U16_F")\n", length));
213 
214  /* determine header offset */
215  switch (layer) {
216  case PBUF_TRANSPORT:
217  /* add room for transport (often TCP) layer header */
219  break;
220  case PBUF_IP:
221  /* add room for IP layer header */
223  break;
224  case PBUF_LINK:
225  /* add room for link layer header */
227  break;
228  case PBUF_RAW:
229  offset = 0;
230  break;
231  default:
232  LWIP_ASSERT("pbuf_alloc: bad pbuf layer", 0);
233  return NULL;
234  }
235 
236  switch (type) {
237  case PBUF_POOL:
238  /* allocate head of pbuf chain into p */
239  p = (struct pbuf *)memp_malloc(MEMP_PBUF_POOL);
240  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_alloc: allocated pbuf %p\n", (void *)p));
241  if (p == NULL) {
243  return NULL;
244  }
245  p->type = type;
246  p->next = NULL;
247 
248  /* make the payload pointer point 'offset' bytes into pbuf data memory */
249  p->payload = LWIP_MEM_ALIGN((void *)((u8_t *)p + (SIZEOF_STRUCT_PBUF + offset)));
250  LWIP_ASSERT("pbuf_alloc: pbuf p->payload properly aligned",
251  ((mem_ptr_t)p->payload % MEM_ALIGNMENT) == 0);
252  /* the total length of the pbuf chain is the requested size */
253  p->tot_len = length;
254  /* set the length of the first pbuf in the chain */
256  LWIP_ASSERT("check p->payload + p->len does not overflow pbuf",
257  ((u8_t*)p->payload + p->len <=
259  LWIP_ASSERT("PBUF_POOL_BUFSIZE must be bigger than MEM_ALIGNMENT",
261  /* set reference count (needed here in case we fail) */
262  p->ref = 1;
263 
264  /* now allocate the tail of the pbuf chain */
265 
266  /* remember first pbuf for linkage in next iteration */
267  r = p;
268  /* remaining length to be allocated */
269  rem_len = length - p->len;
270  /* any remaining pbufs to be allocated? */
271  while (rem_len > 0) {
272  q = (struct pbuf *)memp_malloc(MEMP_PBUF_POOL);
273  if (q == NULL) {
275  /* free chain so far allocated */
276  pbuf_free(p);
277  /* bail out unsuccesfully */
278  return NULL;
279  }
280  q->type = type;
281  q->flags = 0;
282  q->next = NULL;
283  /* make previous pbuf point to this pbuf */
284  r->next = q;
285  /* set total length of this pbuf and next in chain */
286  LWIP_ASSERT("rem_len < max_u16_t", rem_len < 0xffff);
287  q->tot_len = (u16_t)rem_len;
288  /* this pbuf length is pool size, unless smaller sized tail */
289  q->len = LWIP_MIN((u16_t)rem_len, PBUF_POOL_BUFSIZE_ALIGNED);
290  q->payload = (void *)((u8_t *)q + SIZEOF_STRUCT_PBUF);
291  LWIP_ASSERT("pbuf_alloc: pbuf q->payload properly aligned",
292  ((mem_ptr_t)q->payload % MEM_ALIGNMENT) == 0);
293  LWIP_ASSERT("check p->payload + p->len does not overflow pbuf",
294  ((u8_t*)p->payload + p->len <=
296  q->ref = 1;
297  /* calculate remaining length to be allocated */
298  rem_len -= q->len;
299  /* remember this pbuf for linkage in next iteration */
300  r = q;
301  }
302  /* end of chain */
303  /*r->next = NULL;*/
304 
305  break;
306  case PBUF_RAM:
307  /* If pbuf is to be allocated in RAM, allocate memory for it. */
309  if (p == NULL) {
310  return NULL;
311  }
312  /* Set up internal structure of the pbuf. */
313  p->payload = LWIP_MEM_ALIGN((void *)((u8_t *)p + SIZEOF_STRUCT_PBUF + offset));
314  p->len = p->tot_len = length;
315  p->next = NULL;
316  p->type = type;
317 
318  LWIP_ASSERT("pbuf_alloc: pbuf->payload properly aligned",
319  ((mem_ptr_t)p->payload % MEM_ALIGNMENT) == 0);
320  break;
321  /* pbuf references existing (non-volatile static constant) ROM payload? */
322  case PBUF_ROM:
323  /* pbuf references existing (externally allocated) RAM payload? */
324  case PBUF_REF:
325  /* only allocate memory for the pbuf structure */
326  p = (struct pbuf *)memp_malloc(MEMP_PBUF);
327  if (p == NULL) {
329  ("pbuf_alloc: Could not allocate MEMP_PBUF for PBUF_%s.\n",
330  (type == PBUF_ROM) ? "ROM" : "REF"));
331  return NULL;
332  }
333  /* caller must set this field properly, afterwards */
334  p->payload = NULL;
335  p->len = p->tot_len = length;
336  p->next = NULL;
337  p->type = type;
338  break;
339  default:
340  LWIP_ASSERT("pbuf_alloc: erroneous type", 0);
341  return NULL;
342  }
343  /* set reference count */
344  p->ref = 1;
345  /* set flags */
346  p->flags = 0;
347  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_alloc(length=%"U16_F") == %p\n", length, (void *)p));
348  return p;
349 }
#define MEM_ALIGNMENT
Definition: d3d9_helpers.c:15
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLintptr offset
Definition: glext.h:5920
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define PBUF_IP_HLEN
Definition: pbuf.h:48
void * mem_malloc(mem_size_t size)
Definition: mem.c:494
#define LWIP_ASSERT(message, assertion)
Definition: debug.h:66
Definition: pbuf.h:58
Definition: pbuf.h:53
#define PBUF_DEBUG
Definition: opt.h:1912
#define LWIP_MIN(x, y)
Definition: def.h:44
smooth NULL
Definition: ftsmooth.c:416
u8_t pbuf_free(struct pbuf *p)
Definition: pbuf.c:618
Definition: pbuf.h:54
#define LWIP_DEBUGF(debug, message)
Definition: debug.h:95
#define SIZEOF_STRUCT_PBUF
Definition: pbuf.c:82
#define PBUF_TRANSPORT_HLEN
Definition: pbuf.h:47
#define U16_F
Definition: cc.h:36
#define LWIP_MEM_ALIGN_SIZE(size)
Definition: mem.h:101
#define PBUF_POOL_BUFSIZE_ALIGNED
Definition: pbuf.c:85
GLenum GLuint GLint GLint layer
Definition: glext.h:7007
Definition: pbuf.h:79
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
Definition: pbuf.h:61
Definition: pbuf.h:59
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
ULONG_PTR mem_ptr_t
Definition: cc.h:33
#define LWIP_DBG_LEVEL_SERIOUS
Definition: debug.h:47
Definition: pbuf.h:60
unsigned char u8_t
Definition: cc.h:23
#define LWIP_DBG_TRACE
Definition: debug.h:57
#define PBUF_POOL_IS_EMPTY()
Definition: pbuf.c:88
#define LWIP_MEM_ALIGN(addr)
Definition: mem.h:116
signed long s32_t
Definition: cc.h:30
Definition: pbuf.h:52
unsigned short u16_t
Definition: cc.h:24
void * memp_malloc(memp_t type)
Definition: memp.c:390
#define PBUF_LINK_HLEN
Definition: opt.h:1095
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by LibIPInsertPacket(), pbuf_coalesce(), tcp_create_segment_wnd(), and test_tcp_netif_output().

◆ pbuf_cat()

void pbuf_cat ( struct pbuf h,
struct pbuf t 
)

Concatenate two pbufs (each may be a pbuf chain) and take over the caller's reference of the tail pbuf.

Note
The caller MAY NOT reference the tail pbuf afterwards. Use pbuf_chain() for that purpose.
See also
pbuf_chain()

Definition at line 745 of file pbuf.c.

746 {
747  struct pbuf *p;
748 
749  LWIP_ERROR("(h != NULL) && (t != NULL) (programmer violates API)",
750  ((h != NULL) && (t != NULL)), return;);
751 
752  /* proceed to last pbuf of chain */
753  for (p = h; p->next != NULL; p = p->next) {
754  /* add total length of second chain to all totals of first chain */
755  p->tot_len += t->tot_len;
756  }
757  /* { p is last pbuf of first h chain, p->next == NULL } */
758  LWIP_ASSERT("p->tot_len == p->len (of last pbuf in chain)", p->tot_len == p->len);
759  LWIP_ASSERT("p->next == NULL", p->next == NULL);
760  /* add total length of second chain to last pbuf total of first chain */
761  p->tot_len += t->tot_len;
762  /* chain last pbuf of head (p) with first of tail (t) */
763  p->next = t;
764  /* p->next now references t, but the caller will drop its reference to t,
765  * so netto there is no change to the reference count of t.
766  */
767 }
GLdouble GLdouble t
Definition: gl.h:2047
#define LWIP_ASSERT(message, assertion)
Definition: debug.h:66
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
smooth NULL
Definition: ftsmooth.c:416
Definition: pbuf.h:79
#define LWIP_ERROR(message, expression, handler)
Definition: debug.h:74
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by pbuf_chain(), and test_tcp_netif_output().

◆ pbuf_chain()

void pbuf_chain ( struct pbuf h,
struct pbuf t 
)

Chain two pbufs (or pbuf chains) together.

The caller MUST call pbuf_free(t) once it has stopped using it. Use pbuf_cat() instead if you no longer use t.

Parameters
hhead pbuf (chain)
ttail pbuf (chain)
Note
The pbufs MUST belong to the same packet.
MAY NOT be called on a packet queue.

The ->tot_len fields of all pbufs of the head chain are adjusted. The ->next field of the last pbuf of the head chain is adjusted. The ->ref field of the first pbuf of the tail chain is adjusted.

Definition at line 786 of file pbuf.c.

787 {
788  pbuf_cat(h, t);
789  /* t is now referenced by h */
790  pbuf_ref(t);
791  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_chain: %p references %p\n", (void *)h, (void *)t));
792 }
GLdouble GLdouble t
Definition: gl.h:2047
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
#define PBUF_DEBUG
Definition: opt.h:1912
#define LWIP_DEBUGF(debug, message)
Definition: debug.h:95
void pbuf_ref(struct pbuf *p)
Definition: pbuf.c:723
void pbuf_cat(struct pbuf *h, struct pbuf *t)
Definition: pbuf.c:745
#define LWIP_DBG_TRACE
Definition: debug.h:57

◆ pbuf_clen()

u8_t pbuf_clen ( struct pbuf p)

Count number of pbufs in a chain

Parameters
pfirst pbuf of chain
Returns
the number of pbufs in a chain

Definition at line 704 of file pbuf.c.

705 {
706  u8_t len;
707 
708  len = 0;
709  while (p != NULL) {
710  ++len;
711  p = p->next;
712  }
713  return len;
714 }
smooth NULL
Definition: ftsmooth.c:416
GLenum GLsizei len
Definition: glext.h:6722
unsigned char u8_t
Definition: cc.h:23
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by tcp_oos_pbuf_count().

◆ pbuf_coalesce()

struct pbuf* pbuf_coalesce ( struct pbuf p,
pbuf_layer  layer 
)

Creates a single pbuf out of a queue of pbufs.

Remarks
: Either the source pbuf 'p' is freed by this function or the original pbuf 'p' is returned, therefore the caller has to check the result!
Parameters
pthe source pbuf
layerpbuf_layer of the new pbuf
Returns
a new, single pbuf (p->next is NULL) or the old pbuf if allocation fails

Definition at line 1010 of file pbuf.c.

1011 {
1012  struct pbuf *q;
1013  err_t err;
1014  if (p->next == NULL) {
1015  return p;
1016  }
1017  q = pbuf_alloc(layer, p->tot_len, PBUF_RAM);
1018  if (q == NULL) {
1019  /* @todo: what do we do now? */
1020  return p;
1021  }
1022  err = pbuf_copy(q, p);
1023  LWIP_ASSERT("pbuf_copy failed", err == ERR_OK);
1024  pbuf_free(p);
1025  return q;
1026 }
#define LWIP_ASSERT(message, assertion)
Definition: debug.h:66
struct pbuf * pbuf_alloc(pbuf_layer layer, u16_t length, pbuf_type type)
Definition: pbuf.c:207
Definition: pbuf.h:58
smooth NULL
Definition: ftsmooth.c:416
u8_t pbuf_free(struct pbuf *p)
Definition: pbuf.c:618
s8_t err_t
Definition: err.h:47
err_t pbuf_copy(struct pbuf *p_to, struct pbuf *p_from)
Definition: pbuf.c:852
#define ERR_OK
Definition: err.h:52
GLenum GLuint GLint GLint layer
Definition: glext.h:7007
Definition: pbuf.h:79
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
#define err(...)
GLfloat GLfloat p
Definition: glext.h:8902

◆ pbuf_copy()

err_t pbuf_copy ( struct pbuf p_to,
struct pbuf p_from 
)

Create PBUF_RAM copies of pbufs.

Used to queue packets on behalf of the lwIP stack, such as ARP based queueing.

Note
You MUST explicitly use p = pbuf_take(p);
Only one packet is copied, no packet queue!
Parameters
p_topbuf destination of the copy
p_frompbuf source of the copy
Returns
ERR_OK if pbuf was copied ERR_ARG if one of the pbufs is NULL or p_to is not big enough to hold p_from

Definition at line 852 of file pbuf.c.

853 {
854  u16_t offset_to=0, offset_from=0, len;
855 
856  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_copy(%p, %p)\n",
857  (void*)p_to, (void*)p_from));
858 
859  /* is the target big enough to hold the source? */
860  LWIP_ERROR("pbuf_copy: target not big enough to hold source", ((p_to != NULL) &&
861  (p_from != NULL) && (p_to->tot_len >= p_from->tot_len)), return ERR_ARG;);
862 
863  /* iterate through pbuf chain */
864  do
865  {
866  /* copy one part of the original chain */
867  if ((p_to->len - offset_to) >= (p_from->len - offset_from)) {
868  /* complete current p_from fits into current p_to */
869  len = p_from->len - offset_from;
870  } else {
871  /* current p_from does not fit into current p_to */
872  len = p_to->len - offset_to;
873  }
874  MEMCPY((u8_t*)p_to->payload + offset_to, (u8_t*)p_from->payload + offset_from, len);
875  offset_to += len;
876  offset_from += len;
877  LWIP_ASSERT("offset_to <= p_to->len", offset_to <= p_to->len);
878  LWIP_ASSERT("offset_from <= p_from->len", offset_from <= p_from->len);
879  if (offset_from >= p_from->len) {
880  /* on to next p_from (if any) */
881  offset_from = 0;
882  p_from = p_from->next;
883  }
884  if (offset_to == p_to->len) {
885  /* on to next p_to (if any) */
886  offset_to = 0;
887  p_to = p_to->next;
888  LWIP_ERROR("p_to != NULL", (p_to != NULL) || (p_from == NULL) , return ERR_ARG;);
889  }
890 
891  if((p_from != NULL) && (p_from->len == p_from->tot_len)) {
892  /* don't copy more than one packet! */
893  LWIP_ERROR("pbuf_copy() does not allow packet queues!\n",
894  (p_from->next == NULL), return ERR_VAL;);
895  }
896  if((p_to != NULL) && (p_to->len == p_to->tot_len)) {
897  /* don't copy more than one packet! */
898  LWIP_ERROR("pbuf_copy() does not allow packet queues!\n",
899  (p_to->next == NULL), return ERR_VAL;);
900  }
901  } while (p_from);
902  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_copy: end of chain reached.\n"));
903  return ERR_OK;
904 }
u16_t tot_len
Definition: pbuf.h:93
#define ERR_ARG
Definition: err.h:70
struct pbuf * next
Definition: pbuf.h:81
u16_t len
Definition: pbuf.h:96
#define LWIP_ASSERT(message, assertion)
Definition: debug.h:66
#define ERR_VAL
Definition: err.h:58
#define PBUF_DEBUG
Definition: opt.h:1912
smooth NULL
Definition: ftsmooth.c:416
#define LWIP_DEBUGF(debug, message)
Definition: debug.h:95
#define ERR_OK
Definition: err.h:52
#define MEMCPY(DST, SRC, BYTES)
Definition: macros.h:231
GLenum GLsizei len
Definition: glext.h:6722
#define LWIP_ERROR(message, expression, handler)
Definition: debug.h:74
unsigned char u8_t
Definition: cc.h:23
#define LWIP_DBG_TRACE
Definition: debug.h:57
void * payload
Definition: pbuf.h:84
unsigned short u16_t
Definition: cc.h:24

Referenced by pbuf_coalesce(), and test_tcp_netif_output().

◆ pbuf_copy_partial()

u16_t pbuf_copy_partial ( struct pbuf buf,
void dataptr,
u16_t  len,
u16_t  offset 
)

Copy (part of) the contents of a packet buffer to an application supplied buffer.

Parameters
bufthe pbuf from which to copy data
dataptrthe application supplied buffer
lenlength of data to copy (dataptr must be big enough). No more than buf->tot_len will be copied, irrespective of len
offsetoffset into the packet buffer from where to begin copying len bytes
Returns
the number of bytes copied, or 0 on failure

Definition at line 918 of file pbuf.c.

919 {
920  struct pbuf *p;
921  u16_t left;
922  u16_t buf_copy_len;
923  u16_t copied_total = 0;
924 
925  LWIP_ERROR("pbuf_copy_partial: invalid buf", (buf != NULL), return 0;);
926  LWIP_ERROR("pbuf_copy_partial: invalid dataptr", (dataptr != NULL), return 0;);
927 
928  left = 0;
929 
930  if((buf == NULL) || (dataptr == NULL)) {
931  return 0;
932  }
933 
934  /* Note some systems use byte copy if dataptr or one of the pbuf payload pointers are unaligned. */
935  for(p = buf; len != 0 && p != NULL; p = p->next) {
936  if ((offset != 0) && (offset >= p->len)) {
937  /* don't copy from this buffer -> on to the next */
938  offset -= p->len;
939  } else {
940  /* copy from this buffer. maybe only partially. */
941  buf_copy_len = p->len - offset;
942  if (buf_copy_len > len)
943  buf_copy_len = len;
944  /* copy the necessary parts of the buffer */
945  MEMCPY(&((char*)dataptr)[left], &((char*)p->payload)[offset], buf_copy_len);
946  copied_total += buf_copy_len;
947  left += buf_copy_len;
948  len -= buf_copy_len;
949  offset = 0;
950  }
951  }
952  return copied_total;
953 }
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLintptr offset
Definition: glext.h:5920
smooth NULL
Definition: ftsmooth.c:416
Definition: pbuf.h:79
#define MEMCPY(DST, SRC, BYTES)
Definition: macros.h:231
GLint left
Definition: glext.h:7726
GLenum GLsizei len
Definition: glext.h:6722
#define LWIP_ERROR(message, expression, handler)
Definition: debug.h:74
int const JOCTET * dataptr
Definition: jpeglib.h:1027
unsigned short u16_t
Definition: cc.h:24
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by LibTCPGetDataFromConnectionQueue(), and test_tcp_tx_full_window_lost().

◆ pbuf_dechain()

struct pbuf* pbuf_dechain ( struct pbuf p)

Dechains the first pbuf from its succeeding pbufs in the chain.

Makes p->tot_len field equal to p->len.

Parameters
ppbuf to dechain
Returns
remainder of the pbuf chain, or NULL if it was de-allocated.
Note
May not be called on a packet queue.

Definition at line 803 of file pbuf.c.

804 {
805  struct pbuf *q;
806  u8_t tail_gone = 1;
807  /* tail */
808  q = p->next;
809  /* pbuf has successor in chain? */
810  if (q != NULL) {
811  /* assert tot_len invariant: (p->tot_len == p->len + (p->next? p->next->tot_len: 0) */
812  LWIP_ASSERT("p->tot_len == p->len + q->tot_len", q->tot_len == p->tot_len - p->len);
813  /* enforce invariant if assertion is disabled */
814  q->tot_len = p->tot_len - p->len;
815  /* decouple pbuf from remainder */
816  p->next = NULL;
817  /* total length of pbuf p is its own length only */
818  p->tot_len = p->len;
819  /* q is no longer referenced by p, free it */
820  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_dechain: unreferencing %p\n", (void *)q));
821  tail_gone = pbuf_free(q);
822  if (tail_gone > 0) {
824  ("pbuf_dechain: deallocated %p (as it is no longer referenced)\n", (void *)q));
825  }
826  /* return remaining tail or NULL if deallocated */
827  }
828  /* assert tot_len invariant: (p->tot_len == p->len + (p->next? p->next->tot_len: 0) */
829  LWIP_ASSERT("p->tot_len == p->len", p->tot_len == p->len);
830  return ((tail_gone > 0) ? NULL : q);
831 }
#define LWIP_ASSERT(message, assertion)
Definition: debug.h:66
#define PBUF_DEBUG
Definition: opt.h:1912
smooth NULL
Definition: ftsmooth.c:416
u8_t pbuf_free(struct pbuf *p)
Definition: pbuf.c:618
#define LWIP_DEBUGF(debug, message)
Definition: debug.h:95
Definition: pbuf.h:79
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
unsigned char u8_t
Definition: cc.h:23
#define LWIP_DBG_TRACE
Definition: debug.h:57
GLfloat GLfloat p
Definition: glext.h:8902

◆ pbuf_free()

u8_t pbuf_free ( struct pbuf p)

Dereference a pbuf chain or queue and deallocate any no-longer-used pbufs at the head of this chain or queue.

Decrements the pbuf reference count. If it reaches zero, the pbuf is deallocated.

For a pbuf chain, this is repeated for each pbuf in the chain, up to the first pbuf which has a non-zero reference count after decrementing. So, when all reference counts are one, the whole chain is free'd.

Parameters
pThe pbuf (chain) to be dereferenced.
Returns
the number of pbufs that were de-allocated from the head of the chain.
Note
MUST NOT be called on a packet queue (Not verified to work yet).
the reference counter of a pbuf equals the number of pointers that refer to the pbuf (or into the pbuf).

Definition at line 618 of file pbuf.c.

619 {
620  u16_t type;
621  struct pbuf *q;
622  u8_t count;
623 
624  if (p == NULL) {
625  LWIP_ASSERT("p != NULL", p != NULL);
626  /* if assertions are disabled, proceed with debug output */
628  ("pbuf_free(p == NULL) was called.\n"));
629  return 0;
630  }
631  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_free(%p)\n", (void *)p));
632 
633  PERF_START;
634 
635  LWIP_ASSERT("pbuf_free: sane type",
636  p->type == PBUF_RAM || p->type == PBUF_ROM ||
637  p->type == PBUF_REF || p->type == PBUF_POOL);
638 
639  count = 0;
640  /* de-allocate all consecutive pbufs from the head of the chain that
641  * obtain a zero reference count after decrementing*/
642  while (p != NULL) {
643  u16_t ref;
644  SYS_ARCH_DECL_PROTECT(old_level);
645  /* Since decrementing ref cannot be guaranteed to be a single machine operation
646  * we must protect it. We put the new ref into a local variable to prevent
647  * further protection. */
648  SYS_ARCH_PROTECT(old_level);
649  /* all pbufs in a chain are referenced at least once */
650  LWIP_ASSERT("pbuf_free: p->ref > 0", p->ref > 0);
651  /* decrease reference count (number of pointers to pbuf) */
652  ref = --(p->ref);
653  SYS_ARCH_UNPROTECT(old_level);
654  /* this pbuf is no longer referenced to? */
655  if (ref == 0) {
656  /* remember next pbuf in chain for next iteration */
657  q = p->next;
658  LWIP_DEBUGF( PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_free: deallocating %p\n", (void *)p));
659  type = p->type;
660 #if LWIP_SUPPORT_CUSTOM_PBUF
661  /* is this a custom pbuf? */
662  if ((p->flags & PBUF_FLAG_IS_CUSTOM) != 0) {
663  struct pbuf_custom *pc = (struct pbuf_custom*)p;
664  LWIP_ASSERT("pc->custom_free_function != NULL", pc->custom_free_function != NULL);
665  pc->custom_free_function(p);
666  } else
667 #endif /* LWIP_SUPPORT_CUSTOM_PBUF */
668  {
669  /* is this a pbuf from the pool? */
670  if (type == PBUF_POOL) {
671  memp_free(MEMP_PBUF_POOL, p);
672  /* is this a ROM or RAM referencing pbuf? */
673  } else if (type == PBUF_ROM || type == PBUF_REF) {
674  memp_free(MEMP_PBUF, p);
675  /* type == PBUF_RAM */
676  } else {
677  mem_free(p);
678  }
679  }
680  count++;
681  /* proceed to next pbuf */
682  p = q;
683  /* p->ref > 0, this pbuf is still referenced to */
684  /* (and so the remaining pbufs in chain as well) */
685  } else {
686  LWIP_DEBUGF( PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_free: %p has ref %"U16_F", ending here.\n", (void *)p, ref));
687  /* stop walking through the chain */
688  p = NULL;
689  }
690  }
691  PERF_STOP("pbuf_free");
692  /* return number of de-allocated pbufs */
693  return count;
694 }
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
Definition: send.c:47
#define LWIP_ASSERT(message, assertion)
Definition: debug.h:66
void memp_free(memp_t type, void *mem)
Definition: memp.c:435
Definition: pbuf.h:58
#define PERF_START
Definition: perf.h:3
#define PBUF_DEBUG
Definition: opt.h:1912
GLenum GLint ref
Definition: glext.h:6028
smooth NULL
Definition: ftsmooth.c:416
#define LWIP_DEBUGF(debug, message)
Definition: debug.h:95
#define U16_F
Definition: cc.h:36
Definition: pbuf.h:79
Definition: pbuf.h:61
Definition: pbuf.h:59
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
#define SYS_ARCH_PROTECT(lev)
Definition: cc.h:55
#define PBUF_FLAG_IS_CUSTOM
Definition: pbuf.h:69
#define LWIP_DBG_LEVEL_SERIOUS
Definition: debug.h:47
Definition: pbuf.h:60
unsigned char u8_t
Definition: cc.h:23
#define LWIP_DBG_TRACE
Definition: debug.h:57
#define SYS_ARCH_DECL_PROTECT(lev)
Definition: cc.h:54
#define SYS_ARCH_UNPROTECT(lev)
Definition: cc.h:56
#define mem_free(ptr, bsize)
Definition: types.h:124
unsigned short u16_t
Definition: cc.h:24
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by InternalRecvEventHandler(), ip_forward(), ip_input(), LibTCPEmptyQueue(), pbuf_alloc(), pbuf_coalesce(), pbuf_dechain(), pbuf_free_int(), pbuf_realloc(), test_tcp_counters_recv(), and test_tcp_tx_full_window_lost().

◆ pbuf_get_at()

u8_t pbuf_get_at ( struct pbuf p,
u16_t  offset 
)

Get one byte from the specified position in a pbuf WARNING: returns zero for offset >= p->tot_len

Parameters
ppbuf to parse
offsetoffset into p of the byte to return
Returns
byte at an offset into p OR ZERO IF 'offset' >= p->tot_len

Definition at line 1077 of file pbuf.c.

1078 {
1079  u16_t copy_from = offset;
1080  struct pbuf* q = p;
1081 
1082  /* get the correct pbuf */
1083  while ((q != NULL) && (q->len <= copy_from)) {
1084  copy_from -= q->len;
1085  q = q->next;
1086  }
1087  /* return requested data if pbuf is OK */
1088  if ((q != NULL) && (q->len > copy_from)) {
1089  return ((u8_t*)q->payload)[copy_from];
1090  }
1091  return 0;
1092 }
GLintptr offset
Definition: glext.h:5920
smooth NULL
Definition: ftsmooth.c:416
Definition: pbuf.h:79
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
unsigned char u8_t
Definition: cc.h:23
unsigned short u16_t
Definition: cc.h:24
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by pbuf_memcmp().

◆ pbuf_header()

u8_t pbuf_header ( struct pbuf p,
s16_t  header_size_increment 
)

Adjusts the payload pointer to hide or reveal headers in the payload.

Adjusts the ->payload pointer so that space for a header (dis)appears in the pbuf payload.

The ->payload, ->tot_len and ->len fields are adjusted.

Parameters
ppbuf to change the header size.
header_size_incrementNumber of bytes to increment header size which increases the size of the pbuf. New space is on the front. (Using a negative value decreases the header size.) If hdr_size_inc is 0, this function does nothing and returns succesful.

PBUF_ROM and PBUF_REF type buffers cannot have their sizes increased, so the call will fail. A check is made that the increase in header size does not move the payload pointer in front of the start of the buffer.

Returns
non-zero on failure, zero on success.

Definition at line 511 of file pbuf.c.

512 {
513  u16_t type;
514  void *payload;
515  u16_t increment_magnitude;
516 
517  LWIP_ASSERT("p != NULL", p != NULL);
518  if ((header_size_increment == 0) || (p == NULL)) {
519  return 0;
520  }
521 
522  if (header_size_increment < 0){
523  increment_magnitude = -header_size_increment;
524  /* Check that we aren't going to move off the end of the pbuf */
525  LWIP_ERROR("increment_magnitude <= p->len", (increment_magnitude <= p->len), return 1;);
526  } else {
527  increment_magnitude = header_size_increment;
528 #if 0
529  /* Can't assert these as some callers speculatively call
530  pbuf_header() to see if it's OK. Will return 1 below instead. */
531  /* Check that we've got the correct type of pbuf to work with */
532  LWIP_ASSERT("p->type == PBUF_RAM || p->type == PBUF_POOL",
533  p->type == PBUF_RAM || p->type == PBUF_POOL);
534  /* Check that we aren't going to move off the beginning of the pbuf */
535  LWIP_ASSERT("p->payload - increment_magnitude >= p + SIZEOF_STRUCT_PBUF",
536  (u8_t *)p->payload - increment_magnitude >= (u8_t *)p + SIZEOF_STRUCT_PBUF);
537 #endif
538  }
539 
540  type = p->type;
541  /* remember current payload pointer */
542  payload = p->payload;
543 
544  /* pbuf types containing payloads? */
545  if (type == PBUF_RAM || type == PBUF_POOL) {
546  /* set new payload pointer */
547  p->payload = (u8_t *)p->payload - header_size_increment;
548  /* boundary check fails? */
549  if ((u8_t *)p->payload < (u8_t *)p + SIZEOF_STRUCT_PBUF) {
551  ("pbuf_header: failed as %p < %p (not enough space for new header size)\n",
552  (void *)p->payload, (void *)(p + 1)));
553  /* restore old payload pointer */
554  p->payload = payload;
555  /* bail out unsuccesfully */
556  return 1;
557  }
558  /* pbuf types refering to external payloads? */
559  } else if (type == PBUF_REF || type == PBUF_ROM) {
560  /* hide a header in the payload? */
561  if ((header_size_increment < 0) && (increment_magnitude <= p->len)) {
562  /* increase payload pointer */
563  p->payload = (u8_t *)p->payload - header_size_increment;
564  } else {
565  /* cannot expand payload to front (yet!)
566  * bail out unsuccesfully */
567  return 1;
568  }
569  } else {
570  /* Unknown type */
571  LWIP_ASSERT("bad pbuf type", 0);
572  return 1;
573  }
574  /* modify pbuf length fields */
575  p->len += header_size_increment;
576  p->tot_len += header_size_increment;
577 
578  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_header: old %p new %p (%"S16_F")\n",
579  (void *)payload, (void *)p->payload, header_size_increment));
580 
581  return 0;
582 }
#define S16_F
Definition: cc.h:37
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define LWIP_ASSERT(message, assertion)
Definition: debug.h:66
Definition: pbuf.h:58
#define PBUF_DEBUG
Definition: opt.h:1912
smooth NULL
Definition: ftsmooth.c:416
#define LWIP_DEBUGF(debug, message)
Definition: debug.h:95
#define SIZEOF_STRUCT_PBUF
Definition: pbuf.c:82
if(!(yy_init))
Definition: macro.lex.yy.c:714
Definition: pbuf.h:61
Definition: pbuf.h:59
GLenum GLsizei len
Definition: glext.h:6722
#define LWIP_ERROR(message, expression, handler)
Definition: debug.h:74
#define LWIP_DBG_LEVEL_SERIOUS
Definition: debug.h:47
Definition: pbuf.h:60
unsigned char u8_t
Definition: cc.h:23
#define LWIP_DBG_TRACE
Definition: debug.h:57
void * payload
Definition: pbuf.h:84
unsigned short u16_t
Definition: cc.h:24
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by ip_input(), ip_output_if(), tcp_create_segment_wnd(), and test_tcp_input().

◆ pbuf_memcmp()

u16_t pbuf_memcmp ( struct pbuf p,
u16_t  offset,
const void s2,
u16_t  n 
)

Compare pbuf contents at specified offset with memory s2, both of length n

Parameters
ppbuf to compare
offsetoffset into p at wich to start comparing
s2buffer to compare
nlength of buffer to compare
Returns
zero if equal, nonzero otherwise (0xffff if p is too short, diffoffset+1 otherwise)

Definition at line 1104 of file pbuf.c.

1105 {
1106  u16_t start = offset;
1107  struct pbuf* q = p;
1108 
1109  /* get the correct pbuf */
1110  while ((q != NULL) && (q->len <= start)) {
1111  start -= q->len;
1112  q = q->next;
1113  }
1114  /* return requested data if pbuf is OK */
1115  if ((q != NULL) && (q->len > start)) {
1116  u16_t i;
1117  for(i = 0; i < n; i++) {
1118  u8_t a = pbuf_get_at(q, start + i);
1119  u8_t b = ((u8_t*)s2)[i];
1120  if (a != b) {
1121  return i+1;
1122  }
1123  }
1124  return 0;
1125  }
1126  return 0xffff;
1127 }
struct S2 s2
GLintptr offset
Definition: glext.h:5920
GLdouble n
Definition: glext.h:7729
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
smooth NULL
Definition: ftsmooth.c:416
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
Definition: pbuf.h:79
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
GLuint start
Definition: gl.h:1545
unsigned char u8_t
Definition: cc.h:23
u8_t pbuf_get_at(struct pbuf *p, u16_t offset)
Definition: pbuf.c:1077
unsigned short u16_t
Definition: cc.h:24
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by pbuf_memfind().

◆ pbuf_memfind()

u16_t pbuf_memfind ( struct pbuf p,
const void mem,
u16_t  mem_len,
u16_t  start_offset 
)

Find occurrence of mem (with length mem_len) in pbuf p, starting at offset start_offset.

Parameters
ppbuf to search, maximum length is 0xFFFE since 0xFFFF is used as return value 'not found'
memsearch for the contents of this buffer
mem_lenlength of 'mem'
start_offsetoffset into p at which to start searching
Returns
0xFFFF if substr was not found in p or the index where it was found

Definition at line 1140 of file pbuf.c.

1141 {
1142  u16_t i;
1143  u16_t max = p->tot_len - mem_len;
1144  if (p->tot_len >= mem_len + start_offset) {
1145  for(i = start_offset; i <= max; ) {
1146  u16_t plus = pbuf_memcmp(p, i, mem, mem_len);
1147  if (plus == 0) {
1148  return i;
1149  } else {
1150  i += plus;
1151  }
1152  }
1153  }
1154  return 0xFFFF;
1155 }
#define max(a, b)
Definition: svc.c:63
u16_t pbuf_memcmp(struct pbuf *p, u16_t offset, const void *s2, u16_t n)
Definition: pbuf.c:1104
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
Definition: mem.c:156
unsigned short u16_t
Definition: cc.h:24
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by pbuf_strstr().

◆ pbuf_realloc()

void pbuf_realloc ( struct pbuf p,
u16_t  new_len 
)

Shrink a pbuf chain to a desired length.

Parameters
ppbuf to shrink.
new_lendesired new length of pbuf chain

Depending on the desired length, the first few pbufs in a chain might be skipped and left unchanged. The new last pbuf in the chain will be resized, and any remaining pbufs will be freed.

Note
If the pbuf is ROM/REF, only the ->tot_len and ->len fields are adjusted.
May not be called on a packet queue.
Despite its name, pbuf_realloc cannot grow the size of a pbuf (chain).

Definition at line 430 of file pbuf.c.

431 {
432  struct pbuf *q;
433  u16_t rem_len; /* remaining length */
434  s32_t grow;
435 
436  LWIP_ASSERT("pbuf_realloc: p != NULL", p != NULL);
437  LWIP_ASSERT("pbuf_realloc: sane p->type", p->type == PBUF_POOL ||
438  p->type == PBUF_ROM ||
439  p->type == PBUF_RAM ||
440  p->type == PBUF_REF);
441 
442  /* desired length larger than current length? */
443  if (new_len >= p->tot_len) {
444  /* enlarging not yet supported */
445  return;
446  }
447 
448  /* the pbuf chain grows by (new_len - p->tot_len) bytes
449  * (which may be negative in case of shrinking) */
450  grow = new_len - p->tot_len;
451 
452  /* first, step over any pbufs that should remain in the chain */
453  rem_len = new_len;
454  q = p;
455  /* should this pbuf be kept? */
456  while (rem_len > q->len) {
457  /* decrease remaining length by pbuf length */
458  rem_len -= q->len;
459  /* decrease total length indicator */
460  LWIP_ASSERT("grow < max_u16_t", grow < 0xffff);
461  q->tot_len += (u16_t)grow;
462  /* proceed to next pbuf in chain */
463  q = q->next;
464  LWIP_ASSERT("pbuf_realloc: q != NULL", q != NULL);
465  }
466  /* we have now reached the new last pbuf (in q) */
467  /* rem_len == desired length for pbuf q */
468 
469  /* shrink allocated memory for PBUF_RAM */
470  /* (other types merely adjust their length fields */
471  if ((q->type == PBUF_RAM) && (rem_len != q->len)) {
472  /* reallocate and adjust the length of the pbuf that will be split */
473  q = (struct pbuf *)mem_trim(q, (u16_t)((u8_t *)q->payload - (u8_t *)q) + rem_len);
474  LWIP_ASSERT("mem_trim returned q == NULL", q != NULL);
475  }
476  /* adjust length fields for new last pbuf */
477  q->len = rem_len;
478  q->tot_len = q->len;
479 
480  /* any remaining pbufs in chain? */
481  if (q->next != NULL) {
482  /* free remaining pbufs in chain */
483  pbuf_free(q->next);
484  }
485  /* q is last packet in chain */
486  q->next = NULL;
487 
488 }
#define LWIP_ASSERT(message, assertion)
Definition: debug.h:66
Definition: pbuf.h:58
smooth NULL
Definition: ftsmooth.c:416
u8_t pbuf_free(struct pbuf *p)
Definition: pbuf.c:618
Definition: pbuf.h:79
Definition: pbuf.h:61
Definition: pbuf.h:59
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
Definition: pbuf.h:60
unsigned char u8_t
Definition: cc.h:23
signed long s32_t
Definition: cc.h:30
#define mem_trim(_m_, _s_)
Definition: cc.h:20
unsigned short u16_t
Definition: cc.h:24
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by ip_input().

◆ pbuf_ref()

void pbuf_ref ( struct pbuf p)

Increment the reference count of the pbuf.

Parameters
ppbuf to increase reference counter of

Definition at line 723 of file pbuf.c.

724 {
725  SYS_ARCH_DECL_PROTECT(old_level);
726  /* pbuf given? */
727  if (p != NULL) {
728  SYS_ARCH_PROTECT(old_level);
729  ++(p->ref);
730  SYS_ARCH_UNPROTECT(old_level);
731  }
732 }
smooth NULL
Definition: ftsmooth.c:416
#define SYS_ARCH_PROTECT(lev)
Definition: cc.h:55
#define SYS_ARCH_DECL_PROTECT(lev)
Definition: cc.h:54
#define SYS_ARCH_UNPROTECT(lev)
Definition: cc.h:56
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by pbuf_chain().

◆ pbuf_strstr()

u16_t pbuf_strstr ( struct pbuf p,
const char substr 
)

Find occurrence of substr with length substr_len in pbuf p, start at offset start_offset WARNING: in contrast to strstr(), this one does not stop at the first \0 in the pbuf/source string!

Parameters
ppbuf to search, maximum length is 0xFFFE since 0xFFFF is used as return value 'not found'
substrstring to search for in p, maximum length is 0xFFFE
Returns
0xFFFF if substr was not found in p or the index where it was found

Definition at line 1168 of file pbuf.c.

1169 {
1170  size_t substr_len;
1171  if ((substr == NULL) || (substr[0] == 0) || (p->tot_len == 0xFFFF)) {
1172  return 0xFFFF;
1173  }
1174  substr_len = strlen(substr);
1175  if (substr_len >= 0xFFFF) {
1176  return 0xFFFF;
1177  }
1178  return pbuf_memfind(p, substr, (u16_t)substr_len, 0);
1179 }
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
smooth NULL
Definition: ftsmooth.c:416
u16_t pbuf_memfind(struct pbuf *p, const void *mem, u16_t mem_len, u16_t start_offset)
Definition: pbuf.c:1140
unsigned short u16_t
Definition: cc.h:24
static substr_t substr(const WCHAR *str, size_t len)
Definition: internet.h:204
GLfloat GLfloat p
Definition: glext.h:8902

◆ pbuf_take()

err_t pbuf_take ( struct pbuf buf,
const void dataptr,
u16_t  len 
)

Copy application supplied data into a pbuf. This function can only be used to copy the equivalent of buf->tot_len data.

Parameters
bufpbuf to fill with data
dataptrapplication supplied data buffer
lenlength of the application supplied data buffer
Returns
ERR_OK if successful, ERR_MEM if the pbuf is not big enough

Definition at line 966 of file pbuf.c.

967 {
968  struct pbuf *p;
969  u16_t buf_copy_len;
970  u16_t total_copy_len = len;
971  u16_t copied_total = 0;
972 
973  LWIP_ERROR("pbuf_take: invalid buf", (buf != NULL), return 0;);
974  LWIP_ERROR("pbuf_take: invalid dataptr", (dataptr != NULL), return 0;);
975 
976  if ((buf == NULL) || (dataptr == NULL) || (buf->tot_len < len)) {
977  return ERR_ARG;
978  }
979 
980  /* Note some systems use byte copy if dataptr or one of the pbuf payload pointers are unaligned. */
981  for(p = buf; total_copy_len != 0; p = p->next) {
982  LWIP_ASSERT("pbuf_take: invalid pbuf", p != NULL);
983  buf_copy_len = total_copy_len;
984  if (buf_copy_len > p->len) {
985  /* this pbuf cannot hold all remaining data */
986  buf_copy_len = p->len;
987  }
988  /* copy the necessary parts of the buffer */
989  MEMCPY(p->payload, &((char*)dataptr)[copied_total], buf_copy_len);
990  total_copy_len -= buf_copy_len;
991  copied_total += buf_copy_len;
992  }
993  LWIP_ASSERT("did not copy all data", total_copy_len == 0 && copied_total == len);
994  return ERR_OK;
995 }
#define ERR_ARG
Definition: err.h:70
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define LWIP_ASSERT(message, assertion)
Definition: debug.h:66
smooth NULL
Definition: ftsmooth.c:416
#define ERR_OK
Definition: err.h:52
Definition: pbuf.h:79
#define MEMCPY(DST, SRC, BYTES)
Definition: macros.h:231
GLenum GLsizei len
Definition: glext.h:6722
#define LWIP_ERROR(message, expression, handler)
Definition: debug.h:74
int const JOCTET * dataptr
Definition: jpeglib.h:1027
unsigned short u16_t
Definition: cc.h:24
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by tcp_create_segment_wnd().