libjf API reference guide

jf_file.c

Go to the documentation of this file.

/*
 * Copyright 2005 Tiian
 * {In real life Tiian is Christian Ferrari}
 * This file is part of "libjf" package.
 *
 * "libjf" is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * "libjf" is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with ; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include <jf/jf_config.h>



#ifdef HAVE_STDIO_H
# include <stdio.h>
#endif /* HAVE_STDIO_H */
#ifdef HAVE_STDLIB_H
# include <stdlib.h>
#endif /* HAVE_STDLIB_H */
#ifdef HAVE_STRING_H
# include <string.h>
#endif /* HAVE_STRING_H */
#ifdef HAVE_STDARG_H
# include <stdarg.h>
#endif /* HAVE_STDARG_H */
#ifdef HAVE_ERRNO_H
# include <errno.h>
#endif /* HAVE_ERRNO_H */

#include <jf/jf_errors.h>
#include <jf/jf_trace.h>
#include <jf_file.h>



/* set module trace flag */
#ifdef JF_TRACE_MODULE
# undef JF_TRACE_MODULE
#endif /* JF_TRACE_MODULE */
#define JF_TRACE_MODULE   JF_TRACE_MOD_LIB_FILE



void jf_file_reset(jf_file_t *jf)
{
        JF_TRACE(("jf_file_reset\n"));
        jf->journal = NULL;
        jf->private_journal = FALSE;
        jf->id = JF_JOURNAL_GLOBAL_FILE_ID;
        jf->char_buffer = NULL;
        jf->char_buffer_size = 0;
}



