Example #1
0
/* test if the whitespace of the token contains at least 2
 * linebreaks. This means that this token is at the beginning of a new
 * paragraph
 */
s_bool s_test_whitespace_double_line_breaks(const char *token_whitespace, s_erc *error)
{
	const char *forward_linebreak;
	const char *reverse_linebreak;


	S_CLR_ERR(error);
	forward_linebreak = s_strchr(token_whitespace, '\n', error);
	if (S_CHK_ERR(error, S_CONTERR,
				  "s_test_whitespace_double_line_breaks",
				  "Call to \"s_strchr\" failed"))
		return FALSE;

	if (forward_linebreak == NULL) /* no linebreaks */
		return FALSE;

	reverse_linebreak = s_strrchr(token_whitespace, '\n', error);
	if (S_CHK_ERR(error, S_CONTERR,
				  "s_test_whitespace_double_line_breaks",
				  "Call to \"s_strrchr\" failed"))
		return FALSE;

	if (forward_linebreak != reverse_linebreak) /* at least 2
												   linebreaks */
		return TRUE;

	return FALSE;
}
Example #2
0
/*
 * Create registry entries for installing service as an event source
 */
int install_event_source(const char *service_name)
{
	HKEY regkey;
	char path[MAX_PATH] = EVENT_PATH;

	s_strcat(path, MAX_PATH, service_name);

	int ret = RegCreateKeyEx(HKEY_LOCAL_MACHINE,
			path,
			0,
			0,
			REG_OPTION_NON_VOLATILE,
			KEY_SET_VALUE,
			0,
			&regkey,
			0);
	if (ret == ERROR_SUCCESS)
	{
		DWORD types_supported = EVENTLOG_ERROR_TYPE |
				EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE;

		TCHAR message_lib[MAX_PATH];
		char *last_slash;
		GetModuleFileName(NULL, message_lib, MAX_PATH);
		last_slash = s_strrchr(message_lib, '\\', MAX_PATH);
		if (NULL != last_slash)
			*last_slash = '\0';
		s_strcat(message_lib, MAX_PATH, "\\");
		s_strcat(message_lib, MAX_PATH, MESSAGE_LIB);

		ret = RegSetValueEx(regkey,
				"EventMessageFile",
				0,
				REG_SZ,
				(BYTE *) message_lib,
				strlen(message_lib));

		if (ret == ERROR_SUCCESS)
		{
			ret = RegSetValueEx(regkey,
					"TypesSupported",
					0,
					REG_DWORD,
					(LPBYTE) &types_supported,
					sizeof (types_supported));
		}

		if (ret != ERROR_SUCCESS) // Failed to create either of the values
		{
			ret = COMMON_ERR_FAILED;
		}
		else
		{
			ret = COMMON_SUCCESS;
		}

		RegCloseKey(regkey);
	}

	return ret;
}
Example #3
0
/*
* Service Main function - Called by the SCM after the service has started
*/
void WINAPI ServiceMain(DWORD argc, LPTSTR *argv)
{
	gServiceHandle = RegisterServiceCtrlHandler(g_serviceName, ServiceCtrlHandler);
	if (gServiceHandle == 0)
	{
		logStartError("RegisterServiceCtrlHandler failed.");
	}
	else
	{
		// signal service is starting
		setServiceStatus(SERVICE_START_PENDING, TRUE, NO_ERROR, 3000);

		// create event for when service is signaled to stop
		g_serviceStopEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
		if (g_serviceStopEvent)
		{
			TCHAR szPath[MAX_PATH];
			char *last_slash;

			GetModuleFileName(NULL, szPath, MAX_PATH);
			last_slash = s_strrchr(szPath, '\\', MAX_PATH);
			if (NULL != last_slash)
				*last_slash = '\0';

			if (SetCurrentDirectory(szPath))
			{
				std::vector<monitor::NvmMonitorBase *> monitors;
				monitor::NvmMonitorBase::getMonitors(monitors);

				size_t handleCount = monitors.size() + 1; // +1 to also add g_serviceStopEvent
				HANDLE handles[handleCount];
				for (size_t i = 0; i < monitors.size(); i++)
				{
					handles[i] =
							CreateThread(NULL, 0, WorkerThread, (LPVOID) (monitors[i]), 0, NULL);
				}

				// In the case there are no monitor items, adding the stop event will keep the
				// service running until a Service Stop Event occurs.
				handles[handleCount - 1] = g_serviceStopEvent;

				// now running
				setServiceStatus(SERVICE_RUNNING, false, NO_ERROR, 0);

				// wait for all threads to end and Service Stop Event
				WaitForMultipleObjects(handleCount, handles, true, INFINITE);

				// clean up
				for (size_t i = 0; i < handleCount; i++)
				{
					CloseHandle(handles[i]);
				}
				monitor::NvmMonitorBase::deleteMonitors(monitors);

				setServiceStatus(SERVICE_STOPPED, FALSE, NO_ERROR, 0);
			}
			else
			{
				logStartError("Failed to set working directory.");
				setServiceStatus(SERVICE_STOPPED, FALSE, NO_ERROR, 0);
			}

		}
		else
		{
			logStartError("CreateEvent Failed");
			setServiceStatus(SERVICE_STOPPED, FALSE, NO_ERROR, 0);
		}


	}
}
Example #4
0
/*

    Function:   iPrsFinishDocument()

    Purpose:    Finish the document.

    Parameters: pppPrsParser            structure containing the various parser options 
                                        we use to parse the data
                ppfPrsFormat            file profile pointing to the various file options 
                                        we use to parse the data
                pfIndexerFile           file descriptor to which we send the structured index stream
                pucFilePath             file path of the file currently being parsed (optional)
                zStartOffset            start index in the file
                zEndOffset              end index in the file
                uiDocumentTermCount     document term count

    Globals:    none

    Returns:    0 on success, -1 on error

*/
static int iPrsFinishDocument
(
    struct prsParser *pppPrsParser,
    struct prsFormat *ppfPrsFormat,
    FILE *pfIndexerFile,
    unsigned char *pucFilePath,
    off_t zStartOffset,
    off_t zEndOffset,
    unsigned int uiDocumentTermCount
)
{

    int             iError = UTL_NoError;
    wchar_t         pwcDocumentTitle[SPI_TITLE_MAXIMUM_LENGTH + 1] = {L'\0'};
    wchar_t         pwcDocumentKey[SPI_DOCUMENT_KEY_MAXIMUM_LENGTH + 1] = {L'\0'};
    wchar_t         pwcDocumentUrl[SPI_URL_MAXIMUM_LENGTH + 1] = {L'\0'};
    unsigned int    uiDocumentRank = 0;
    unsigned long   ulDocumentAnsiDate = 0;


    ASSERT(pppPrsParser != NULL);
    ASSERT(ppfPrsFormat != NULL);
    ASSERT(pfIndexerFile != NULL);
    ASSERT(zStartOffset >= 0);
    ASSERT(zEndOffset >= 0);
    ASSERT(zEndOffset >= zStartOffset);
    ASSERT(uiDocumentTermCount >= 0);


    /* Get the document information */
    if ( ppfPrsFormat->vPrsDocumentInformationFunction != NULL ) {
        ppfPrsFormat->vPrsDocumentInformationFunction(pucFilePath, pwcDocumentTitle, pwcDocumentKey, pwcDocumentUrl, &uiDocumentRank, &ulDocumentAnsiDate);
    }


    /* Clean the title and document key from extraneous characters that may have crept in */
    iUtlStringsTrimWideString(pwcDocumentTitle);
    iUtlStringsTrimWideString(pwcDocumentKey);


    /* Use the base name of the file path as the title if we have no title */                
    if ( (bUtlStringsIsWideStringNULL(pwcDocumentTitle) == true) && (bUtlStringsIsStringNULL(pucFilePath) == false) ) {

        unsigned char   *pucFilePathBasePtr = NULL;

        swprintf(pwcDocumentTitle, SPI_TITLE_MAXIMUM_LENGTH + 1, L"%s", 
                (iUtlFileGetPathBase(pucFilePath, &pucFilePathBasePtr) == UTL_NoError) ? pucFilePathBasePtr : pucFilePath);
    }


    /* Send the document title
    ** H    title{A} (Title)
    */
    if ( fprintf(pfIndexerFile, "H %ls\n", pwcDocumentTitle) < 0 ) {
        iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a title line to the indexer");
    }


    /* Send the date
    ** D   date{D} (Document ansi date - optional)
    */
    if ( ulDocumentAnsiDate > 0 ) {
        if ( fprintf(pfIndexerFile, "D %lu\n", ulDocumentAnsiDate) < 0 ) {
            iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a date line to the indexer");
        }
    }
    /* There is no date or date/time defined, so we get them from the file we are parsing */
    else if ( bUtlStringsIsStringNULL(pucFilePath) == false ) {

        time_t          tTime = (time_t)0;
        struct tm       tmTime;
        unsigned char   pucDateString[UTL_FILE_PATH_MAX + 1] = {'\0'};

        /* Get the date and time from the file */
        if ( iUtlFileGetPathModificationTimeT(pucFilePath, &tTime) == UTL_NoError ) {

            s_localtime_r(&tTime, &tmTime);

            s_strftime(pucDateString, UTL_FILE_PATH_MAX, "%Y%m%d%H%M%S", &tmTime);
            if ( fprintf(pfIndexerFile, "D %s\n", pucDateString) < 0 ) {
                iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a date line to the indexer");
            }
        }
    }


    /* Send the rank
    ** R   rank{N}] (Document rank - optional)
    */
    if ( uiDocumentRank > 0 ) {
        if ( fprintf(pfIndexerFile, "R %u\n", uiDocumentRank) < 0 ) {
            iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a rank line to the indexer");
        }
    }


    /* Send the document key if needed
    ** K   key{A} (document key - optional)
    */
    if ( bUtlStringsIsWideStringNULL(pwcDocumentKey) == false ) {
        if ( fprintf(pfIndexerFile, "K %ls\n", pwcDocumentKey) < 0 ) {
            iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a document key line to the indexer");
        }
    }
    else {

        if ( pppPrsParser->uiDocumentKey > 0 ) {
            if ( fprintf(pfIndexerFile, "K %u\n", pppPrsParser->uiDocumentKey) < 0 ) {
                iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a document key line to the indexer");
            }
        }
    }


    /* Send the term count
    ** C   count{N} (term count - optional)
    */
    if ( fprintf(pfIndexerFile, "C %u\n", uiDocumentTermCount) < 0 ) {
        iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a term count line to the indexer");
    }


    /* Send the item information
    ** I    itemName{A} mimeType{A} length{N} [filepath{A} start{N} end{N}] [URL{A}] (Document types and source files)
    */
    if ( pppPrsParser->ppaPrsAssociation == NULL ) {

        if ( fprintf(pfIndexerFile, "I %s %s %ld", (pppPrsParser->pucItemName != NULL) ? pppPrsParser->pucItemName : ppfPrsFormat->pucItemName, 
                (pppPrsParser->pucMimeType != NULL) ? pppPrsParser->pucMimeType : ppfPrsFormat->pucMimeType, (long)(zEndOffset - zStartOffset)) < 0 ) {
            iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a document type line to the indexer");
        }

        if ( (pppPrsParser->bStoreFilePaths == true) && (bUtlStringsIsStringNULL(pucFilePath) == false) ) {
            if ( fprintf(pfIndexerFile, " %s %ld %ld", pucFilePath, (long)zStartOffset, (long)(zEndOffset - 1)) < 0 ) {
                iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a document type line to the indexer");
            }
        }

        if ( bUtlStringsIsWideStringNULL(pwcDocumentUrl) == false ) {
            if ( fprintf(pfIndexerFile, " %ls", pwcDocumentUrl) < 0 ) {
                iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a document type line to the indexer");
            }
        }

        if ( fprintf(pfIndexerFile, "\n") < 0 ) {
            iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a document type line to the indexer");
        }
    }
    else if ( bUtlStringsIsStringNULL(pucFilePath) == false ) {

        unsigned int    uiI = 0;

        for ( uiI = 0; uiI < pppPrsParser->uiPrsAssociationLength; uiI++ ) {

            unsigned char   pucSavedFilePath[UTL_FILE_PATH_MAX + 1] = {'\0'};
            unsigned char   *pucSavedFilePathPtr = NULL;

            s_strnncpy(pucSavedFilePath, pucFilePath, UTL_FILE_PATH_MAX + 1);

            /* Strip the current extension, but not the period (add a period if it is not there) */
            if ( (pucSavedFilePathPtr = (unsigned char *)s_strrchr(pucSavedFilePath, '.')) != NULL ) {
                *pucSavedFilePathPtr = '\0';
            }

            /* Append the extension to the file path */
            s_strnncat(pucSavedFilePath, (pppPrsParser->ppaPrsAssociation + uiI)->pucExtension, UTL_FILE_PATH_MAX, UTL_FILE_PATH_MAX + 1);


            /* Check to see if the file is there */
            if ( bUtlFilePathRead(pucSavedFilePath) == true ) {
                
                off_t   zFileLength = 0;

                /* Get the file length */
                if ( (iError = iUtlFileGetFilePathLength(pucSavedFilePath, &zFileLength)) != UTL_NoError ) {
                    iUtlLogError(UTL_LOG_CONTEXT, "Failed to get length of the file: '%s', utl error: %d.", pucSavedFilePath, iError);
                    return (-1);
                }

                if ( fprintf(pfIndexerFile, "I %s %s", (pppPrsParser->ppaPrsAssociation + uiI)->pucItemName, (pppPrsParser->ppaPrsAssociation + uiI)->pucMimeType) < 0 ) {
                    iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a document type line to the indexer");
                }


                if ( (pppPrsParser->bStoreFilePaths == true) && (bUtlStringsIsStringNULL(pucFilePath) == false) ) {
                    if ( fprintf(pfIndexerFile, " %ld %s 0", (long)zFileLength, pucSavedFilePath) < 0 ) {
                        iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a document type line to the indexer");
                    }
                }

                if ( fprintf(pfIndexerFile, " %ld\n", (long)(zFileLength - 1)) < 0 ) {
                    iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a document type line to the indexer");
                }
            }
        }
    }


    /* Send end of document marker
    ** E    (End of document marker)
    */
    if ( fprintf(pfIndexerFile, "E\n") < 0 ) {
        iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a end of document line to the indexer");
    }
    
                
    /* Increment the number of documents */
    pppPrsParser->uiDocumentCount++;

    
    /* Check to see if we have reached the document count limit and generate a message if we have */
    if ( (pppPrsParser->uiDocumentCountMax > 0) && (pppPrsParser->uiDocumentCount >= pppPrsParser->uiDocumentCountMax) ) {

        if ( bUtlStringsIsWideStringNULL(pwcDocumentKey) == false ) {
            
            iUtlLogInfo(UTL_LOG_CONTEXT, "Reached maximum number of documents to parse (%u), last document key: '%ls'.", pppPrsParser->uiDocumentCountMax, pwcDocumentKey);
            
            if ( fprintf(pfIndexerFile, "M Reached maximum number of documents to parse (%u), last document key: '%ls'\n", pppPrsParser->uiDocumentCountMax, pwcDocumentKey) < 0 ) {
                iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a message line to the indexer");
            }
        }
        else {
            if ( pppPrsParser->uiDocumentKey > 0 ) {

                iUtlLogInfo(UTL_LOG_CONTEXT, "Reached maximum number of documents to parse (%u), last document key: '%u'.", pppPrsParser->uiDocumentCountMax, pppPrsParser->uiDocumentKey);

                if ( fprintf(pfIndexerFile, "M Reached maximum number of documents to parse (%u), last document key: '%u'\n", pppPrsParser->uiDocumentCountMax, pppPrsParser->uiDocumentKey) < 0 ) {
                    iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a message line to the indexer");
                }
            }
            else {
                iUtlLogInfo(UTL_LOG_CONTEXT, "Reached maximum number of documents to parse (%u).", pppPrsParser->uiDocumentCountMax);

                if ( fprintf(pfIndexerFile, "M Reached maximum number of documents to parse (%u)\n", pppPrsParser->uiDocumentCountMax) < 0 ) {
                    iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a message line to the indexer");
                }
            }
        }
    }
    
    
    /* Increment the document key */
    if ( pppPrsParser->uiDocumentKey > 0 ) {
        pppPrsParser->uiDocumentKey++;
    }


    return (0);

}