1 /* $OpenBSD: test_sshbuf.c,v 1.1 2014/04/30 05:32:00 djm Exp $ */ 2 /* 3 * Regress test for sshbuf.h buffer API 4 * 5 * Placed in the public domain 6 */ 7 8 #define SSHBUF_INTERNAL 1 /* access internals for testing */ 9 #include "includes.h" 10 11 #include <sys/types.h> 12 #include <sys/param.h> 13 #include <stdio.h> 14 #ifdef HAVE_STDINT_H 15 # include <stdint.h> 16 #endif 17 #include <stdlib.h> 18 #include <string.h> 19 20 #include "../test_helper/test_helper.h" 21 22 #include "ssherr.h" 23 #include "sshbuf.h" 24 25 void sshbuf_tests(void); 26 27 void 28 sshbuf_tests(void) 29 { 30 struct sshbuf *p1; 31 const u_char *cdp; 32 u_char *dp; 33 size_t sz; 34 int r; 35 36 TEST_START("allocate sshbuf"); 37 p1 = sshbuf_new(); 38 ASSERT_PTR_NE(p1, NULL); 39 TEST_DONE(); 40 41 TEST_START("max size on fresh buffer"); 42 ASSERT_SIZE_T_GT(sshbuf_max_size(p1), 0); 43 TEST_DONE(); 44 45 TEST_START("available on fresh buffer"); 46 ASSERT_SIZE_T_GT(sshbuf_avail(p1), 0); 47 TEST_DONE(); 48 49 TEST_START("len = 0 on empty buffer"); 50 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 0); 51 TEST_DONE(); 52 53 TEST_START("set valid max size"); 54 ASSERT_INT_EQ(sshbuf_set_max_size(p1, 65536), 0); 55 ASSERT_SIZE_T_EQ(sshbuf_max_size(p1), 65536); 56 TEST_DONE(); 57 58 TEST_START("available on limited buffer"); 59 ASSERT_SIZE_T_EQ(sshbuf_avail(p1), 65536); 60 TEST_DONE(); 61 62 TEST_START("free"); 63 sshbuf_free(p1); 64 TEST_DONE(); 65 66 TEST_START("consume on empty buffer"); 67 p1 = sshbuf_new(); 68 ASSERT_PTR_NE(p1, NULL); 69 ASSERT_INT_EQ(sshbuf_consume(p1, 0), 0); 70 ASSERT_INT_EQ(sshbuf_consume(p1, 1), SSH_ERR_MESSAGE_INCOMPLETE); 71 sshbuf_free(p1); 72 TEST_DONE(); 73 74 TEST_START("consume_end on empty buffer"); 75 p1 = sshbuf_new(); 76 ASSERT_PTR_NE(p1, NULL); 77 ASSERT_INT_EQ(sshbuf_consume_end(p1, 0), 0); 78 ASSERT_INT_EQ(sshbuf_consume_end(p1, 1), SSH_ERR_MESSAGE_INCOMPLETE); 79 sshbuf_free(p1); 80 TEST_DONE(); 81 82 TEST_START("reserve space"); 83 p1 = sshbuf_new(); 84 ASSERT_PTR_NE(p1, NULL); 85 r = sshbuf_reserve(p1, 1, &dp); 86 ASSERT_INT_EQ(r, 0); 87 ASSERT_PTR_NE(dp, NULL); 88 *dp = 0x11; 89 r = sshbuf_reserve(p1, 3, &dp); 90 ASSERT_INT_EQ(r, 0); 91 ASSERT_PTR_NE(dp, NULL); 92 *dp++ = 0x22; 93 *dp++ = 0x33; 94 *dp++ = 0x44; 95 TEST_DONE(); 96 97 TEST_START("sshbuf_len on filled buffer"); 98 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 4); 99 TEST_DONE(); 100 101 TEST_START("sshbuf_ptr on filled buffer"); 102 cdp = sshbuf_ptr(p1); 103 ASSERT_PTR_NE(cdp, NULL); 104 ASSERT_U8_EQ(cdp[0], 0x11); 105 ASSERT_U8_EQ(cdp[1], 0x22); 106 ASSERT_U8_EQ(cdp[2], 0x33); 107 ASSERT_U8_EQ(cdp[3], 0x44); 108 TEST_DONE(); 109 110 TEST_START("consume on filled buffer"); 111 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 4); 112 ASSERT_INT_EQ(sshbuf_consume(p1, 0), 0); 113 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 4); 114 r = sshbuf_consume(p1, 64); 115 ASSERT_INT_EQ(r, SSH_ERR_MESSAGE_INCOMPLETE); 116 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 4); 117 ASSERT_INT_EQ(sshbuf_consume(p1, 1), 0); 118 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 3); 119 cdp = sshbuf_ptr(p1); 120 ASSERT_PTR_NE(p1, NULL); 121 ASSERT_U8_EQ(cdp[0], 0x22); 122 ASSERT_INT_EQ(sshbuf_consume(p1, 2), 0); 123 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 1); 124 cdp = sshbuf_ptr(p1); 125 ASSERT_PTR_NE(p1, NULL); 126 ASSERT_U8_EQ(cdp[0], 0x44); 127 r = sshbuf_consume(p1, 2); 128 ASSERT_INT_EQ(r, SSH_ERR_MESSAGE_INCOMPLETE); 129 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 1); 130 ASSERT_INT_EQ(sshbuf_consume(p1, 1), 0); 131 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 0); 132 r = sshbuf_consume(p1, 1); 133 ASSERT_INT_EQ(r, SSH_ERR_MESSAGE_INCOMPLETE); 134 sshbuf_free(p1); 135 TEST_DONE(); 136 137 TEST_START("consume_end on filled buffer"); 138 p1 = sshbuf_new(); 139 ASSERT_PTR_NE(p1, NULL); 140 r = sshbuf_reserve(p1, 4, &dp); 141 ASSERT_INT_EQ(r, 0); 142 ASSERT_PTR_NE(dp, NULL); 143 *dp++ = 0x11; 144 *dp++ = 0x22; 145 *dp++ = 0x33; 146 *dp++ = 0x44; 147 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 4); 148 r = sshbuf_consume_end(p1, 5); 149 ASSERT_INT_EQ(r, SSH_ERR_MESSAGE_INCOMPLETE); 150 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 4); 151 ASSERT_INT_EQ(sshbuf_consume_end(p1, 3), 0); 152 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 1); 153 cdp = sshbuf_ptr(p1); 154 ASSERT_PTR_NE(cdp, NULL); 155 ASSERT_U8_EQ(*cdp, 0x11); 156 r = sshbuf_consume_end(p1, 2); 157 ASSERT_INT_EQ(r, SSH_ERR_MESSAGE_INCOMPLETE); 158 ASSERT_INT_EQ(sshbuf_consume_end(p1, 1), 0); 159 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 0); 160 sshbuf_free(p1); 161 TEST_DONE(); 162 163 TEST_START("fill limited buffer"); 164 p1 = sshbuf_new(); 165 ASSERT_PTR_NE(p1, NULL); 166 ASSERT_INT_EQ(sshbuf_set_max_size(p1, 1223), 0); 167 ASSERT_SIZE_T_EQ(sshbuf_max_size(p1), 1223); 168 ASSERT_SIZE_T_EQ(sshbuf_avail(p1), 1223); 169 r = sshbuf_reserve(p1, 1223, &dp); 170 ASSERT_INT_EQ(r, 0); 171 ASSERT_PTR_NE(dp, NULL); 172 memset(dp, 0xd7, 1223); 173 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 1223); 174 ASSERT_SIZE_T_EQ(sshbuf_avail(p1), 0); 175 r = sshbuf_reserve(p1, 1, &dp); 176 ASSERT_INT_EQ(r, SSH_ERR_NO_BUFFER_SPACE); 177 ASSERT_PTR_EQ(dp, NULL); 178 TEST_DONE(); 179 180 TEST_START("consume and force compaction"); 181 ASSERT_INT_EQ(sshbuf_consume(p1, 223), 0); 182 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 1000); 183 ASSERT_SIZE_T_EQ(sshbuf_avail(p1), 223); 184 r = sshbuf_reserve(p1, 224, &dp); 185 ASSERT_INT_EQ(r, SSH_ERR_NO_BUFFER_SPACE); 186 ASSERT_PTR_EQ(dp, NULL); 187 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 1000); 188 ASSERT_SIZE_T_EQ(sshbuf_avail(p1), 223); 189 r = sshbuf_reserve(p1, 223, &dp); 190 ASSERT_INT_EQ(r, 0); 191 ASSERT_PTR_NE(dp, NULL); 192 memset(dp, 0x7d, 223); 193 cdp = sshbuf_ptr(p1); 194 ASSERT_PTR_NE(cdp, NULL); 195 ASSERT_MEM_FILLED_EQ(cdp, 0xd7, 1000); 196 ASSERT_MEM_FILLED_EQ(cdp + 1000, 0x7d, 223); 197 TEST_DONE(); 198 199 TEST_START("resize full buffer"); 200 r = sshbuf_set_max_size(p1, 1000); 201 ASSERT_INT_EQ(r, SSH_ERR_NO_BUFFER_SPACE); 202 sz = roundup(1223 + SSHBUF_SIZE_INC * 3, SSHBUF_SIZE_INC); 203 ASSERT_INT_EQ(sshbuf_set_max_size(p1, sz), 0); 204 ASSERT_SIZE_T_EQ(sshbuf_max_size(p1), sz); 205 ASSERT_SIZE_T_EQ(sshbuf_avail(p1), sz - 1223); 206 ASSERT_INT_EQ(sshbuf_len(p1), 1223); 207 TEST_DONE(); 208 209 /* NB. uses sshbuf internals */ 210 TEST_START("alloc chunking"); 211 r = sshbuf_reserve(p1, 1, &dp); 212 ASSERT_INT_EQ(r, 0); 213 ASSERT_PTR_NE(dp, NULL); 214 *dp = 0xff; 215 cdp = sshbuf_ptr(p1); 216 ASSERT_PTR_NE(cdp, NULL); 217 ASSERT_MEM_FILLED_EQ(cdp, 0xd7, 1000); 218 ASSERT_MEM_FILLED_EQ(cdp + 1000, 0x7d, 223); 219 ASSERT_MEM_FILLED_EQ(cdp + 1223, 0xff, 1); 220 ASSERT_SIZE_T_EQ(sshbuf_alloc(p1) % SSHBUF_SIZE_INC, 0); 221 sshbuf_free(p1); 222 TEST_DONE(); 223 224 TEST_START("reset buffer"); 225 p1 = sshbuf_new(); 226 ASSERT_PTR_NE(p1, NULL); 227 ASSERT_INT_EQ(sshbuf_set_max_size(p1, 1223), 0); 228 ASSERT_SIZE_T_EQ(sshbuf_max_size(p1), 1223); 229 r = sshbuf_reserve(p1, 1223, &dp); 230 ASSERT_INT_EQ(r, 0); 231 ASSERT_PTR_NE(dp, NULL); 232 memset(dp, 0xd7, 1223); 233 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 1223); 234 sshbuf_reset(p1); 235 ASSERT_SIZE_T_EQ(sshbuf_max_size(p1), 1223); 236 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 0); 237 ASSERT_SIZE_T_EQ(sshbuf_avail(p1), 1223); 238 sshbuf_free(p1); 239 TEST_DONE(); 240 } 241