1 /* $OpenBSD: inout.c,v 1.23 2023/03/08 04:43:10 guenther Exp $ */ 2 3 /* 4 * Copyright (c) 2003, Otto Moerbeek <otto@drijf.net> 5 * 6 * Permission to use, copy, modify, and distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include <ctype.h> 20 #include <err.h> 21 #include <string.h> 22 23 #include "extern.h" 24 25 #define MAX_CHARS_PER_LINE 68 26 27 static int lastchar; 28 static int charcount; 29 30 static int src_getcharstream(struct source *); 31 static void src_ungetcharstream(struct source *); 32 static char *src_getlinestream(struct source *); 33 static void src_freestream(struct source *); 34 static int src_getcharstring(struct source *); 35 static void src_ungetcharstring(struct source *); 36 static char *src_getlinestring(struct source *); 37 static void src_freestring(struct source *); 38 static void flushwrap(FILE *); 39 static void putcharwrap(FILE *, int); 40 static void printwrap(FILE *, const char *); 41 static char *get_digit(u_long, int, u_int); 42 43 static struct vtable stream_vtable = { 44 src_getcharstream, 45 src_ungetcharstream, 46 src_getlinestream, 47 src_freestream 48 }; 49 50 static struct vtable string_vtable = { 51 src_getcharstring, 52 src_ungetcharstring, 53 src_getlinestring, 54 src_freestring 55 }; 56 57 void 58 src_setstream(struct source *src, FILE *stream) 59 { 60 src->u.stream = stream; 61 src->vtable = &stream_vtable; 62 } 63 64 void 65 src_setstring(struct source *src, char *p) 66 { 67 src->u.string.buf = (u_char *)p; 68 src->u.string.pos = 0; 69 src->vtable = &string_vtable; 70 } 71 72 static int 73 src_getcharstream(struct source *src) 74 { 75 return src->lastchar = getc(src->u.stream); 76 } 77 78 static void 79 src_ungetcharstream(struct source *src) 80 { 81 (void)ungetc(src->lastchar, src->u.stream); 82 } 83 84 static void 85 src_freestream(struct source *src) 86 { 87 } 88 89 static char * 90 src_getlinestream(struct source *src) 91 { 92 char buf[BUFSIZ]; 93 94 if (fgets(buf, BUFSIZ, src->u.stream) == NULL) 95 return bstrdup(""); 96 return bstrdup(buf); 97 } 98 99 static int 100 src_getcharstring(struct source *src) 101 { 102 src->lastchar = src->u.string.buf[src->u.string.pos]; 103 if (src->lastchar == '\0') 104 return EOF; 105 else { 106 src->u.string.pos++; 107 return src->lastchar; 108 } 109 } 110 111 static void 112 src_ungetcharstring(struct source *src) 113 { 114 if (src->u.string.pos > 0) { 115 if (src->lastchar != '\0') 116 --src->u.string.pos; 117 } 118 } 119 120 static char * 121 src_getlinestring(struct source *src) 122 { 123 char buf[BUFSIZ]; 124 int ch, i; 125 126 i = 0; 127 while (i < BUFSIZ-1) { 128 ch = src_getcharstring(src); 129 if (ch == EOF) 130 break; 131 buf[i++] = ch; 132 if (ch == '\n') 133 break; 134 } 135 buf[i] = '\0'; 136 return bstrdup(buf); 137 } 138 139 static void 140 src_freestring(struct source *src) 141 { 142 free(src->u.string.buf); 143 } 144 145 static void 146 flushwrap(FILE *f) 147 { 148 if (lastchar != -1) 149 (void)putc(lastchar, f); 150 } 151 152 static void 153 putcharwrap(FILE *f, int ch) 154 { 155 if (charcount >= MAX_CHARS_PER_LINE) { 156 charcount = 0; 157 (void)fputs("\\\n", f); 158 } 159 if (lastchar != -1) { 160 charcount++; 161 (void)putc(lastchar, f); 162 } 163 lastchar = ch; 164 } 165 166 static void 167 printwrap(FILE *f, const char *p) 168 { 169 char buf[12]; 170 char *q = buf; 171 172 (void)strlcpy(buf, p, sizeof(buf)); 173 while (*q) 174 putcharwrap(f, *q++); 175 } 176 177 struct number * 178 readnumber(struct source *src, u_int base) 179 { 180 struct number *n; 181 int ch; 182 bool sign = false; 183 bool dot = false; 184 BN_ULONG v; 185 u_int i; 186 187 n = new_number(); 188 bn_check(BN_set_word(n->number, 0)); 189 190 while ((ch = (*src->vtable->readchar)(src)) != EOF) { 191 192 if ('0' <= ch && ch <= '9') 193 v = ch - '0'; 194 else if ('A' <= ch && ch <= 'F') 195 v = ch - 'A' + 10; 196 else if (ch == '_') { 197 sign = true; 198 continue; 199 } else if (ch == '.') { 200 if (dot) 201 break; 202 dot = true; 203 continue; 204 } else { 205 (*src->vtable->unreadchar)(src); 206 break; 207 } 208 if (dot) 209 n->scale++; 210 211 bn_check(BN_mul_word(n->number, base)); 212 213 #if 0 214 /* work around a bug in BN_add_word: 0 += 0 is buggy.... */ 215 if (v > 0) 216 #endif 217 bn_check(BN_add_word(n->number, v)); 218 } 219 if (base != 10) { 220 scale_number(n->number, n->scale); 221 for (i = 0; i < n->scale; i++) 222 (void)BN_div_word(n->number, base); 223 } 224 if (sign) 225 negate(n); 226 return n; 227 } 228 229 char * 230 read_string(struct source *src) 231 { 232 int count, i, sz, new_sz, ch; 233 char *p; 234 bool escape; 235 236 escape = false; 237 count = 1; 238 i = 0; 239 sz = 15; 240 p = bmalloc(sz + 1); 241 242 while ((ch = (*src->vtable->readchar)(src)) != EOF) { 243 if (!escape) { 244 if (ch == '[') 245 count++; 246 else if (ch == ']') 247 count--; 248 if (count == 0) 249 break; 250 } 251 if (ch == '\\' && !escape) 252 escape = true; 253 else { 254 escape = false; 255 if (i == sz) { 256 new_sz = sz * 2; 257 p = breallocarray(p, 1, new_sz + 1); 258 sz = new_sz; 259 } 260 p[i++] = ch; 261 } 262 } 263 p[i] = '\0'; 264 return p; 265 } 266 267 static char * 268 get_digit(u_long num, int digits, u_int base) 269 { 270 char *p; 271 272 if (base <= 16) { 273 p = bmalloc(2); 274 p[0] = num >= 10 ? num + 'A' - 10 : num + '0'; 275 p[1] = '\0'; 276 } else { 277 if (asprintf(&p, "%0*lu", digits, num) == -1) 278 err(1, NULL); 279 } 280 return p; 281 } 282 283 void 284 printnumber(FILE *f, const struct number *b, u_int base) 285 { 286 struct number *int_part, *fract_part; 287 int digits; 288 char buf[11]; 289 size_t sz; 290 int i; 291 struct stack stack; 292 char *p; 293 294 charcount = 0; 295 lastchar = -1; 296 if (BN_is_zero(b->number)) 297 putcharwrap(f, '0'); 298 299 int_part = new_number(); 300 fract_part = new_number(); 301 fract_part->scale = b->scale; 302 303 if (base <= 16) 304 digits = 1; 305 else { 306 digits = snprintf(buf, sizeof(buf), "%u", base-1); 307 } 308 split_number(b, int_part->number, fract_part->number); 309 310 i = 0; 311 stack_init(&stack); 312 while (!BN_is_zero(int_part->number)) { 313 BN_ULONG rem = BN_div_word(int_part->number, base); 314 stack_pushstring(&stack, get_digit(rem, digits, base)); 315 i++; 316 } 317 sz = i; 318 if (BN_is_negative(b->number)) 319 putcharwrap(f, '-'); 320 for (i = 0; i < sz; i++) { 321 p = stack_popstring(&stack); 322 if (base > 16) 323 putcharwrap(f, ' '); 324 printwrap(f, p); 325 free(p); 326 } 327 stack_clear(&stack); 328 if (b->scale > 0) { 329 struct number *num_base; 330 BIGNUM *mult, *stop; 331 332 putcharwrap(f, '.'); 333 num_base = new_number(); 334 bn_check(BN_set_word(num_base->number, base)); 335 mult = BN_new(); 336 bn_checkp(mult); 337 bn_check(BN_one(mult)); 338 stop = BN_new(); 339 bn_checkp(stop); 340 bn_check(BN_one(stop)); 341 scale_number(stop, b->scale); 342 343 i = 0; 344 while (BN_cmp(mult, stop) < 0) { 345 u_long rem; 346 347 if (i && base > 16) 348 putcharwrap(f, ' '); 349 i = 1; 350 351 bmul_number(fract_part, fract_part, num_base, 352 bmachine_scale()); 353 split_number(fract_part, int_part->number, NULL); 354 rem = BN_get_word(int_part->number); 355 p = get_digit(rem, digits, base); 356 int_part->scale = 0; 357 normalize(int_part, fract_part->scale); 358 bn_check(BN_sub(fract_part->number, fract_part->number, 359 int_part->number)); 360 printwrap(f, p); 361 free(p); 362 bn_check(BN_mul_word(mult, base)); 363 } 364 free_number(num_base); 365 BN_free(mult); 366 BN_free(stop); 367 } 368 flushwrap(f); 369 free_number(int_part); 370 free_number(fract_part); 371 } 372 373 void 374 print_value(FILE *f, const struct value *value, const char *prefix, u_int base) 375 { 376 (void)fputs(prefix, f); 377 switch (value->type) { 378 case BCODE_NONE: 379 if (value->array != NULL) 380 (void)fputs("<array>", f); 381 break; 382 case BCODE_NUMBER: 383 printnumber(f, value->u.num, base); 384 break; 385 case BCODE_STRING: 386 (void)fputs(value->u.string, f); 387 break; 388 } 389 } 390 391 void 392 print_ascii(FILE *f, const struct number *n) 393 { 394 int numbits, i, ch; 395 396 numbits = BN_num_bytes(n->number) * 8; 397 while (numbits > 0) { 398 ch = 0; 399 for (i = 0; i < 8; i++) 400 ch |= BN_is_bit_set(n->number, numbits-i-1) << (7 - i); 401 (void)putc(ch, f); 402 numbits -= 8; 403 } 404 } 405