contentLister/src/history.c File Reference

#include <stdio.h>
#include <memory.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
#include <string.h>
#include <strings.h>
#include <errno.h>
#include <glib.h>
#include <liberregxml/erregapi.h>
#include <libermanifest/ermanifest.h>
#include "contentListerLog.h"
#include "stack.h"
#include "history.h"
#include "programManager.h"
#include "regValue.h"
#include "metadataStoreManager.h"
#include "system.h"

Go to the source code of this file.

Defines
#define	NO_VIEWER_ACTIVE   ""
Functions
static clDisplayItem_t *	hsCreateItem (regLastRead_t *content)
static void	hsCreateConvertItem (regLastRead_t *content, clDisplayItem_t *item)
static void	hsAddRecent (const clDisplayItem_t *item)
void	hsInit (void)
void	hsDestroy (void)
void	hsStoreItem (st_ContentType_e contentType, clDisplayItem_t *item)
void	hsGetItem (st_ContentType_e contentType, clDisplayItem_t *item)
gboolean	hsSetLocation (st_ContentType_e contentType, char *location)
char *	hsGetLocation (st_ContentType_e contentType)
gboolean	hsRemoveLocation (st_ContentType_e contentType)
void	hsSetActiveViewer (st_ContentType_e contentType, char *viewerId)
char *	hsGetActiveViewer (st_ContentType_e contentType)
st_ContentType_e	hsGetContentType (char *viewerId)
static gboolean	isSymLink (const char *szPath)
void	hsCleanupSymlinks (const char *szLinkDir)
void	hsLimitSymlinks (const char *szLinkDir, int maxItems)
Variables
static clDisplayItem_t *	g_history [ARCHIVE_TYPE_COUNT]
static char *	g_location [TOTAL_STACK_COUNT]
static char	g_activeViewer [ARCHIVE_TYPE_COUNT][UAID_MAX_SIZE]

---

Define Documentation

#define NO_VIEWER_ACTIVE   ""

Definition at line 58 of file history.c.

---

Function Documentation

static void hsAddRecent

(

const clDisplayItem_t *

item

)

[static]

Definition at line 420 of file history.c.