int jf_file_open(jf_file_t *jfile, jf_journal_t *journal,
                 const char *path, const char *mode,
                 const struct jf_file_open_opts_s *options)
{
        enum Exception { INVALID_PATH
                         , MALLOC_NAME
                         , MALLOC_JOURNAL
                         , JOURNAL_OPEN
                         , JOURNAL_OPEN_ATTACH_FILE
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        char *journal_path = NULL;
      
        JF_TRACE(("jf_file_open\n"));
        TRY {
                const struct jf_journal_file_opts_s *journal_file_opts = NULL;
                struct jf_file_open_opts_s opts;
                int join_the_journal = TRUE;

                if (NULL != options)
                        opts = *options;
                else
                        jf_set_default_file_open_opts(&opts);

                if (path == NULL || strlen(path) == 0)
                        THROW(INVALID_PATH);

                /* reset object */
                jf_file_reset(jfile);

                if (NULL == journal) {
                        /* a private journal must be opened, building name */
                        if (NULL == (journal_path = (char *)malloc(
                                             strlen(path) +
                                             strlen(JF_JOURNAL_EXTENSION)+1)))
                                THROW(MALLOC_NAME);
                        strcpy(journal_path, path);
                        strcat(journal_path, JF_JOURNAL_EXTENSION);

                        /* allocate a private journal object */
                        jfile->private_journal = TRUE;
                        if (NULL == (jfile->journal = (jf_journal_t *)malloc(
                                             sizeof(jf_journal_t))))
                                THROW(MALLOC_JOURNAL);

                        opts.journal_opts.flags |=
                                JF_JOURNAL_PROP_OPEN_O_CREAT;
                        /* open the journal */
                        ret_cod = jf_journal_open(
                                jfile->journal, journal_path, 1,
                                &(opts.journal_opts));
                        if (JF_RC_OK != ret_cod)
                                THROW(JOURNAL_OPEN);
                } else {
                        jfile->private_journal = FALSE;
                        jfile->journal = journal;
                }

                if (options != NULL) {
                        join_the_journal = opts.join_the_journal;
                } /* if (options != NULL) */
                journal_file_opts = &(opts.journal_opts.journal_file_opts);
            
                /* open file (if not already opened) and attach to journal */
                ret_cod = jf_journal_open_attach_file(
                        jfile->journal, path, mode, &(jfile->id),
                        join_the_journal, journal_file_opts);
                if (JF_RC_OK != ret_cod)
                        THROW(JOURNAL_OPEN_ATTACH_FILE);
            
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case INVALID_PATH:
                        ret_cod = JF_RC_INVALID_PATH_NAME;
                        break;
                    case MALLOC_NAME:
                        ret_cod = JF_RC_MALLOC_ERROR;
                        break;
                    case MALLOC_JOURNAL:
                        ret_cod = JF_RC_MALLOC_ERROR;
                        break;
                    case JOURNAL_OPEN:
                        break;
                    case JOURNAL_OPEN_ATTACH_FILE:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */

                /* release storage */
                if (NULL != journal_path)
                        free(journal_path);

                /* release storage */
                if (excp > MALLOC_JOURNAL && excp < NONE) {
                        if (journal == NULL && jfile->journal != NULL)
                                free(jfile->journal);
                        jfile->journal = NULL;
                } /* if (excp > MALLOC_JOURNAL) */
            
        } /* TRY-CATCH */
        JF_TRACE(("jf_file_open/excp=%d/ret_cod=%d/errno=%d\n", 
                  excp, ret_cod, errno));
        return ret_cod;
}



int jf_file_check_mode(const char *mode, uint32_t *flags)
{
        enum Exception { INVALID_POINTER
                         , INVALID_FIRST
                         , INVALID_SECOND
                         , INVALID_THIRD
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        uint32_t tmp_flags = 0;

        JF_TRACE(("jf_file_check_mode\n"));      
        TRY {
                if (mode == NULL)
                        THROW(INVALID_POINTER);
            
                /* check first char, it must be in set [r,R,w,W,a] */
                switch (mode[0]) {
                    case 'r':
                        tmp_flags |= JF_FILE_OM_READ;
                        break;
                    case 'R':
                        tmp_flags |= JF_FILE_OM_READ | JF_FILE_OM_RESTART;
                        break;
                    case 'w':
                        tmp_flags |= JF_FILE_OM_WRITE | JF_FILE_OM_TRUNCATE;
                        break;
                    case 'W':
                        tmp_flags |= JF_FILE_OM_WRITE | JF_FILE_OM_RESTART |
                                JF_FILE_OM_TRUNCATE;
                        break;
                    case 'a':
                        tmp_flags |= JF_FILE_OM_WRITE | JF_FILE_OM_APPEND;
                        break;
                    default:
                        THROW(INVALID_FIRST);
                } /* switch mode[0] */

                /* check second char, it can be in set [D,+] */
                switch (mode[1]) {
                    case '\0': /* break parsing */
                        THROW(NONE);
                    case 'D':
                        tmp_flags |= JF_FILE_OM_MSDOS;
                        break;
                    case '+':
                        tmp_flags |= JF_FILE_OM_READ | JF_FILE_OM_WRITE;
                        break;
                    default:
                        THROW(INVALID_SECOND);
                } /* switch (mode[1]) */

                /* check third char, it can be in set [D,+] */
                switch (mode[2]) {
                    case '\0': /* break parsing */
                        THROW(NONE);
                    case 'D':
                        tmp_flags |= JF_FILE_OM_MSDOS;
                        break;
                    case '+':
                        tmp_flags |= JF_FILE_OM_READ | JF_FILE_OM_WRITE;
                        break;
                    default:
                        THROW(INVALID_THIRD);                  
                } /* switch (mode[2]) */
            
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case INVALID_POINTER:
                        ret_cod = JF_RC_NULL_OBJECT;
                        break;
                    case INVALID_FIRST:
                        /* intentionally missed break ... */
                    case INVALID_SECOND:
                        /* intentionally missed break ... */
                    case INVALID_THIRD:
                        ret_cod = JF_RC_INVALID_OPTION;
                        break;
                    case NONE:
                        *flags = tmp_flags;
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("jf_file_check_mode/excp=%d/ret_cod=%d\n", 
                  excp, ret_cod));
        return ret_cod;
}



int jf_file_build_open_mode(uint32_t flags, char *mode1, char *mode2,
                            int *repos, int *resize, int *append)
{
        enum Exception { UNSUPPORTED_MODE
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("jf_file_build_open_mode\n"));      
        TRY {
                /* keeping only interesting bits */
                uint32_t tmp_flags = flags &
                        (JF_FILE_OM_MASK & (~JF_FILE_OM_MSDOS));

                /* resetting boolean flags */
                *repos = FALSE;
                *resize = FALSE;
                *append = FALSE;

                /* resetting modes */
                *mode1 = '\0';
                *mode2 = '\0';
            
                /* building fopen mode associated to flags: note the stream is
                 * EVER opened as a BINARY stream; MS-DOS new line conversion
                 * is operated at libjf level */
                switch (tmp_flags) {
                    case JF_FILE_OM_READ:
                        /* "r" -> "r" */
                        strcpy(mode1, "rb");
                        break;
                    case JF_FILE_OM_READ | JF_FILE_OM_WRITE:
                        /* "r+" -> "r+" */
                        strcpy(mode1, "r+b");
                        break;
                    case JF_FILE_OM_READ | JF_FILE_OM_RESTART:
                        /* "R" -> "r" */
                        *repos = TRUE;
                        strcpy(mode1, "rb");
                        break;
                        case JF_FILE_OM_READ | JF_FILE_OM_WRITE |
                                JF_FILE_OM_RESTART:
                        /* "R+" -> "r+" */
                        *repos = TRUE;
                        strcpy(mode1, "r+b");
                        break;
                    case JF_FILE_OM_WRITE | JF_FILE_OM_TRUNCATE:
                        /* "w" -> "r+", "w" */
                        *resize = TRUE;
                        strcpy(mode1, "r+b");
                        strcpy(mode2, "wb");
                        break;
                        case JF_FILE_OM_WRITE | JF_FILE_OM_READ |
                                JF_FILE_OM_TRUNCATE:
                        /* "w+" -> "r+", "w+" */
                        *resize = TRUE;
                        strcpy(mode1, "r+b");
                        strcpy(mode2, "w+b");
                        break;
                        case JF_FILE_OM_WRITE | JF_FILE_OM_TRUNCATE |
                                JF_FILE_OM_RESTART:
                        /* "W" -> "r+", "w" */
                        *repos = TRUE;
                        *resize = TRUE;
                        strcpy(mode1, "r+b");
                        strcpy(mode2, "wb");
                        break;
                        case JF_FILE_OM_WRITE | JF_FILE_OM_READ |
                                JF_FILE_OM_TRUNCATE | JF_FILE_OM_RESTART:
                                /* "W+" -> "r+", "w+" */
                                *repos = TRUE;
                        *resize = TRUE;
                        strcpy(mode1, "r+b");
                        strcpy(mode2, "w+b");
                        break;
                    case JF_FILE_OM_WRITE | JF_FILE_OM_APPEND:
                        /* "a" -> "r+", "w" */
                        *append = TRUE;
                        strcpy(mode1, "r+b");
                        strcpy(mode2, "wb");
                        break;
                        case JF_FILE_OM_WRITE | JF_FILE_OM_READ |
                                JF_FILE_OM_APPEND:
                        /* "a+" -> "r+", "w+" */
                        *append = TRUE;
                        strcpy(mode1, "r+b");
                        strcpy(mode2, "w+b");
                        break;
                    default: /* unsupported mode */
                        THROW(UNSUPPORTED_MODE);
                } /* switch (flags) */

                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case UNSUPPORTED_MODE:
                        ret_cod = JF_RC_INVALID_OPTION;
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("jf_file_build_open_mode/excp=%d/ret_cod=%d\n", 
                  excp, ret_cod));
        return ret_cod;
}



int jf_file_close(jf_file_t *jfile)
{
        enum Exception { NOT_SAFE
                         , INVALID_BUFFER
                         , ROLLBACK
                         , JOURNAL_CLOSE_DETACH_FILE
                         , JOURNAL_CLOSE
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;
      
        JF_TRACE(("jf_file_close\n"));      
        TRY {
                /* check safety */
                if (!jf_file_is_safe(jfile))
                        THROW(NOT_SAFE);

#ifdef _EXTRA_CHECK
                if ((NULL == jfile->char_buffer &&
                     0 != jfile->char_buffer_size) ||
                    (NULL != jfile->char_buffer &&
                     0 == jfile->char_buffer_size))
                        THROW(INVALID_BUFFER);
#endif /* _EXTRA_CHECK */

                if (NULL != jfile->char_buffer) {
                        free(jfile->char_buffer);
                        jfile->char_buffer = NULL;
                        jfile->char_buffer_size = 0;
                } /* if (NULL != jfile->char_buffer) */
                
                /* rollback uncommitted changes (if necessary) */
                if (JF_RC_OK != (ret_cod = jf_file_rollback(jfile)))
                        THROW(ROLLBACK);

                /* close file and detach from journal */
                if (JF_RC_OK != (ret_cod = jf_journal_close_detach_file(
                                         jfile->journal, jfile->id)))
                        THROW(JOURNAL_CLOSE_DETACH_FILE);

                /* close journal file too */
                if (jfile->private_journal &&
                    JF_RC_OK != (ret_cod = jf_journal_close(jfile->journal)))
                        THROW(JOURNAL_CLOSE);
            
                /* reset journaled file object */
                jf_file_reset(jfile);
            
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case NOT_SAFE:
                        ret_cod = JF_RC_OBJ_CORRUPTED;
                        break;
#ifdef _EXTRA_CHECK
                    case INVALID_BUFFER:
                        ret_cod = JF_RC_INVALID_STATUS;
                        break;
#endif /* _EXTRA_CHECK */
                    case ROLLBACK:
                    case JOURNAL_CLOSE_DETACH_FILE:
                    case JOURNAL_CLOSE:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("jf_file_close/excp=%d/ret_cod=%d/errno=%d\n", 
                  excp, ret_cod, errno));
        return ret_cod;
}



jf_offset_t jf_file_get_cache_limit(const jf_file_t *jfile)
{
        jf_journal_file_t *jf;
        jf_cache_file_t *cf;
        
        if (!jf_file_is_safe(jfile))
                return -1;
        if (NULL == (jf = jf_journal_get_jfile(
                             jfile->journal, jfile->id)))
                return -1;
        if (NULL == (cf = jf_journal_file_get_cache_file(jf)))
                return -1;
        return jf_cache_file_get_limit(cf);
}



int jf_file_seek(jf_file_t *jf, jf_offset_t offset, int whence)
{
        enum Exception { OBJ_NOT_SAFE
                         , NOTHING_TO_DO
                         , INVALID_WHENCE_VALUE
                         , INVALID_OFFSET
                         , SET_LAST_UC_POS
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("jf_file_seek\n"));      
        TRY {
                jf_journal_t *journal;
                jf_word_t     file_id;
                jf_journal_file_t *jfp;
                jf_offset_t   tmp_off;
                uint32_t open_mode;

                if (!jf_file_is_safe(jf))
                        THROW(OBJ_NOT_SAFE);
            
                journal = jf_file_get_journal(jf);
                file_id = jf_file_get_id(jf);
                jfp = jf_journal_get_jfile(journal, file_id);
                open_mode = jf_journal_file_get_open_mode(jfp);

                /* "a" mode can not support "seek" operation */
                if (open_mode & JF_FILE_OM_APPEND &&
                    !(open_mode & JF_FILE_OM_READ))
                        THROW(NOTHING_TO_DO);

                switch (whence) {
                    case SEEK_SET:
                        tmp_off = offset;
                        break;
                    case SEEK_CUR:
                        tmp_off = jf_journal_file_get_last_uc_pos(jfp) +
                                offset;
                        break;
                    case SEEK_END:
                        tmp_off = jf_journal_file_get_last_uc_size(jfp) +
                                offset;
                        break;
                    default:
                        THROW(INVALID_WHENCE_VALUE);
                } /* switch (whence) */

                /* check new offset value */
                if (tmp_off < 0 ||
                    tmp_off > jf_journal_file_get_last_uc_size(jfp))
                        THROW(INVALID_OFFSET);

                ret_cod = jf_journal_file_set_last_uc_pos(jfp, tmp_off);
                if (JF_RC_OK != ret_cod)
                        THROW(SET_LAST_UC_POS);
            
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case OBJ_NOT_SAFE:
                        ret_cod = JF_RC_OBJ_CORRUPTED;
                        break;
                    case INVALID_WHENCE_VALUE:
                        ret_cod = JF_RC_OUT_OF_RANGE;
                        break;
                    case INVALID_OFFSET:
                        ret_cod = JF_RC_INVALID_STREAM_POSITION;
                        break;
                    case SET_LAST_UC_POS:
                        break;
                    case NOTHING_TO_DO:
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("jf_file_seek/excp=%d/ret_cod=%d/errno=%d\n", 
                  excp, ret_cod, errno));
        return ret_cod;
}



int jf_file_size(jf_file_t *jf, jf_offset_t *last_size,
            jf_offset_t *last_uc_size)
{
        enum Exception { OBJ_NOT_SAFE
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;
        
        JF_TRACE(("jf_file_size\n"));      
        TRY {
                jf_journal_t *journal;
                jf_word_t     file_id;
                jf_journal_file_t *jfp;

                if (!jf_file_is_safe(jf))
                        THROW(OBJ_NOT_SAFE);
            
                journal = jf_file_get_journal(jf);
                file_id = jf_file_get_id(jf);
                jfp = jf_journal_get_jfile(journal, file_id);

                if (NULL != last_size)
                        *last_size = jf_journal_file_get_last_size(jfp);
                if (NULL != last_uc_size)
                        *last_uc_size = jf_journal_file_get_last_uc_size(jfp);
                
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case OBJ_NOT_SAFE:
                        ret_cod = JF_RC_OBJ_CORRUPTED;
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("jf_file_size/excp=%d/ret_cod=%d/errno=%d\n", 
                  excp, ret_cod, errno));
        return ret_cod;
}



int jf_file_write(jf_file_t *jf, const void *data,
                  size_t size, size_t *write_number)
{
        enum Exception { NOTHING_TO_DO
                         , JOURNAL_ADD_DATA
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("jf_file_write\n"));      
        TRY {
                jf_journal_t *journal = jf_file_get_journal(jf);

                if (size == 0)
                        THROW(NOTHING_TO_DO);
                
                ret_cod = jf_journal_add_byte_data(journal, jf_file_get_id(jf),
                                                   (byte_t *)data, size);
                if (JF_RC_OK != ret_cod)
                        THROW(JOURNAL_ADD_DATA);

                *write_number = size;
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case JOURNAL_ADD_DATA:
                        break;
                    case NOTHING_TO_DO:
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("jf_file_write/excp=%d/ret_cod=%d/errno=%d\n", 
                  excp, ret_cod, errno));
        return ret_cod;
}



int jf_file_read(jf_file_t *jf, void *data, size_t size, size_t *read_number)
{
        enum Exception { JOURNAL_GET_DATA
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;
    
        JF_TRACE(("jf_file_read\n"));      
        TRY {
                jf_journal_t *journal = jf_file_get_journal(jf);
        
                ret_cod = jf_journal_get_byte_data(
                        journal, jf_file_get_id(jf),
                        (byte_t *)data, size, read_number);
                if (JF_RC_OK != ret_cod)
                        THROW(JOURNAL_GET_DATA);
        
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case JOURNAL_GET_DATA:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("jf_file_read/excp=%d/ret_cod=%d/errno=%d\n", 
                  excp, ret_cod, errno));
        return ret_cod;
}



int jf_file_putc(jf_file_t *jf, int c)
{
        enum Exception { JOURNAL_BUFFER_ADD_C
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("jf_file_putc\n"));      
        TRY {
                jf_journal_t *journal = jf_file_get_journal(jf);

                ret_cod = jf_journal_add_c(journal, jf_file_get_id(jf), c);
                if (JF_RC_OK != ret_cod)
                        THROW(JOURNAL_BUFFER_ADD_C);
            
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case JOURNAL_BUFFER_ADD_C:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("jf_file_putc/excp=%d/ret_cod=%d\n", 
                  excp, ret_cod));
        return ret_cod;
}



int jf_file_puts(jf_file_t *jf, const char *s)
{
        enum Exception { NOTHING_TO_DO
                         , JOURNAL_ADD_DATA
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("jf_file_puts\n"));      
        TRY {
                jf_journal_t *journal = jf_file_get_journal(jf);
                size_t size = strlen(s);

                if (size == 0)
                        THROW(NOTHING_TO_DO);
                
                ret_cod = jf_journal_add_byte_data(journal, jf_file_get_id(jf),
                                                   (byte_t *)s, size);
                if (JF_RC_OK != ret_cod)
                        THROW(JOURNAL_ADD_DATA);

                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case JOURNAL_ADD_DATA:
                        break;
                    case NOTHING_TO_DO:
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("jf_file_puts/excp=%d/ret_cod=%d/errno=%d\n", 
                  excp, ret_cod, errno));
        return ret_cod;
}



int jf_file_getc(jf_file_t *jf, int *c)
{
        enum Exception { INVALID_OBJECT
                         , JOURNAL_BUFFER_GET_C
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("jf_file_getc\n"));      
        TRY {
                jf_journal_t *journal;
                jf_word_t jf_id;
                jf_journal_file_t *jfile;

                if (!jf_file_is_safe(jf))
                        THROW(INVALID_OBJECT);
            
                jf_id = jf_file_get_id(jf);
                journal = jf_file_get_journal(jf);
                jfile = jf_journal_get_jfile(journal, jf_id);

                ret_cod = jf_journal_get_c(journal, jf_id, c);
                if (JF_RC_OK != ret_cod)
                        THROW(JOURNAL_BUFFER_GET_C);
                *c &= 0xff;
                        
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case INVALID_OBJECT:
                        ret_cod = JF_RC_OBJ_CORRUPTED;
                        break;
                    case JOURNAL_BUFFER_GET_C:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("jf_file_getc/excp=%d/ret_cod=%d/errno=%d\n", 
                  excp, ret_cod, errno));
        return ret_cod;
}



int jf_file_gets(jf_file_t *jf, size_t size, char *s)
{
        enum Exception { INVALID_OBJECT
                         , JOURNAL_BUFFER_GET_C
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("jf_file_gets\n"));
        TRY {
                size_t i = 0;
                jf_journal_t *journal;
                jf_word_t jf_id;
                jf_journal_file_t *jfile;

                if (!jf_file_is_safe(jf))
                        THROW(INVALID_OBJECT);

                jf_id = jf_file_get_id(jf);
                journal = jf_file_get_journal(jf);
                jfile = jf_journal_get_jfile(journal, jf_id);

                for (i = 0; i < size - 1; ++i) {
                        int c;
                        ret_cod = jf_journal_get_c(
                                journal, jf_file_get_id(jf), &c);
                        if (JF_RC_EOF == ret_cod)
                                break;
                        if (JF_RC_OK != ret_cod)
                                THROW(JOURNAL_BUFFER_GET_C);
                        c &= 0xff;
                        s[i] = c;
                        if (c == '\n')
                                break;
                } /* for (i = 0; i < size; ++i) */
                s[++i] = '\0';
                
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case INVALID_OBJECT:
                        ret_cod = JF_RC_OBJ_CORRUPTED;
                        break;
                    case JOURNAL_BUFFER_GET_C:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("jf_file_gets/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}



#ifdef HAVE_VSNPRINTF
int jf_file_printf(jf_file_t *jf, size_t *write_number,
                   const char *format, ...)
{
        enum Exception { VPRINTF_ERROR
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("jf_file_printf\n"));
        TRY {
                va_list ap;
                va_start(ap, format);
                
                ret_cod = jf_file_vprintf(jf, write_number, format, ap);
                if (JF_RC_OK != ret_cod)
                        THROW(VPRINTF_ERROR);

                va_end(ap);
                
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case VPRINTF_ERROR:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("jf_file_printf/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}



int jf_file_vprintf(jf_file_t *jf, size_t *write_number, const char *format,
                    va_list ap)
{
        enum Exception { INVALID_BUFFER
                         , MALLOC_ERROR1
                         , VSNPRINTF_ERROR
                         , MALLOC_ERROR2
                         , FILE_WRITE
                         , NONE } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("jf_file_vprintf\n"));
        TRY {
                int chars;
                *write_number = 0;
                uint32_t flags;

# ifdef _EXTRA_CHECK
                if ((NULL == jf->char_buffer && 0 != jf->char_buffer_size) ||
                    (NULL != jf->char_buffer && 0 == jf->char_buffer_size))
                        THROW(INVALID_BUFFER);
# endif /* _EXTRA_CHECK */

                if (NULL == jf->char_buffer) {
                        jf->char_buffer = (char *)malloc(
                                JF_FILE_BUFFER_PAGE_SIZE);
                        if (NULL == jf->char_buffer)
                                THROW(MALLOC_ERROR1);
                        jf->char_buffer_size = JF_FILE_BUFFER_PAGE_SIZE;
                } /* if (NULL == jf->char_buffer) */

                while (TRUE) {
                        va_list aq;
# ifdef HAVE_VA_COPY
                        va_copy(aq, ap);
# else
                        if (sizeof(aq) == sizeof(ap))
                                memcpy(&aq, &ap, sizeof(va_list));
                        else
                                memcpy(&aq, ap, sizeof(va_list));
# endif /* HAVE_VA_COPY */
                        chars = vsnprintf(jf->char_buffer,
                                          jf->char_buffer_size, format, aq);
                        va_end(aq);

                        if (chars > 0 && chars < jf->char_buffer_size)
                                break;
                        /* detect error or expand buffer */
                        if (chars < 0)
                                THROW(VSNPRINTF_ERROR);
                        free(jf->char_buffer);
                        jf->char_buffer_size += JF_FILE_BUFFER_PAGE_SIZE;
                        jf->char_buffer = (char *)malloc(jf->char_buffer_size);
                        if (NULL == jf->char_buffer)
                                THROW(MALLOC_ERROR2);                        
                } /* while (TRUE) */

                ret_cod = jf_file_write(jf, jf->char_buffer, chars,
                                        write_number);
                if (JF_RC_OK != ret_cod)
                        THROW(FILE_WRITE);

                flags = jf_journal_get_open_opts_flags(
                        jf_file_get_journal(jf));
                if ((flags & JF_JOURNAL_PROP_VIRTMEM_LOW) ||
                    ((flags & JF_JOURNAL_PROP_VIRTMEM_MEDIUM) &&
                     (chars + JF_FILE_BUFFER_PAGE_SIZE <
                      jf->char_buffer_size))) {
                        /* release storage */
                        free(jf->char_buffer);
                        jf->char_buffer = NULL;
                        jf->char_buffer_size = 0;
                } /* if ((flags & JF_JOURNAL_PROP_STORAGE_LOW) || ... */
                        
                THROW(NONE);
        } CATCH {
                switch (excp) {
                    case INVALID_BUFFER:
                        ret_cod = JF_RC_INVALID_STATUS;
                        break;
                    case MALLOC_ERROR1:
                    case MALLOC_ERROR2:
                        ret_cod = JF_RC_MALLOC_ERROR;
                        break;
                    case VSNPRINTF_ERROR:
                        ret_cod = JF_RC_VSNPRINTF_ERROR;
                        break;
                    case FILE_WRITE:
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("jf_file_vprintf/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}
#endif /* HAVE_VSNPRINTF */

---

Copyright 2005 © Tiian