![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to istgt_misc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / istgt / src|
Return to istgt_misc.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / istgt / src |
1.1 misho 1: /*
2: * Copyright (C) 2008-2010 Daisuke Aoyama <aoyama@peach.ne.jp>.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: *
14: * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17: * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
18: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24: * SUCH DAMAGE.
25: *
26: */
27:
28: #ifdef HAVE_CONFIG_H
29: #include "config.h"
30: #endif
31:
32: #include <inttypes.h>
33: #include <stdint.h>
34:
35: #include <ctype.h>
36: #include <stdarg.h>
37: #include <stdio.h>
38: #include <stdlib.h>
39: #include <string.h>
40: #include <syslog.h>
41:
42: #include <unistd.h>
43:
44: #ifdef HAVE_LIBPTHREAD
45: #include <pthread.h>
46: #endif
47: #ifdef HAVE_SCHED
48: #include <sched.h>
49: #endif
50:
51: #include "istgt.h"
52: #include "istgt_misc.h"
53:
54: static void
55: fatal(const char *format, ...)
56: {
57: char buf[MAX_TMPBUF];
58: va_list ap;
59:
60: va_start(ap, format);
61: vsnprintf(buf, sizeof buf, format, ap);
62: fprintf(stderr, "%s", buf);
63: syslog(LOG_ERR, "%s", buf);
64: va_end(ap);
65: exit(EXIT_FAILURE);
66: }
67:
68: void *
69: xmalloc(size_t size)
70: {
71: void *p;
72:
73: if (size < 1)
74: size = 1;
75: p = malloc(size);
76: if (p == NULL)
77: fatal("no memory\n");
78: return p;
79: }
80:
81: void *
82: xrealloc(void *p, size_t size)
83: {
84: if (size < 1)
85: size = 1;
86: if (p == NULL) {
87: p = malloc(size);
88: } else {
89: p = realloc(p, size);
90: }
91: if (p == NULL)
92: fatal("no memory\n");
93: return p;
94: }
95:
96: void
97: xfree(void *p)
98: {
99: if (p == NULL)
100: return;
101: free(p);
102: }
103:
104: char *
105: xstrdup(const char *s)
106: {
107: char *p;
108: size_t size;
109:
110: if (s == NULL)
111: return NULL;
112: size = strlen(s) + 1;
113: p = xmalloc(size);
114: memcpy(p, s, size - 1);
115: p[size - 1] = '\0';
116: return p;
117: }
118:
119: char *
120: strlwr(char *s)
121: {
122: char *p;
123:
124: if (s == NULL)
125: return NULL;
126:
127: p = s;
128: while (*p != '\0') {
129: *p = tolower((int) *p);
130: p++;
131: }
132: return s;
133: }
134:
135: char *
136: strupr(char *s)
137: {
138: char *p;
139:
140: if (s == NULL)
141: return NULL;
142:
143: p = s;
144: while (*p != '\0') {
145: *p = toupper((int) *p);
146: p++;
147: }
148: return s;
149: }
150:
151: char *
152: strsepq(char **stringp, const char *delim)
153: {
154: char *p, *q, *r;
155: int quoted = 0, bslash = 0;
156:
157: p = *stringp;
158: if (p == NULL)
159: return NULL;
160:
161: r = q = p;
162: while (*q != '\0' && *q != '\n') {
163: /* eat quoted characters */
164: if (bslash) {
165: bslash = 0;
166: *r++ = *q++;
167: continue;
168: } else if (quoted) {
169: if (quoted == '"' && *q == '\\') {
170: bslash = 1;
171: q++;
172: continue;
173: } else if (*q == quoted) {
174: quoted = 0;
175: q++;
176: continue;
177: }
178: *r++ = *q++;
179: continue;
180: } else if (*q == '\\') {
181: bslash = 1;
182: q++;
183: continue;
184: } else if (*q == '"' || *q == '\'') {
185: quoted = *q;
186: q++;
187: continue;
188: }
189:
190: /* separator? */
191: if (strchr(delim, (int) *q) == NULL) {
192: *r++ = *q++;
193: continue;
194: }
195:
196: /* new string */
197: q++;
198: break;
199: }
200: *r = '\0';
201:
202: /* skip tailer */
203: while (*q != '\0' && strchr(delim, (int) *q) != NULL) {
204: q++;
205: }
206: if (*q != '\0') {
207: *stringp = q;
208: } else {
209: *stringp = NULL;
210: }
211:
212: return p;
213: }
214:
215: char *
216: trim_string(char *s)
217: {
218: char *p, *q;
219:
220: if (s == NULL)
221: return NULL;
222:
223: /* remove header */
224: p = s;
225: while (*p != '\0' && isspace((int) *p)) {
226: p++;
227: }
228: /* remove tailer */
229: q = p + strlen(p);
230: while (q - 1 >= p && isspace((int) *(q - 1))) {
231: q--;
232: *q = '\0';
233: }
234: /* if remove header, move */
235: if (p != s) {
236: q = s;
237: while (*p != '\0') {
238: *q++ = *p++;
239: }
240: }
241: return s;
242: }
243:
244: char *
245: escape_string(const char *s)
246: {
247: const char *p;
248: char *q, *r;
249: size_t size;
250:
251: if (s == NULL)
252: return NULL;
253:
254: p = s;
255: size = 0;
256: while (*p != '\0') {
257: if (*p == '"' || *p == '\\' || *p == '\'') {
258: size += 2;
259: } else {
260: size++;
261: }
262: p++;
263: }
264:
265: p = s;
266: r = q = xmalloc(size + 1);
267: while (*p != '\0') {
268: if (*p == '"' || *p == '\\' || *p == '\'') {
269: *q++ = '\\';
270: *q++ = *p++;
271: } else {
272: *q++ = *p++;
273: }
274: }
275: *q++ = '\0';
276: return r;
277: }
278:
279: /* LBA = (M * 60 + S) * 75 + F - 150 */
280: uint32_t
281: istgt_msf2lba(uint32_t msf)
282: {
283: uint32_t lba;
284:
285: lba = ((msf >> 16) & 0xff) * 60 * 75;
286: lba += ((msf >> 8) & 0xff) * 75;
287: lba += msf & 0xff;
288: lba -= 150;
289: return lba;
290: }
291:
292: uint32_t
293: istgt_lba2msf(uint32_t lba)
294: {
295: uint32_t m, s, f;
296:
297: lba += 150;
298: m = (lba / 75) / 60;
299: s = (lba / 75) % 60;
300: f = lba % 75;
301:
302: return ((m << 16) | (s << 8) | f);
303: }
304:
305: uint8_t
306: istgt_dget8(const uint8_t *data)
307: {
308: uint8_t value;
309:
310: value = (data[0] & 0xffU) << 0;
311: return value;
312: }
313:
314: void
315: istgt_dset8(uint8_t *data, uint32_t value)
316: {
317: data[0] = (value >> 0) & 0xffU;
318: }
319:
320: uint16_t
321: istgt_dget16(const uint8_t *data)
322: {
323: uint16_t value;
324:
325: value = (data[0] & 0xffU) << 8;
326: value |= (data[1] & 0xffU) << 0;
327: return value;
328: }
329:
330: void
331: istgt_dset16(uint8_t *data, uint32_t value)
332: {
333: data[0] = (value >> 8) & 0xffU;
334: data[1] = (value >> 0) & 0xffU;
335: }
336:
337: uint32_t
338: istgt_dget24(const uint8_t *data)
339: {
340: uint32_t value;
341:
342: value = (data[0] & 0xffU) << 16;
343: value |= (data[1] & 0xffU) << 8;
344: value |= (data[2] & 0xffU) << 0;
345: return value;
346: }
347:
348: void
349: istgt_dset24(uint8_t *data, uint32_t value)
350: {
351: data[0] = (value >> 16) & 0xffU;
352: data[1] = (value >> 8) & 0xffU;
353: data[2] = (value >> 0) & 0xffU;
354: }
355:
356: uint32_t
357: istgt_dget32(const uint8_t *data)
358: {
359: uint32_t value;
360:
361: value = (data[0] & 0xffU) << 24;
362: value |= (data[1] & 0xffU) << 16;
363: value |= (data[2] & 0xffU) << 8;
364: value |= (data[3] & 0xffU) << 0;
365: return value;
366: }
367:
368: void
369: istgt_dset32(uint8_t *data, uint32_t value)
370: {
371: data[0] = (value >> 24) & 0xffU;
372: data[1] = (value >> 16) & 0xffU;
373: data[2] = (value >> 8) & 0xffU;
374: data[3] = (value >> 0) & 0xffU;
375: }
376:
377: uint64_t
378: istgt_dget48(const uint8_t *data)
379: {
380: uint64_t value;
381:
382: value = (data[0] & 0xffULL) << 40;
383: value |= (data[1] & 0xffULL) << 32;
384: value |= (data[2] & 0xffULL) << 24;
385: value |= (data[3] & 0xffULL) << 16;
386: value |= (data[4] & 0xffULL) << 8;
387: value |= (data[5] & 0xffULL) << 0;
388: return value;
389: }
390:
391: void
392: istgt_dset48(uint8_t *data, uint64_t value)
393: {
394: data[0] = (value >> 40) & 0xffULL;
395: data[1] = (value >> 32) & 0xffULL;
396: data[2] = (value >> 24) & 0xffULL;
397: data[3] = (value >> 16) & 0xffULL;
398: data[4] = (value >> 8) & 0xffULL;
399: data[5] = (value >> 0) & 0xffULL;
400: }
401:
402: uint64_t
403: istgt_dget64(const uint8_t *data)
404: {
405: uint64_t value;
406:
407: value = (data[0] & 0xffULL) << 56;
408: value |= (data[1] & 0xffULL) << 48;
409: value |= (data[2] & 0xffULL) << 40;
410: value |= (data[3] & 0xffULL) << 32;
411: value |= (data[4] & 0xffULL) << 24;
412: value |= (data[5] & 0xffULL) << 16;
413: value |= (data[6] & 0xffULL) << 8;
414: value |= (data[7] & 0xffULL) << 0;
415: return value;
416: }
417:
418: void
419: istgt_dset64(uint8_t *data, uint64_t value)
420: {
421: data[0] = (value >> 56) & 0xffULL;
422: data[1] = (value >> 48) & 0xffULL;
423: data[2] = (value >> 40) & 0xffULL;
424: data[3] = (value >> 32) & 0xffULL;
425: data[4] = (value >> 24) & 0xffULL;
426: data[5] = (value >> 16) & 0xffULL;
427: data[6] = (value >> 8) & 0xffULL;
428: data[7] = (value >> 0) & 0xffULL;
429: }
430:
431: void
432: istgt_dump(const char *label, const uint8_t *buf, size_t len)
433: {
434: istgt_fdump(stdout, label, buf, len);
435: }
436:
437: void
438: istgt_fdump(FILE *fp, const char *label, const uint8_t *buf, size_t len)
439: {
440: char tmpbuf[MAX_TMPBUF];
441: char buf8[8+1];
442: int total;
443: int i;
444:
445: fprintf(fp, "%s\n", label);
446:
447: memset(buf8, 0, sizeof buf8);
448: total = 0;
449: for (i = 0; i < len; i++) {
450: if (i != 0 && i % 8 == 0) {
451: total += snprintf(tmpbuf + total, sizeof tmpbuf - total,
452: "%s", buf8);
453: fprintf(fp, "%s\n", tmpbuf);
454: total = 0;
455: }
456: total += snprintf(tmpbuf + total, sizeof tmpbuf - total,
457: "%2.2x ", buf[i] & 0xff);
458: buf8[i % 8] = isprint(buf[i]) ? buf[i] : '.';
459: }
460: for ( ; i % 8 != 0; i++) {
461: total += snprintf(tmpbuf + total, sizeof tmpbuf - total, " ");
462: buf8[i % 8] = ' ';
463: }
464: total += snprintf(tmpbuf + total, sizeof tmpbuf - total, "%s", buf8);
465: fprintf(fp, "%s\n", tmpbuf);
466: fflush(fp);
467: }
468:
469: #ifndef HAVE_SRANDOMDEV
470: #include <time.h>
471: void
472: srandomdev(void)
473: {
474: unsigned long seed;
475: time_t now;
476: pid_t pid;
477:
478: pid = getpid();
479: now = time(NULL);
480: seed = pid ^ now;
481: srandom(seed);
482: }
483: #endif /* HAVE_SRANDOMDEV */
484:
485: #ifndef HAVE_ARC4RANDOM
486: static int istgt_arc4random_initialized = 0;
487:
488: uint32_t
489: arc4random(void)
490: {
491: uint32_t r;
492: uint32_t r1, r2;
493:
494: if (!istgt_arc4random_initialized) {
495: srandomdev();
496: istgt_arc4random_initialized = 1;
497: }
498: r1 = (uint32_t) (random() & 0xffff);
499: r2 = (uint32_t) (random() & 0xffff);
500: r = (r1 << 16) | r2;
501: return r;
502: }
503: #endif /* HAVE_ARC4RANDOM */
504:
505: void
506: istgt_gen_random(uint8_t *buf, size_t len)
507: {
508: #ifdef USE_RANDOM
509: long l;
510: int i;
511:
512: srandomdev();
513: for (i = 0; i < len; i++) {
514: l = random();
515: buf[i] = (uint8_t) l;
516: }
517: #else
518: uint32_t r;
519: int i;
520:
521: for (i = 0; i < len; i++) {
522: r = arc4random();
523: buf[i] = (uint8_t) r;
524: }
525: #endif /* USE_RANDOM */
526: }
527:
528: int
529: istgt_bin2hex(char *buf, size_t len, const uint8_t *data, size_t data_len)
530: {
531: const char *digits = "0123456789ABCDEF";
532: int total = 0;
533: int i;
534:
535: if (len < 3)
536: return -1;
537: buf[total] = '0';
538: total++;
539: buf[total] = 'x';
540: total++;
541: buf[total] = '\0';
542:
543: for (i = 0; i < data_len; i++) {
544: if (total + 3 > len) {
545: buf[total] = '\0';
546: return - 1;
547: }
548: buf[total] = digits[(data[i] >> 4) & 0x0fU];
549: total++;
550: buf[total] = digits[data[i] & 0x0fU];
551: total++;
552: }
553: buf[total] = '\0';
554: return total;
555: }
556:
557: int
558: istgt_hex2bin(uint8_t *data, size_t data_len, const char *str)
559: {
560: const char *digits = "0123456789ABCDEF";
561: const char *dp;
562: const char *p;
563: int total = 0;
564: int n0, n1;
565:
566: p = str;
567: if (p[0] != '0' && (p[1] != 'x' && p[1] != 'X'))
568: return -1;
569: p += 2;
570:
571: while (p[0] != '\0' && p[1] != '\0') {
572: if (total >= data_len) {
573: return -1;
574: }
575: dp = strchr(digits, toupper((int) p[0]));
576: if (dp == NULL) {
577: return -1;
578: }
579: n0 = (int) (dp - digits);
580: dp = strchr(digits, toupper((int) p[1]));
581: if (dp == NULL) {
582: return -1;
583: }
584: n1 = (int) (dp - digits);
585:
586: data[total] = (uint8_t) (((n0 & 0x0fU) << 4) | (n1 & 0x0fU));
587: total++;
588: p += 2;
589: }
590: return total;
591: }
592:
593: void
594: istgt_yield(void)
595: {
596: #if defined (HAVE_PTHREAD_YIELD)
597: pthread_yield();
598: #elif defined (HAVE_SCHED_YIELD)
599: sched_yield();
600: #else
601: usleep(0);
602: #endif
603: }
604:
605: #ifndef HAVE_STRLCPY
606: size_t
607: strlcpy(char *dst, const char *src, size_t size)
608: {
609: size_t len;
610:
611: if (dst == NULL)
612: return 0;
613: if (size < 1) {
614: return 0;
615: }
616: len = strlen(src);
617: if (len > size - 1) {
618: len = size - 1;
619: }
620: memcpy(dst, src, len);
621: dst[len] = '\0';
622: return len;
623: }
624: #endif /* HAVE_STRLCPY */