{
    g_assert(item != NULL);
    CL_HISTORYPRINTF("Entry: filename [%s] fit [%d]", item->szFilename, item->fit);
    g_return_if_fail(item->fit == mdsFitFile  ||  item->fit == mdsFitContainer);

    int      sequence;
    int      err;
    int      n;
    gboolean done;
    char     *cp;
    char     szTargetFile[ERMDS_MAX_FILENAME_SIZE] = "";
    char     szLinkName[ERMDS_MAX_FILENAME_SIZE]   = "";
    char     szLinkTarget[ERMDS_MAX_FILENAME_SIZE] = "";

    DIR           *dirp;
    struct dirent *direntp;
    const char    *linkdir = g_location[st_RecentDocuments];


    // determine target name
    switch (item->fit)
    {
        case mdsFitFile:
            snprintf(szLinkName, sizeof(szLinkName), item->szFilename);
            break;
            
        case mdsFitContainer:
            snprintf(szLinkName, sizeof(szLinkName), item->szManifest);
            // strip filename, use directory name
            cp = strrchr(szLinkName, '/');
            g_return_if_fail(cp != NULL);
            *cp = '\0';
            break;
            
        default:
            break;  // ignore
    }

    // resolve symlink and symlinks in directory path
    if ( realpath(szLinkName, szTargetFile) == NULL )
    {
        CL_ERRORPRINTF("Could not resolve path [%s] error [%s]", szLinkName, strerror(errno));
        return;
    }
    CL_HISTORYPRINTF("target [%s]", szTargetFile);

    // remove existing link(s) to the target, if any
    if ((dirp = opendir(linkdir)) == NULL)
    {
        CL_ERRORPRINTF("Could not open directory [%s] error [%s].", linkdir, strerror(errno));
    }
    else
    {
        while ((direntp = readdir(dirp)) != NULL)
        {
            // directory entry read
            snprintf(szLinkName, sizeof(szLinkName), "%s/%s", linkdir, direntp->d_name);
            if ( isSymLink(szLinkName) )
            {
                // directory entry is a symlink
                // Note: The code below removes existing symlinks to the new target,
                //       but also symlinks to its parent directory or higher ancestor directories.
                //       This behaviour is unintentional, but serves is good in case a symlink
                //       points to a multi-language document (see tracker 962) while a specific
                //       version of this document is opened.
                //       Example:
                //         symlnk exists to          /mnt/free/documents/Reference/usermanual
                //         new symlink must point to /mnt/free/documents/Reference/usermanual/en_US
                n = readlink(szLinkName, szLinkTarget, sizeof(szLinkTarget) - 1);
                if (n > 0  &&  strncmp(szLinkTarget, szTargetFile, n) == 0)
                {
                    // symlink points to our target: delete symlink
                    szLinkTarget[n] = '\0';
                    CL_HISTORYPRINTF("Remove symlink [%s] -> [%s]", szLinkName, szLinkTarget);
                    unlink(szLinkName);
                }
            }
        }
        closedir(dirp);
    }
    
    // create a new symlink to the target
    done = FALSE;
    for ( sequence = 0 ; !done  &&  sequence <= 99 ; sequence++ )
    {
        // determine name of symlink
        time_t     t_time  = time(NULL);
        struct tm* tm_time = localtime( &t_time );
        snprintf( szLinkName,
                  ERMDS_MAX_FILENAME_SIZE,
                  "%s/Link_%04d-%02d-%02dT%02d:%02d:%02d:%02d",
                   linkdir,
                           tm_time->tm_year + 1900,
                                tm_time->tm_mon + 1,
                                     tm_time->tm_mday,
                                          tm_time->tm_hour,
                                               tm_time->tm_min,
                                                    tm_time->tm_sec,
                                                         sequence   );

        // create symbolic link, replace existing link when present
        if (symlink(szTargetFile, szLinkName) == 0)
        {
            CL_HISTORYPRINTF("Created symlink [%s] -> [%s]", szLinkName, szTargetFile);
            done = TRUE;
        }
        else
        {
            err = errno;
            CL_ERRORPRINTF("Error [%s] on create symlink [%s] -> [%s]", strerror(err), szLinkName, szTargetFile);
            if (err == EEXIST)
            {
                CL_ERRORPRINTF("[%s] already exists", szLinkName);
            }
        }
    }

    // limit the number of symlinks
    hsLimitSymlinks(linkdir, MAX_RECENT_ITEMS);
}

Here is the call graph for this function:

void hsCleanupSymlinks

(

const char *

szLinkDir

)

Remove symlinks for which the target is not present

Parameters:

szTargetDir

directory to scan for symlinks

Returns:

--

Definition at line 544 of file history.c.

{
    g_assert(szLinkDir != NULL);
    CL_HISTORYPRINTF("Entry: directory [%s]", szLinkDir);
    
    DIR*   dirp;
    struct dirent* direntp;
    struct stat    statBuf;
    
    char   szName[ERMDS_MAX_FILENAME_SIZE];


    if ((dirp = opendir(szLinkDir)) == NULL)
    {
        CL_ERRORPRINTF("Could not open directory %s (error %s).", szLinkDir, strerror(errno));
        return;
    }
    else
    {
        while ((direntp = readdir(dirp)) != NULL)
        {
            if (   strcmp(".",  direntp->d_name) == 0
                || strcmp("..", direntp->d_name) == 0)
            {
                // skip this entry
                continue;
            }
            
            snprintf(szName, ERMDS_MAX_FILENAME_SIZE, "%s/%s", szLinkDir, direntp->d_name);
            if (   isSymLink(szName)
                && stat(szName, &statBuf) == -1 )
            {
                // directory entry is a symlink, but no file/directory behind it: remove symlink
                CL_HISTORYPRINTF("Remove symlink [%s]", szName);
                unlink(szName);
            }
        }

        closedir(dirp);
    }
}

Here is the call graph for this function:

static void hsCreateConvertItem	(	regLastRead_t *	content,
		clDisplayItem_t *	item
	)			[static]

Definition at line 390 of file history.c.

