1 /**
2 * @file
3 * Network buffer management
4 *
5 * @defgroup netbuf Network buffers
6 * @ingroup netconn
7 * Network buffer descriptor for @ref netconn. Based on @ref pbuf internally
8 * to avoid copying data around.\n
9 * Buffers must not be shared accross multiple threads, all functions except
10 * netbuf_new() and netbuf_delete() are not thread-safe.
11 */
12
13 /*
14 * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
15 * All rights reserved.
16 *
17 * Redistribution and use in source and binary forms, with or without modification,
18 * are permitted provided that the following conditions are met:
19 *
20 * 1. Redistributions of source code must retain the above copyright notice,
21 * this list of conditions and the following disclaimer.
22 * 2. Redistributions in binary form must reproduce the above copyright notice,
23 * this list of conditions and the following disclaimer in the documentation
24 * and/or other materials provided with the distribution.
25 * 3. The name of the author may not be used to endorse or promote products
26 * derived from this software without specific prior written permission.
27 *
28 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
29 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
30 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
31 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
32 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
33 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
36 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
37 * OF SUCH DAMAGE.
38 *
39 * This file is part of the lwIP TCP/IP stack.
40 *
41 * Author: Adam Dunkels <adam@sics.se>
42 *
43 */
44
45 #include "lwip/opt.h"
46
47 #if LWIP_NETCONN /* don't build if not configured for use in lwipopts.h */
48
49 #include "lwip/netbuf.h"
50 #include "lwip/memp.h"
51
52 #include <string.h>
53
54 /**
55 * @ingroup netbuf
56 * Create (allocate) and initialize a new netbuf.
57 * The netbuf doesn't yet contain a packet buffer!
58 *
59 * @return a pointer to a new netbuf
60 * NULL on lack of memory
61 */
62 struct
netbuf_new(void)63 netbuf *netbuf_new(void)
64 {
65 struct netbuf *buf;
66
67 buf = (struct netbuf *)memp_malloc(MEMP_NETBUF);
68 if (buf != NULL) {
69 memset(buf, 0, sizeof(struct netbuf));
70 }
71 return buf;
72 }
73
74 /**
75 * @ingroup netbuf
76 * Deallocate a netbuf allocated by netbuf_new().
77 *
78 * @param buf pointer to a netbuf allocated by netbuf_new()
79 */
80 void
netbuf_delete(struct netbuf * buf)81 netbuf_delete(struct netbuf *buf)
82 {
83 if (buf != NULL) {
84 if (buf->p != NULL) {
85 pbuf_free(buf->p);
86 buf->p = buf->ptr = NULL;
87 }
88 memp_free(MEMP_NETBUF, buf);
89 }
90 }
91
92 /**
93 * @ingroup netbuf
94 * Allocate memory for a packet buffer for a given netbuf.
95 *
96 * @param buf the netbuf for which to allocate a packet buffer
97 * @param size the size of the packet buffer to allocate
98 * @return pointer to the allocated memory
99 * NULL if no memory could be allocated
100 */
101 void *
netbuf_alloc(struct netbuf * buf,u16_t size)102 netbuf_alloc(struct netbuf *buf, u16_t size)
103 {
104 LWIP_ERROR("netbuf_alloc: invalid buf", (buf != NULL), return NULL;);
105
106 /* Deallocate any previously allocated memory. */
107 if (buf->p != NULL) {
108 pbuf_free(buf->p);
109 }
110 buf->p = pbuf_alloc(PBUF_TRANSPORT, size, PBUF_RAM);
111 if (buf->p == NULL) {
112 return NULL;
113 }
114 LWIP_ASSERT("check that first pbuf can hold size",
115 (buf->p->len >= size));
116 buf->ptr = buf->p;
117 return buf->p->payload;
118 }
119
120 /**
121 * @ingroup netbuf
122 * Free the packet buffer included in a netbuf
123 *
124 * @param buf pointer to the netbuf which contains the packet buffer to free
125 */
126 void
netbuf_free(struct netbuf * buf)127 netbuf_free(struct netbuf *buf)
128 {
129 LWIP_ERROR("netbuf_free: invalid buf", (buf != NULL), return;);
130 if (buf->p != NULL) {
131 pbuf_free(buf->p);
132 }
133 buf->p = buf->ptr = NULL;
134 #if LWIP_CHECKSUM_ON_COPY
135 buf->flags = 0;
136 buf->toport_chksum = 0;
137 #endif /* LWIP_CHECKSUM_ON_COPY */
138 }
139
140 /**
141 * @ingroup netbuf
142 * Let a netbuf reference existing (non-volatile) data.
143 *
144 * @param buf netbuf which should reference the data
145 * @param dataptr pointer to the data to reference
146 * @param size size of the data
147 * @return ERR_OK if data is referenced
148 * ERR_MEM if data couldn't be referenced due to lack of memory
149 */
150 err_t
netbuf_ref(struct netbuf * buf,const void * dataptr,u16_t size)151 netbuf_ref(struct netbuf *buf, const void *dataptr, u16_t size)
152 {
153 LWIP_ERROR("netbuf_ref: invalid buf", (buf != NULL), return ERR_ARG;);
154 if (buf->p != NULL) {
155 pbuf_free(buf->p);
156 }
157 buf->p = pbuf_alloc(PBUF_TRANSPORT, 0, PBUF_REF);
158 if (buf->p == NULL) {
159 buf->ptr = NULL;
160 return ERR_MEM;
161 }
162 ((struct pbuf_rom *)buf->p)->payload = dataptr;
163 buf->p->len = buf->p->tot_len = size;
164 buf->ptr = buf->p;
165 return ERR_OK;
166 }
167
168 /**
169 * @ingroup netbuf
170 * Chain one netbuf to another (@see pbuf_chain)
171 *
172 * @param head the first netbuf
173 * @param tail netbuf to chain after head, freed by this function, may not be reference after returning
174 */
175 void
netbuf_chain(struct netbuf * head,struct netbuf * tail)176 netbuf_chain(struct netbuf *head, struct netbuf *tail)
177 {
178 LWIP_ERROR("netbuf_chain: invalid head", (head != NULL), return;);
179 LWIP_ERROR("netbuf_chain: invalid tail", (tail != NULL), return;);
180 pbuf_cat(head->p, tail->p);
181 head->ptr = head->p;
182 memp_free(MEMP_NETBUF, tail);
183 }
184
185 /**
186 * @ingroup netbuf
187 * Get the data pointer and length of the data inside a netbuf.
188 *
189 * @param buf netbuf to get the data from
190 * @param dataptr pointer to a void pointer where to store the data pointer
191 * @param len pointer to an u16_t where the length of the data is stored
192 * @return ERR_OK if the information was retrieved,
193 * ERR_BUF on error.
194 */
195 err_t
netbuf_data(struct netbuf * buf,void ** dataptr,u16_t * len)196 netbuf_data(struct netbuf *buf, void **dataptr, u16_t *len)
197 {
198 LWIP_ERROR("netbuf_data: invalid buf", (buf != NULL), return ERR_ARG;);
199 LWIP_ERROR("netbuf_data: invalid dataptr", (dataptr != NULL), return ERR_ARG;);
200 LWIP_ERROR("netbuf_data: invalid len", (len != NULL), return ERR_ARG;);
201
202 if (buf->ptr == NULL) {
203 return ERR_BUF;
204 }
205 *dataptr = buf->ptr->payload;
206 *len = buf->ptr->len;
207 return ERR_OK;
208 }
209
210 /**
211 * @ingroup netbuf
212 * Move the current data pointer of a packet buffer contained in a netbuf
213 * to the next part.
214 * The packet buffer itself is not modified.
215 *
216 * @param buf the netbuf to modify
217 * @return -1 if there is no next part
218 * 1 if moved to the next part but now there is no next part
219 * 0 if moved to the next part and there are still more parts
220 */
221 s8_t
netbuf_next(struct netbuf * buf)222 netbuf_next(struct netbuf *buf)
223 {
224 LWIP_ERROR("netbuf_next: invalid buf", (buf != NULL), return -1;);
225 if (buf->ptr->next == NULL) {
226 return -1;
227 }
228 buf->ptr = buf->ptr->next;
229 if (buf->ptr->next == NULL) {
230 return 1;
231 }
232 return 0;
233 }
234
235 /**
236 * @ingroup netbuf
237 * Move the current data pointer of a packet buffer contained in a netbuf
238 * to the beginning of the packet.
239 * The packet buffer itself is not modified.
240 *
241 * @param buf the netbuf to modify
242 */
243 void
netbuf_first(struct netbuf * buf)244 netbuf_first(struct netbuf *buf)
245 {
246 LWIP_ERROR("netbuf_first: invalid buf", (buf != NULL), return;);
247 buf->ptr = buf->p;
248 }
249
250 #endif /* LWIP_NETCONN */
251