source: umon/main/common/tfslog.c @ 87db514

/**************************************************************************
 *
 * Copyright (c) 2013 Alcatel-Lucent
 * 
 * Alcatel Lucent licenses this file to You under the Apache License,
 * Version 2.0 (the "License"); you may not use this file except in
 * compliance with the License.  A copy of the License is contained the
 * file LICENSE at the top level of this repository.
 * You may also obtain a copy of the License at:
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **************************************************************************
 *
 * tfslog.c:
 *
 * Optional facility for TFS that supports the ability to log all
 * tfs actions that affect flash, to a log file.
 *
 * This function is called by tfsadd(), tfsunlink() and tfsipmod() to
 * write to a log file indicating that something in tfs has been changed.
 * Note that the function can be called at any user level, but it must be
 * able to modify the TFS_CHANGELOG_FILE that has "u3" flags.  The 
 * user level must be temporarily forced to MAXUSRLEVEL for this.
 *
 * Original author:     Ed Sutter (ed.sutter@alcatel-lucent.com)
 *
 */
#include "config.h"
#include "stddefs.h"
#include "genlib.h"
#include "tfs.h"
#include "tfsprivate.h"
#include "cli.h"

#if TFS_CHANGELOG_SIZE
static int      tfsLogging;
#endif

void
tfslog(int action, char *string)
{
#if TFS_CHANGELOG_SIZE
        static char *tfslogaction[] = { "ADD", "DEL", "IPM", " ON", "OFF" };
        
        extern  void *setTmpMaxUsrLvl();
        static  char buf[TFS_CHANGELOG_SIZE];
        TFILE   *tfp;
        int             (*fptr)();
        char    *eol, *eob, *logaction, tbuf[32];
        int             newfsize, fsize, lsize, tfd, err, len, tbuflen;

        switch(action) {
                case TFSLOG_ADD:                /* Return here if logging is off,       */
                case TFSLOG_DEL:                /* or this tfslog() call is on the      */
                case TFSLOG_IPM:                /* TFS_CHANGELOG_FILE itself.           */
                        if (!tfsLogging || !strcmp(string,TFS_CHANGELOG_FILE))
                                return;
                        break;
                case TFSLOG_ON:
                        if (tfsLogging == 1)
                                return;
                        tfsLogging = 1;
                        break;
                case TFSLOG_OFF:
                        if (tfsLogging == 0)
                                return;
                        tfsLogging = 0;
                        break;
        }

        /* Force the getUsrLvl() function to return MAX: */
        fptr = (int(*)())setTmpMaxUsrLvl();

        logaction = tfslogaction[action];
        tfp = tfsstat(TFS_CHANGELOG_FILE);
        tfsGetAtime(0,tbuf,sizeof(tbuf));
        tbuflen = strlen(tbuf); 

        if (tfp) {
                tfd = tfsopen(TFS_CHANGELOG_FILE,TFS_RDONLY,0);
                fsize = tfsread(tfd,buf,TFS_CHANGELOG_SIZE);
                tfsclose(tfd,0);

                newfsize = (fsize+strlen(logaction)+strlen(string)+3);
                if (tbuflen)
                        newfsize += tbuflen + 3;

                eob = buf + fsize;

                /* If newfsize is greater than the maximum size the file is
                 * allowed to grow, then keep removing the first line
                 * (oldest entry) until new size is within the limit...
                 */
                if (newfsize > TFS_CHANGELOG_SIZE) {
                        lsize = 0;
                        eol = buf;
                        while ((newfsize-lsize) > TFS_CHANGELOG_SIZE) {
                                while((*eol != '\r') && (*eol != '\n')) eol++;
                                while((*eol == '\r') || (*eol == '\n')) eol++;
                                lsize = eol-buf;
                        }
                        fsize -= lsize;
                        newfsize -= lsize;
                        eob -= lsize;
                        memcpy(buf,eol,fsize);
                }
                if (tbuflen)
                        sprintf(eob,"%s: %s @ %s\n",logaction,string,tbuf);
                else
                        sprintf(eob,"%s: %s\n",logaction,string);
                err = _tfsunlink(TFS_CHANGELOG_FILE);
                if (err < 0)
                        printf("%s: %s\n",TFS_CHANGELOG_FILE,
                                (char *)tfsctrl(TFS_ERRMSG,err,0));
                err = tfsadd(TFS_CHANGELOG_FILE,0,"u3",buf,newfsize);
                if (err < 0)
                        printf("%s: %s\n",TFS_CHANGELOG_FILE,
                                (char *)tfsctrl(TFS_ERRMSG,err,0));
        }
        else {
                if (tbuflen)
                        len = sprintf(buf,"%s: %s @ %s\n",logaction,string,tbuf);
                else
                        len = sprintf(buf,"%s: %s\n",logaction,string);
                err = tfsadd(TFS_CHANGELOG_FILE,0,"u3",buf,len);
                if (err < 0)
                        printf("%s: %s\n",TFS_CHANGELOG_FILE,
                                (char *)tfsctrl(TFS_ERRMSG,err,0));
        }

        /* Restore the original getUsrLvl() functionality: */
        clrTmpMaxUsrLvl(fptr);
#endif
}

int
tfsLogCmd(int argc,char *argv[], int optind)
{
#if TFS_CHANGELOG_SIZE
        int     status;
        int     retval = 0;

        if (getUsrLvl() < MAXUSRLEVEL) {
                status = showTfsError(TFSERR_USERDENIED,0);
        }
        else {
                if (argc == optind + 3) {
                        if (!strcmp(argv[optind+1],"on"))
                                tfslog(TFSLOG_ON,argv[optind+2]);
                        else if (!strcmp(argv[optind+1],"off"))
                                tfslog(TFSLOG_OFF,argv[optind+2]);
                        else
                                retval = CMD_PARAM_ERROR;
                }
                else if (argc == optind + 1)
                        printf("TFS logging %sabled\n",tfsLogging ? "en" : "dis");
                else
                        retval = CMD_PARAM_ERROR;
        }
        return(retval);
#else
        return(CMD_FAILURE);
#endif
}