{
    if ((content) && (theItem))
    {
        content->documentPath = g_strdup(theItem->szFilename);
        content->extension = g_strdup(theItem->szFileExt);
        content->manifestPath = g_strdup(theItem->szManifest);
    }
}

static clDisplayItem_t * hsCreateItem

(

regLastRead_t *

content

)

[static]

Definition at line 366 of file history.c.

{
    clDisplayItem_t *theItem = NULL;

    theItem = g_new0(clDisplayItem_t, 1);
    if ((theItem) && (content))
    {
        g_snprintf(theItem->szFilename, ERMDS_MAX_FILENAME_SIZE, "%s", content->documentPath);
        g_snprintf(theItem->szFileExt,  ERMDS_MAX_FILENAME_SIZE, "%s", content->extension   );
        if (   content->manifestPath    == NULL
            || content->manifestPath[0] == '\0' )
        {
            theItem->fit = mdsFitFile;
            strcpy(theItem->szManifest, ""); 
        }
        else
        {
            theItem->fit = mdsFitContainer;
            g_snprintf(theItem->szManifest, ERMDS_MAX_FILENAME_SIZE, "%s", content->manifestPath);
        }
    }
    return theItem;
}

void hsDestroy

(

void

)

Store the history information in the registry and destroy allocated resources used by the history module

Returns:

-

Definition at line 137 of file history.c.

{
    int     index;
    regLastRead_t *theLastRead = NULL;

    CL_HISTORYPRINTF("");

    //store the history information in the registry
    prepare_registry_write();
    CL_HISTORYPRINTF("Checked and loaded registry");

    CL_HISTORYPRINTF("Store BOOKS_CATEGORY");
    theLastRead = g_new0(regLastRead_t, 1);
    hsCreateConvertItem(theLastRead, g_history[st_ContentTypeBooks]);
    // avoid writing NULL to registry
    if (g_location[st_ContentTypeBooks])
    {
        theLastRead->position = g_strdup(g_location[st_ContentTypeBooks]);
    }
    else
    {
        theLastRead->position = g_strdup("");
    }
    erRegSetLastRead(BOOKS_CATEGORY, theLastRead);
    erRegFreeLastRead(theLastRead);

    CL_HISTORYPRINTF("Store NEWSPAPERS_CATEGORY");
    theLastRead = g_new0(regLastRead_t, 1);
    hsCreateConvertItem(theLastRead, g_history[st_ContentTypeNews]);
    // avoid writing NULL to registry
    if (g_location[st_ContentTypeNews])
    {
        theLastRead->position = g_strdup(g_location[st_ContentTypeNews]);
    }
    else
    {
        theLastRead->position = g_strdup("");
    }
    CL_HISTORYPRINTF("position %s", theLastRead->position);
    erRegSetLastRead(NEWSPAPERS_CATEGORY, theLastRead);
    erRegFreeLastRead(theLastRead);

    CL_HISTORYPRINTF("Store DOCUMENTS_CATEGORY");
    theLastRead = g_new0(regLastRead_t, 1);
    hsCreateConvertItem(theLastRead, g_history[st_ContentTypeDocs]);
    CL_HISTORYPRINTF("position %s", theLastRead->position);
    // avoid writing NULL to registry
    if (g_location[st_ContentTypeDocs])
    {
        theLastRead->position = g_strdup(g_location[st_ContentTypeDocs]);
    }
    else
    {
        theLastRead->position = g_strdup("");
    }
    CL_HISTORYPRINTF("position %s", theLastRead->position);
    erRegSetLastRead(DOCUMENTS_CATEGORY, theLastRead);
    erRegFreeLastRead(theLastRead);

    CL_HISTORYPRINTF("Store NOTES_CATEGORY");
    theLastRead = g_new0(regLastRead_t, 1);
    hsCreateConvertItem(theLastRead, g_history[st_ContentTypeNotes]);
    // avoid writing NULL to registry
    if (g_location[st_ContentTypeNotes])
    {
        theLastRead->position = g_strdup(g_location[st_ContentTypeNotes]);
    }
    else
    {
        theLastRead->position = g_strdup("");
    }
    CL_HISTORYPRINTF("position %s", theLastRead->position);
    erRegSetLastRead(NOTES_CATEGORY, theLastRead);
    erRegFreeLastRead(theLastRead);

    do_registry_write();
    CL_HISTORYPRINTF("Stored registry");


    CL_HISTORYPRINTF("Free resources");

    for (index = 0; index < ARCHIVE_TYPE_COUNT; index++)
    {
        if (g_history[index])
        {
            g_free(g_history[index]);
            g_history[index] = NULL;
        }

        if (g_location[index])
        {
            g_free(g_location[index]);
            g_location[index] = NULL;
        }
    }
}

