damus

nostr ios client
git clone git://jb55.com/damus
Log | Files | Refs | README | LICENSE

mem.c (2294B)


      1 /* CC0 (Public domain) - see LICENSE file for details */
      2 
      3 #include "config.h"
      4 
      5 #include <assert.h>
      6 #include <string.h>
      7 #include <ccan/mem/mem.h>
      8 
      9 #if !HAVE_MEMMEM
     10 void *memmem(const void *haystack, size_t haystacklen,
     11 	     const void *needle, size_t needlelen)
     12 {
     13 	const char *p;
     14 
     15 	if (needlelen > haystacklen)
     16 		return NULL;
     17 
     18 	p = haystack;
     19 
     20 	for (p = haystack;
     21 	     (p + needlelen) <= ((const char *)haystack + haystacklen);
     22 	     p++)
     23 		if (memcmp(p, needle, needlelen) == 0)
     24 			return (void *)p;
     25 
     26 	return NULL;
     27 }
     28 #endif
     29 
     30 #if !HAVE_MEMRCHR
     31 void *memrchr(const void *s, int c, size_t n)
     32 {
     33 	unsigned char *p = (unsigned char *)s;
     34 
     35 	while (n) {
     36 		if (p[n-1] == c)
     37 			return p + n - 1;
     38 		n--;
     39 	}
     40 
     41 	return NULL;
     42 }
     43 #endif
     44 
     45 void *mempbrkm(const void *data_, size_t len, const void *accept_, size_t accept_len)
     46 {
     47 	const char *data = data_, *accept = accept_;
     48 	size_t i, j;
     49 
     50 	for (i = 0; i < len; i++)
     51 		for (j = 0; j < accept_len; j++)
     52 			if (accept[j] == data[i])
     53 				return (void *)&data[i];
     54 	return NULL;
     55 }
     56 
     57 void *memcchr(void const *data, int c, size_t data_len)
     58 {
     59 	char const *p = data;
     60 	size_t i;
     61 
     62 	for (i = 0; i < data_len; i++)
     63 		if (p[i] != c)
     64 			return (void *)&p[i];
     65 
     66 	return NULL;
     67 }
     68 
     69 #define MEMSWAP_TMP_SIZE	256
     70 
     71 void memswap(void *a, void *b, size_t n)
     72 {
     73 	char *ap = a;
     74 	char *bp = b;
     75 	char tmp[MEMSWAP_TMP_SIZE];
     76 
     77 	assert(!memoverlaps(a, n, b, n));
     78 
     79 	while (n) {
     80 		size_t m = n > MEMSWAP_TMP_SIZE ? MEMSWAP_TMP_SIZE : n;
     81 
     82 		memcpy(tmp, bp, m);
     83 		memcpy(bp, ap, m);
     84 		memcpy(ap, tmp, m);
     85 
     86 		ap += m;
     87 		bp += m;
     88 		n -= m;
     89 	}
     90 }
     91 
     92 bool memeqzero(const void *data, size_t length)
     93 {
     94 	const unsigned char *p = data;
     95 	size_t len;
     96 
     97 	/* Check first 16 bytes manually */
     98 	for (len = 0; len < 16; len++) {
     99 		if (!length)
    100 			return true;
    101 		if (*p)
    102 			return false;
    103 		p++;
    104 		length--;
    105 	}
    106 
    107 	/* Now we know that's zero, memcmp with self. */
    108 	return memcmp(data, p, length) == 0;
    109 }
    110 
    111 void memtaint(void *data, size_t len)
    112 {
    113 	/* Using 16 bytes is a bit quicker than 4 */
    114 	const unsigned tainter[]
    115 		= { 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef };
    116 	char *p = data;
    117 
    118 	while (len >= sizeof(tainter)) {
    119 		memcpy(p, tainter, sizeof(tainter));
    120 		p += sizeof(tainter);
    121 		len -= sizeof(tainter);
    122 	}
    123 	memcpy(p, tainter, len);
    124 
    125 #if HAVE_VALGRIND_MEMCHECK_H
    126 	VALGRIND_MAKE_MEM_UNDEFINED(data, len);
    127 #endif
    128 }