Annotation of libaitio/src/bufio.c, revision 1.1.2.1
1.1.2.1 ! misho 1: #include "global.h"
! 2:
! 3:
! 4: static void
! 5: unmap_cf(struct tagBufIO *buf)
! 6: {
! 7: if (buf)
! 8: munmap(buf->buf_base, buf->buf_size);
! 9: }
! 10:
! 11: static int
! 12: cf_(struct tagBufIO *buf)
! 13: {
! 14: if (!buf) {
! 15: io_SetErr(EINVAL, "Invalid arguments ...");
! 16: return -1;
! 17: }
! 18:
! 19: if (buf->buf_mode == BUFIO_MODE_INFINIT)
! 20: free(buf->buf_base);
! 21: else if (buf->buf_unmap)
! 22: buf->buf_unmap(buf);
! 23:
! 24: free(buf);
! 25: return 0;
! 26: }
! 27:
! 28: static fpos_t
! 29: sf_lim(struct tagBufIO *buf, fpos_t pos, int w)
! 30: {
! 31: if (!buf)
! 32: goto err;
! 33:
! 34: switch (w) {
! 35: case SEEK_SET:
! 36: if (buf->buf_size < pos || pos < 0)
! 37: goto err;
! 38: buf->buf_offset = pos;
! 39: break;
! 40: case SEEK_CUR:
! 41: if (buf->buf_size < (buf->buf_offset + pos) || (buf->buf_offset + pos) < 0)
! 42: goto err;
! 43: buf->buf_offset += pos;
! 44: break;
! 45: case SEEK_END:
! 46: if (buf->buf_size < (buf->buf_size + pos) || (buf->buf_size + pos) < 0)
! 47: goto err;
! 48: buf->buf_offset = buf->buf_size + pos;
! 49: break;
! 50: default:
! 51: goto err;
! 52: }
! 53:
! 54: return buf->buf_offset;
! 55: err:
! 56: io_SetErr(EINVAL, "Invalid arguments ...");
! 57: return -1;
! 58: }
! 59:
! 60: static int
! 61: rf_lim(struct tagBufIO *buf, char *dat, int siz)
! 62: {
! 63: if (!buf || !dat) {
! 64: io_SetErr(EINVAL, "Invalid arguments ...");
! 65: return -1;
! 66: }
! 67:
! 68: if (buf->buf_offset + siz > buf->buf_size)
! 69: siz = buf->buf_size - buf->buf_offset;
! 70:
! 71: memcpy(dat, buf->buf_base + buf->buf_offset, siz);
! 72: buf->buf_offset += siz;
! 73: return siz;
! 74: }
! 75:
! 76: static int
! 77: wf_lim(struct tagBufIO *buf, const char *dat, int siz)
! 78: {
! 79: if (!buf || !dat) {
! 80: io_SetErr(EINVAL, "Invalid arguments ...");
! 81: return -1;
! 82: }
! 83:
! 84: if (buf->buf_offset + siz > buf->buf_size)
! 85: siz = buf->buf_size - buf->buf_offset;
! 86:
! 87: memcpy(buf->buf_base + buf->buf_offset, dat, siz);
! 88: buf->buf_offset += siz;
! 89: return siz;
! 90: }
! 91:
! 92: static fpos_t
! 93: sf_inf(struct tagBufIO *buf, fpos_t pos, int w)
! 94: {
! 95: void *b;
! 96:
! 97: if (!buf)
! 98: goto err;
! 99:
! 100: switch (w) {
! 101: case SEEK_SET:
! 102: if (pos < 0)
! 103: goto err;
! 104: if (buf->buf_size < pos) {
! 105: b = realloc(buf->buf_base, pos);
! 106: if (!b) {
! 107: LOGERR;
! 108: return -1;
! 109: } else {
! 110: buf->buf_base = b;
! 111: memset(buf->buf_base + buf->buf_size, 0, pos - buf->buf_size);
! 112: buf->buf_size = pos;
! 113: }
! 114: }
! 115: buf->buf_offset = pos;
! 116: break;
! 117: case SEEK_CUR:
! 118: if ((buf->buf_offset + pos) < 0)
! 119: goto err;
! 120: if (buf->buf_size < (buf->buf_offset + pos)) {
! 121: b = realloc(buf->buf_base, buf->buf_offset + pos);
! 122: if (!b) {
! 123: LOGERR;
! 124: return -1;
! 125: } else {
! 126: buf->buf_base = b;
! 127: memset(buf->buf_base + buf->buf_size, 0,
! 128: buf->buf_offset + pos - buf->buf_size);
! 129: buf->buf_size = buf->buf_offset + pos;
! 130: }
! 131: }
! 132: buf->buf_offset += pos;
! 133: break;
! 134: case SEEK_END:
! 135: if ((buf->buf_size + pos) < 0)
! 136: goto err;
! 137: if (buf->buf_size < (buf->buf_size + pos)) {
! 138: b = realloc(buf->buf_base, buf->buf_size + pos);
! 139: if (!b) {
! 140: LOGERR;
! 141: return -1;
! 142: } else {
! 143: buf->buf_base = b;
! 144: memset(buf->buf_base + buf->buf_size, 0, pos);
! 145: buf->buf_size += pos;
! 146: buf->buf_offset = buf->buf_size;
! 147: }
! 148: } else
! 149: buf->buf_offset = buf->buf_size + pos;
! 150: break;
! 151: default:
! 152: goto err;
! 153: }
! 154:
! 155: return buf->buf_offset;
! 156: err:
! 157: io_SetErr(EINVAL, "Invalid arguments ...");
! 158: return -1;
! 159: }
! 160:
! 161: static int
! 162: wf_inf(struct tagBufIO *buf, const char *dat, int siz)
! 163: {
! 164: void *b;
! 165:
! 166: if (!buf || !dat) {
! 167: io_SetErr(EINVAL, "Invalid arguments ...");
! 168: return -1;
! 169: }
! 170:
! 171: if (buf->buf_offset + siz > buf->buf_size) {
! 172: b = realloc(buf->buf_base, buf->buf_offset + siz);
! 173: if (!b) {
! 174: LOGERR;
! 175: return -1;
! 176: } else {
! 177: buf->buf_base = b;
! 178: memset(buf->buf_base + buf->buf_size, 0,
! 179: buf->buf_offset + siz - buf->buf_size);
! 180: buf->buf_size = buf->buf_offset + siz;
! 181: }
! 182: }
! 183:
! 184: memcpy(buf->buf_base + buf->buf_offset, dat, siz);
! 185: buf->buf_offset += siz;
! 186: return siz;
! 187: }
! 188:
! 189:
! 190: /*
! 191: * io_fmemopen() File buffered stream operations over memory block
! 192: *
! 193: * @base = Base address of memory block, if =NULL Infinit length(auto-grow)
! 194: * @basesize = Size of memory block
! 195: * return: NULL error or !=NULL Opened file resource
! 196: */
! 197: FILE *
! 198: io_fmemopen(void ** __restrict base, off_t basesize)
! 199: {
! 200: FILE *f = NULL;
! 201: struct tagBufIO *buf;
! 202:
! 203: if (!base) {
! 204: io_SetErr(EINVAL, "Invalid base argument ...");
! 205: return NULL;
! 206: }
! 207:
! 208: buf = malloc(sizeof(struct tagBufIO));
! 209: if (!buf) {
! 210: LOGERR;
! 211: return NULL;
! 212: } else
! 213: memset(buf, 0, sizeof(struct tagBufIO));
! 214:
! 215: if (!*base) {
! 216: *base = malloc(basesize);
! 217: if (!*base) {
! 218: LOGERR;
! 219: free(buf);
! 220: return NULL;
! 221: } else
! 222: memset(*base, 0, basesize);
! 223:
! 224: buf->buf_mode = BUFIO_MODE_INFINIT;
! 225: } else
! 226: buf->buf_mode = BUFIO_MODE_LIMIT;
! 227:
! 228: buf->buf_base = *base;
! 229: buf->buf_size = basesize;
! 230:
! 231: if (buf->buf_mode == BUFIO_MODE_INFINIT)
! 232: f = funopen(buf, (int (*)(void *, char *, int)) rf_lim,
! 233: (int (*)(void *, char const *, int)) wf_inf,
! 234: (fpos_t (*)(void *, fpos_t, int)) sf_inf,
! 235: (int (*)(void *)) cf_);
! 236: else
! 237: f = funopen(buf, (int (*)(void *, char *, int)) rf_lim,
! 238: (int (*)(void *, char const *, int)) wf_lim,
! 239: (fpos_t (*)(void *, fpos_t, int)) sf_lim,
! 240: (int (*)(void *)) cf_);
! 241: if (!f) {
! 242: LOGERR;
! 243: if (buf->buf_mode == BUFIO_MODE_INFINIT) {
! 244: free(*base);
! 245: *base = NULL;
! 246: }
! 247: free(buf);
! 248: return NULL;
! 249: }
! 250:
! 251: return f;
! 252: }
! 253:
! 254: /*
! 255: * io_fmapopen() File buffered stream operations over MMAP block
! 256: *
! 257: * @csFile = Filename for MMAP, if =NULL private MMAP block
! 258: * @mode = File open mode
! 259: * @perm = If file not exists will be created with this access permissions
! 260: * @prot = MMAP protection
! 261: * @flags = MMAP mode flags
! 262: * @offset = Map from file offset, if csFile==NULL then this is size of MMAP private block
! 263: * return: NULL error or !=NULL Opened file resource
! 264: */
! 265: FILE *
! 266: io_fmapopen(const char *csFile, int mode, int perm, int prot, int flags, off_t offset)
! 267: {
! 268: FILE *f;
! 269: struct tagBufIO *buf;
! 270: void *base;
! 271: off_t basesize;
! 272: int fd = -1;
! 273:
! 274: if (csFile) {
! 275: fd = open(csFile, mode, perm);
! 276: if (fd == -1) {
! 277: LOGERR;
! 278: return NULL;
! 279: }
! 280: basesize = lseek(fd, 0, SEEK_END);
! 281: if (basesize == -1) {
! 282: LOGERR;
! 283: close(fd);
! 284: return NULL;
! 285: } else
! 286: lseek(fd, 0, SEEK_SET);
! 287:
! 288: base = mmap(NULL, basesize, prot, flags | MAP_FILE, fd, offset);
! 289: if (base == MAP_FAILED) {
! 290: LOGERR;
! 291: close(fd);
! 292: return NULL;
! 293: } else
! 294: close(fd);
! 295: } else if (offset) {
! 296: basesize = offset;
! 297: base = mmap(NULL, basesize, prot, MAP_ANON, -1, 0);
! 298: if (base == MAP_FAILED) {
! 299: LOGERR;
! 300: return NULL;
! 301: }
! 302: } else {
! 303: io_SetErr(EINVAL, "Invalid base argument ...");
! 304: return NULL;
! 305: }
! 306:
! 307:
! 308: buf = malloc(sizeof(struct tagBufIO));
! 309: if (!buf) {
! 310: LOGERR;
! 311: munmap(base, basesize);
! 312: return NULL;
! 313: } else
! 314: memset(buf, 0, sizeof(struct tagBufIO));
! 315:
! 316: buf->buf_mode = BUFIO_MODE_LIMIT;
! 317: buf->buf_base = base;
! 318: buf->buf_size = basesize;
! 319: buf->buf_unmap = unmap_cf;
! 320:
! 321: f = funopen(buf, (int (*)(void *, char *, int)) rf_lim,
! 322: (int (*)(void *, char const *, int)) wf_lim,
! 323: (fpos_t (*)(void *, fpos_t, int)) sf_lim,
! 324: (int (*)(void *)) cf_);
! 325: if (!f) {
! 326: LOGERR;
! 327: free(buf);
! 328: munmap(base, basesize);
! 329: return NULL;
! 330: }
! 331:
! 332: return f;
! 333: }
! 334:
! 335: /*
! 336: * io_dumbFile() Create empry or dumb file with fixed size
! 337: *
! 338: * @csFile = Filename for create
! 339: * @mode = File access permissions
! 340: * @size = File size
! 341: * return: -1 error or open file handle
! 342: */
! 343: int
! 344: io_dumbFile(const char *csFile, int mode, off_t size)
! 345: {
! 346: int fd;
! 347:
! 348: fd = open(csFile, O_RDWR | O_CREAT, mode);
! 349: if (fd == -1) {
! 350: LOGERR;
! 351: return -1;
! 352: }
! 353:
! 354: if (lseek(fd, size - 1, SEEK_SET) == -1)
! 355: goto err;
! 356: if (write(fd, "", 1) != 1)
! 357: goto err;
! 358: else
! 359: lseek(fd, 0, SEEK_SET);
! 360:
! 361: return fd;
! 362: err:
! 363: LOGERR;
! 364: close(fd);
! 365: return -1;
! 366: }
! 367:
! 368: /*
! 369: * io_fd2buf() Convert open file handle to buffered file I/O
! 370: *
! 371: * @fd = File handle
! 372: * @mode = Permissions for new buffered file I/O
! 373: * return: NULL error or open buffered file
! 374: */
! 375: inline FILE *
! 376: io_fd2buf(int fd, const char *mode)
! 377: {
! 378: FILE *f;
! 379:
! 380: f = fdopen(fd, mode);
! 381: if (!f)
! 382: LOGERR;
! 383:
! 384: return f;
! 385: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to bufio.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / libaitio / src