Here is the call graph for this function:

char* hsGetActiveViewer

(

st_ContentType_e

contentType

)

Get the active viewer for the specified contentType

Parameters:

contentType

Returns:

viewerId " " or NULL in case no viewer

Definition at line 335 of file history.c.

{
    char   *viewerId = NULL;

    if (stackIsArchive(contentType))
    {
        viewerId = g_activeViewer[contentType];

        CL_HISTORYPRINTF("contentType %d viewerId %s", contentType, viewerId);
    }
    return viewerId;
}

Here is the call graph for this function:

st_ContentType_e hsGetContentType

(

char *

viewerid

)

Get the contentType associated with the "active viewer"

Parameters:

contentType

Returns:

viewerId

Definition at line 348 of file history.c.

{
    st_ContentType_e theType = st_ContentTypeUndefined;
    int     index;

    CL_HISTORYPRINTF("viewerId %s", viewerId);

    for (index = 0; index < ARCHIVE_TYPE_COUNT; index++)
    {
        if (strncmp(g_activeViewer[index], viewerId, UAID_MAX_SIZE) == 0)
        {
            CL_HISTORYPRINTF("theType %d", index);
            theType = index;
        }
    }
    return theType;
}

void hsGetItem	(	st_ContentType_e	contentType,
		clDisplayItem_t *	item
	)

retrieve a copy of the history item of the specified content type

Parameters:

	contentType
	item	- reference to memory where the copy should be returned

Returns:

-

Definition at line 258 of file history.c.

{
    CL_HISTORYPRINTF("contentType %d item 0x%x", contentType, (unsigned int) item);

    if ((item) && (stackIsArchive(contentType)))
    {
        memcpy(item, g_history[contentType], sizeof(clDisplayItem_t));
    }
}

Here is the call graph for this function:

char* hsGetLocation

(

st_ContentType_e

contentType

)

Get the item location information from the history data (RAM)

Parameters:

contentType

Returns:

last viewer location of this item, NULL when not available (this string value should be freed by the calling routine !!)

Definition at line 286 of file history.c.

{
    char   *theLocation = NULL;

    CL_HISTORYPRINTF("type %d", contentType);

    if (stackIsArchive(contentType))
    {
        theLocation = g_strdup(g_location[contentType]);
    }
    return theLocation;
}

Here is the call graph for this function:

void hsInit

(

void

)

Allocate memory to store one history item for the available archive content types and retrieve the history values from the registry

Returns:

-

Definition at line 70 of file history.c.

