/*  OSSP rc - Run-command processor
**  Copyright (c) 2002 Ralf S. Engelschall
**  Copyright (c) 2002 Cable & Wireless Deutschland GmbH
**  Copyright (c) 2002 The OSSP Project <http://www.ossp.org/>
**
**  This file is part of OSSP rc, a portable Run-command processor
**  which can be found at http://www.ossp.org/pkg/lib/rc/
**
**  Permission to use, copy, modify, and distribute this software for
**  any purpose with or without fee is hereby granted, provided that
**  the above copyright notice and this permission notice appear in all
**  copies.
**
**  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
**  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
**  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
**  IN NO EVENT SHALL THE AUTHORS AND COPYRIGHT HOLDERS AND THEIR
**  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
**  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
**  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
**  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
**  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
**  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
**  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
**  SUCH DAMAGE.
**
**  rc_file.c: Run-command processor ISO C source file
*/

#include <string.h> /* For string copy and such data ops */
#include <stdlib.h> /* For memory ops */

#include "rc.h"     /* Public Rc interface */


/************************************************
* rcfileNew(void)                               *
* Construct a new rcfile                        *
************************************************/
rc_file_t *rcfileNew(const char *szName)
{
    rc_file_t *pRcfile = NULL;

    pRcfile = (rc_file_t *)calloc(1, sizeof(rc_file_t));   /* Allocate and clear */
    if (!pRcfile)                                          /* Ensure storage */
        RC_THROW(RC_ERR_MEM);

    if (szName) {
        pRcfile->m_szName = malloc((strlen(szName) + 1) * sizeof(char));
        strcpy(pRcfile->m_szName, szName);
    }
    else
        pRcfile->m_szName = NULL;

    /* Default values */
    pRcfile->m_nSecs = -1;
    pRcfile->m_ppSecvec = NULL;

    return(pRcfile);
}

/****************************************************
* rcfileAppendsec(rc_file_t *, rc_section_t *)      *
* Append a section to this rcfile                   *
****************************************************/
rc_return_t rcfileAppendsec(rc_file_t *pRcfile, rc_section_t *pInsec)
{
    assert(pRcfile);    /* Rcfile parameter must be valid */
    if (!pInsec)        /* Check sanity */
        return(RC_THROW(RC_ERR_USE));

    /* When appending to a brand new rcfile, reset the object key (m_nSecs) */
    if (pRcfile->m_nSecs == -1)
        pRcfile->m_nSecs = 0;

    /* First make our vector larger to hold one more section */
    pRcfile->m_ppSecvec = realloc(pRcfile->m_ppSecvec, sizeof(rc_section_t *) \
                                                     * (pRcfile->m_nSecs + 1));
    pRcfile->m_ppSecvec[pRcfile->m_nSecs] = sectionNew(pInsec->m_szName);
    pRcfile->m_ppSecvec[pRcfile->m_nSecs + 1] = NULL;

    /* Simple value copy */
    pRcfile->m_ppSecvec[pRcfile->m_nSecs]->m_nPri  = pInsec->m_nPri;
    pRcfile->m_ppSecvec[pRcfile->m_nSecs]->m_nUid  = pInsec->m_nUid;

    /* Deep copy of user name */
    if (pInsec->m_szLogin) {
        pRcfile->m_ppSecvec[pRcfile->m_nSecs]->m_szLogin = \
            malloc((strlen(pInsec->m_szLogin) + sizeof(char)) * sizeof(char));
        strcpy(pRcfile->m_ppSecvec[pRcfile->m_nSecs]->m_szLogin, pInsec->m_szLogin);
    }

    /* Deep copy of section text */
    if (pInsec->m_szData) {
        pRcfile->m_ppSecvec[pRcfile->m_nSecs]->m_szData = \
            malloc((strlen(pInsec->m_szData) + sizeof(char)) * sizeof(char));
        strcpy(pRcfile->m_ppSecvec[pRcfile->m_nSecs]->m_szData, pInsec->m_szData);
    }

    /* Finally increment section count */
    pRcfile->m_nSecs++;

    return(RC_THROW(RC_OK));
}

/************************************************
* rcfileGetXXX(rc_file_t *)                     *
* Accessor methods                              *
************************************************/
const char *rcfileGetname(rc_file_t *pRcfile)
{ /* Name of rcfile, used for display during verbose */
    if (pRcfile)
        return(pRcfile->m_szName);
    else
        RC_THROW(RC_ERR_USE);

    return(0); /* Not reached */
}

/************************************************
* rcfileSetXXX(rc_file_t *, const ... *)        *
* Accessor methods                              *
************************************************/
rc_return_t rcfileSetname(rc_file_t *pRcfile, const char *szName)
{ /* Name of rcfile, used for display during verbose */
    if (pRcfile) {
        pRcfile->m_szName = malloc((strlen(szName) + 1) * sizeof (char));
        strcpy(pRcfile->m_szName, szName);
        return(RC_THROW(RC_OK));
    }

    return(RC_THROW(RC_ERR_USE));
}

/************************************************
* rcfileExists(rc_file_t *)                     *
* Tests for an existing rcfile object           *
************************************************/
short rcfileExists(rc_file_t *pRcfile)
{ /* Key on name of rcfile */
    if (pRcfile) {
        if (pRcfile->m_szName)
            return(TRUE);   /* Object does indeed exist */
        else
            return(FALSE);  /* Object does not exist    */
    }

    return(RC_THROW(RC_ERR_USE));
}

/************************************************
* rcfileDelete(rc_file_t *)                     *
* Destruct a rcfile                             *
************************************************/
rc_return_t rcfileDelete(rc_file_t *pRcfile)
{
    int nSecs = pRcfile->m_nSecs;

    /* Cleanup our junk */
    if (pRcfile) {
        pRcfile->m_nSecs = 0;       /* Blank the section count    */
        if (pRcfile->m_szName) {    /* Destroy the rc name        */
            free(pRcfile->m_szName);
            pRcfile->m_szName = NULL;
        }
        while (nSecs-- > 0) {       /* Destroy the section vector */
            if (pRcfile->m_ppSecvec[nSecs]) {
                sectionDelete(pRcfile->m_ppSecvec[nSecs]);
                pRcfile->m_ppSecvec[nSecs] = NULL;
            }
        }
        free(pRcfile->m_ppSecvec);
        pRcfile->m_ppSecvec = NULL;
        free(pRcfile);
        pRcfile = NULL;
    }
    else    /* Dumbass passed an empty rcfile object */
        assert(FALSE);

    return(RC_THROW(RC_OK));
}