void* ringbuf_memcpy_from(void* dst, ringbuf_t src, size_t count) { size_t bytes_used = ringbuf_bytes_used(src); if (count > bytes_used) { return NULL; } const uint8_t* u8dst = dst; const uint8_t* bufend = ringbuf_end(src); size_t nwritten = 0; while (nwritten != count) { lwIP_ASSERT(bufend > src->tail); size_t n = LWIP_MIN(bufend - src->tail, count - nwritten); memcpy((uint8_t*)u8dst + nwritten, src->tail, n); src->tail += n; nwritten += n; if (src->tail == bufend) { src->tail = src->buf; } } lwIP_ASSERT(count + ringbuf_bytes_used(src) == bytes_used); return src->tail; }
size_t ringbuf_memset(ringbuf_t dst, int c, size_t len) { const uint8_t* bufend = ringbuf_end(dst); size_t nwritten = 0; size_t count = LWIP_MIN(len, ringbuf_buffer_size(dst)); int overflow = count > ringbuf_bytes_free(dst); while (nwritten != count) { lwIP_ASSERT(bufend > dst->head); size_t n = LWIP_MIN(bufend - dst->head, count - nwritten); os_memset(dst->head, c, n); dst->head += n; nwritten += n; if (dst->head == bufend) { dst->head = dst->buf; } } if (overflow) { dst->tail = ringbuf_nextp(dst, dst->head); lwIP_ASSERT(ringbuf_is_full(dst)); } return nwritten; }
void* ringbuf_memcpy_into(ringbuf_t dst, const void* src, size_t count) { const uint8_t* u8src = src; const uint8_t* bufend = ringbuf_end(dst); int overflow = count > ringbuf_bytes_free(dst); size_t nread = 0; while (nread != count) { lwIP_ASSERT(bufend > dst->head); size_t n = LWIP_MIN(bufend - dst->head, count - nread); memcpy(dst->head, u8src + nread, n); dst->head += n; nread += n; if (dst->head == bufend) { dst->head = dst->buf; } } if (overflow) { dst->tail = ringbuf_nextp(dst, dst->head); lwIP_ASSERT(ringbuf_is_full(dst)); } return dst->head; }
static void mbedtls_msg_free(pmbedtls_msg *msg) { lwIP_ASSERT(msg); lwIP_ASSERT(*msg); /*to prevent memory leaks, ensure that each allocated is deleted at every handshake*/ if ((*msg)->psession){ mbedtls_session_free(&((*msg)->psession)); } #if defined(ESP8266_PLATFORM) if ((*msg)->quiet && (*msg)->ssl.out_buf) { mbedtls_zeroize((*msg)->ssl.out_buf, MBEDTLS_SSL_OUTBUFFER_LEN); os_free((*msg)->ssl.out_buf); (*msg)->ssl.out_buf = NULL; } #endif mbedtls_entropy_free(&(*msg)->entropy); mbedtls_ssl_free(&(*msg)->ssl); mbedtls_ssl_config_free(&(*msg)->conf); mbedtls_ctr_drbg_free(&(*msg)->ctr_drbg); os_free(*msg); *msg = NULL; }
static void mbedtls_finished_free(pmbedtls_finished *pfinished) { lwIP_ASSERT(pfinished); lwIP_ASSERT(*pfinished); os_free((*pfinished)->finished_buf); os_free(*pfinished); *pfinished = NULL; }
static void mbedtls_parame_free(pmbedtls_parame *fp) { lwIP_ASSERT(fp); lwIP_ASSERT(*fp); os_free((*fp)->parame_data); os_free(*fp); *fp = NULL; }
static void mbedtls_espconn_free(pmbedtls_espconn *mbedtlsconn) { lwIP_ASSERT(mbedtlsconn); lwIP_ASSERT(*mbedtlsconn); os_free((*mbedtlsconn)->proto.tcp); (*mbedtlsconn)->proto.tcp = NULL; os_free((*mbedtlsconn)); *mbedtlsconn = NULL; }
static void mbedtls_session_free(pmbedtls_session *session) { lwIP_ASSERT(session); lwIP_ASSERT(*session); mbedtls_x509_crt_free(&(*session)->cacert); mbedtls_x509_crt_free(&(*session)->clicert); mbedtls_pk_free(&(*session)->pkey); // mbedtls_entropy_free(&(*session)->entropy); os_free(*session); *session = NULL; }
void ringbuf_free(ringbuf_t* rb) { lwIP_ASSERT(rb && *rb); os_free((*rb)->buf); os_free(*rb); *rb = NULL; }
static void mbedtls_msg_server_step(pmbedtls_msg msg) { lwIP_ASSERT(msg); /*to prevent memory leaks, ensure that each allocated is deleted at every handshake*/ if (msg->psession){ mbedtls_session_free(&msg->psession); } #if defined(ESP8266_PLATFORM) if (msg->quiet && msg->ssl.out_buf) { mbedtls_zeroize(msg->ssl.out_buf, MBEDTLS_SSL_OUTBUFFER_LEN); os_free(msg->ssl.out_buf); msg->ssl.out_buf = NULL; } #endif mbedtls_entropy_free(&msg->entropy); mbedtls_ssl_free(&msg->ssl); mbedtls_ssl_config_free(&msg->conf); mbedtls_ctr_drbg_free(&msg->ctr_drbg); /*New connection ensure that each initial for next handshake */ os_bzero(msg, sizeof(mbedtls_msg)); msg->psession = mbedtls_session_new(); if (msg->psession){ mbedtls_net_init(&msg->fd); mbedtls_ssl_init(&msg->ssl); mbedtls_ssl_config_init(&msg->conf); mbedtls_ctr_drbg_init(&msg->ctr_drbg); mbedtls_entropy_init(&msg->entropy); } }
void ICACHE_FLASH_ATTR ringbuf_free(ringbuf_t *rb) { lwIP_ASSERT(rb && *rb); os_free((*rb)->buf); os_free(*rb); *rb = NULL; }
size_t ICACHE_FLASH_ATTR ringbuf_findchr(const struct ringbuf_t *rb, int c, size_t offset) { const uint8_t *bufend = ringbuf_end(rb); size_t bytes_used = ringbuf_bytes_used(rb); if (offset >= bytes_used) return bytes_used; const uint8_t *start = rb ->buf + (((rb->tail - rb->buf) + offset) % ringbuf_buffer_size(rb)); lwIP_ASSERT(bufend > start); size_t n = LWIP_MIN(bufend - start, bytes_used - offset); const uint8_t *found = (const uint8_t *)memchr(start, c, n); if (found) return offset + (found - start); else return ringbuf_findchr(rb, c, offset + n); }
static uint8_t* ringbuf_nextp(ringbuf_t rb, const uint8_t* p) { lwIP_ASSERT((p >= rb->buf) && (p < ringbuf_end(rb))); return rb->buf + ((++p - rb->buf) % ringbuf_buffer_size(rb)); }