{
    int  i;
    char buf[ERMDS_MAX_FILENAME_SIZE];
    regLastRead_t *theBooks = NULL;
    regLastRead_t *theNews  = NULL;
    regLastRead_t *theDocs  = NULL;
    regLastRead_t *theNotes = NULL;

    CL_HISTORYPRINTF("");

    // retrieve the history information from the registry
    theBooks = erRegGetLastRead(BOOKS_CATEGORY);
    theNews = erRegGetLastRead(NEWSPAPERS_CATEGORY);
    theDocs = erRegGetLastRead(DOCUMENTS_CATEGORY);
    theNotes = erRegGetLastRead(NOTES_CATEGORY);
 
    g_history[st_ContentTypeBooks] = hsCreateItem(theBooks);
    if (theBooks)
    {
        CL_HISTORYPRINTF("Found BOOKS_CATEGORY (loc %s)", theBooks->position);
        g_location[st_ContentTypeBooks] = g_strdup(theBooks->position);
        erRegFreeLastRead(theBooks);
    }
    strncpy(g_activeViewer[st_ContentTypeBooks], NO_VIEWER_ACTIVE, UAID_MAX_SIZE);

    g_history[st_ContentTypeNews] = hsCreateItem(theNews);
    if (theNews)
    {
        CL_HISTORYPRINTF("Found NEWSPAPERS_CATEGORY (loc %s)", theNews->position);
        g_location[st_ContentTypeNews] = g_strdup(theNews->position);
        erRegFreeLastRead(theNews);
    }
    strncpy(g_activeViewer[st_ContentTypeNews], NO_VIEWER_ACTIVE, UAID_MAX_SIZE);

    g_history[st_ContentTypeDocs] = hsCreateItem(theDocs);
    if (theDocs)
    {
        CL_HISTORYPRINTF("Found DOCUMENTS_CATEGORY (loc %s)", theDocs->position);
        g_location[st_ContentTypeDocs] = g_strdup(theDocs->position);
        erRegFreeLastRead(theDocs);
    }
    strncpy(g_activeViewer[st_ContentTypeDocs], NO_VIEWER_ACTIVE, UAID_MAX_SIZE);

    g_history[st_ContentTypeNotes] = hsCreateItem(theNotes);
    if (theNotes)
    {
        CL_HISTORYPRINTF("Found NOTES_CATEGORY (loc %s)", theNotes->position);
        g_location[st_ContentTypeNotes] = g_strdup(theNotes->position);
        erRegFreeLastRead(theNotes);
    }
    strncpy(g_activeViewer[st_ContentTypeNotes], NO_VIEWER_ACTIVE, UAID_MAX_SIZE);

    // retrieve the recent-documents information from the registry
    i = mdsGetRootLocation(st_RecentDocuments, buf, sizeof(buf));
    if (i > 0)
    {
        g_location[st_RecentDocuments] = g_strdup(buf);
    }
    else
    {
        CL_ERRORPRINTF("mdsGetRootLocation(st_RecentDocuments) returns [%d]", i);
    }
}

Here is the call graph for this function:

void hsLimitSymlinks	(	const char *	szLinkDir,
		int	maxItems
	)

Limit symlinks to the specified number, removing symlinks with "lowest" names

Parameters:

	szTargetDir	directory to scan for symlinks
	maxItems	maximum number of symlinks allowed

Returns:

--

Definition at line 588 of file history.c.

{
    int    i;
    DIR*   dirp;
    struct dirent* direntp;

    typedef struct
    {
        char    szName[ERMDS_MAX_FILENAME_SIZE];
    } linkInfo_t;

    linkInfo_t* linkTable = alloca( sizeof(linkInfo_t) * (maxItems + 1) );
    linkInfo_t* linkOldest  = NULL;
    linkInfo_t* linkCurrent = &linkTable[0];
    int         linkNum = 0;

    g_return_if_fail(linkTable != NULL);

    if ((dirp = opendir(szLinkDir)) == NULL)
    {
        CL_ERRORPRINTF("Could not open directory %s (error %s).", szLinkDir, strerror(errno));
        return;
    }
    else
    {
        while ((direntp = readdir(dirp)) != NULL)
        {
            if (   strcmp(".",  direntp->d_name) == 0
                || strcmp("..", direntp->d_name) == 0)
            {
                // skip this entry
                continue;
            }
            
            linkCurrent = &linkTable[linkNum];
            snprintf(linkCurrent->szName, ERMDS_MAX_FILENAME_SIZE, "%s/%s", szLinkDir, direntp->d_name);

            if (linkNum < maxItems)
            {
                // table not full: add this item
                linkNum++;
                if (   linkOldest == NULL
                    || strcmp(linkCurrent->szName, linkOldest->szName) < 0)
                {
                    linkOldest = linkCurrent;
                }
            }
            else if (strcmp(linkCurrent->szName, linkOldest->szName) < 0)
            {
                // table full and item older than oldest: remove current item
                CL_HISTORYPRINTF("Remove symlink [%s]", linkCurrent->szName);
                delete_fsitem(linkCurrent->szName);
            }
            else
            {
                // table full and item newer than oldest: replace oldest item
                CL_HISTORYPRINTF("Remove symlink [%s]", linkOldest->szName);
                delete_fsitem(linkOldest->szName);
                *linkOldest = *linkCurrent;

                // find the oldest item now in the list
                for ( i = 0,      linkCurrent = &linkTable[0] ;
                      i < linkNum ;
                      i++,        linkCurrent++ )
                {
                    if (strcmp(linkCurrent->szName, linkOldest->szName) < 0)
                    {
                        linkOldest = linkCurrent;
                    }
                }
            }
        }// while
        
        closedir(dirp);
    }
}

