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 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 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 * 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 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 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 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 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 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 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