Annotation of /trunk/mkinitrd-magellan/busybox/libbb/xfuncs.c
Parent Directory | Revision Log
Revision 532 -
(hide annotations)
(download)
Sat Sep 1 22:45:15 2007 UTC (16 years, 8 months ago) by niro
File MIME type: text/plain
File size: 14228 byte(s)
Sat Sep 1 22:45:15 2007 UTC (16 years, 8 months ago) by niro
File MIME type: text/plain
File size: 14228 byte(s)
-import if magellan mkinitrd; it is a fork of redhats mkinitrd-5.0.8 with all magellan patches and features; deprecates magellan-src/mkinitrd
1 | niro | 532 | /* vi: set sw=4 ts=4: */ |
2 | /* | ||
3 | * Utility routines. | ||
4 | * | ||
5 | * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org> | ||
6 | * Copyright (C) 2006 Rob Landley | ||
7 | * Copyright (C) 2006 Denis Vlasenko | ||
8 | * | ||
9 | * Licensed under GPL version 2, see file LICENSE in this tarball for details. | ||
10 | */ | ||
11 | |||
12 | #include "busybox.h" | ||
13 | |||
14 | /* All the functions starting with "x" call bb_error_msg_and_die() if they | ||
15 | * fail, so callers never need to check for errors. If it returned, it | ||
16 | * succeeded. */ | ||
17 | |||
18 | #ifndef DMALLOC | ||
19 | /* dmalloc provides variants of these that do abort() on failure. | ||
20 | * Since dmalloc's prototypes overwrite the impls here as they are | ||
21 | * included after these prototypes in libbb.h, all is well. | ||
22 | */ | ||
23 | // Die if we can't allocate size bytes of memory. | ||
24 | void *xmalloc(size_t size) | ||
25 | { | ||
26 | void *ptr = malloc(size); | ||
27 | if (ptr == NULL && size != 0) | ||
28 | bb_error_msg_and_die(bb_msg_memory_exhausted); | ||
29 | return ptr; | ||
30 | } | ||
31 | |||
32 | // Die if we can't resize previously allocated memory. (This returns a pointer | ||
33 | // to the new memory, which may or may not be the same as the old memory. | ||
34 | // It'll copy the contents to a new chunk and free the old one if necessary.) | ||
35 | void *xrealloc(void *ptr, size_t size) | ||
36 | { | ||
37 | ptr = realloc(ptr, size); | ||
38 | if (ptr == NULL && size != 0) | ||
39 | bb_error_msg_and_die(bb_msg_memory_exhausted); | ||
40 | return ptr; | ||
41 | } | ||
42 | #endif /* DMALLOC */ | ||
43 | |||
44 | // Die if we can't allocate and zero size bytes of memory. | ||
45 | void *xzalloc(size_t size) | ||
46 | { | ||
47 | void *ptr = xmalloc(size); | ||
48 | memset(ptr, 0, size); | ||
49 | return ptr; | ||
50 | } | ||
51 | |||
52 | // Die if we can't copy a string to freshly allocated memory. | ||
53 | char * xstrdup(const char *s) | ||
54 | { | ||
55 | char *t; | ||
56 | |||
57 | if (s == NULL) | ||
58 | return NULL; | ||
59 | |||
60 | t = strdup(s); | ||
61 | |||
62 | if (t == NULL) | ||
63 | bb_error_msg_and_die(bb_msg_memory_exhausted); | ||
64 | |||
65 | return t; | ||
66 | } | ||
67 | |||
68 | // Die if we can't allocate n+1 bytes (space for the null terminator) and copy | ||
69 | // the (possibly truncated to length n) string into it. | ||
70 | char * xstrndup(const char *s, int n) | ||
71 | { | ||
72 | int m; | ||
73 | char *t; | ||
74 | |||
75 | if (ENABLE_DEBUG && s == NULL) | ||
76 | bb_error_msg_and_die("xstrndup bug"); | ||
77 | |||
78 | /* We can just xmalloc(n+1) and strncpy into it, */ | ||
79 | /* but think about xstrndup("abc", 10000) wastage! */ | ||
80 | m = n; | ||
81 | t = (char*) s; | ||
82 | while (m) { | ||
83 | if (!*t) break; | ||
84 | m--; | ||
85 | t++; | ||
86 | } | ||
87 | n -= m; | ||
88 | t = xmalloc(n + 1); | ||
89 | t[n] = '\0'; | ||
90 | |||
91 | return memcpy(t, s, n); | ||
92 | } | ||
93 | |||
94 | // Die if we can't open a file and return a FILE * to it. | ||
95 | // Notice we haven't got xfread(), This is for use with fscanf() and friends. | ||
96 | FILE *xfopen(const char *path, const char *mode) | ||
97 | { | ||
98 | FILE *fp = fopen(path, mode); | ||
99 | if (fp == NULL) | ||
100 | bb_perror_msg_and_die("%s", path); | ||
101 | return fp; | ||
102 | } | ||
103 | |||
104 | // Die if we can't open an existing file and return an fd. | ||
105 | int xopen(const char *pathname, int flags) | ||
106 | { | ||
107 | //if (ENABLE_DEBUG && (flags & O_CREAT)) | ||
108 | // bb_error_msg_and_die("xopen() with O_CREAT"); | ||
109 | |||
110 | return xopen3(pathname, flags, 0666); | ||
111 | } | ||
112 | |||
113 | // Die if we can't open a new file and return an fd. | ||
114 | int xopen3(const char *pathname, int flags, int mode) | ||
115 | { | ||
116 | int ret; | ||
117 | |||
118 | ret = open(pathname, flags, mode); | ||
119 | if (ret < 0) { | ||
120 | bb_perror_msg_and_die("%s", pathname); | ||
121 | } | ||
122 | return ret; | ||
123 | } | ||
124 | |||
125 | // Turn on nonblocking I/O on a fd | ||
126 | int ndelay_on(int fd) | ||
127 | { | ||
128 | return fcntl(fd,F_SETFL,fcntl(fd,F_GETFL,0) | O_NONBLOCK); | ||
129 | } | ||
130 | |||
131 | int ndelay_off(int fd) | ||
132 | { | ||
133 | return fcntl(fd,F_SETFL,fcntl(fd,F_GETFL,0) & ~O_NONBLOCK); | ||
134 | } | ||
135 | |||
136 | // Die with an error message if we can't write the entire buffer. | ||
137 | void xwrite(int fd, const void *buf, size_t count) | ||
138 | { | ||
139 | if (count) { | ||
140 | ssize_t size = full_write(fd, buf, count); | ||
141 | if (size != count) | ||
142 | bb_error_msg_and_die("short write"); | ||
143 | } | ||
144 | } | ||
145 | |||
146 | // Die with an error message if we can't lseek to the right spot. | ||
147 | off_t xlseek(int fd, off_t offset, int whence) | ||
148 | { | ||
149 | off_t off = lseek(fd, offset, whence); | ||
150 | if (off == (off_t)-1) { | ||
151 | if (whence == SEEK_SET) | ||
152 | bb_perror_msg_and_die("lseek(%"OFF_FMT"u)", offset); | ||
153 | bb_perror_msg_and_die("lseek"); | ||
154 | } | ||
155 | return off; | ||
156 | } | ||
157 | |||
158 | // Die with supplied filename if this FILE * has ferror set. | ||
159 | void die_if_ferror(FILE *fp, const char *fn) | ||
160 | { | ||
161 | if (ferror(fp)) { | ||
162 | bb_error_msg_and_die("%s: I/O error", fn); | ||
163 | } | ||
164 | } | ||
165 | |||
166 | // Die with an error message if stdout has ferror set. | ||
167 | void die_if_ferror_stdout(void) | ||
168 | { | ||
169 | die_if_ferror(stdout, bb_msg_standard_output); | ||
170 | } | ||
171 | |||
172 | // Die with an error message if we have trouble flushing stdout. | ||
173 | void xfflush_stdout(void) | ||
174 | { | ||
175 | if (fflush(stdout)) { | ||
176 | bb_perror_msg_and_die(bb_msg_standard_output); | ||
177 | } | ||
178 | } | ||
179 | |||
180 | // This does a fork/exec in one call, using vfork(). Return PID of new child, | ||
181 | // -1 for failure. Runs argv[0], searching path if that has no / in it. | ||
182 | pid_t spawn(char **argv) | ||
183 | { | ||
184 | /* Why static? */ | ||
185 | static int failed; | ||
186 | pid_t pid; | ||
187 | void *app = ENABLE_FEATURE_SH_STANDALONE_SHELL ? find_applet_by_name(argv[0]) : 0; | ||
188 | |||
189 | // Be nice to nommu machines. | ||
190 | failed = 0; | ||
191 | pid = vfork(); | ||
192 | if (pid < 0) return pid; | ||
193 | if (!pid) { | ||
194 | execvp(app ? CONFIG_BUSYBOX_EXEC_PATH : *argv, argv); | ||
195 | |||
196 | // We're sharing a stack with blocked parent, let parent know we failed | ||
197 | // and then exit to unblock parent (but don't run atexit() stuff, which | ||
198 | // would screw up parent.) | ||
199 | |||
200 | failed = errno; | ||
201 | _exit(0); | ||
202 | } | ||
203 | if (failed) { | ||
204 | errno = failed; | ||
205 | return -1; | ||
206 | } | ||
207 | return pid; | ||
208 | } | ||
209 | |||
210 | // Die with an error message if we can't spawn a child process. | ||
211 | pid_t xspawn(char **argv) | ||
212 | { | ||
213 | pid_t pid = spawn(argv); | ||
214 | if (pid < 0) bb_perror_msg_and_die("%s", *argv); | ||
215 | return pid; | ||
216 | } | ||
217 | |||
218 | // Wait for the specified child PID to exit, returning child's error return. | ||
219 | int wait4pid(int pid) | ||
220 | { | ||
221 | int status; | ||
222 | |||
223 | if (pid == -1 || waitpid(pid, &status, 0) == -1) return -1; | ||
224 | if (WIFEXITED(status)) return WEXITSTATUS(status); | ||
225 | if (WIFSIGNALED(status)) return WTERMSIG(status); | ||
226 | return 0; | ||
227 | } | ||
228 | |||
229 | void xsetenv(const char *key, const char *value) | ||
230 | { | ||
231 | if (setenv(key, value, 1)) | ||
232 | bb_error_msg_and_die(bb_msg_memory_exhausted); | ||
233 | } | ||
234 | |||
235 | // Converts unsigned long long value into compact 4-char | ||
236 | // representation. Examples: "1234", "1.2k", " 27M", "123T" | ||
237 | // Fifth char is always '\0' | ||
238 | void smart_ulltoa5(unsigned long long ul, char buf[5]) | ||
239 | { | ||
240 | char *fmt; | ||
241 | char c; | ||
242 | unsigned v,idx = 0; | ||
243 | ul *= 10; | ||
244 | if (ul > 9999*10) { // do not scale if 9999 or less | ||
245 | while (ul >= 10000) { | ||
246 | ul /= 1024; | ||
247 | idx++; | ||
248 | } | ||
249 | } | ||
250 | v = ul; // ullong divisions are expensive, avoid them | ||
251 | |||
252 | fmt = " 123456789"; | ||
253 | if (!idx) { // 9999 or less: use 1234 format | ||
254 | c = buf[0] = " 123456789"[v/10000]; | ||
255 | if (c!=' ') fmt = "0123456789"; | ||
256 | c = buf[1] = fmt[v/1000%10]; | ||
257 | if (c!=' ') fmt = "0123456789"; | ||
258 | buf[2] = fmt[v/100%10]; | ||
259 | buf[3] = "0123456789"[v/10%10]; | ||
260 | } else { | ||
261 | if (v>=10*10) { // scaled value is >=10: use 123M format | ||
262 | c = buf[0] = " 123456789"[v/1000]; | ||
263 | if (c!=' ') fmt = "0123456789"; | ||
264 | buf[1] = fmt[v/100%10]; | ||
265 | buf[2] = "0123456789"[v/10%10]; | ||
266 | } else { // scaled value is <10: use 1.2M format | ||
267 | buf[0] = "0123456789"[v/10]; | ||
268 | buf[1] = '.'; | ||
269 | buf[2] = "0123456789"[v%10]; | ||
270 | } | ||
271 | // see http://en.wikipedia.org/wiki/Tera | ||
272 | buf[3] = " kMGTPEZY"[idx]; | ||
273 | } | ||
274 | buf[4] = '\0'; | ||
275 | } | ||
276 | |||
277 | // Convert unsigned integer to ascii, writing into supplied buffer. A | ||
278 | // truncated result is always null terminated (unless buflen is 0), and | ||
279 | // contains the first few digits of the result ala strncpy. | ||
280 | void BUG_sizeof_unsigned_not_4(void); | ||
281 | void utoa_to_buf(unsigned n, char *buf, unsigned buflen) | ||
282 | { | ||
283 | unsigned i, out, res; | ||
284 | if (sizeof(unsigned) != 4) | ||
285 | BUG_sizeof_unsigned_not_4(); | ||
286 | if (buflen) { | ||
287 | out = 0; | ||
288 | for (i = 1000000000; i; i /= 10) { | ||
289 | res = n / i; | ||
290 | if (res || out || i == 1) { | ||
291 | if (!--buflen) break; | ||
292 | out++; | ||
293 | n -= res*i; | ||
294 | *buf++ = '0' + res; | ||
295 | } | ||
296 | } | ||
297 | *buf = '\0'; | ||
298 | } | ||
299 | } | ||
300 | |||
301 | // Convert signed integer to ascii, like utoa_to_buf() | ||
302 | void itoa_to_buf(int n, char *buf, unsigned buflen) | ||
303 | { | ||
304 | if (buflen && n<0) { | ||
305 | n = -n; | ||
306 | *buf++ = '-'; | ||
307 | buflen--; | ||
308 | } | ||
309 | utoa_to_buf((unsigned)n, buf, buflen); | ||
310 | } | ||
311 | |||
312 | // The following two functions use a static buffer, so calling either one a | ||
313 | // second time will overwrite previous results. | ||
314 | // | ||
315 | // The largest 32 bit integer is -2 billion plus null terminator, or 12 bytes. | ||
316 | // Int should always be 32 bits on any remotely Unix-like system, see | ||
317 | // http://www.unix.org/whitepapers/64bit.html for the reasons why. | ||
318 | |||
319 | static char local_buf[12]; | ||
320 | |||
321 | // Convert unsigned integer to ascii using a static buffer (returned). | ||
322 | char *utoa(unsigned n) | ||
323 | { | ||
324 | utoa_to_buf(n, local_buf, sizeof(local_buf)); | ||
325 | |||
326 | return local_buf; | ||
327 | } | ||
328 | |||
329 | // Convert signed integer to ascii using a static buffer (returned). | ||
330 | char *itoa(int n) | ||
331 | { | ||
332 | itoa_to_buf(n, local_buf, sizeof(local_buf)); | ||
333 | |||
334 | return local_buf; | ||
335 | } | ||
336 | |||
337 | // Emit a string of hex representation of bytes | ||
338 | char *bin2hex(char *p, const char *cp, int count) | ||
339 | { | ||
340 | while (count) { | ||
341 | unsigned char c = *cp++; | ||
342 | /* put lowercase hex digits */ | ||
343 | *p++ = 0x20 | bb_hexdigits_upcase[c >> 4]; | ||
344 | *p++ = 0x20 | bb_hexdigits_upcase[c & 0xf]; | ||
345 | count--; | ||
346 | } | ||
347 | return p; | ||
348 | } | ||
349 | |||
350 | // Die with an error message if we can't set gid. (Because resource limits may | ||
351 | // limit this user to a given number of processes, and if that fills up the | ||
352 | // setgid() will fail and we'll _still_be_root_, which is bad.) | ||
353 | void xsetgid(gid_t gid) | ||
354 | { | ||
355 | if (setgid(gid)) bb_error_msg_and_die("setgid"); | ||
356 | } | ||
357 | |||
358 | // Die with an error message if we can't set uid. (See xsetgid() for why.) | ||
359 | void xsetuid(uid_t uid) | ||
360 | { | ||
361 | if (setuid(uid)) bb_error_msg_and_die("setuid"); | ||
362 | } | ||
363 | |||
364 | // Return how long the file at fd is, if there's any way to determine it. | ||
365 | off_t fdlength(int fd) | ||
366 | { | ||
367 | off_t bottom = 0, top = 0, pos; | ||
368 | long size; | ||
369 | |||
370 | // If the ioctl works for this, return it. | ||
371 | |||
372 | if (ioctl(fd, BLKGETSIZE, &size) >= 0) return size*512; | ||
373 | |||
374 | // FIXME: explain why lseek(SEEK_END) is not used here! | ||
375 | |||
376 | // If not, do a binary search for the last location we can read. (Some | ||
377 | // block devices don't do BLKGETSIZE right.) | ||
378 | |||
379 | do { | ||
380 | char temp; | ||
381 | |||
382 | pos = bottom + (top - bottom) / 2; | ||
383 | |||
384 | // If we can read from the current location, it's bigger. | ||
385 | |||
386 | if (lseek(fd, pos, SEEK_SET)>=0 && safe_read(fd, &temp, 1)==1) { | ||
387 | if (bottom == top) bottom = top = (top+1) * 2; | ||
388 | else bottom = pos; | ||
389 | |||
390 | // If we can't, it's smaller. | ||
391 | |||
392 | } else { | ||
393 | if (bottom == top) { | ||
394 | if (!top) return 0; | ||
395 | bottom = top/2; | ||
396 | } | ||
397 | else top = pos; | ||
398 | } | ||
399 | } while (bottom + 1 != top); | ||
400 | |||
401 | return pos + 1; | ||
402 | } | ||
403 | |||
404 | // Die with an error message if we can't malloc() enough space and do an | ||
405 | // sprintf() into that space. | ||
406 | char *xasprintf(const char *format, ...) | ||
407 | { | ||
408 | va_list p; | ||
409 | int r; | ||
410 | char *string_ptr; | ||
411 | |||
412 | #if 1 | ||
413 | // GNU extension | ||
414 | va_start(p, format); | ||
415 | r = vasprintf(&string_ptr, format, p); | ||
416 | va_end(p); | ||
417 | #else | ||
418 | // Bloat for systems that haven't got the GNU extension. | ||
419 | va_start(p, format); | ||
420 | r = vsnprintf(NULL, 0, format, p); | ||
421 | va_end(p); | ||
422 | string_ptr = xmalloc(r+1); | ||
423 | va_start(p, format); | ||
424 | r = vsnprintf(string_ptr, r+1, format, p); | ||
425 | va_end(p); | ||
426 | #endif | ||
427 | |||
428 | if (r < 0) bb_error_msg_and_die(bb_msg_memory_exhausted); | ||
429 | return string_ptr; | ||
430 | } | ||
431 | |||
432 | #if 0 /* If we will ever meet a libc which hasn't [f]dprintf... */ | ||
433 | int fdprintf(int fd, const char *format, ...) | ||
434 | { | ||
435 | va_list p; | ||
436 | int r; | ||
437 | char *string_ptr; | ||
438 | |||
439 | #if 1 | ||
440 | // GNU extension | ||
441 | va_start(p, format); | ||
442 | r = vasprintf(&string_ptr, format, p); | ||
443 | va_end(p); | ||
444 | #else | ||
445 | // Bloat for systems that haven't got the GNU extension. | ||
446 | va_start(p, format); | ||
447 | r = vsnprintf(NULL, 0, format, p); | ||
448 | va_end(p); | ||
449 | string_ptr = xmalloc(r+1); | ||
450 | va_start(p, format); | ||
451 | r = vsnprintf(string_ptr, r+1, format, p); | ||
452 | va_end(p); | ||
453 | #endif | ||
454 | |||
455 | if (r >= 0) { | ||
456 | full_write(fd, string_ptr, r); | ||
457 | free(string_ptr); | ||
458 | } | ||
459 | return r; | ||
460 | } | ||
461 | #endif | ||
462 | |||
463 | // Die with an error message if we can't copy an entire FILE * to stdout, then | ||
464 | // close that file. | ||
465 | void xprint_and_close_file(FILE *file) | ||
466 | { | ||
467 | fflush(stdout); | ||
468 | // copyfd outputs error messages for us. | ||
469 | if (bb_copyfd_eof(fileno(file), 1) == -1) | ||
470 | exit(xfunc_error_retval); | ||
471 | |||
472 | fclose(file); | ||
473 | } | ||
474 | |||
475 | // Die if we can't chdir to a new path. | ||
476 | void xchdir(const char *path) | ||
477 | { | ||
478 | if (chdir(path)) | ||
479 | bb_perror_msg_and_die("chdir(%s)", path); | ||
480 | } | ||
481 | |||
482 | // Print a warning message if opendir() fails, but don't die. | ||
483 | DIR *warn_opendir(const char *path) | ||
484 | { | ||
485 | DIR *dp; | ||
486 | |||
487 | if ((dp = opendir(path)) == NULL) { | ||
488 | bb_perror_msg("cannot open '%s'", path); | ||
489 | return NULL; | ||
490 | } | ||
491 | return dp; | ||
492 | } | ||
493 | |||
494 | // Die with an error message if opendir() fails. | ||
495 | DIR *xopendir(const char *path) | ||
496 | { | ||
497 | DIR *dp; | ||
498 | |||
499 | if ((dp = opendir(path)) == NULL) | ||
500 | bb_perror_msg_and_die("cannot open '%s'", path); | ||
501 | return dp; | ||
502 | } | ||
503 | |||
504 | #ifndef BB_NOMMU | ||
505 | // Die with an error message if we can't daemonize. | ||
506 | void xdaemon(int nochdir, int noclose) | ||
507 | { | ||
508 | if (daemon(nochdir, noclose)) | ||
509 | bb_perror_msg_and_die("daemon"); | ||
510 | } | ||
511 | #endif | ||
512 | |||
513 | void bb_sanitize_stdio_maybe_daemonize(int daemonize) | ||
514 | { | ||
515 | int fd; | ||
516 | /* Mega-paranoid */ | ||
517 | fd = xopen(bb_dev_null, O_RDWR); | ||
518 | while (fd < 2) | ||
519 | fd = dup(fd); /* have 0,1,2 open at least to /dev/null */ | ||
520 | if (daemonize) { | ||
521 | pid_t pid = fork(); | ||
522 | if (pid < 0) /* wtf? */ | ||
523 | bb_perror_msg_and_die("fork"); | ||
524 | if (pid) /* parent */ | ||
525 | exit(0); | ||
526 | /* child */ | ||
527 | /* if daemonizing, make sure we detach from stdio */ | ||
528 | setsid(); | ||
529 | dup2(fd, 0); | ||
530 | dup2(fd, 1); | ||
531 | dup2(fd, 2); | ||
532 | } | ||
533 | while (fd > 2) | ||
534 | close(fd--); /* close everything after fd#2 */ | ||
535 | } | ||
536 | void bb_sanitize_stdio(void) | ||
537 | { | ||
538 | bb_sanitize_stdio_maybe_daemonize(0); | ||
539 | } | ||
540 | void bb_daemonize(void) | ||
541 | { | ||
542 | bb_sanitize_stdio_maybe_daemonize(1); | ||
543 | } | ||
544 | |||
545 | // Die with an error message if we can't open a new socket. | ||
546 | int xsocket(int domain, int type, int protocol) | ||
547 | { | ||
548 | int r = socket(domain, type, protocol); | ||
549 | |||
550 | if (r < 0) bb_perror_msg_and_die("socket"); | ||
551 | |||
552 | return r; | ||
553 | } | ||
554 | |||
555 | // Die with an error message if we can't bind a socket to an address. | ||
556 | void xbind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen) | ||
557 | { | ||
558 | if (bind(sockfd, my_addr, addrlen)) bb_perror_msg_and_die("bind"); | ||
559 | } | ||
560 | |||
561 | // Die with an error message if we can't listen for connections on a socket. | ||
562 | void xlisten(int s, int backlog) | ||
563 | { | ||
564 | if (listen(s, backlog)) bb_perror_msg_and_die("listen"); | ||
565 | } | ||
566 | |||
567 | // xstat() - a stat() which dies on failure with meaningful error message | ||
568 | void xstat(char *name, struct stat *stat_buf) | ||
569 | { | ||
570 | if (stat(name, stat_buf)) | ||
571 | bb_perror_msg_and_die("can't stat '%s'", name); | ||
572 | } | ||
573 | |||
574 | /* It is perfectly ok to pass in a NULL for either width or for | ||
575 | * height, in which case that value will not be set. */ | ||
576 | int get_terminal_width_height(int fd, int *width, int *height) | ||
577 | { | ||
578 | struct winsize win = { 0, 0, 0, 0 }; | ||
579 | int ret = ioctl(fd, TIOCGWINSZ, &win); | ||
580 | |||
581 | if (height) { | ||
582 | if (!win.ws_row) { | ||
583 | char *s = getenv("LINES"); | ||
584 | if (s) win.ws_row = atoi(s); | ||
585 | } | ||
586 | if (win.ws_row <= 1 || win.ws_row >= 30000) | ||
587 | win.ws_row = 24; | ||
588 | *height = (int) win.ws_row; | ||
589 | } | ||
590 | |||
591 | if (width) { | ||
592 | if (!win.ws_col) { | ||
593 | char *s = getenv("COLUMNS"); | ||
594 | if (s) win.ws_col = atoi(s); | ||
595 | } | ||
596 | if (win.ws_col <= 1 || win.ws_col >= 30000) | ||
597 | win.ws_col = 80; | ||
598 | *width = (int) win.ws_col; | ||
599 | } | ||
600 | |||
601 | return ret; | ||
602 | } |