lib/libstand/stand.h

   1 /*
   2  * Copyright (c) 1998 Michael Smith.
   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 THE 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 THE 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  * $FreeBSD: src/lib/libstand/stand.h,v 1.18.2.8 2002/06/17 11:22:39 sobomax Exp $
  27  * $DragonFly: src/lib/libstand/stand.h,v 1.11 2008/09/13 11:38:58 corecode Exp $
  28  * From $NetBSD: stand.h,v 1.22 1997/06/26 19:17:40 drochner Exp $
  29  */
  30
  31 /*-
  32  * Copyright (c) 1993
  33  *      The Regents of the University of California.  All rights reserved.
  34  *
  35  * Redistribution and use in source and binary forms, with or without
  36  * modification, are permitted provided that the following conditions
  37  * are met:
  38  * 1. Redistributions of source code must retain the above copyright
  39  *    notice, this list of conditions and the following disclaimer.
  40  * 2. Redistributions in binary form must reproduce the above copyright
  41  *    notice, this list of conditions and the following disclaimer in the
  42  *    documentation and/or other materials provided with the distribution.
  43  * 3. All advertising materials mentioning features or use of this software
  44  *    must display the following acknowledgement:
  45  *      This product includes software developed by the University of
  46  *      California, Berkeley and its contributors.
  47  * 4. Neither the name of the University nor the names of its contributors
  48  *    may be used to endorse or promote products derived from this software
  49  *    without specific prior written permission.
  50  *
  51  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  52  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  53  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  54  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  55  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  56  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  57  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  58  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  59  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  60  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  61  * SUCH DAMAGE.
  62  *
  63  *      @(#)stand.h     8.1 (Berkeley) 6/11/93
  64  */
  65
  66 #ifndef _MACHINE_STDARG_H_
  67 #include <machine/stdarg.h>     /* __va_list */
  68 #endif
  69 #include <sys/types.h>
  70 #include <sys/cdefs.h>
  71 #include <sys/stat.h>
  72 #include <sys/dirent.h>
  73 #include <string.h>
  74
  75 #define CHK(fmt, args...)       printf("%s(%d): " fmt "\n", __func__, __LINE__ , ##args)
  76 #define PCHK(fmt, args...)      {printf("%s(%d): " fmt "\n", __func__, __LINE__ , ##args); getchar();}
  77
  78 /* Avoid unwanted userlandish components */
  79 #define _KERNEL
  80 #include <sys/errno.h>
  81 #undef _KERNEL
  82
  83 /* special stand error codes */
  84 #define EADAPT  (ELAST+1)       /* bad adaptor */
  85 #define ECTLR   (ELAST+2)       /* bad controller */
  86 #define EUNIT   (ELAST+3)       /* bad unit */
  87 #define ESLICE  (ELAST+4)       /* bad slice */
  88 #define EPART   (ELAST+5)       /* bad partition */
  89 #define ERDLAB  (ELAST+6)       /* can't read disk label */
  90 #define EUNLAB  (ELAST+7)       /* unlabeled disk */
  91 #define EOFFSET (ELAST+8)       /* relative seek not supported */
  92 #define ESALAST (ELAST+8)       /* */
  93
  94 struct open_file;
  95
  96 /*
  97  * This structure is used to define file system operations in a file system
  98  * independent way.
  99  *
 100  * XXX note that filesystem providers should export a pointer to their fs_ops
 101  *     struct, so that consumers can reference this and thus include the
 102  *     filesystems that they require.
 103  */
 104 struct fs_ops {
 105     const char  *fs_name;
 106     int         (*fo_open)(const char *, struct open_file *);
 107     int         (*fo_close)(struct open_file *);
 108     int         (*fo_read)(struct open_file *, void *,
 109                            size_t, size_t *);
 110     int         (*fo_write)(struct open_file *, void *,
 111                             size_t, size_t *);
 112     off_t       (*fo_seek)(struct open_file *, off_t, int);
 113     int         (*fo_stat)(struct open_file *, struct stat *);
 114     int         (*fo_readdir)(struct open_file *, struct dirent *);
 115 };
 116
 117 /*
 118  * libstand-supplied filesystems
 119  */
 120 extern struct fs_ops ufs_fsops;
 121 extern struct fs_ops hammer_fsops;
 122 extern struct fs_ops tftp_fsops;
 123 extern struct fs_ops nfs_fsops;
 124 extern struct fs_ops cd9660_fsops;
 125 extern struct fs_ops gzipfs_fsops;
 126 extern struct fs_ops zipfs_fsops;
 127 extern struct fs_ops bzipfs_fsops;
 128 extern struct fs_ops dosfs_fsops;
 129 extern struct fs_ops ext2fs_fsops;
 130 extern struct fs_ops splitfs_fsops;
 131
 132 /* where values for lseek(2) */
 133 #define SEEK_SET        0       /* set file offset to offset */
 134 #define SEEK_CUR        1       /* set file offset to current plus offset */
 135 #define SEEK_END        2       /* set file offset to EOF plus offset */
 136
 137 /*
 138  * Device switch
 139  */
 140 struct devsw {
 141     const char  dv_name[8];
 142     int         dv_type;                /* opaque type constant, arch-dependant */
 143     int         (*dv_init)(void);       /* early probe call */
 144     int         (*dv_strategy)(void *, int, daddr_t, size_t, char *, size_t *);
 145     int         (*dv_open)(struct open_file *, ...);
 146     int         (*dv_close)(struct open_file *);
 147     int         (*dv_ioctl)(struct open_file *, u_long, void *);
 148     void        (*dv_print)(int);       /* print device information */
 149     void        (*dv_cleanup)(void);
 150 };
 151
 152 /*
 153  * libstand-supplied device switch
 154  */
 155 extern struct devsw netdev;
 156
 157 extern int errno;
 158
 159 struct open_file {
 160     int                 f_flags;        /* see F_* below */
 161     struct devsw        *f_dev;         /* pointer to device operations */
 162     void                *f_devdata;     /* device specific data */
 163     struct fs_ops       *f_ops;         /* pointer to file system operations */
 164     void                *f_fsdata;      /* file system specific data */
 165     off_t               f_offset;       /* current file offset */
 166     char                *f_rabuf;       /* readahead buffer pointer */
 167     size_t              f_ralen;        /* valid data in readahead buffer */
 168     off_t               f_raoffset;     /* consumer offset in readahead buffer */
 169 #define SOPEN_RASIZE    512
 170 };
 171
 172 #define SOPEN_MAX       8
 173 extern struct open_file files[];
 174
 175 /* f_flags values */
 176 #define F_READ          0x0001  /* file opened for reading */
 177 #define F_WRITE         0x0002  /* file opened for writing */
 178 #define F_RAW           0x0004  /* raw device open - no file system */
 179 #define F_NODEV         0x0008  /* network open - no device */
 180
 181 #define isascii(c)      (((c) & ~0x7F) == 0)
 182
 183 static __inline int
 184 isupper(int c)
 185 {
 186     return c >= 'A' && c <= 'Z';
 187 }
 188
 189 static __inline int
 190 islower(int c)
 191 {
 192     return c >= 'a' && c <= 'z';
 193 }
 194
 195 static __inline int
 196 isspace(int c)
 197 {
 198     return c == ' ' || (c >= 0x9 && c <= 0xd);
 199 }
 200
 201 static __inline int
 202 isdigit(int c)
 203 {
 204     return c >= '0' && c <= '9';
 205 }
 206
 207 static __inline int
 208 isxdigit(int c)
 209 {
 210     return isdigit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
 211 }
 212
 213 static __inline int
 214 isalpha(int c)
 215 {
 216     return isupper(c) || islower(c);
 217 }
 218
 219 static __inline int
 220 isalnum(int c)
 221 {
 222     return isalpha(c) || isdigit(c);
 223 }
 224
 225 static __inline int
 226 toupper(int c)
 227 {
 228     return islower(c) ? c - 'a' + 'A' : c;
 229 }
 230
 231 static __inline int
 232 tolower(int c)
 233 {
 234     return isupper(c) ? c - 'A' + 'a' : c;
 235 }
 236
 237 /* sbrk emulation */
 238 extern void     setheap(void *, void *);
 239 extern char     *sbrk(int);
 240
 241 /* Matt Dillon's zalloc/zmalloc */
 242 extern void     *malloc(size_t);
 243 extern void     free(void *);
 244 /*#define free(p)       {CHK("free %p", p); free(p);} */ /* use for catching guard violations */
 245 extern void     *calloc(size_t, size_t);
 246 extern void     *realloc(void *, size_t);
 247 extern void     *reallocf(void *, size_t);
 248 extern void     mallocstats(void);
 249
 250 /* disklabel support (undocumented, may be junk) */
 251 struct          disklabel32;
 252 extern char     *getdisklabel32(const char *, struct disklabel32 *);
 253
 254 extern int      printf(const char *, ...) __printflike(1, 2);
 255 extern void     vprintf(const char *, __va_list) __printflike(1, 0);
 256 extern int      sprintf(char *, const char *, ...) __printflike(2, 3);
 257 extern void     vsprintf(char *, const char *, __va_list) __printflike(2, 0);
 258 int             snprintf(char *, size_t, const char *, ...) __printflike(3, 4);
 259 int             vsnprintf(char *, size_t, const char *, __va_list)
 260                     __printflike(3, 0);
 261
 262 extern void     twiddle(void);
 263
 264 extern void     ngets(char *, int);
 265 #define gets(x) ngets((x), 0)
 266 extern int      fgetstr(char *, int, int);
 267
 268 extern int      open(const char *, int);
 269 #define O_RDONLY        0x0
 270 #define O_WRONLY        0x1                     /* writing not (yet?) supported */
 271 #define O_RDWR          0x2
 272 extern int      close(int);
 273 extern void     closeall(void);
 274 extern ssize_t  read(int, void *, size_t);
 275 extern ssize_t  write(int, void *, size_t);
 276 extern struct   dirent *readdirfd(int);
 277
 278 extern void     srandom(u_long);
 279 extern u_long   random(void);
 280
 281 extern void     exit(int);
 282
 283 /* imports from stdlib, locally modified */
 284 extern long     strtol(const char *, char **, int);
 285 extern char     *optarg;                        /* getopt(3) external variables */
 286 extern int      optind, opterr, optopt, optreset;
 287 extern int      getopt(int, char * const [], const char *);
 288
 289 /* pager.c */
 290 extern void     pager_open(void);
 291 extern void     pager_close(void);
 292 extern int      pager_output(const char *);
 293 extern int      pager_file(const char *);
 294
 295 /* No signal state to preserve */
 296 #define setjmp  _setjmp
 297 #define longjmp _longjmp
 298
 299 /* environment.c */
 300 #define EV_DYNAMIC      (1<<0)          /* value was dynamically allocated, free if changed/unset */
 301 #define EV_VOLATILE     (1<<1)          /* value is volatile, make a copy of it */
 302 #define EV_NOHOOK       (1<<2)          /* don't call hook when setting */
 303
 304 struct env_var;
 305 typedef char    *(ev_format_t)(struct env_var *);
 306 typedef int     (ev_sethook_t)(struct env_var *, int, const void *);
 307 typedef int     (ev_unsethook_t)(struct env_var *);
 308
 309 struct env_var
 310 {
 311     char                *ev_name;
 312     int                 ev_flags;
 313     void                *ev_value;
 314     ev_sethook_t        *ev_sethook;
 315     ev_unsethook_t      *ev_unsethook;
 316     struct env_var      *ev_next, *ev_prev;
 317 };
 318 extern struct env_var   *environ;
 319
 320 extern struct env_var   *env_getenv(const char *);
 321 extern int              env_setenv(const char *, int, const void *, ev_sethook_t,
 322                                    ev_unsethook_t);
 323 extern char             *getenv(const char *);
 324 extern int              setenv(const char *, const char *, int);
 325 extern int              putenv(const char *);
 326 extern int              unsetenv(const char *);
 327
 328 extern ev_sethook_t     env_noset;              /* refuse set operation */
 329 extern ev_unsethook_t   env_nounset;            /* refuse unset operation */
 330
 331 /* BCD conversions (undocumented) */
 332 extern u_char const     bcd2bin_data[];
 333 extern u_char const     bin2bcd_data[];
 334 extern char const       hex2ascii_data[];
 335
 336 #define bcd2bin(bcd)    (bcd2bin_data[bcd])
 337 #define bin2bcd(bin)    (bin2bcd_data[bin])
 338 #define hex2ascii(hex)  (hex2ascii_data[hex])
 339
 340 /* min/max (undocumented) */
 341 static __inline int imax(int a, int b) { return (a > b ? a : b); }
 342 static __inline int imin(int a, int b) { return (a < b ? a : b); }
 343 static __inline long lmax(long a, long b) { return (a > b ? a : b); }
 344 static __inline long lmin(long a, long b) { return (a < b ? a : b); }
 345 static __inline u_int max(u_int a, u_int b) { return (a > b ? a : b); }
 346 static __inline u_int min(u_int a, u_int b) { return (a < b ? a : b); }
 347 static __inline quad_t qmax(quad_t a, quad_t b) { return (a > b ? a : b); }
 348 static __inline quad_t qmin(quad_t a, quad_t b) { return (a < b ? a : b); }
 349 static __inline u_long ulmax(u_long a, u_long b) { return (a > b ? a : b); }
 350 static __inline u_long ulmin(u_long a, u_long b) { return (a < b ? a : b); }
 351 static __inline size_t szmax(size_t a, size_t b) { return (a > b ? a : b); }
 352 static __inline size_t szmin(size_t a, size_t b) { return (a < b ? a : b); }
 353
 354 /* swaps (undocumented, useful?) */
 355 #ifdef __i386__
 356 extern u_int32_t        bswap32(u_int32_t);
 357 extern u_int64_t        bswap64(u_int64_t);
 358 #endif
 359
 360 /* null functions for device/filesystem switches (undocumented) */
 361 extern int      nodev(void);
 362 extern int      noioctl(struct open_file *, u_long, void *);
 363 extern void     nullsys(void);
 364
 365 extern int      null_open(const char *, struct open_file *);
 366 extern int      null_close(struct open_file *);
 367 extern int      null_read(struct open_file *, void *, size_t, size_t *);
 368 extern int      null_write(struct open_file *, void *, size_t, size_t *);
 369 extern off_t    null_seek(struct open_file *, off_t, int);
 370 extern int      null_stat(struct open_file *, struct stat *);
 371 extern int      null_readdir(struct open_file *, struct dirent *);
 372
 373
 374 /*
 375  * Machine dependent functions and data, must be provided or stubbed by
 376  * the consumer
 377  */
 378 extern int              getchar(void);
 379 extern int              ischar(void);
 380 extern void             putchar(int);
 381 extern int              devopen(struct open_file *, const char *, const char **);
 382 extern int              devclose(struct open_file *);
 383 extern void             panic(const char *, ...) __dead2 __printflike(1, 2);
 384 extern struct fs_ops    *file_system[];
 385 extern struct devsw     *devsw[];
 386
 387 #if 0
 388
 389 static inline void *
 390 malloc_debug(size_t size, const char *file, int line)
 391 {
 392     void *p;
 393     printf("%s:%d malloc(%ld)", file, line, size);
 394     p = malloc(size);
 395     printf("=%p\n", p);
 396     return p;
 397 }
 398
 399 static inline void
 400 free_debug(void *p, const char *file, int line)
 401 {
 402     printf("%s:%d free(%p)\n", file, line, p);
 403     free(p);
 404 }
 405
 406 #define malloc(x)       malloc_debug(x, __FILE__, __LINE__)
 407 #define free(x)         free_debug(x, __FILE__, __LINE__)
 408
 409 #endif