Here is the call graph for this function:

gboolean hsRemoveLocation

(

st_ContentType_e

contentType

)

Remove the item location information from the history data (RAM)

Parameters:

contentType

Returns:

FALSE when not available

Definition at line 299 of file history.c.

{
    gboolean returnValue = FALSE;

    if (stackIsArchive(contentType))
    {
        if (g_location[contentType])
        {
            g_free(g_location[contentType]);
            g_location[contentType] = NULL;
            returnValue = TRUE;
        }
    }
    return returnValue;
}

Here is the call graph for this function:

void hsSetActiveViewer	(	st_ContentType_e	contentType,
		char *	viewerId
	)

Store the active viewer for the specified contentType and clear viewer ID if used for another contentType.

Parameters:

	contentType
	viewerId	unique identification of the viewere

Definition at line 315 of file history.c.

{
    int     index;

    CL_HISTORYPRINTF("contentType %d viewerId %s", contentType, viewerId);

    for (index = 0; index < ARCHIVE_TYPE_COUNT; index++)
    {
        if (g_activeViewer[index] == viewerId)
        {
            strncpy(g_activeViewer[index], NO_VIEWER_ACTIVE, UAID_MAX_SIZE);
        }
    }

    if (stackIsArchive(contentType))
    {
        strncpy(g_activeViewer[contentType], viewerId, UAID_MAX_SIZE);
    }
}

Here is the call graph for this function:

gboolean hsSetLocation	(	st_ContentType_e	contentType,
		char *	location
	)

Set the item location information in the history data (RAM) Thread safe

Parameters:

	contentType
	location	current viewer location of the current history item of this contentType

Returns:

FALSE in case of failure

Definition at line 268 of file history.c.

{
    CL_HISTORYPRINTF("type %d - %s", contentType, location);

    if (stackIsArchive(contentType))
    {
        if (g_location[contentType])
        {
            g_free(g_location[contentType]);
            g_location[contentType] = NULL;
        }

        g_location[contentType] = g_strdup(location);
    }

    return TRUE;
}

Here is the call graph for this function:

void hsStoreItem	(	st_ContentType_e	contentType,
		clDisplayItem_t *	item
	)

Store (copy) the content of the item in the history of the specified content type

Parameters:

	contentType
	item	- details of the currently "open item"

Returns:

-

Definition at line 234 of file history.c.

{
    CL_HISTORYPRINTF("contentType %d item 0x%x", contentType, (unsigned int) item);

    if ((item) && (stackIsArchive(contentType)))
    {
        memcpy(g_history[contentType], item, sizeof(clDisplayItem_t));
    }

    if (item)
    {
        if (    item->fit == mdsFitFile
            &&  strcasecmp(item->szFileExt, "png") == 0 )
        {
            // Notes template: do not add to recent documents
            CL_WARNPRINTF("Notes template: file [%s] not added to recent documents", item->szFilename);
        }
        else
        {
            hsAddRecent(item);
        }
    }
}

Here is the call graph for this function:

static gboolean isSymLink

(

const char *

szPath

)

[static]

Definition at line 403 of file history.c.

{
    struct stat statBuf;

    if (   lstat(szPath, &statBuf) == 0
        && S_ISLNK(statBuf.st_mode)    )
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

---

Variable Documentation

char g_activeViewer[ARCHIVE_TYPE_COUNT][UAID_MAX_SIZE] [static]

Definition at line 63 of file history.c.

clDisplayItem_t* g_history[ARCHIVE_TYPE_COUNT] [static]

Definition at line 61 of file history.c.

char* g_location[TOTAL_STACK_COUNT] [static]

Definition at line 62 of file history.c.