1 #include "stdinc.h"
2 #include "dat.h"
3 #include "fns.h"
4 
5 int
6 namecmp(char *s, char *t)
7 {
8 	return strncmp(s, t, ANameSize);
9 }
10 
11 void
12 namecp(char *dst, char *src)
13 {
14 	strncpy(dst, src, ANameSize - 1);
15 	dst[ANameSize - 1] = '\0';
16 }
17 
18 int
19 nameok(char *name)
20 {
21 	char *t;
22 	int c;
23 
24 	if(name == nil)
25 		return -1;
26 	for(t = name; c = *t; t++)
27 		if(t - name >= ANameSize
28 		|| c < ' ' || c >= 0x7f)
29 			return -1;
30 	return 0;
31 }
32 
33 int
34 stru32int(char *s, u32int *r)
35 {
36 	char *t;
37 	u32int n, nn, m;
38 	int c;
39 
40 	m = TWID32 / 10;
41 	n = 0;
42 	for(t = s; ; t++){
43 		c = *t;
44 		if(c < '0' || c > '9')
45 			break;
46 		if(n > m)
47 			return -1;
48 		nn = n * 10 + c - '0';
49 		if(nn < n)
50 			return -1;
51 		n = nn;
52 	}
53 	*r = n;
54 	return s != t && *t == '\0';
55 }
56 
57 int
58 stru64int(char *s, u64int *r)
59 {
60 	char *t;
61 	u64int n, nn, m;
62 	int c;
63 
64 	m = TWID64 / 10;
65 	n = 0;
66 	for(t = s; ; t++){
67 		c = *t;
68 		if(c < '0' || c > '9')
69 			break;
70 		if(n > m)
71 			return -1;
72 		nn = n * 10 + c - '0';
73 		if(nn < n)
74 			return -1;
75 		n = nn;
76 	}
77 	*r = n;
78 	return s != t && *t == '\0';
79 }
80 
81 int
82 vttypevalid(int type)
83 {
84 	return type < VtMaxType;
85 }
86 
87 void
88 fmtzbinit(Fmt *f, ZBlock *b)
89 {
90 	f->runes = 0;
91 	f->start = b->data;
92 	f->to = f->start;
93 	f->stop = (char*)f->start + b->len;
94 	f->flush = nil;
95 	f->farg = nil;
96 	f->nfmt = 0;
97 	f->args = nil;
98 }
99 
100 static int
101 sflush(Fmt *f)
102 {
103 	char *s;
104 	int n;
105 
106 	n = (int)f->farg;
107 	n += 256;
108 	f->farg = (void*)n;
109 	s = f->start;
110 	f->start = realloc(s, n);
111 	if(f->start == nil){
112 		f->start = s;
113 		return 0;
114 	}
115 	f->to = (char*)f->start + ((char*)f->to - s);
116 	f->stop = (char*)f->start + n - 1;
117 	return 1;
118 }
119 
120 static char*
121 logit(int severity, char *fmt, va_list args)
122 {
123 	Fmt f;
124 	int n;
125 
126 	f.runes = 0;
127 	n = 32;
128 	f.start = malloc(n);
129 	if(f.start == nil)
130 		return nil;
131 	f.to = f.start;
132 	f.stop = (char*)f.start + n - 1;
133 	f.flush = sflush;
134 	f.farg = (void*)n;
135 	f.nfmt = 0;
136 	f.args = args;
137 	n = dofmt(&f, fmt);
138 	if(n < 0)
139 {
140 fprint(2, "dofmt %s failed\n", fmt);
141 		return nil;
142 }
143 	*(char*)f.to = '\0';
144 
145 	if(argv0 == nil)
146 		fprint(2, "%s: err %d: %s\n", argv0, severity, f.start);
147 	else
148 		fprint(2, "err %d: %s\n", severity, f.start);
149 	return f.start;
150 }
151 
152 void
153 seterr(int severity, char *fmt, ...)
154 {
155 	char *s;
156 	va_list args;
157 
158 	va_start(args, fmt);
159 	s = logit(severity, fmt, args);
160 	va_end(args);
161 	if(s == nil)
162 		werrstr("error setting error");
163 	else{
164 		werrstr("%s", s);
165 		free(s);
166 	}
167 }
168 
169 void
170 logerr(int severity, char *fmt, ...)
171 {
172 	char *s;
173 	va_list args;
174 
175 	va_start(args, fmt);
176 	s = logit(severity, fmt, args);
177 	va_end(args);
178 	free(s);
179 }
180 
181 u32int
182 now(void)
183 {
184 	return time(nil);
185 }
186 
187 void
188 fatal(char *fmt, ...)
189 {
190 	Fmt f;
191 	char buf[256];
192 
193 	f.runes = 0;
194 	f.start = buf;
195 	f.to = buf;
196 	f.stop = buf + sizeof(buf);
197 	f.flush = fmtfdflush;
198 	f.farg = (void*)2;
199 	f.nfmt = 0;
200 	fmtprint(&f, "fatal %s error:", argv0);
201 	va_start(f.args, fmt);
202 	dofmt(&f, fmt);
203 	va_end(f.args);
204 	fmtprint(&f, "\n");
205 	fmtfdflush(&f);
206 	if(0)
207 		abort();
208 	threadexitsall(buf);
209 }
210 
211 ZBlock *
212 alloczblock(u32int size, int zeroed)
213 {
214 	ZBlock *b;
215 	static ZBlock z;
216 
217 	b = malloc(sizeof(ZBlock) + size);
218 	if(b == nil){
219 		seterr(EOk, "out of memory");
220 		return nil;
221 	}
222 
223 	*b = z;
224 	b->data = (u8int*)&b[1];
225 	b->len = size;
226 	if(zeroed)
227 		memset(b->data, 0, size);
228 	return b;
229 }
230 
231 void
232 freezblock(ZBlock *b)
233 {
234 	free(b);
235 }
236 
237 ZBlock*
238 packet2zblock(Packet *p, u32int size)
239 {
240 	ZBlock *b;
241 
242 	if(p == nil)
243 		return nil;
244 	b = alloczblock(size, 0);
245 	if(b == nil)
246 		return nil;
247 	b->len = size;
248 	if(packetcopy(p, b->data, 0, size) < 0){
249 		freezblock(b);
250 		return nil;
251 	}
252 	return b;
253 }
254 
255 Packet*
256 zblock2packet(ZBlock *zb, u32int size)
257 {
258 	Packet *p;
259 
260 	if(zb == nil)
261 		return nil;
262 	p = packetalloc();
263 	packetappend(p, zb->data, size);
264 	return p;
265 }
266 
267 void *
268 emalloc(ulong n)
269 {
270 	void *p;
271 
272 	p = malloc(n);
273 	if(p == nil)
274 		sysfatal("out of memory");
275 	memset(p, 0xa5, n);
276 if(0)print("emalloc %p-%p by %lux\n", p, (char*)p+n, getcallerpc(&n));
277 	return p;
278 }
279 
280 void *
281 ezmalloc(ulong n)
282 {
283 	void *p;
284 
285 	p = malloc(n);
286 	if(p == nil)
287 		sysfatal("out of memory");
288 	memset(p, 0, n);
289 if(0)print("ezmalloc %p-%p by %lux\n", p, (char*)p+n, getcallerpc(&n));
290 	return p;
291 }
292 
293 void *
294 erealloc(void *p, ulong n)
295 {
296 	p = realloc(p, n);
297 	if(p == nil)
298 		sysfatal("out of memory");
299 if(0)print("erealloc %p-%p by %lux\n", p, (char*)p+n, getcallerpc(&p));
300 	return p;
301 }
302 
303 char *
304 estrdup(char *s)
305 {
306 	char *t;
307 	int n;
308 
309 	n = strlen(s) + 1;
310 	t = emalloc(n);
311 	memmove(t, s, n);
312 if(0)print("estrdup %p-%p by %lux\n", t, (char*)t+n, getcallerpc(&s));
313 	return t;
314 }
315 
316 ZBlock*
317 readfile(char *name)
318 {
319 	Part *p;
320 	ZBlock *b;
321 
322 	p = initpart(name, 1);
323 	if(p == nil)
324 		return nil;
325 	b = alloczblock(p->size, 0);
326 	if(b == nil){
327 		seterr(EOk, "can't alloc %s: %r", name);
328 		freepart(p);
329 		return nil;
330 	}
331 	if(readpart(p, 0, b->data, p->size) < 0){
332 		seterr(EOk, "can't read %s: %r", name);
333 		freepart(p);
334 		freezblock(b);
335 		return nil;
336 	}
337 	freepart(p);
338 	return b;
339 }
340 
341 /*
342  * return floor(log2(v))
343  */
344 int
345 u64log2(u64int v)
346 {
347 	int i;
348 
349 	for(i = 0; i < 64; i++)
350 		if((v >> i) <= 1)
351 			break;
352 	return i;
353 }
354 
355 int
356 vtproc(void (*fn)(void*), void *arg)
357 {
358 	proccreate(fn, arg, 256*1024);
359 	return 0;
360 }
361