1 /*
2  * Copyright (c) 2001, 2002, 2003 Ian F. Darwin.  All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  * 3. The name of the author may not be used to endorse or promote products
13  *    derived from this software without specific prior written permission.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26 
27 /*
28  * fmt_scaled: Format numbers scaled for human comprehension
29  * scan_scaled: Scan numbers in this format.
30  *
31  * "Human-readable" output uses 4 digits max, and puts a unit suffix at
32  * the end.  Makes output compact and easy-to-read esp. on huge disks.
33  * Formatting code was originally in OpenBSD "df", converted to library routine.
34  * Scanning code written for OpenBSD libutil.
35  */
36 
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <errno.h>
40 #include <string.h>
41 #include <ctype.h>
42 #include <limits.h>
43 
44 #include "got_compat.h"
45 
46 typedef enum {
47 	NONE = 0, KILO = 1, MEGA = 2, GIGA = 3, TERA = 4, PETA = 5, EXA = 6
48 } unit_type;
49 
50 /* These three arrays MUST be in sync!  XXX make a struct */
51 static unit_type units[] = { NONE, KILO, MEGA, GIGA, TERA, PETA, EXA };
52 static char scale_chars[] = "BKMGTPE";
53 static long long scale_factors[] = {
54 	1LL,
55 	1024LL,
56 	1024LL*1024,
57 	1024LL*1024*1024,
58 	1024LL*1024*1024*1024,
59 	1024LL*1024*1024*1024*1024,
60 	1024LL*1024*1024*1024*1024*1024,
61 };
62 #define	SCALE_LENGTH (sizeof(units)/sizeof(units[0]))
63 
64 #define MAX_DIGITS (SCALE_LENGTH * 3)	/* XXX strlen(sprintf("%lld", -1)? */
65 
66 /* Convert the given input string "scaled" into numeric in "result".
67  * Return 0 on success, -1 and errno set on error.
68  */
69 int
70 scan_scaled(char *scaled, long long *result)
71 {
72 	char *p = scaled;
73 	int sign = 0;
74 	unsigned int i, ndigits = 0, fract_digits = 0;
75 	long long scale_fact = 1, whole = 0, fpart = 0;
76 
77 	/* Skip leading whitespace */
78 	while (isascii(*p) && isspace(*p))
79 		++p;
80 
81 	/* Then at most one leading + or - */
82 	while (*p == '-' || *p == '+') {
83 		if (*p == '-') {
84 			if (sign) {
85 				errno = EINVAL;
86 				return -1;
87 			}
88 			sign = -1;
89 			++p;
90 		} else if (*p == '+') {
91 			if (sign) {
92 				errno = EINVAL;
93 				return -1;
94 			}
95 			sign = +1;
96 			++p;
97 		}
98 	}
99 
100 	/* Main loop: Scan digits, find decimal point, if present.
101 	 * We don't allow exponentials, so no scientific notation
102 	 * (but note that E for Exa might look like e to some!).
103 	 * Advance 'p' to end, to get scale factor.
104 	 */
105 	for (; isascii(*p) && (isdigit(*p) || *p=='.'); ++p) {
106 		if (*p == '.') {
107 			if (fract_digits > 0) {	/* oops, more than one '.' */
108 				errno = EINVAL;
109 				return -1;
110 			}
111 			fract_digits = 1;
112 			continue;
113 		}
114 
115 		i = (*p) - '0';			/* whew! finally a digit we can use */
116 		if (fract_digits > 0) {
117 			if (fract_digits >= MAX_DIGITS-1)
118 				/* ignore extra fractional digits */
119 				continue;
120 			fract_digits++;		/* for later scaling */
121 			fpart *= 10;
122 			fpart += i;
123 		} else {				/* normal digit */
124 			if (++ndigits >= MAX_DIGITS) {
125 				errno = ERANGE;
126 				return -1;
127 			}
128 			whole *= 10;
129 			whole += i;
130 		}
131 	}
132 
133 	if (sign) {
134 		whole *= sign;
135 		fpart *= sign;
136 	}
137 
138 	/* If no scale factor given, we're done. fraction is discarded. */
139 	if (!*p) {
140 		*result = whole;
141 		return 0;
142 	}
143 
144 	/* Validate scale factor, and scale whole and fraction by it. */
145 	for (i = 0; i < SCALE_LENGTH; i++) {
146 
147 		/* Are we there yet? */
148 		if (*p == scale_chars[i] ||
149 			*p == tolower(scale_chars[i])) {
150 
151 			/* If it ends with alphanumerics after the scale char, bad. */
152 			if (isalnum(*(p+1))) {
153 				errno = EINVAL;
154 				return -1;
155 			}
156 			scale_fact = scale_factors[i];
157 
158 			/* scale whole part */
159 			whole *= scale_fact;
160 
161 			/* truncate fpart so it does't overflow.
162 			 * then scale fractional part.
163 			 */
164 			while (fpart >= LLONG_MAX / scale_fact) {
165 				fpart /= 10;
166 				fract_digits--;
167 			}
168 			fpart *= scale_fact;
169 			if (fract_digits > 0) {
170 				for (i = 0; i < fract_digits -1; i++)
171 					fpart /= 10;
172 			}
173 			whole += fpart;
174 			*result = whole;
175 			return 0;
176 		}
177 	}
178 	errno = ERANGE;
179 	return -1;
180 }
181 
182 /* Format the given "number" into human-readable form in "result".
183  * Result must point to an allocated buffer of length FMT_SCALED_STRSIZE.
184  * Return 0 on success, -1 and errno set if error.
185  */
186 int
187 fmt_scaled(long long number, char *result)
188 {
189 	long long abval, fract = 0;
190 	unsigned int i;
191 	unit_type unit = NONE;
192 
193 	abval = llabs(number);
194 
195 	/* Not every negative long long has a positive representation.
196 	 * Also check for numbers that are just too darned big to format
197 	 */
198 	if (abval < 0 || abval / 1024 >= scale_factors[SCALE_LENGTH-1]) {
199 		errno = ERANGE;
200 		return -1;
201 	}
202 
203 	/* scale whole part; get unscaled fraction */
204 	for (i = 0; i < SCALE_LENGTH; i++) {
205 		if (abval/1024 < scale_factors[i]) {
206 			unit = units[i];
207 			fract = (i == 0) ? 0 : abval % scale_factors[i];
208 			number /= scale_factors[i];
209 			if (i > 0)
210 				fract /= scale_factors[i - 1];
211 			break;
212 		}
213 	}
214 
215 	fract = (10 * fract + 512) / 1024;
216 	/* if the result would be >= 10, round main number */
217 	if (fract == 10) {
218 		if (number >= 0)
219 			number++;
220 		else
221 			number--;
222 		fract = 0;
223 	}
224 
225 	if (number == 0)
226 		strlcpy(result, "0B", FMT_SCALED_STRSIZE);
227 	else if (unit == NONE || number >= 100 || number <= -100) {
228 		if (fract >= 5) {
229 			if (number >= 0)
230 				number++;
231 			else
232 				number--;
233 		}
234 		(void)snprintf(result, FMT_SCALED_STRSIZE, "%lld%c",
235 			number, scale_chars[unit]);
236 	} else
237 		(void)snprintf(result, FMT_SCALED_STRSIZE, "%lld.%1lld%c",
238 			number, fract, scale_chars[unit]);
239 
240 	return 0;
241 }