예제 #1
0
파일: help.cpp 프로젝트: donzelot/openBCM
mbhelp_t::~mbhelp_t ()
//*************************************************************************
//
//*************************************************************************
{
  if (helpf) s_fclose(helpf);
  if (idxf) s_fclose(idxf);
}
예제 #2
0
파일: wx.cpp 프로젝트: donzelot/openBCM
time_t wx::read_wx_data (char *oneline, time_t time_m)
//*************************************************************************
// Reads wx-data which is next to time_m, returns data and
// timestamp of data found.
// returns 0 when no data is found
//*************************************************************************
{
 char name[20];
 int found = 0;
 char times[13];
 char data[80];
 time_t times_l;
 long line = 0;

 strcpy(name, "wx:read_wx_data");
 FILE *wxf = s_fopen(time2wxfn(time_m), "srt");
 if (! wxf)
 {
   trace(report, name, "fopen %s err", time2wxfn(time_m));
   return 0L;
 }
 while (! found && ! feof(wxf))
 {
   fgets(data, 80, wxf);
   line++;
   rm_crlf(data);
   if (strlen(data) != 70)
   {
     trace(replog, name, "%s line %ld len %d invalid",
                   time2wxfn(time_m), line, strlen(data));
     s_fclose(wxf);
     return 0L;
   }
   //extract time stamp
   strncpy(times, data+57, 12);
   times[12] = 0;
   times_l = atol(times);
   //printf("%ld %ld %s\n",line,times_l,datestr(times_l,12));
   if (times_l>=time_m-360 && //max. 6min in advance (midnight)
       times_l< time_m+3960)  //max. 1h 6min past (daylightsaving)
     found++;
 }
 s_fclose(wxf);
 if (! found)
 {
   trace(report, name, "data missing");
   return 0L;
 }
 else
 {
   data[56] = 0;
   strcpy(oneline, data+6);
   return times_l;
 }
}
예제 #3
0
파일: grep.cpp 프로젝트: donzelot/openBCM
int grep (char *name, char *pattern, bitfeld options)
//*************************************************************************
//
//
//
//*************************************************************************
{
  FILE *f;
  CRegEx cr;
  int matches = 0;
  cr.m_options = options;

  if (name[0])
  {
    if (cr.regex_compile(pattern))
    {
      f = s_fopen(name, "srt");
      if (f)
      {
        setvbuf(f, NULL, _IOFBF, 4096);
        matches = cr.grepfile(f);
        s_fclose(f);
      }
      else
        putf(ms(m_filenotopen), name);
    }
    else
      putf(ms(m_badregex));
  }
  return matches;
}
예제 #4
0
/*
 * Send "QUIT" command and close the connection to the server
 *
 * Side effects: Closes the connection to the server.
 *	              You can't use "put_server" or "get_server" after this
 *	              routine is called.
 *
 * TODO: remember servers response string and if it contains anything else
 *       than just "." (i.e. transfer statistics) present it to the user?
 *
 */
void
close_server(
	void)
{
	if (nntp_wr_fp == NULL || nntp_rd_fp == NULL)
		return;

	if (!batch_mode || verbose)
		my_fputs(_(txt_disconnecting), stdout);
	nntp_command("QUIT", OK_GOODBYE, NULL, 0);
	quitting = TRUE;										/* Don't reconnect just for this */

	(void) s_fclose(nntp_wr_fp);
	(void) s_fclose(nntp_rd_fp);
	s_end();
	nntp_wr_fp = nntp_rd_fp = NULL;
}
예제 #5
0
파일: help.cpp 프로젝트: donzelot/openBCM
int mbhelp_t::helpopen (char *speech)
//*************************************************************************
//
//*************************************************************************
{
  time_t helptime = 0L;

  sprintf(helpname, MSGPATH "/help.%s", speech);
  strlwr(helpname);
  if ((helpf = s_fopen(helpname, "srt")) != NULL)
  {
    sprintf(idxname, MSGPATH "/helpidx.%s", speech);
    strlwr(idxname);
    idxf = s_fopen(idxname, "srb");
    {
      if (idxf)
      {
        fscanf(idxf, "%ld", &helptime);
        if (file_isreg(helpname) != helptime)
        {
          s_fclose(idxf);
          idxf = NULL;
        }
      }
      if (! idxf)
      {
        if (! helpindex()) // generate index file
        {
          s_fclose(helpf); // do not loose filehandles if no correct index
          helpf = NULL;
          return 0;
        }
      }
      fgets(inbuf, LINELEN, idxf); // skip the first line containing filetime
      return 1;
    }
  }
  else return 0;
}
예제 #6
0
파일: filter.c 프로젝트: fschiettecatte/mps
/*

    Function:   iSrchFilterGetSearchBitmapFromFilter()

    Purpose:    This function collects and searches filters and returns
                a bit map if there are any filters.
                
                The filter can either be a list name (mapping to a file),
                or a list of terms. If it is a list of terms, then each term has to be
                comma separated and must not contain any spaces.
                
                A search bitmap will not be allocated if no terms were found
                and an existing bitmap was not passed

    Parameters: pssSrchSearch           search structure
                psiSrchIndex            index structure
                uiLanguageID            language ID
                pspfSrchParserFilter    search parser string filter
                uiStartDocumentID       start document ID restriction (0 for no restriction)
                uiEndDocumentID         end document ID restriction (0 for no restriction)
                ppsbSrchBitmap          return pointer for the search bitmap structure 

    Globals:    none

    Returns:    SRCH error code

*/
static int iSrchFilterGetSearchBitmapFromFilter
(
    struct srchSearch *pssSrchSearch,
    struct srchIndex *psiSrchIndex,
    unsigned int uiLanguageID,
    struct srchParserFilter *pspfSrchParserFilter, 
    unsigned int uiStartDocumentID,
    unsigned int uiEndDocumentID,
    struct srchBitmap **ppsbSrchBitmap
)
{

    int                         iError = SRCH_NoError;
    void                        *pvLngStemmer = NULL;
    
    unsigned int                uiSrchParserSearchCacheID = SRCH_PARSER_MODIFIER_UNKNOWN_ID;
    
    unsigned char               pucConfigValue[SRCH_INFO_SYMBOL_MAXIMUM_LENGTH + 1] = {'\0'};
    unsigned char               pucFilterFilePath[UTL_FILE_PATH_MAX + 1] = {'\0'};
    FILE                        *pfFilterFile = NULL;
    off_t                       zFilterFileLength = 0;
    unsigned char               *pucFilterFileMappingPtr = NULL;
    time_t                      tFilterFileLastUpdate = (time_t)0;

    wchar_t                     *pwcTerms = NULL;
    wchar_t                     *pwcNormalizedExcludedTermsStrtokPtr = NULL;

    struct srchTermDictInfo     *pstdiSrchTermDictInfos = NULL;
    struct srchTermDictInfo     *pstdiSrchTermDictInfosPtr = NULL;
    unsigned int                uiSrchTermDictInfosLength = 0;
    unsigned int                uiI = 0;
    
    unsigned int                uiNormalizedTermsLength = 0;

    wchar_t                     *pwcTerm = NULL;
    unsigned char               *pucTerm = NULL;
    
    unsigned char               *pucFieldIDBitmap = NULL;

    

/*     iUtlLogDebug(UTL_LOG_CONTEXT, "iSrchFilterGetSearchBitmapFromFilter - pspfSrchParserFilter->pwcFilter: '%ls'", pspfSrchParserFilter->pwcFilter); */


    ASSERT(pssSrchSearch != NULL);
    ASSERT(psiSrchIndex != NULL);
    ASSERT(uiLanguageID >= 0);
    ASSERT(pspfSrchParserFilter != NULL);
    ASSERT(uiStartDocumentID >= 0);
    ASSERT(uiEndDocumentID >= 0);
    ASSERT(ppsbSrchBitmap != NULL);


    /* Create the stemmer */
    if ( (iError = iLngStemmerCreateByID(psiSrchIndex->uiStemmerID, uiLanguageID, &pvLngStemmer)) != LNG_NoError ) {
        iUtlLogError(UTL_LOG_CONTEXT, "Failed to create a stemmer, lng error: %d.", iError);
        iError = SRCH_FilterCreateStemmerFailed;
        goto bailFromiSrchFilterGetSearchBitmapFromFilter;
    }

    /* Get the parser search cache ID */
    if ( (iError = iSrchParserGetModifierID(pssSrchSearch->pvSrchParser, SRCH_PARSER_MODIFIER_SEARCH_CACHE_ID, &uiSrchParserSearchCacheID)) != SRCH_NoError ) {
        iUtlLogError(UTL_LOG_CONTEXT, "Failed to get the parser search cache ID, srch error: %d.", iError);
        goto bailFromiSrchFilterGetSearchBitmapFromFilter;
    }


    /* Terms based filter */
    if ( pspfSrchParserFilter->uiFilterTypeID == SRCH_PARSER_FILTER_TYPE_TERMS_ID ) {
        ;
    }
    
    /* List based filter */
    else if ( pspfSrchParserFilter->uiFilterTypeID == SRCH_PARSER_FILTER_TYPE_LIST_ID ) {

        unsigned char   *pucFilterDirectoryPath = NULL;
        unsigned char   *pucFilterName = NULL;
        unsigned char   pucFilterFileName[UTL_FILE_PATH_MAX + 1] = {'\0'};


        /* Check for the filter file if there is a location for these files */
        if ( (iError = iUtlConfigGetValue(pssSrchSearch->pvUtlConfig, SRCH_SEARCH_CONFIG_FILTER_FILES_LOCATION, pucConfigValue, SRCH_INFO_SYMBOL_MAXIMUM_LENGTH + 1)) != UTL_NoError ) {
            iUtlLogError(UTL_LOG_CONTEXT, "Failed to get the file file location from the search configuration, symbol name: '%s', utl error: %d.", 
                    SRCH_SEARCH_CONFIG_FILTER_FILES_LOCATION, iError); 
            iError = SRCH_FilterInvalidFilterFileLocation;
            goto bailFromiSrchFilterGetSearchBitmapFromFilter;
        }

        /* Get a pointer to the filter directory path, exclude the file protocol url if it is there */
        pucFilterDirectoryPath = (s_strncasecmp(pucConfigValue, SRCH_FILTER_FILE_PROTOCOL_URL, s_strlen(SRCH_FILTER_FILE_PROTOCOL_URL)) == 0) ? 
                pucConfigValue + s_strlen(SRCH_FILTER_FILE_PROTOCOL_URL) : pucConfigValue;

        /* Convert the filter from wide characters to utf-8, pucFilterName is allocated */
        if ( (iError = iLngConvertWideStringToUtf8_d(pspfSrchParserFilter->pwcFilter, 0, &pucFilterName)) != LNG_NoError ) {
            iUtlLogError(UTL_LOG_CONTEXT, "Failed to convert a filter name from wide characters to utf-8, lng error: %d.", iError);
            iError = SRCH_FilterCharacterSetConvertionFailed;
            goto bailFromiSrchFilterGetSearchBitmapFromFilter;
        }

        /* Create the filter file name */
        snprintf(pucFilterFileName, UTL_FILE_PATH_MAX + 1, "%s%s", pucFilterName, SRCH_FILTER_FILENAME_EXTENSION);
        
        /* Free the utf-8 filter file name */
        s_free(pucFilterName);

        /* Create the filter file path */
        if ( (iError = iUtlFileMergePaths(pucFilterDirectoryPath, pucFilterFileName, pucFilterFilePath, UTL_FILE_PATH_MAX + 1)) != UTL_NoError ) {
            iUtlLogError(UTL_LOG_CONTEXT, "Failed to create the filter file path, file file name: '%s', filter directory path: '%s', utl error: %d", 
                    pucFilterFileName, pucFilterDirectoryPath, iError); 
            iError = SRCH_FilterInvalidFilterFile;
            goto bailFromiSrchFilterGetSearchBitmapFromFilter;
        }
    
        /* Check if the filter file is there */
        if ( bUtlFileIsFile(pucFilterFilePath) == false ) {
                iUtlLogError(UTL_LOG_CONTEXT, "Failed to find the filter file: '%s'.", pucFilterFilePath); 
            iError = SRCH_FilterInvalidFilterFile;
            goto bailFromiSrchFilterGetSearchBitmapFromFilter;
        }

        /* Open the filter file */
        if ( (pfFilterFile = s_fopen(pucFilterFilePath, "r")) == NULL ) {
            iUtlLogError(UTL_LOG_CONTEXT, "Failed to open the filter file: '%s'.", pucFilterFilePath); 
            iError = SRCH_FilterInvalidFilterFile;
            goto bailFromiSrchFilterGetSearchBitmapFromFilter;
        }

        /* Get the filter file modification date */            
        if ( (iError = iUtlFileGetFileModificationTimeT(pfFilterFile, &tFilterFileLastUpdate)) != UTL_NoError ) {
            iUtlLogError(UTL_LOG_CONTEXT, "Failed to get the last modification time of the filter file: '%s', utl error: %d.", pucFilterFilePath, iError); 
            iError = SRCH_FilterInvalidFilterFile;
            goto bailFromiSrchFilterGetSearchBitmapFromFilter;
        }
    }


    /* Get the bitmap from the search cache, note that we dont need to differentiate between terms or lists 
    ** since terms will have a tFilterFileLastUpdate of 0 and lists will have a non-zero tFilterFileLastUpdate 
    */
    if ( uiSrchParserSearchCacheID == SRCH_PARSER_MODIFIER_SEARCH_CACHE_ENABLE_ID ) {

        if ( (iError = iSrchCacheGetSearchBitmap(pssSrchSearch->pvSrchCache, psiSrchIndex, pspfSrchParserFilter->pwcFilter, 
                tFilterFileLastUpdate, ppsbSrchBitmap)) == SRCH_NoError ) {

            /* We are all set */
            goto bailFromiSrchFilterGetSearchBitmapFromFilter;
        }
    }

    
    /* Terms based filter */
    if ( pspfSrchParserFilter->uiFilterTypeID == SRCH_PARSER_FILTER_TYPE_TERMS_ID ) {
    
        /* Make a straight copy of the terms */
        if ( (pwcTerms = s_wcsdup(pspfSrchParserFilter->pwcFilter)) == NULL ) {
            iError = SRCH_MemError;
            goto bailFromiSrchFilterGetSearchBitmapFromFilter;
        }
        
        iSrchReportAppend(pssSrchSearch->pvSrchReport, "%s The search filtered on the following terms: '%ls'\n", REP_SEARCH_RESTRICTION, pspfSrchParserFilter->pwcFilter);

    }
    /* List based filter */
    else if ( pspfSrchParserFilter->uiFilterTypeID == SRCH_PARSER_FILTER_TYPE_LIST_ID ) {

        /* Get the file length */
        if ( (iError = iUtlFileGetFileLength(pfFilterFile, &zFilterFileLength)) != UTL_NoError ) {
            iUtlLogError(UTL_LOG_CONTEXT, "Failed to get the length of the filter file: '%s', utl error: %d.", pucFilterFilePath, iError); 
            iError = SRCH_FilterInvalidFilterFile;
            goto bailFromiSrchFilterGetSearchBitmapFromFilter;
        }
        
        /* Map in the entire file */
        if ( (iError = iUtlFileMemoryMap(fileno(pfFilterFile), 0, zFilterFileLength, PROT_READ, (void **)&pucFilterFileMappingPtr) != UTL_NoError) ) {
            iUtlLogError(UTL_LOG_CONTEXT, "Failed to map in the filter file: '%s', utl error: %d.", pucFilterFilePath, iError);
            iError = SRCH_FilterInvalidFilterFile;
            goto bailFromiSrchFilterGetSearchBitmapFromFilter;
        }

        /* Convert the terms from utf-8 to wide characters, pwcTerms is allocated */
        if ( (iError = iLngConvertUtf8ToWideString_d(pucFilterFileMappingPtr, zFilterFileLength, &pwcTerms)) != LNG_NoError ) {
            iUtlLogError(UTL_LOG_CONTEXT, "Failed to convert the terms from utf-8 to wide characters, lng error: %d.", iError);
            iError = SRCH_FilterCharacterSetConvertionFailed;
            goto bailFromiSrchFilterGetSearchBitmapFromFilter;
        }

        /* Unmap the filter file */
        iUtlFileMemoryUnMap(pucFilterFileMappingPtr, zFilterFileLength);
        pucFilterFileMappingPtr = NULL;

        /* Close the filter file */
        s_fclose(pfFilterFile);
        pfFilterFile = NULL;

        /* Convert newlines to commas */
        iUtlStringsReplaceCharacterInWideString(pwcTerms, L'\n', L',');

        iSrchReportAppend(pssSrchSearch->pvSrchReport, "%s The search filtered on the following list: '%ls'\n", REP_SEARCH_RESTRICTION, pspfSrchParserFilter->pwcFilter);
    }



    /* Allocate a field ID bitmap only if there are any fields other than field ID 0 */
    if ( psiSrchIndex->uiFieldIDMaximum > 0 ) {

        /* Allocate the field ID bitmap - field ID 0 is not a field */
        if ( (pucFieldIDBitmap = (unsigned char *)s_malloc(sizeof(unsigned char) * UTL_BITMAP_GET_BITMAP_BYTE_LENGTH(psiSrchIndex->uiFieldIDMaximum))) == NULL ) {
            iError = SRCH_MemError;
            goto bailFromiSrchFilterGetSearchBitmapFromFilter;
        }
    }


    /* Loop parsing the terms */
    for ( pwcTerm = s_wcstok(pwcTerms, SRCH_FILTER_TERM_SEPARATORS, (wchar_t **)&pwcNormalizedExcludedTermsStrtokPtr); pwcTerm != NULL; 
            pwcTerm = s_wcstok(NULL, SRCH_FILTER_TERM_SEPARATORS, (wchar_t **)&pwcNormalizedExcludedTermsStrtokPtr) ) {

        /* Trim the string if needed, we do this so that we can handle lists like 'bats, lions, elephants' */
        iUtlStringsTrimWideString(pwcTerm);

        /* Term contains spaces, treat as a phrase */
        if ( s_wcschr(pwcTerm, L' ') != NULL ) {

            wchar_t                     *pwcTermStrtokPtr = NULL;
            wchar_t                     *pwcSubTerm = NULL;
            struct srchPostingsList     *psplSrchPostingsList = NULL;

            /* Get the first subterm - wcstok_r along spaces */
            pwcSubTerm = s_wcstok(pwcTerm, L" ", (wchar_t **)&pwcTermStrtokPtr);

            /* Loop while there are subterm */
            while ( pwcSubTerm != NULL ) {

                boolean     bFieldIDBitmapSet = false;

                /* Clear the bitmap */
                if ( pucFieldIDBitmap != NULL ) {
                    UTL_BITMAP_CLEAR_POINTER(pucFieldIDBitmap, psiSrchIndex->uiFieldIDMaximum);
                }

                /* Process the term, this returns a pointer to the processed term and sets the bitmap as needed */
                if ( (iError = iSrchFilterProcessTerm(pssSrchSearch, psiSrchIndex, pvLngStemmer, pwcSubTerm, pucFieldIDBitmap, psiSrchIndex->uiFieldIDMaximum, 
                        &pwcSubTerm, &bFieldIDBitmapSet)) != SRCH_NoError ) {
                    goto bailFromiSrchFilterGetSearchBitmapFromFilter;
                }

                /* Skip the term if it was stemmed out of existence */
                if ( bUtlStringsIsWideStringNULL(pwcSubTerm) == false ) {

                    unsigned char               *pucSubTerm = NULL;
                    struct srchPostingsList     *psplSrchPostingsTempList = NULL;


                    /* Convert the subterm from wide characters to utf-8, pucSubTerm is allocated */
                    if ( (iError = iLngConvertWideStringToUtf8_d(pwcSubTerm, 0, &pucSubTerm)) != LNG_NoError ) {
                        iUtlLogError(UTL_LOG_CONTEXT, "Failed to convert a filter term from wide characters to utf-8, lng error: %d.", iError);
                        iError = SRCH_FilterCharacterSetConvertionFailed;
                        goto bailFromiSrchFilterGetSearchBitmapFromFilter;
                    }

                    /* Search to postings list */
                    iError = iSrchTermSearchGetSearchPostingsListFromTerm(pssSrchSearch, psiSrchIndex, pucSubTerm, SRCH_SEARCH_TERM_WEIGHT_DEFAULT, 
                            (bFieldIDBitmapSet == true) ? pucFieldIDBitmap : NULL, (bFieldIDBitmapSet == true) ? psiSrchIndex->uiFieldIDMaximum : 0, 
                            0, 0, 0, &psplSrchPostingsTempList);

                    /* Free the subterm */
                    s_free(pucSubTerm);

                    /* Check the returned error */
                    if ( iError != SRCH_NoError ) {
                        goto bailFromiSrchFilterGetSearchBitmapFromFilter;
                    }

                    
                    /* Break here if there was no terms returned as this will kill the phrase */
                    if ( (psplSrchPostingsTempList == NULL) || (psplSrchPostingsTempList->uiSrchPostingsLength == 0) ) {
                        
                        iSrchPostingFreeSrchPostingsList(psplSrchPostingsTempList);
                        psplSrchPostingsTempList = NULL;

                        iSrchPostingFreeSrchPostingsList(psplSrchPostingsList);
                        psplSrchPostingsList = NULL;

                        break;
                    }


                    /* Merge the postings lists, ADJ with a distance of 1 and a strict boolean match */
                    if ( psplSrchPostingsList != NULL ) {
                        if ( (iError = iSrchPostingMergeSrchPostingsListsADJ(psplSrchPostingsList, psplSrchPostingsTempList, 1, SRCH_PARSER_MODIFIER_BOOLEAN_OPERATION_STRICT_ID, &psplSrchPostingsList)) != SRCH_NoError ) {
                            goto bailFromiSrchFilterGetSearchBitmapFromFilter;
                        }
                    }
                    else {
                        psplSrchPostingsList = psplSrchPostingsTempList;
                    }
                }
            
                /* Get the next subterm */
                pwcSubTerm = s_wcstok(NULL, L" ", (wchar_t **)&pwcTermStrtokPtr);
            }
            
            
            /* Set the search bitmap structure from the search postings list structure */
            if ( psplSrchPostingsList != NULL ) {

                struct srchPosting      *pspSrchPostingsPtr = NULL;
                struct srchPosting      *pspSrchPostingsEnd = NULL;
                unsigned int            uiLastDocumentID = 0;
                
                unsigned char           *pucBitmapPtr = NULL;

                /* We only process the search postings list structure if there is something in it */
                if ( psplSrchPostingsList->uiSrchPostingsLength > 0 ) {
                
                    /* Allocate the search bitmap structure if it has not yet been allocated */
                    if ( *ppsbSrchBitmap == NULL ) {
                        if ( (iError = iSrchBitmapCreate(NULL, psiSrchIndex->uiDocumentCount + 1, false, ppsbSrchBitmap)) != SRCH_NoError ) {
                            iUtlLogError(UTL_LOG_CONTEXT, "Failed to create a new search bitmap, srch error: %d.", iError);
                            goto bailFromiSrchFilterGetSearchBitmapFromFilter;
                        }
                    }
    
    
                    /* Dereference the bitmap array */
                    pucBitmapPtr = (*ppsbSrchBitmap)->pucBitmap;
                
                    /* Set the bitmap for these documents  */
                    for ( pspSrchPostingsPtr = psplSrchPostingsList->pspSrchPostings, pspSrchPostingsEnd = psplSrchPostingsList->pspSrchPostings + psplSrchPostingsList->uiSrchPostingsLength; 
                            pspSrchPostingsPtr < pspSrchPostingsEnd; pspSrchPostingsPtr++ ) {
                        
                        /* Set the document in the bitmap if it has not already been set */
                        if ( pspSrchPostingsPtr->uiDocumentID != uiLastDocumentID ) {
                            UTL_BITMAP_SET_BIT_IN_POINTER(pucBitmapPtr, pspSrchPostingsPtr->uiDocumentID);
                            uiLastDocumentID = pspSrchPostingsPtr->uiDocumentID;
                        }
                    }
                }
                
                /* Free the postings list */
                iSrchPostingFreeSrchPostingsList(psplSrchPostingsList);
                psplSrchPostingsList = NULL;
            }
        }

        /* Term does not contain spaces, treat as a term */
        else {

            boolean     bFieldIDBitmapSet = false;

            /* Clear the bitmap */
            if ( pucFieldIDBitmap != NULL ) {
                UTL_BITMAP_CLEAR_POINTER(pucFieldIDBitmap, psiSrchIndex->uiFieldIDMaximum);
            }

            /* Process the term, this returns a pointer to the processed term and sets the bitmap as needed */
            if ( (iError = iSrchFilterProcessTerm(pssSrchSearch, psiSrchIndex, pvLngStemmer, pwcTerm, pucFieldIDBitmap, psiSrchIndex->uiFieldIDMaximum, 
                    &pwcTerm, &bFieldIDBitmapSet)) != SRCH_NoError ) {
                goto bailFromiSrchFilterGetSearchBitmapFromFilter;
            }
    
            /* Skip the term if it was stemmed out of existence */
            if ( bUtlStringsIsWideStringNULL(pwcTerm) == false ) {

                /* Convert the term from wide characters to utf-8, pucTerm is allocated */
                if ( (iError = iLngConvertWideStringToUtf8_d(pwcTerm, 0, &pucTerm)) != LNG_NoError ) {
                    iUtlLogError(UTL_LOG_CONTEXT, "Failed to convert a filter term from wide characters to utf-8, lng error: %d.", iError);
                    iError = SRCH_FilterCharacterSetConvertionFailed;
                    goto bailFromiSrchFilterGetSearchBitmapFromFilter;
                }

                /* Expand the term if it contains a wildcard (or two) */
                if ( s_strpbrk(pucTerm, SRCH_PARSER_WILDCARDS_STRING) != NULL ) {
                
                    /* Expand the term */
                    iError = iSrchTermDictLookupWildCard(psiSrchIndex, pucTerm, (bFieldIDBitmapSet == true) ? pucFieldIDBitmap : NULL, 
                            (bFieldIDBitmapSet == true) ? psiSrchIndex->uiFieldIDMaximum : 0, &pstdiSrchTermDictInfos, &uiSrchTermDictInfosLength);
                    
                    /* Check for non recoverable errors */
                    if ( !((iError == SRCH_NoError) || (iError == SRCH_TermDictTermBadRange) || (iError == SRCH_TermDictTermBadWildCard) ||
                            (iError == SRCH_IndexHasNoTerms) || (iError == SRCH_TermDictTermNotFound) || (iError == SRCH_TermDictTermDoesNotOccur)) ) {
                        goto bailFromiSrchFilterGetSearchBitmapFromFilter;
                    }
                    
                    /* Reset the error */
                    iError = SRCH_NoError;


                    /* Loop through all the terms in the term list */
                    for ( pstdiSrchTermDictInfosPtr = pstdiSrchTermDictInfos, uiI = 0; uiI < uiSrchTermDictInfosLength; pstdiSrchTermDictInfosPtr++, uiI++ ) {

                        /* Search to bitmap */
                        if ( (iError = iSrchTermSearchGetSearchBitmapFromTerm(pssSrchSearch, psiSrchIndex, pstdiSrchTermDictInfosPtr->pucTerm, 
                                (bFieldIDBitmapSet == true) ? pucFieldIDBitmap : NULL, ((bFieldIDBitmapSet == true) ? psiSrchIndex->uiFieldIDMaximum : 0), 
                                0, uiStartDocumentID, uiEndDocumentID, ppsbSrchBitmap)) != SRCH_NoError ) {
                            goto bailFromiSrchFilterGetSearchBitmapFromFilter;
                        }
                    }
                }
                else {
                
                    /* Search to bitmap */
                    if ( (iError = iSrchTermSearchGetSearchBitmapFromTerm(pssSrchSearch, psiSrchIndex, pucTerm, (bFieldIDBitmapSet == true) ? pucFieldIDBitmap : NULL, 
                            ((bFieldIDBitmapSet == true) ? psiSrchIndex->uiFieldIDMaximum : 0), 0, uiStartDocumentID, uiEndDocumentID, ppsbSrchBitmap)) != SRCH_NoError )  {
                        goto bailFromiSrchFilterGetSearchBitmapFromFilter;
                    }
                }


                /* Free the term */
                s_free(pucTerm);
            }
        }
    }



    /* Store the bipmap to cache if the cache is enabled */
    if ( uiSrchParserSearchCacheID == SRCH_PARSER_MODIFIER_SEARCH_CACHE_ENABLE_ID ) {
        if ( *ppsbSrchBitmap != NULL ) {
            iSrchCacheSaveSearchBitmap(pssSrchSearch->pvSrchCache, psiSrchIndex, pspfSrchParserFilter->pwcFilter, tFilterFileLastUpdate, *ppsbSrchBitmap);
        }    
    }    



    /* Bail label */
    bailFromiSrchFilterGetSearchBitmapFromFilter:


    /* Free the stemmer */
    iLngStemmerFree(pvLngStemmer);
    pvLngStemmer = NULL;

    /* List based filter */
    if ( pspfSrchParserFilter->uiFilterTypeID == SRCH_PARSER_FILTER_TYPE_LIST_ID ) {

        /* Unmap the terms file */
        iUtlFileMemoryUnMap(pucFilterFileMappingPtr, zFilterFileLength);
        pucFilterFileMappingPtr = NULL;
    
        /* Close the terms file */
        s_fclose(pfFilterFile);
    }
        
    /* Free the term information structure */
    if ( pstdiSrchTermDictInfos != NULL ) {
        for ( pstdiSrchTermDictInfosPtr = pstdiSrchTermDictInfos, uiI = 0; uiI < uiSrchTermDictInfosLength; pstdiSrchTermDictInfosPtr++, uiI++ ) {
            s_free(pstdiSrchTermDictInfosPtr->pucTerm);
        }
        s_free(pstdiSrchTermDictInfos);
    }

    s_free(pucFieldIDBitmap);

    s_free(pucTerm);
    s_free(pwcTerms);


    /* Handle the error */
    if ( iError != SRCH_NoError ) {
        iSrchBitmapFree(*ppsbSrchBitmap);
        *ppsbSrchBitmap = NULL;
    }


    return (iError);

}
예제 #7
0
int mbtransfer (char *ziel)
//*************************************************************************
//
//  TRANSFER-Prozedur
//  (wird fuer jedes transferierte File einzeln aufgerufen)
//
//*************************************************************************
{
  char name[20];
  strcpy(name, "mbtransfer");
  lastfunc(name);
  char *line = b->line;
  int findex;
  FILE *oldf, *newf;
  char usermail = 0;
  int retwert = NO;
  int nocp; //no-copy flag
  char oldsubject[101];
  unsigned long int oldfpos;
  char oldmsgty;
  char oldmailfname[10];
  time_t oldmsgtime;
  char old_ziel[DIRLEN+1];
  int old_usermail;
  char oldboardname[10];
  char oldmailpath[FNAMELEN+1];
  char zielcall[CALLEN+1];
  char newcall[CALLEN+1];
  int gleichesboard = NO;
  unsigned long nummer;
#ifdef USERLT
  short int old_lt;
#endif

#ifdef DEBUG_FWD
  trace(report, "mbtransfer", "ziel: %s", ziel);
#endif
  strupr(ziel);

  nexttoken(ziel, zielcall, CALLEN);
  strcpy(oldmailpath, b->mailpath);
  if (sema_test("sendlock") || m.disable)
  {
    putf(ms(m_sendnotpossible));
    return NO;
  }
  if (mbcallok(zielcall))
  { // Use newcall
    if (get_newcall(zielcall, newcall))
    {
      strcpy(zielcall, newcall);
      putf(ms(m_usingnewcall), newcall);
    }
  }
  char *bbuf = (char *) t_malloc(sizeof(tvar_t) - sizeof(task_t), "tran");
  char *oldfname;
  oldfname = (char *) t_malloc(sizeof(char) * (FNAMELEN+1), "tra2");
  if (! bbuf || ! oldfname)
    return NO;
  memcpy(bbuf, (char *) b + sizeof(task_t), sizeof(tvar_t) - sizeof(task_t));
  strlwr(b->mailpath);
  strcpy(oldfname, b->mailpath);
  strcpy(oldmailfname, b->mailfname);
  oldmsgtime = filename2time(b->mailfname);
  if ((oldf = s_fopen(oldfname, "srt")) != NULL)
  {
    fgets(b->line, BUFLEN - 1, oldf);    // Befehlszeile einlesen
    mbsend_parse(line, 0);
    if (b->mailtype == 'A'
        || (b->mailtype == 'B' && b->eraseinfo == 'T'))
    {
      retwert = NIL;
      s_fclose(oldf);
      goto error_exit;
    }
    oldmsgty = b->conttype;              // save mailflags ...(conttype)
    fgets(b->line, BUFLEN - 1, oldf);    // Forwardzeile vernichten
    fgets(b->line, BUFLEN - 1, oldf);    // Read-Zeile
    fgets(oldsubject, BETREFFLEN, oldf); // Betreff
    cut_blank(oldsubject);               // Newline entfernen
    if (mbcallok(zielcall)) *b->at = 0;  // Verteiler loeschen -> Neubestimmen
    strcpy(old_ziel, b->ziel);
#ifdef USERLT
    old_lt = b->lifetime;
    b->lifetime = 0;
#endif
    old_usermail = b->usermail;
    mbsend_parse(ziel, 2);
    if (! stricmp(b->ziel, b->mailpath+strlen(b->mailpath)-strlen(b->ziel)-8))
    {
      retwert = NIL;
      s_fclose(oldf);
      goto error_exit;
    }
    b->conttype = oldmsgty;              // set mailflags again.. (conttype)
    if (b->mailtype == 'B' && ! old_usermail)
      strcpy(b->ziel, old_ziel);
    weiterleiten(1, b->zielboard);
    waitfor(e_ticsfull);
    findex = finddir(b->zielboard, b->sysop);
    if (findex && !(strlen(b->zielboard)==1 && !b->sysop))
    {
      if (xmkdir(b->boardpath))
      {
        trace(serious, name, "mkdir %s error", b->boardpath);
        s_fclose(oldf);
        goto error_exit;
      }
      nocp = ! strcmp(b->herkunft, b->logincall) || b->sysop;
             //kein "CP " wenn Sysop!
      if (nocp || b->mailtype == 'B')
        strcpy(b->betreff, oldsubject);
      else
        sprintf(b->betreff, "CP %s: %.67s", b->logincall, oldsubject);
      //Bei Nicht-Bulletin BID neu generieren bzw. wenn BID fehlt
      if (b->mailtype != 'B'|| ! *b->bid) strcpy(b->bid, newbid());
      make_mask(b->mailpath, b->boardfullname);
      strcpy(b->mask, b->mailpath);
      // Ursprungsboardnamen aus b->mailpath holen und mit ziel vergleichen
      strcpy(oldboardname, b->boardname);
      oldmailpath[strlen(oldmailpath)-8] = 0;
      if (finddir(oldmailpath,0) > 0)
      {
        if (! strcmp(ziel, b->boardname))
          gleichesboard = YES;
      }
      else
        gleichesboard = NO;
      strcpy(b->boardname,oldboardname); // b->boardname wieder herstellen
      // bei Usermail oder gleichem Board zum Sortieren
      // Filezeit/-namen neu setzen
      if (mbcallok(zielcall) || gleichesboard)
      {
        strcpy(b->mailfname, time2filename(0));
      }
      else
        strcpy(b->mailfname, oldmailfname);
      if (! strstr(b->mailpath, "*.*"))
        trace(fatal, name, "mask %s", b->mailpath);
      strcpy(strstr(b->mailpath, "*.*"), b->mailfname);
      strlwr(b->mailpath);
      if ((newf = s_fopen(b->mailpath, "sw+t")) != NULL)
      {
        s_fsetopt(newf, 1);
#ifdef USERLT
        set_boardlife_max(old_lt);
        b->lifetime = old_lt;
#endif
        writeheader(newf, 1);
        if (b->mailtype != 'B')
        {
          if (fgets(b->line, BUFLEN - 1, oldf))
          {
            do
            { // fputs(line,f); skip old R-lines
              waitfor(e_ticsfull);
              fgets(b->line, BUFLEN - 1, oldf);
            }
            while (! feof(oldf) && *line == 'R' && line[1] == ':');
          }
          fprintf(newf, "%s\n", makeheader(1));
          fprintf(newf, "X-Transfer: %s by %s @ %s\n",
                  datestr(ad_time(), 12), b->logincall, m.boxadress);
          fprintf(newf, "X-Original-Date: %s\n", datestr(oldmsgtime, 10));
          do
          {
            if((   ! strncasecmp(line, "from", 4)
                || ! strncmp(line, "de: ", 4)
                || ! strncmp(line, "de ", 3)
                || ! strncmp(line, "fm ", 3)) && ! nocp)
              fprintf(newf, "X-Originally %s", line);
            else if ((   ! strncasecmp(line, "to: ", 4)
                      || ! strncasecmp(line, "to ", 3)) && ! nocp)
              fprintf(newf, "X-Originally %s", line);
            else if (! strncmp(line, "X-MID: ", 7))
              fprintf(newf, "X-Old-MID: %s", line + 7);
            else if (! strncmp(line, "X-BID: ", 7))
              fprintf(newf, "X-Old-BID: %s", line + 7);
            else fputs(line, newf);
            waitfor(e_ticsfull);
            fgets(b->line, BUFLEN - 1, oldf);
          }
          while (! feof(oldf) && *line != LF);
          fputc(LF, newf);
        }
        //Files binaer behandeln
        oldfpos = ftell(oldf);
        s_fclose(oldf);
        s_fclose(newf);
        writemailflags();
        if ((oldf = s_fopen(oldfname, "srb")) != NULL)
        {
          if ((newf = s_fopen(b->mailpath, "sab")) != NULL) //append to file
          {
            fseek(oldf, oldfpos, SEEK_SET);
            do
            { //oe3dzw: Transferroutine transparent
              int len;
              len = fread(line, 1, 255, oldf);
              if (len) fwrite(line, 1, len, newf);
              waitfor(e_ticsfull);
            }
            while (! feof(oldf));
            if (b->binstart)  //bei binaeren Mails offset neu berechnen
            {
              b->binstart += ftell(newf) - ftell(oldf);
              if (b->binstart < 0)
                trace(serious, name, "offset %ld in %s", b->binstart, b->mailpath);
            }
            s_fclose(newf);
            if (b->binstart) writelines(); //Neuen Binstart speichern
            if (b->bytes)
            {
              if (old_usermail || gleichesboard)
                nummer = appenddirlist(1);
              else
                nummer = appenddirlist(0); //change old CHECKLINE
              if (b->usermail)
              {
                add_fwdfile("", get_fdelay(b->herkunft), 0);
                sprintf(b->line, "%s %lu", b->herkunft, nummer);
                mbtalk("\001", b->zielboard, b->line);
                trigger_ufwd(b->zielboard);
              }
              else
              {
                handle fh;
                char found;
                if (old_usermail)
                  add_fwdfile("", get_fdelay(b->herkunft), 0);
                else
                  add_fwdfile("", get_fdelay(b->herkunft), 1);
                if (findex > 0)
                  tree[findex - 1].newestmail = oldmsgtime;
                if ((fh = s_open(CHECKNAME, "sr+b")) != EOF)
                {
                  seek_fname(fh, b->mailfname, &found, 1);
                  long pos = ltell(fh);
                  if (found)
                  {
                    _read(fh, b->line, BLEN);
                    sprintf(b->line + 15, "%-8s", b->boardname);
                    b->line[23] = '~';
#ifdef USERLT
                    char nlt[4];
                    sprintf(nlt, "%3.3d", b->boardlife_max);
                    memcpy(b->line + 51, nlt, 3);
#endif
                    lseek(fh, -(LBLEN), SEEK_CUR);
                    _write(fh, b->line, BLEN);
                  }
                  s_close(fh);
                  if (found && (fh = s_open(CHECKNUMNAME, "sr+b")) != EOF)
                  {
                    lseek(fh, 2*(pos >> 6), SEEK_SET); //2* da 32bit!
                    _write(fh, &nummer, 4); // 4Byte=32 bit
                    s_close(fh);
                  }
                }
                else
                  trace(serious, name, "check");
              }
              inc_mailgot(b->boardname);
              writemailflags();
              retwert = OK;
예제 #8
0
파일: parser.c 프로젝트: fschiettecatte/mps
/*

    Function:   iPrsParseTextFile()

    Purpose:    Adds term to the index for a given file.

    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
                pucFilePath     file path to be parsed
                pfInputFile     data stream to be parsed
                pfIndexerFile   structured index stream output file
                pfDataLength    return pointer for the data length parsed

    Globals:    none

    Returns:    0 on success, -1 on error

*/
int iPrsParseTextFile
(
    struct prsParser *pppPrsParser,
    struct prsFormat *ppfPrsFormat,
    unsigned char *pucFilePath,
    FILE *pfInputFile,
    FILE *pfIndexerFile,
    float *pfDataLength
)
{

    int             iError = UTL_NoError;
    int             iStatus = 0;
    FILE            *pfLocalFile = NULL;
    unsigned char   *pucLine = NULL;
    unsigned char   *pucNormalizedLine = NULL;
    wchar_t         *pwcLine = NULL;
    unsigned int    uiLineLength = 0;
    unsigned int    ulLineCapacity = 0;
    unsigned int    uiNormalizedLineCapacity = 0;
    wchar_t         *pwcParseLinePtr = NULL;
    off_t           zCurrentOffset = 0;
    off_t           zStartOffset = 0;
    off_t           zEndOffset = 0;
    unsigned int    uiTermPosition = 0;
    unsigned char   pucTrueFilePath[UTL_FILE_PATH_MAX + 1] = {'\0'};

    unsigned int    uiLanguageID = LNG_LANGUAGE_ANY_ID;
    unsigned int    uiFieldID = 0;
    boolean         bIndexLine = false;
    boolean         bParseLine = false;
    boolean         bTermPositions = false;

    boolean         bIndexing = false;
    boolean         bSetStartCharacter = true;
    boolean         bFinishDocument = false;

    float           fLineLength = 0;
    float           fDataLength = 0;


    /* Check the parameters */
    if ( pppPrsParser == NULL ) {
        iUtlLogError(UTL_LOG_CONTEXT, "Null 'pppPrsParser' parameter passed to 'iPrsParseTextFile'."); 
        return (-1);
    }

    if ( ppfPrsFormat == NULL ) {
        iUtlLogError(UTL_LOG_CONTEXT, "Null 'ppfPrsFormat' parameter passed to 'iPrsParseTextFile'."); 
        return (-1);
    }

    if ( pfIndexerFile == NULL ) {
        iUtlLogError(UTL_LOG_CONTEXT, "Null 'pfIndexerFile' parameter passed to 'iPrsParseTextFile'."); 
        return (-1);
    }

    if ( (bUtlStringsIsStringNULL(pucFilePath) == true) && (pfInputFile == NULL) ) {
        iUtlLogError(UTL_LOG_CONTEXT, "Null or empty 'pucFilePath' &'pfInputFile' parameters passed to 'iPrsParseTextFile'."); 
        return (-1);
    }

    if ( (bUtlStringsIsStringNULL(pucFilePath) == false) && (pfInputFile != NULL) ) {
        iUtlLogError(UTL_LOG_CONTEXT, "Invalid 'pucFilePath' &'pfInputFile' parameters passed to 'iPrsParseTextFile'."); 
        return (-1);
    }

    if ( pfDataLength == NULL ) {
        iUtlLogError(UTL_LOG_CONTEXT, "Null 'pfDataLength' parameter passed to 'iPrsParseTextFile'."); 
        return (-1);
    }


    /* Preset the data length return pointer */
    *pfDataLength = 0;
        

    /* Open the file path if it was provided */
    if ( bUtlStringsIsStringNULL(pucFilePath) == false ) {

        /* Get the real file path of this file */
        if ( (iError = iUtlFileGetTruePath(pucFilePath, pucTrueFilePath, UTL_FILE_PATH_MAX + 1)) != UTL_NoError ) {
            iUtlLogError(UTL_LOG_CONTEXT, "Failed to get the true path of the file path: '%s', utl error: %d.", pucFilePath, iError);
            iStatus = -1;
            goto bailFromlPrsParseTextFile;
        }
    
        /* Open the file to index */
        if ( (pfLocalFile = s_fopen(pucTrueFilePath, "r")) == NULL ) {
            /* Send a message 
            ** M    message
            */
            if ( fprintf(pfIndexerFile, "M File: '%s' could not be opened.\n", pucTrueFilePath) < 0 ) {
                iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a message line to the indexer");
            }
            iStatus = -1;
            goto bailFromlPrsParseTextFile;
        }

        /* Send a message to the indexer
        ** M    (Message to be displayed by the indexer)
        */
        if ( pppPrsParser->bSuppressMessages == false ) {
            if ( fprintf(pfIndexerFile, "M Parsing file: '%s'.\n", pucTrueFilePath) < 0 ) {
                iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a message line to the indexer");
            }
        }
    }
    /* Otherwise read from the input file */ 
    else if ( pfInputFile != NULL ) {
        pfLocalFile = pfInputFile;
    }
    /* Otherwise croak */
    else {
        iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to find data either from a file path or an input file stream");
    }


    
    /* Initialize for the first document */
    zCurrentOffset = 0;
    zStartOffset = 0;
    zEndOffset = 0;
    uiTermPosition = 1;

    bIndexing = false;
    bSetStartCharacter = true;
    bFinishDocument = false;


    /* Loop around reading every line in the file */
    while ( true ) {
    
        boolean         bEoF = false;
        unsigned char   *pucLineEndPtr = NULL;


        /* Reset the line to an empty string, note that pucLine is dynamically
        ** allocated so we make sure that it is allocated before doing so 
        */
        if ( pucLine != NULL ) {
            pucLine[0] = '\0';
        }

        /* Reset the line length */
        uiLineLength = 0;

        /* This ugly little loop reads stuff from the file we are indexing making sure that
        ** it reads an entire actual line (ie not limited by the fact that fgets() can only 
        ** read fixed length buffers) and erases any end of line characters
        */
        do {

            /* Allocate/reallocate lines if needed */
            if ( (pucLine == NULL) || (ulLineCapacity == 0) || ((uiLineLength + BUFSIZ) > ulLineCapacity) ) {

                unsigned char   *pucLinePtr = NULL;


                /* Extend the line */
                if ( (pucLinePtr = (unsigned char *)s_realloc(pucLine, (size_t)(sizeof(unsigned char) * (ulLineCapacity + BUFSIZ)))) == NULL ) {
                    iStatus = -1;
                    goto bailFromlPrsParseTextFile;
                }

                /* Hand over the pointer */
                pucLine = pucLinePtr;

                /* Clear the new allocation */
                s_memset(pucLine + ulLineCapacity, 0, BUFSIZ);
                
                /* Set the line capacity */
                ulLineCapacity += BUFSIZ;

                
                /* Extend the normalized line if normalization is supported */
                if ( pppPrsParser->pvLngUnicodeNormalizer != NULL ) {
                
                    unsigned char    *pucNormalizedLinePtr = NULL;
                    
                    /* Set the normalized line capacity */
                    uiNormalizedLineCapacity = ulLineCapacity * LNG_UNICODE_NORMALIZATION_EXPANSION_MULTIPLIER_MAX;

                    /* Extend the normalized line */
                    if ( (pucNormalizedLinePtr = (unsigned char *)s_realloc(pucNormalizedLine, (size_t)(sizeof(unsigned char) * uiNormalizedLineCapacity))) == NULL ) {
                        iStatus = -1;
                        goto bailFromlPrsParseTextFile;
                    }
    
                    /* Hand over the pointer */
                    pucNormalizedLine = pucNormalizedLinePtr;
                }

                
                /* Extend the wide character line */
                {
                    wchar_t     *pwcLinePtr = NULL;
                
                    /* Extend the wide character line */
                    if ( (pwcLinePtr = (wchar_t *)s_realloc(pwcLine, (size_t)(sizeof(wchar_t) * ulLineCapacity))) == NULL ) {
                        iStatus = -1;
                        goto bailFromlPrsParseTextFile;
                    }
    
                    /* Hand over the pointer */
                    pwcLine = pwcLinePtr;
                }
            }


            /* Read the next line chunk, appending to the current line and setting the end of file flag */
            bEoF = (s_fgets(pucLine + uiLineLength, ulLineCapacity - uiLineLength, pfLocalFile) == NULL) ? true : false;

            /* Get the new line length here for optimization */
            uiLineLength = s_strlen(pucLine);

            /* Erase the trailing new line - be platform sensitive, handle PC first, then Unix and Mac  */
            if ( (uiLineLength >= 2) && (pucLine[uiLineLength - 2] == '\r') ) {
                pucLineEndPtr = pucLine + (uiLineLength - 2);
                uiLineLength -= 2;
            }
            else if ( (uiLineLength >= 1) && ((pucLine[uiLineLength - 1] == '\n') || (pucLine[uiLineLength - 1] == '\r')) ) {
                pucLineEndPtr = pucLine + (uiLineLength - 1);
                uiLineLength -= 1;
            }
            else if ( (uiLineLength >= 1) && (bEoF == true) ) {
                pucLineEndPtr = pucLine + uiLineLength;
            }
            else {
                pucLineEndPtr = NULL;
            }

            if ( pucLineEndPtr != NULL ) {
                *pucLineEndPtr = '\0';
            }

        } while ( (pucLineEndPtr == NULL) && (bEoF == false) );


        /* Increment the line length */
        fLineLength++;

        /* Increment the data length */
        fDataLength += uiLineLength;
        

        /* Set the current character */
        zCurrentOffset += uiLineLength;


        /* Check to see if we have reached the end of the file, if we have we finish the document and bail */
        if ( (bEoF == true) && (pucLineEndPtr == NULL) ) {
            
            /* Finish the document if we are indexing */
            if ( bIndexing == true ) {
                
                /* Finish the document */
                if ( iPrsFinishDocument(pppPrsParser, ppfPrsFormat, pfIndexerFile, pucTrueFilePath, zStartOffset, zCurrentOffset - 1, uiTermPosition - 1) != 0 ) {
                    iStatus = -1;
                    goto bailFromlPrsParseTextFile;
                }
            }
            
            break;
        }


        /* Reset the wide character line */
        if ( pwcLine != NULL ) {
            pwcLine[0] = L'\0';
        }
        
        /* Set the parse line pointer */
        pwcParseLinePtr = pwcLine;

        /* Convert the line from its native character set to wide characters */
        if ( bUtlStringsIsStringNULL(pucLine) == false ) {
            
            /* Set the line pointer */
            unsigned char   *pucLinePtr = pucLine;
            
            /* Use a separate variable for the line length */
            unsigned int    uiLineAllocatedByteLength = ulLineCapacity * sizeof(wchar_t);


            /* Clean the unicode if requested */
            if ( pppPrsParser->bCleanUnicode == true ) {
                
                /* Clean the unicode */
                if ( (iError = iLngUnicodeCleanUtf8String(pucLinePtr, PRS_UNICODE_REPLACEMENT_CHARACTER)) != LNG_NoError ) {
                    iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to clean the string, lng error: %d, string: '%s'", iError, pucLinePtr);
                }
            }


            /* Normalize the line if the unicode normalizer is enabled */
            if ( pppPrsParser->pvLngUnicodeNormalizer != NULL ) {
                
                /* Normalize the line */
                if ( (iError = iLngUnicodeNormalizeString(pppPrsParser->pvLngUnicodeNormalizer, pucLinePtr, uiLineLength, &pucNormalizedLine, &uiNormalizedLineCapacity)) != LNG_NoError ) {
                    iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to normalize the string, lng error: %d, string: '%s'", iError, pucLinePtr);
                }
                
                /* Set the line pointer */
                pucLinePtr = pucNormalizedLine;
                uiLineLength = s_strlen(pucLinePtr);
            }


            /* Convert the line from utf-8 to wide character, note the conversion error handling */
            if ( (iError = iLngConverterConvertString(pppPrsParser->pvLngConverter, ((pppPrsParser->bSkipUnicodeErrors == true) ? LNG_CONVERTER_SKIP_ON_ERROR : LNG_CONVERTER_RETURN_ON_ERROR), 
                    pucLinePtr, uiLineLength, (unsigned char **)&pwcLine, &uiLineAllocatedByteLength)) != LNG_NoError ) {
                iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to convert the string from utf-8 set to wide characters, lng error: %d, string: '%s'", iError, pucLinePtr);
            }

            /* Set the parse line pointer */
            pwcParseLinePtr = pwcLine;
        }


        /* Check for a document start if a start function was supplied */
        if ( (ppfPrsFormat->bPrsDocumentStartFunction != NULL) && (ppfPrsFormat->bPrsDocumentStartFunction(pwcParseLinePtr) == true) ) {
            
            /* We need to finish the current document if we are currently indexing */
            if ( bIndexing == true ) {

                /* Set the end character if it has not been set, this occurs if we have 
                ** both a start function and an end function, and we detect a new document
                ** start without having first detected a document end
                */
                if ( zEndOffset <= zStartOffset ) {
                    zEndOffset = (zCurrentOffset - uiLineLength) - 1;
                }
                
                /* Finish the document, we do this here because we dont want to process the current line, it belongs to the new document */
                if ( iPrsFinishDocument(pppPrsParser, ppfPrsFormat, pfIndexerFile, pucTrueFilePath, zStartOffset, zEndOffset, uiTermPosition - 1) != 0 ) {
                    iStatus = -1;
                    goto bailFromlPrsParseTextFile;
                }

                /* Check to see if we have reached the document count limit and bail if we have */
                if ( (pppPrsParser->uiDocumentCountMax > 0) && (pppPrsParser->uiDocumentCount >= pppPrsParser->uiDocumentCountMax) ) {
                    break;
                }

                /* Initialize for the next document */
                uiTermPosition = 1;
            }
            else {
                /* Turn on indexing */
                bIndexing = true;
            }
            
            /* Set the start character */
            zStartOffset = zCurrentOffset - uiLineLength;
            bSetStartCharacter = false;
        }

        /* We are always indexing if there is no start function, because if we
        ** reach the end of a document, we are automatically indexing the next one
        */
        else if ( ppfPrsFormat->bPrsDocumentStartFunction == NULL ) {
            
            /* Make sure indexing is turned on */
            bIndexing = true;
            
            /* Set the start character if needed */
            if ( bSetStartCharacter == true ) {
                zStartOffset = zCurrentOffset - uiLineLength;
                bSetStartCharacter = false;
            }
        }

        
        /* Check for a document end if an end function was supplied */ 
        if ( (ppfPrsFormat->bPrsDocumentEndFunction != NULL) && (ppfPrsFormat->bPrsDocumentEndFunction(pwcParseLinePtr) == true) && (fLineLength > 1) ) {
            
            /* Finish the document if we run into a document end */ 
            if ( bIndexing == true ) {
            
                /* Request that we set a new start character, finish the document, and turn off indexing */
                bSetStartCharacter = true;
                bFinishDocument = true;
                bIndexing = false;
                
                /* Set the end character */
                zEndOffset = zCurrentOffset - 1;
            }
        }
        
        /* No end function */
        else if ( ppfPrsFormat->bPrsDocumentEndFunction == NULL ) {
            /* Set the end character */
            zEndOffset = zCurrentOffset - 1;
        }



        /* Just loop to read the next line if we are not indexing and we dont need to finish a document */
        if ( (bIndexing == false) && (bFinishDocument == false) ) {
            continue;
        }



        /* Clear the parameters */
        uiLanguageID = LNG_LANGUAGE_ANY_ID;
        uiFieldID = 0;
        bIndexLine = true;
        bParseLine = true;
        bTermPositions = true;

        /* Process the document line */
        if ( ppfPrsFormat->vPrsDocumentLineFunction != NULL ) {
            ppfPrsFormat->vPrsDocumentLineFunction(pwcParseLinePtr, &uiLanguageID, &uiFieldID, &bIndexLine, &bParseLine, &bTermPositions);
        }


        /* Index the contents of the line */
        if ( bIndexLine == true ) {

            /* Parse the line */
            if ( bParseLine == true ) {

                /* Parse the text line */
                if ( iPrsParseTextLine(pppPrsParser, ppfPrsFormat, pfIndexerFile, pwcParseLinePtr, pwcParseLinePtr + s_wcslen(pwcParseLinePtr), 
                        uiLanguageID, uiFieldID, (bTermPositions == true) ? &uiTermPosition : NULL) != 0 ) {
                    if ( fprintf(pfIndexerFile, "M Failed to add the document terms.\n") < 0 ) {
                        iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a message line to the indexer");
                    }
                }
            }
            /* Get a term from the line and add */
            else {

                wchar_t     *pwcLinePtr = NULL;


                /* Find the start of the term */
                for ( pwcLinePtr = pwcParseLinePtr; *pwcLinePtr != L'\0'; pwcLinePtr++ ) { 
                    if ( iswalnum(*pwcLinePtr) != 0 ) {
                        break;
                    }
                }


                /* Is the term long enough to add? */
                if ( s_wcslen(pwcLinePtr) >= pppPrsParser->uiTermLengthMinimum ) {
    
                    /* Send the language line if the language is known */
                    if ( uiLanguageID != LNG_LANGUAGE_ANY_ID ) {

                        unsigned char   pucLanguageCode[LNG_LANGUAGE_CODE_LENGTH + 1] = {'\0'};
                        
                        if ( iLngGetLanguageCodeFromID(uiLanguageID, pucLanguageCode, LNG_LANGUAGE_CODE_LENGTH + 1) == LNG_NoError ) {
                
                            /* Send the language
                            ** L language{A}
                            */
                            if ( fprintf(pfIndexerFile, "L %s\n", pucLanguageCode) < 0 ) {
                                iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a language line to the indexer");
                            }
                        }
                    }

                    /* Send the term to the indexer */
                    if ( iPrsSendTermToIndexer(pppPrsParser, ppfPrsFormat, pfIndexerFile, pwcLinePtr, pwcLinePtr + s_wcslen(pwcLinePtr), 
                            uiFieldID, (bTermPositions == true) ? uiTermPosition : 0) != 0 ) {
                        if ( fprintf(pfIndexerFile, "M Failed to add a document term.\n") < 0 ) {
                            iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a message line to the indexer");
                        }
                    }
                    
                    /* Increment the term position */
                    if ( bTermPositions == true ) {
                        uiTermPosition++;
                    }
                }
            }
        }

    
        /* Finish the document if we were requested to do so */    
        if ( bFinishDocument == true ) {

            /* Finish the current document */
            if ( iPrsFinishDocument(pppPrsParser, ppfPrsFormat, pfIndexerFile, pucTrueFilePath, zStartOffset, zEndOffset, uiTermPosition - 1) != 0 ) {
                if ( fprintf(pfIndexerFile, "M Failed to finish adding a document.\n") < 0 ) {
                    iUtlLogPanic(UTL_LOG_CONTEXT, "Failed to send a message line to the indexer");
                }
            }
    
            /* Check to see if we have reached the document count limit */
            if ( (pppPrsParser->uiDocumentCountMax > 0) && (pppPrsParser->uiDocumentCount >= pppPrsParser->uiDocumentCountMax) ) {
                break;
            }
            
            /* Initialize for the next document */
            uiTermPosition = 1;
    
            /* Turn off the flag requesting that we finish the document */
            bFinishDocument = false;
        }
        

    }    /* while (true) */



    /* Bail label */
    bailFromlPrsParseTextFile:
    

    /* Close the file descriptor if we opened it ourselves */
    if ( bUtlStringsIsStringNULL(pucFilePath) == false ) {
        s_fclose(pfLocalFile);
    }

    /* Free the line pointers */
    s_free(pucLine);
    s_free(pucNormalizedLine);
    s_free(pwcLine);

    
    /* Increment the data length return pointer */
    *pfDataLength += fDataLength;


    return (iStatus);

}
예제 #9
0
파일: sysop.cpp 프로젝트: donzelot/openBCM
int sysbef (char *befbuf)
//*************************************************************************
//
//*************************************************************************
{
  static char shutdown_reason[23];
  char xbuf[20];
  static char *beftab[] =
    {
      "CONNECT", "LOGIN", "CALL", "OSHELL",
#ifdef __DOS16__
#ifdef _TNC
      "TNC",
#endif
      "W2", "UWIN", "TWIN",
#ifdef _AUTOTRCWIN
      "TRWIN",
#endif
#endif
      "RTEXT", "CAT", "RPRG", "WTEXT", "WPRG", "RBIN", "WBIN",
      "SLR", "CLOG", "REORG",
      "LIFETIME", "MKBOARD", "RMBOARD", "MVBOARD", "SHUTDOWN", "NEW",
      "KILL", "TEST", "IMPORT", "DISABLE", "ENABLE",
#ifdef DIEBOX_UIMPORT
      "UIMPORT",
#endif
#ifdef OLDMAILIMPORT
      "OLDMAILIMPORT",
#endif
      "SETUSER", "BEACON", "GREP", "TGREP", "TAIL", "BEGIN", "BATCH",
      "EXPORT", "PWGEN", "POSTFWD", "MONITOR", "NOTE", "MACRO", "CFGFLEX",
      "ORM", "OMV", "OCP", "OMD", "APPEND",
#ifdef DF3VI_EXTRACT
      "EXTRACT",
#endif
      "HOLD", "SETPW",
#ifdef FEATURE_YAPP
      "WYAPP", "RYAPP",
#endif
#ifdef FEATURE_DIDADIT
      "WDIDADIT", "RDIDADIT",
#endif
#if defined FEATURE_SERIAL || defined _TELEPHONE
      "TTYINIT",
#endif
#ifdef _TELEPHONE // JJ
      "TTYCMD", "TTYDIAL", "TTYHANGUP", "TTYSTATUS", "TTYWIN",
      "TTYCOUNTERRESET",
#endif
#ifdef _AUTOFWD
      "AFWDLIST",
#endif
#ifdef FEATURE_MDPW
      "MD2SUM", "MD5SUM",
#endif
#ifdef FEATURE_EDITOR
      "EDIT", "FEDIT", "REDIT",
#else
 #ifdef DF3VI_FWD_EDIT
      "FEDIT", "FWDEDIT",
 #endif
 #ifdef DF3VI_REJ_EDIT
      "REDIT", "REJECTEDIT",
 #endif
 #ifdef DF3VI_CONV_EDIT
      "CEDIT", "CONVEDIT",
 #endif
#endif
#ifdef _FILEFWD
      "FWDIMPORT", "FWDEXPORT",
#endif
      "YMBTEST",
      "SCMDLIST", // Dies ist immer das letzte Kommando!
      NULL
    };

  enum befnum
    { unsinn, connect_, login, call_, oshell_,
#ifdef __DOS16__
#ifdef _TNC
      tnc,
#endif
      w2, uwin, twin,
#ifdef _AUTOTRCWIN
      trwin,
#endif
#endif
      rtext, rtext_, rprg, wtext, wprg, rbin, wbin,
      slr, clog, reorg,
      life_, mkb, rmb, mvb, shutdown_, new_,
      kill_, test, import, disable_, enable_,
#ifdef DIEBOX_UIMPORT
      uimport_,
#endif
#ifdef OLDMAILIMPORT
      oldmailimport_,
#endif
      setuser, beacon, grep_, tgrep, tail, begin, batch,
      export_, pwgen, postfwd_, monitor_, note, macro, cfgflex_,
      orm, omv, ocp, omd, _append,
#ifdef DF3VI_EXTRACT
      extract_,
#endif
      hold, setpw,
#ifdef FEATURE_YAPP
      wyapp, ryapp,
#endif
#ifdef FEATURE_DIDADIT
      wdidadit, rdidadit,
#endif
#if defined FEATURE_SERIAL || defined _TELEPHONE
      ttyinit,
#endif
#ifdef _TELEPHONE // JJ
      ttycmd, ttydial, ttyhangup, ttystatus, ttywin_,
      ttycounterreset,
#endif
#ifdef _AUTOFWD
      afwdlist_,
#endif
#ifdef FEATURE_MDPW
      md2sum, md5sum,
#endif
#ifdef FEATURE_EDITOR
      edit, fedit, redit,
#else
 #ifdef DF3VI_FWD_EDIT
      fedit, fwdedit,
 #endif
 #ifdef DF3VI_REJ_EDIT
      redit, rejectedit,
 #endif
 #ifdef DF3VI_CONV_EDIT
      cedit, convedit_,
 #endif
#endif
#ifdef _FILEFWD
      fwdimport, fwdexport,
#endif
      ymbtest,
      scmdlist // Dies ist immer das letzte Kommando!
    } cmd = unsinn;
  befbuf += blkill(befbuf);
  cmd = (befnum) readcmd(beftab, &befbuf, 0);
  switch (cmd)
  {
#ifdef FEATURE_YAPP
    case ryapp:
#endif
#ifdef FEATURE_DIDADIT
    case rdidadit:
#endif
#if defined(FEATURE_YAPP) || defined(FEATURE_DIDADIT)
      break;
#endif
    default:
      if (u->lf != 6)
        putv(LF);
      leerzeile(); // Sends the number of CRs stored in "ALTER LF"
  }

  switch (cmd)
  {
    case unsinn:
      if (   mbinitbef(befbuf, 0)
      #ifdef _TELEPHONE // JJ
          || ttyinitbef(befbuf, 0)
      #endif
         )
      {
        strcpy(xbuf, "^");
        mbparsave();
#ifdef _TELEPHONE // JJ
        ttyparsave();
#endif
        strncpy(xbuf + 1, befbuf, 18);
        xbuf[19] = 0;
        subst1(xbuf, ' ', 0);
        subst1(xbuf, '=', 0);
        grep(MBINITNAME, xbuf, o_i);
#ifdef _TELEPHONE // JJ
        grep(INITTTYNAME, xbuf, o_i);
#endif
        return OK;
      }
      else return NO;
    case note: trace(replog, "note", "%s", befbuf); break;
#ifdef DF3VI_EXTRACT
    case extract_: mbchange(befbuf, w_extract, 1); break;
#endif
    case hold: mbchange(befbuf, w_hold, 1); break;
    case omv:
    {
      char f1[50], f2[50];
      befbuf = nexttoken(befbuf, f1, 49);
      befbuf = nexttoken(befbuf, f2, 49);
      if (! *f1 || ! *f2 || xrename(f1, f2))
        putf(ms(m_error));
      else
      {
        putf(ms(m_moving));
        putf(ms(m_nach), f1, f2);
      }
      break;
    }
    case ocp:
    {
      char f1[50], f2[50];
      befbuf = nexttoken(befbuf, f1, 49);
      befbuf = nexttoken(befbuf, f2, 49);
      if (! *f1 || ! *f2 || filecopy(f1, f2))
        putf(ms(m_error));
      else
      {
        putf(ms(m_copying));
        putf(ms(m_nach), f1, f2);
      }
      break;
    }
    case orm:
    {
      char f1[50];
      befbuf = nexttoken(befbuf, f1, 49);
      if (! *f1 || xunlink(f1))
        putf(ms(m_filecantdeleted), f1);
      else
        putf(ms(m_filedeleted), f1);
      break;
    }
    case omd:
    {
      char f1[50];
      befbuf = nexttoken(befbuf, f1, 49);
      killbackslash(f1);
      if (! *f1 || xmkdir(f1))
        putf(ms(m_directorycantcreated), f1);
      else
        putf(ms(m_directorycreated), f1);
      break;
    }
    case _append:
    {
      char textline[LINELEN+1];
      befbuf = nexttoken(befbuf, textline, LINELEN);
      if (! *befbuf)
      {
        putf("Syntax: APPEND <textline> <filename>\n");
        break;
      }
      FILE *f = s_fopen(befbuf, "sat");
      if (f)
      {
        fprintf(f, "%s\n", textline);
        s_fclose(f);
      }
      else putf(ms(m_filenotfound), befbuf);
    } break;
    case macro:
    {
      mk_start(befbuf);
    } break;
    case setuser:
    {
      char call[CALLEN+1];
      befbuf = nexttoken(befbuf, call, CALLEN+1);
      strupr(call);
      if (mbcallok(call) && *befbuf)
      {
        trace(report, "setuser", "%s", befbuf);
        {
          if (! mbalter(NULL, befbuf, call))
            putf(ms(m_isunknown), call);
          b->msg_loadnum = 0; //reload msg
          loaduser(b->logincall, u, 1);
        }
      }
      else
        putf("Syntax: SETUSER <call> <option> <value>\n");
    } break;
    case setpw: //automatisierte Passwort-Vergabe
    {
      char call[CALLEN+1];
      char passwd[40];
      int i, pwline = 0;
      FILE *upwf;
      befbuf = nexttoken(befbuf, call, CALLEN+1);
      strupr(call);
      pwline = atoi(befbuf);
      if (! mbcallok(call) || ! pwline)
      {
        putf("Syntax: SETPW <call> <number>\n");
        break;
      }
      if (! loaduser(call, u, 0))
      {
        putf(ms(m_isunknown), call);
        break;
      }
      upwf = s_fopen("userpw.bcm", "sr");
      if (! upwf)
      {
        putf(ms(m_filenotfound), "userpw.bcm");
        break;
      }
      for (i = 0; i < pwline && ! feof(upwf); i++)
        fgets(passwd, sizeof(passwd) - 1, upwf);
      s_fclose(upwf);
      if (i < pwline)
      {
        putf(ms(m_userpwlines), i - 1);
        break;
      }
      strcpy(u->password, passwd);
      saveuser(u);
      pwline = strlen(u->password);
      putf(ms(m_loginpw), pwtypestr(u->loginpwtype), pwtypestr(u->sfpwtype));
      putf(" ");
      putf(ms(m_pwdlength), pwline);
      sprintf(passwd, "pw set to %i char", pwline);
      pwlog(call, b->logincall, passwd);
      b->msg_loadnum = 0; //reload msg
      loaduser(b->logincall, u, 1);
    } break;
#ifdef DIEBOX_UIMPORT
    case uimport_:
    {
      putf(ms(m_dieboximport));
      uimport();
    } break;
#endif
#ifdef OLDMAILIMPORT
    case oldmailimport_:
    {
      scanoptions(befbuf);
      formoptions();
      befbuf += blkill(befbuf);
      if (isdir(befbuf))
      {
        putf(ms(m_omi_started), befbuf);
        putflush();
        oldmailimport(befbuf);
      }
      else
        putf(ms(m_dirunknown), befbuf);
    } break;
#endif
    case disable_:
    {
      putf(ms(m_boxdisabled));
      m.disable = 1;
      mbparsave();
    } break;
    case enable_:
    {
      putf(ms(m_boxenabled));
      m.disable = 0;
      mbparsave();
    } break;
    case test:
    {
      if (*befbuf == 'W') { while (1); } // for testing watchdog
      else if (*befbuf == 'S') { trace(fatal, "test", "abort"); }
      else if (*befbuf == 'V') { *(char *)0 = 1; }
      else mk_start(befbuf);
    } break;
    case batch:
    {
      runbatch(befbuf);
    } break;
    case rtext:
    case rtext_:
    {
      fileio_text fio;
      fio.usefile(befbuf);
      fio.tx();
      putf("\032\n"); // CTRL-Z
    } break;
    case wtext:
    {
      fileio_text fio;
      fio.usefile(befbuf);
      fio.rx();
    } break;
    case rbin:
    case rprg:
    {
      fileio_abin fio;
      fio.usefile(befbuf);
      fio.tx();
    } break;
    case wbin:
    case wprg:
    {
      fileio_abin fio;
      fio.usefile(befbuf);
      fio.rx();
    } break;
#ifdef FEATURE_YAPP
    case ryapp:
    {
      fileio_yapp fio;
      fio.usefile(befbuf);
      fio.tx();
    } break;
    case wyapp:
    {
      fileio_yapp fio;
      fio.usefile(befbuf);
      fio.rx();
    } break;
#endif // FEATURE_YAPP
#ifdef FEATURE_DIDADIT
    case rdidadit:
    {
      fileio_dida fio;
      fio.usefile(befbuf);
      fio.tx();
    } break;
    case wdidadit:
    {
      fileio_dida fio;
      if (! *befbuf) fio.usefile("dummy");
      else
      {
        if (befbuf[strlen(befbuf) - 1] != '/') strcat(befbuf, "/");
        strcat(befbuf, "dummy");
        fio.usefile(befbuf);
      }
      fio.rx();
    } break;
#endif // FEATURE_DIDADIT
    case slr:
    {
      scanoptions(befbuf);
      putlog(TRACEPATH "/" SYSLOGRNAME, befbuf);
    } break;
    case clog:
    {
      scanoptions(befbuf);
      putlog(TRACEPATH "/" CMDLOGNAME, befbuf);
    } break;
    case tail:
    {
      scanoptions(befbuf);
      befbuf += blkill(befbuf);
      if (b->optplus&o_f && *befbuf)
      {
        int a;
        FILE *f = s_fopen(befbuf, "lrt");
        if (f)
        {
          fseek(f, 0, SEEK_END);
          do
          {
            while ((a = fgetc(f)) != EOF) putv(a);
            wdelay(349);
          }
          while (! testabbruch());
          s_fclose(f);
        }
      }
      else
      {
        fileio_text fio;
        fio.usefile(befbuf);
        fio.settail(-2000);
        fio.tx();
      }
    } break;
    case begin:
    {
      fileio_text fio;
      fio.usefile(befbuf);
      fio.settail(2000);
      fio.tx();
    } break;
    case monitor_:
    {
      if (*befbuf)
      {
        scanoptions(befbuf);
        b->continous = 1;
        monitor(atoi(befbuf), b->optplus);
      }
      else
        putf("Syntax: MONITOR [-iords] <task-id>\n");
    } break;
    case tgrep:
    {
      char string[61];
      char name[40];
      scanoptions(befbuf);
      if (b->optminus & o_i) b->optplus |= o_i;
      //wenn nicht explizit "-i-", ist "-i" default
      b->usermail = 0;
      if (! *befbuf)
      {
        putf("Syntax: TGREP [pattern] <fwd-bbs>\n");
        break;
      }
      befbuf = nexttoken(befbuf, string, 60);
      if (*befbuf)
      {
        sprintf(name, TRACEPATH "/t_%s.bcm", befbuf);
        grep(name, string, b->optplus);
      }
      else
      {
        sprintf(name, TRACEPATH "/t_%s.bcm", string);
        putlog(name, "");
      }
    } break;
    case grep_:
    {
      char string[61];
      scanoptions(befbuf);
      if (b->optminus & o_i) b->optplus |= o_i;
      //wenn nicht explizit "-i-", ist "-i" default
      b->usermail = 0;
      befbuf = nexttoken(befbuf, string, 60);
      grep(befbuf, string, b->optplus);
    } break;
#ifdef _AUTOFWD
    case afwdlist_:
    {
      afwdlist(befbuf);
    } break;
#endif
    case life_:
    {
      if (*befbuf)
      {
        strupr(befbuf);
        char *life = skip(befbuf);
        int board = finddir(befbuf, b->sysop);
        if (board > 0)
        {
          board -= 1;
          if (life && *life)
          {
            tree[board].lifetime_max = atoi(life);
            tree[board].lifetime_min = 1;
            if (tree[board].lifetime_max > 999)
              tree[board].lifetime_max = 999;
            if (tree[board].lifetime_max < 1)
              tree[board].lifetime_max = 1;
            char *life_min = skip(life);
            if (life_min && *life_min)
            {
              tree[board].lifetime_min = atoi(life_min);
              if (tree[board].lifetime_min > 999)
                tree[board].lifetime_min = 999;
              if (tree[board].lifetime_min < 1)
                tree[board].lifetime_min = 1;
            }
            mbtreesave();
          }
          putf(ms(m_lifetimestat), b->boardfullname, tree[board].lifetime_max,
                                                     tree[board].lifetime_min);
        }
        else
          putf(ms(m_notfound), befbuf);
      }
      else
        putf("Syntax: LIFETIME <board> <days_maximum> [<days_minimum>]\n"
             "            (with 1 <= days_maximum/days_minimum <= 999)\n\n");
    } break;
#ifdef _TNC
    case tnc:
    {
      control_tnc(befbuf);
    } break;
#endif
    case connect_:
    {
      termqso(befbuf);
    } break;
    case login:
    {
      if (mbcallok(befbuf))
      {
        mblogin(befbuf, login_standard, b->uplink);
        cmdlog("login changed");
        putf(ms(m_loginchanged));
      }
      else
        putf("Syntax: LOGIN <new logincall>\n");
    } break;
    case call_:
    {
      if (mbcallok(befbuf))
      {
        mblogin(befbuf, login_silent, b->uplink);
        b->msg_loadnum--; //Sonst wird falsche Sprache benutzt
        cmdlog("call changed");
      }
      else
        putf("Syntax: CALL <new logincall>\n");
    } break;
    case oshell_:
    {
      if (t->input == io_file || t->output == io_file)
        oshell(befbuf, sh_noinput);
      else oshell(befbuf, m.dosinput ? sh_forceinput : sh_ifmultitask);
    } break;
    case reorg:
    {
      if (sema_test("purgereorg") == 1)
        putf(ms(m_purgeallstarted));
      else
      {
        putf(ms(m_reorginvoked));
        fork(P_BACK | P_MAIL, 0, mbreorg, befbuf);
      }
    } break;
    case postfwd_:
    {
      putf(ms(m_postfwdinvoked));
      fork(P_BACK | P_MAIL, 0, postfwd, "Postfwd");
    } break;
#ifdef FEATURE_EDITOR
    case edit:
    {
      fork(P_WIND | P_KEYB, 0, editfile, befbuf);
    } break;
    case fedit:
    {
      fork(P_WIND | P_KEYB, 0, editfile, FWDLISTNAME);
    } break;
    case redit:
    {
      fork(P_WIND | P_KEYB, 0, editfile, REJECTNAME);
    } break;
#else
 #ifdef DF3VI_FWD_EDIT
    case fedit: //wenn kein editor vorhanden remote-editor aufrufen
    case fwdedit:
    {
      fwdlistedit(befbuf);
    } break;
 #endif
 #ifdef DF3VI_REJ_EDIT
    case redit:
    case rejectedit:
    {
      rejectlistedit(befbuf);
    } break;
 #endif
 #ifdef DF3VI_CONV_EDIT
    case cedit:
    case convedit_:
    {
      convedit(befbuf);
    } break;
 #endif
#endif
    case new_:
    {
      scanoptions(befbuf);
      mbinit();
      initfwdlist();
#ifdef _AUTOFWD
      initafwdlist();
#endif
      if (! (b->optplus & o_q)) // skip statistics on "new -q"
      {
        b->optplus = o_s | o_f | o_c;
        putf(ms(m_hadrstat));
        browse_hadr("");
      }
      mbcvtload();
#ifdef RUNUTILS
      read_runfile();
#endif
      msg_dealloc(1);
      mk_read_jobs();
    } break;
    case kill_:
    {
      if (atoi(befbuf))
      {
        while (atoi(befbuf))
        {
          if (! killtask(nextdez(&befbuf), 1))
            putf(ms(m_cantkilltask));
        }
      }
      else
        putf("Syntax: KILL <task-id>\n");
    } break;
#ifdef __DOS16__
    case w2:
    {
      fork(P_WIND | P_KEYB|P_MAIL, 0, mbwin2, m.sysopcall);
    } break;
    case uwin:
    {
      fork(P_WIND | P_KEYB|P_MAIL, 0, userwin, "Users");
    } break;
    case twin:
    {
      fork(P_WIND | P_MAIL, 0, taskwin, befbuf);
    } break;
#ifdef _AUTOTRCWIN
    case trwin:
    {
      if (*befbuf) fork(P_WIND | P_MAIL, 0, trcwin, befbuf);
      else putf("Syntax: TRWIN [-iords] <task-id>\n");
    } break;
#endif
#endif //__DOS16__
    case mkb:
    {
      char mainboard[30];
      char newboard[20];
      char *slash;
      befbuf = nexttoken(befbuf, mainboard, 29);
      befbuf = nexttoken(befbuf, newboard, 19);
      slash = strchr(mainboard + 1, '/');
      if (slash && (! *newboard))
      {
        *slash = 0;
        strcpy(newboard, slash + 1);
      }
      if (! *newboard && *mainboard == '/')
      {
        strcpy(newboard, mainboard + 1);
        mainboard[1] = 0;
      }
      if (*mainboard && *newboard)
      {
        switch (mkboard(mainboard, newboard, 0))
        {
          case 0: putf(ms(m_boardcreated)); break;
          case 1: putf(ms(m_mainboardnotfound)); break;
          case 2: putf(ms(m_toomanyboards)); break;
          case 3: putf(ms(m_boardnameexist)); break;
          case 4: putf(ms(m_invalidboardname)); break;
        }
      }
      else
        putf("Syntax: MKBOARD <mainboard> <subboard>\n");
    } break;
    case rmb:
    {
      if (*befbuf)
      {
        subst1(befbuf, ' ', '/');
        if (*befbuf == '/' && befbuf[1] == '/') befbuf++;
        switch (rmboard(befbuf))
        {
          case 0: putf(ms(m_boardremoved)); break;
          case 1: putf(ms(m_boardnotfound)); break;
          case 2: putf(ms(m_boardnotempty)); break;
        }
      }
      else
        putf("Syntax: RMBOARD <mainboard> <subboard>\n");
    } break;
    case mvb:
    {
      char oldboard[20];
      char subboard[20];
      char neuboard[20];
      befbuf = nexttoken(befbuf, oldboard, 19);
      befbuf = nexttoken(befbuf, subboard, 19);
      befbuf = nexttoken(befbuf, neuboard, 19);
      if (*oldboard && *subboard && *neuboard)
      {
        switch (mvboard(oldboard, subboard, neuboard))
        {
          case 0: putf(ms(m_boardmoved)); break;
          case 1: putf(ms(m_newboardnotfound)); break;
          case 2: putf(ms(m_toomanyboards)); break;
          case 4: putf(ms(m_oldboardnotfound)); break;
        }
      }
      else
        putf("Syntax: MVBOARD <oldboard> <subboard> <newboard>\n");
    } break;
    case shutdown_:
    {
      scanoptions(befbuf);
#ifdef __DOS16__
      if (b->optplus & o_r) atexit((void(*)()) MK_FP(0xffff, 0x0000));
#endif
      runterfahren = 1;
      sprintf(shutdown_reason, "shutdown by %s", b->logincall);
      stopreason = shutdown_reason;
    } break;
    case cfgflex_:
    {
      if (*befbuf && file_isreg("cfgflex.bcm"))
      {
        putf(ms(m_flexstarted));
        fork(P_BACK | P_MAIL, 0, cfgflex, befbuf);
      }
      else
        putf("Syntax: CFGFLEX <flexcall> (cfgflex.bcm must exist)\n");
    } break;
    case import:
    {
      sysimport(befbuf);
    } break;
    case export_:
    {
      if (*befbuf)
      {
        if ((t->input != io_file || t->output == io_dummy)
            && t->output != io_file)
        {
          char fname[51];
          scanoptions(befbuf);
          befbuf = nexttoken(befbuf, fname, 50);
          if (b->optplus & o_a) // neue Option -b fuer binaer
          {
            if (b->optplus & o_b) b->outputfile = s_fopen(fname, "sab");
            else b->outputfile = s_fopen(fname, "sat");
          }
          else
          {
            if (b->optplus & o_b) b->outputfile = s_fopen(fname, "swb");
            else b->outputfile = s_fopen(fname, "swt");
          }
          if (b->outputfile)
          {
            s_fsetopt(b->outputfile, 1);
            b->oldinput = t->input;
            b->oldoutput = t->output;
            t->input = io_dummy;
            t->output = io_file;
            b->continous = 1;
            if (b->optplus & o_u) b->sysop = 0;
            if (*befbuf) mailbef(befbuf, 0);
            b->sysop = 1;
          }
          else
            putf(ms(m_filenotopen), fname);
        }
      }
      else
        putf("Syntax: EXPORT <filename> <box-command>\n");
    } break;
    case beacon:
    {
      if (*befbuf)
      {
        FILE *f = s_fopen(BEACONNAME, "srt");
        unsigned int i = 0;
        char s[LINELEN+1];
        if (f)
        {
          while (fgets(s, LINELEN, f))
          {
            if (*s)
            {
              s[strlen(s) - 1] = 0;
              putbeacon_tnc(s, befbuf);
              i++;
            }
          }
          s_fclose(f);
        }
        putf(ms(m_beaconframes), i);
      }
      else
      {
        fork(P_BACK | P_MAIL, 0, sendmailbake, "Beacon");
        putf(ms(m_beaconstarted));
      }
    } break;
    case pwgen:
    {
      FILE *f;
      if (*befbuf && (f = s_fopen(befbuf, "swt")) != 0)
      {
        unsigned int i;
        int upw;
        upw = ! stricmp(befbuf, "userpw.bcm"); // file fuer setpw
        for (i = 0; i < 1620; i++)
        {
          char c = 0;
          while (! isalnum(c)) c = random_max('z');
          fputc(c, f);
          //pw-file fuer setpw erzeugen (81 Zeilen mit je 20 Zeichen)
          if (upw && (i % 20) == 19) fputc(LF, f);
        }
        trace(report, "pwgen", "%s created", befbuf);
        s_fclose(f);
      }
      else //ohne Parameter immer userpw.bcm erzeugen
      if (! *befbuf && (f = s_fopen("userpw.bcm", "swt")) != 0)
      {
        unsigned int i;
        for (i = 0; i < 1620; i++)
        {
          char c = 0;
          while (! isalnum(c)) c = random_max('z');
          fputc(c, f);
          //pw-file fuer setpw erzeugen (81 Zeilen mit je 20 Zeichen)
          if ((i % 20) == 19) fputc(LF, f);
        }
        trace(report, "pwgen", "userpw.bcm created");
        s_fclose(f);
      }
    } break;
    case scmdlist: // DH3MB
    {
      unsigned int i = 0;
      while (beftab[i]) putf("(%02d) %s\n", ++i, beftab[i]);
    } break;
#ifdef FEATURE_MDPW
    case md2sum:
    {
      if (! *befbuf)
      {
        putf("Syntax: MD2SUM <filename>\n");
        break;
      }
      if (! file_isreg(befbuf))
        putf(ms(m_filenotfound), befbuf);
      else
      {
        MD2 md2;
        md2.readfile(befbuf, 0L);
        md2.gethexdigest(b->line);
        putf("%s  %s\n", b->line, befbuf);
      }
    } break;
    case md5sum:
    {
      if (! *befbuf)
      {
        putf("Syntax: MD5SUM <filename>\n");
        break;
      }
      if (! file_isreg(befbuf))
        putf(ms(m_filenotfound), befbuf);
      else
      {
        MD5 md5;
        md5.readfile(befbuf, 0L);
        md5.gethexdigest(b->line);
        putf("%s  %s\n", b->line, befbuf);
      }
    } break;
#endif
#if defined FEATURE_SERIAL || defined _TELEPHONE
    case ttyinit:
    {
      if (eingelogt("getty", 0, 0))
        putf(ms(m_ttyactive));
      else
        init_tty();
    } break;
#endif
#ifdef _TELEPHONE // JJ
    case ttycmd:
    {
      if (*befbuf)
      {
        if (m.ttydevice > 1)
          putf_tty("%s\r", befbuf);
        else
          putf(ms(m_nomodem));
      }
      else
        putf("Syntax: TTYCMD <command>\n");
    } break;
    case ttydial:
    {
      strupr(befbuf);
      char *nummer;
      char call[8];
      nummer = nexttoken(befbuf, call, 8);
      if (*befbuf && mbcallok(call))
      {
        if (m.ttydevice
            && (get_ufwd(call)[0] || isforwardpartner(call) >= 0))
        {
          putf(ms(m_startphonefwd), call, nummer);
          sprintf(befbuf, "%s TTY %s", call, nummer);
          fork(P_BACK | P_MAIL, 0, fwdsend, befbuf);
        }
        else
          putf(ms(m_nottyactive));
      }
      else
        putf("Syntax: TTYDIAL <call> <number>\n");
    } break;
    case ttyhangup:
    {
      tty_hangup();
      putf(ms(m_hangupmodem));
    } break;
    case ttystatus:
    {
      tty_statustext();
      putv(LF);
    } break;
    case ttywin_:
    {
      fork(P_WIND | P_MAIL, 0, tty_win, befbuf);
    } break;
    case ttycounterreset:
    {
      tty_counterreset();
      putv(LF);
    } break;
#endif
#ifdef _FILEFWD
    case fwdimport:
    {
      if (*befbuf) fwd_import(befbuf);
    } break;
    case fwdexport:
    {
      if (*befbuf) fwd_export(befbuf);
    } break;
#endif

    case ymbtest:
    {
#ifdef _USERCOMP
      if (u->comp == 1)
      {
/*
    char output[256] = { 0 };
    char output2[256] = { 0 };
    int i, il = 0;
*/
        putf("//COMP 1\n\n");
        putflush();

/*
    il = comp_sp_stat_huff(befbuf, strlen(befbuf), output);
//    printf("il: %d strlen: %d\n",il,strlen(befbuf));
//    printf("befbuf:\n-%s-\nOut:\n-%s-\n",befbuf,output);
    //putflush();
    for (i = 1; i < il ; i++)
      bputv(output[i]);

    putv(LF);
    putflush();
    output[0] = '\0';
    strcpy(befbuf, "dies ist noch ein laengerer text 2");
    il = comp_sp_stat_huff(befbuf, strlen(befbuf), output);
    for (i = 1; i < il ; i++)
      bputv(output[i]);

    putv(LF);
    putflush();
    output[0] = '\0';
    strcpy(befbuf, "dies ist ein noch laengerer text 3");
    il = comp_sp_stat_huff(befbuf, strlen(befbuf), output);
    for (i = 1; i < il ; i++)
      bputv(output[i]);


    putv(LF);
    putflush();
    putf("\n");
    il = decomp_sp_stat_huff(output, strlen(output), output2);
    printf("il: %d strlen: %d\n",il,strlen(output));
    printf("Out2:\n-%s-\n",output2);
*/

/*
#include "ahuf.h"
   // TOP-Huffman
class AHUF;
   AHUF *ahuf;
   ahuf = new AHUF();

    il = ahuf->Komprimieren(true, befbuf, output, strlen(befbuf) );
    printf("il: %d strlen: %d\n",il,strlen(befbuf));
    printf("befbuf:\n-%s-\nOut:\n-%s-\n",befbuf,output);
    putflush();
    putf("%s",output);
    putflush();
    putf("\n");
*/
      }
#endif
    } break;
  }
  return OK;
예제 #10
0
파일: wx.cpp 프로젝트: donzelot/openBCM
void wx::savedata (char *rawdata, wxdata_t *wx)
//*************************************************************************
//file-format: wx-data:
//
//filename: directory: 'wx'
//          filename:  'wx251296.dat' 96..year,12..month,25..day
//
//         1       2       3       4       5       6       7
//1234567890123456789012345678901234567890123456789012345678901234567890
//007200!!00000271003C0000255F02B503E8----0167044800000000-000851548504Y
//      !!0000000F00DC05D7254202CA03AB----0164045D00000000
//      12345678901234567890123456789012345678901234567890
//               1         2       3       4       5
//vvvvvxwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww-ttttttttttttc
//12345                                               123456789012
//v...Version of Software,5digits  as defined in header, defining file-format
//    (numversion)
//x...Type of line: '0': data
//                  '1': comment
//                  else: undefined
//t...time of System (not WX-station) in Unix-Format
//w...oneline-wx-data, as received from wx-station
//c...simple check sum of string  (mod 64)+32
//-...Error in privious versions, inserted "-" for compatibility
//
//*************************************************************************
{
#define DASH "-"
#define DATA_TYPE "0"
 char name[20];
 strcpy(name, "wx:savedata");
 char wxfilen[FNAMELEN+1];
 FILE *wxfile;
 char filestr[200];
 int i;
 long csum;

 // create wxpath
 strcpy(wxfilen, time2wxfn(wx->t));
 // open file if existing, else create it
 wxfile = s_fopen(wxfilen, "sat");
 if (! wxfile)
   wxfile = s_fopen(wxfilen, "swt");
 if (! wxfile)
 {
   trace(serious, name, "create %s", wxfile);
   return;
 }
 trace(report, name, "store to %s", wxfilen);
 sprintf(filestr, WXNUMVERSION""DATA_TYPE"%s"DASH"%012ld",
                  rawdata, wx->t);
 csum = 0;
 for (i=0; filestr[i]; i++)
 {
   csum += filestr[i];
 }
 csum = (csum%64)+32; //this check is stupid, but necassary for compatiblity
 sprintf(filestr+strlen(filestr), "%c\n", (int) csum);
 fputs(filestr, wxfile);
 s_fclose(wxfile);
}
예제 #11
0
void extract (unsigned msgnr)
//*************************************************************************
//
//  EXTRACT-Utility by DF3VI, extrahiert Binaerteile einer Mail auf
//  die Mailbox-Festplatte ins Box-temp-Verzeichnis
//
//*************************************************************************
{ //is this re-entrant? if not, pse set semaphor
  FILE *f, *g;
  char name[FNAMELEN+1], s[BUFLEN], st[FNAMELEN+1], *ptr;
  unsigned long posi, bytes;
  int err;
  unsigned int w, r;
  char *puffer;

  strlwr(b->mailpath);
  if (! (f = s_fopen(b->mailpath, "sr")))
  {
    putf(ms(m_extract_errorread), b->mailpath);
    return;
  }
  fgets(s, BUFLEN - 1, f);
  mbsend_parse(s, 0);
  do
  {
    waitfor(e_ticsfull);
    fgets(s, BUFLEN - 1, f);
  }
  while (! feof(f)
         && ! (strstr(s, " go_") == s) && ! (strstr(s, "#BIN#") == s));
  if (feof(f)) // keine Markierung gefunden
  {
    putf(ms(m_extract_nostartline), b->boardname, msgnr);
    s_fclose(f);
    return;
  }
  do
  {
    if (strstr(s, "#BIN#") == s)
    {
      s_fclose(f);
      subst1(s, LF, 0);
      if (! sscanf(s, "#BIN#%lu", &bytes)) // Laenge lesen
      {
        putf(ms(m_extract_invalidheader), b->boardname, msgnr);
        return;
      }
      unsigned long bintime;
      sscanf(strchr(s, '$'), "$%lX#", &bintime);
      ptr = s + strlen(s);
      while (*ptr != '#' && ptr > s) ptr--;    // Dateinamen suchen
      if (*(ptr - 1) != '#') ptr++;            // # im Dateinamen ?
      if (! *ptr || *ptr == '$' || *ptr == '|' )
      {
        putf(ms(m_extract_filenamemissing));
        err = 0;
        do                              // Ersatzname RUBRIK.lfn erzeugen
        {
          waitfor(e_ticsfull);
          sprintf(s, TEMPPATH "/%s.%03i", b->boardname, ++err);
          strlwr(s);
        }
        while (! access(s, 0) && err <= 999);
        if (err > 999)
        {
          putf(ms(m_extract_filecantcreate));
          return;
        }
        else
          putf(ms(m_extract_filecreate), s);
      }
      else
      {
        strcpy(name, ptr);
        ptr = name + strlen(name);
        while (ptr >= name && *ptr != ':' && *ptr != '\\' && *ptr != '/')
          ptr--; // LW/Pfad abtrennnen
//      putf("Dateiname: %s\n", ptr+1);
        sprintf(s, TEMPPATH "/%s", ptr + 1);
        strlwr(s);
      }
      if (! (g = s_fopen(s, "swb")))
      {                                  // Ziel-Datei oeffnen
        putf(ms(m_extract_errorwritebin), errno, s, strerror(errno));
//      perror("");
        return;
      }
      if (! (puffer = (char *) t_malloc(2048, "extr")))
      {                                  // 2 kb Puffer zum Daten-Kopieren
        putf(ms(m_nomem));
        s_fclose(g);
        return;
      }
      f = s_fopen(b->mailpath, "srb"); // BIN-Datei oeffnen
      fseek(f, b->binstart + BINCMDLEN, SEEK_SET); // Position auf Anfang
      posi = r = 0; // Byte-Zaehler gesamt/gelesen
      do
      {
        r = fread(puffer, 1, 2048, f);
        posi += r;
        fwrite(puffer, 1, r, g);
        waitfor(e_ticsfull);
      }
      while (r == 2048);
      t_free(puffer);
      s_fclose(g);
      s_fclose(f);
      setfiletime(s, bintime);
      putf(ms(m_extract_extractbin), s, posi, bytes, b->boardname, msgnr);
      return; // BIN ist immer Fileende
    }
    // Ansonsten DG1BBQ-FFR-Markierung
    if ((strstr(s, " go_text. ") == s) || (strstr(s, " go_info. ") == s))
    {
      sscanf(s + 10, "%s", st); // Text-Datei-Namen lesen
      sprintf(name, TEMPPATH "/%s", st);
      strlwr(name);
      if (! access(name, 0)) // Wenn vorhanden, Extension hochzaehlen
      {
        err = 1;
        switch (name + strlen(name) - strchr(name, '.'))
        {
          case 1:                              // "name."    -> "name.__"
          case 2: strcat(name, "__" ); break;  // "name.x"   -> "name.x__"
          case 3: strcat(name, "_");           // "name.xx"  -> "name.xx_"
          case 4: break;                       // "name.xxx" -> "name.xxx"
          default: strcat(name, ".__");        // "name"     -> "name.__"
        }
        *(name + strlen(name) - 2) = 0;
        do                            // ZWEI-stellige laufenden Nummer
        {
          waitfor(e_ticsfull);
          sprintf(s, "%s%02x", name, err++);
        }
        while (! access(s, 0) && err < 255);
        if (err >= 255)
        {
          putf(ms(m_extract_filecantcreate));
          *name = 0;
        }
        else
        {
          strcpy(st, s);
          strlwr(st);
        }
      }
      *s = 0; // Keine Startmarkierung schreiben
    }
    else
    if (strstr(s, " go_7+. ") == s) // 7PLUS-Datei-Kopf auswerten
    {                               // lfn, Bereich, File-Name
      if (sscanf(s + 8, "%u of %u %s", &w, &r, name) != 3)
      {
        putf(ms(m_extract_invalidstartline), b->boardname, msgnr);
        *name = 0;
      }
      else
      {
        subst1(name, '.', 0); // Extension abtrennen
        if (r == 1)
          sprintf(st, TEMPPATH "/%s.7pl", name); // Einteilig: Endung .7PL
        else
          sprintf(st, TEMPPATH "/%s.p%02x", name, w); // Mehrteilig: End. .PXX
      }
    }
    else
    {
      putf(ms(m_extract_invalidstartline), b->boardname, msgnr);
      *st = 0;
    }
    if (*st)
    {
      strlwr(st);
      if (! (g = s_fopen(st, "sw"))) // Ziel-Datei schreiben
      {
        putf(ms(m_extract_errorwrite), st);
        return;
      }
      do
      {
        fputs(s, g);
        *s = 0;
        waitfor(e_ticsfull);
        fgets(s, BUFLEN - 1, f);
      }                            // Bis File-Ende oder Stop-Markierung
      while (! feof(f) && ! (strstr(s, " stop_") == s));
      if (strstr(s, " stop_7+"))
        fputs(s, g); //nur bei 7+ Endemarkierung schreiben
      s_fclose(g);
      putf(ms(m_extract_extract7p), st, b->boardname, msgnr);
    }
    do
    {
      waitfor(e_ticsfull);
      *s = 0;
      fgets(s, BUFLEN - 1, f); // Naechste Start-Markierung suchen
    }
    while (! feof(f)
           && ! (strstr(s, " go_") == s) && ! (strstr(s, "#BIN#") == s));
  }
  while (! feof(f));                     // solange 7+ folgt
  s_fclose(f);                           // oder File-Ende
}
예제 #12
0
void initafwdlist ()
//*************************************************************************
//
// read afwd.bcm into memory
//
//*************************************************************************
{
  FILE *f;
  char s[LINELEN+1];
  char word[MAXPARSE];
  char dstb[HADRESSLEN+1];
  int boxindex = 0;
  int line = 0;
  int i;
  int destlen = 0;
  afwdpara_t *ff;
  char name[20];

  strcpy(name, "initafwdlist");
  if (! m.autofwdtime) return;
  if (afp) t_free(afp);
  afp = (afwdpara_t *) t_malloc(MAXFWD * sizeof(afwdpara_t), "*afp");
  if (aboxdest) t_free(aboxdest);
  aboxdest = (char *) t_malloc(MAXDESTLEN * sizeof(char), "*ads");
  if (! afp || ! aboxdest)
  {
    trace(fatal, name, "out of memory");
    return;
  }
  memset(afp, 0, MAXFWD * sizeof(afwdpara_t));
  ff = afp;
  if ((f = s_fopen(AFWDLISTNAME, "srt")) != NULL)
  {
    while (fgets(s, LINELEN, f))
    {
      line++;
      subst1(s, ';', 0);
      if (strlen(s) > 3)
      {
        i = (*s == ' ');
        strupr(s);
        parseline(s, word);
        if (i)
        {
          if (! boxindex)
            goto error; // erster Eintrag: Boxcall fehlt
          else
          {
            char *dest = afp[boxindex - 1].dest;
            i = 0;
            while (word[i])
            {
              strncpy(dstb, s + word[i++], HADRESSLEN);
              dstb[HADRESSLEN] = 0;
              //strip_hadr(dstb);
              if (*dstb && (destlen + strlen(dstb) + 1) < MAXDESTLEN)
              {
                strcat(dest, dstb);
                strcat(dest, " ");
                destlen += (strlen(dstb) + 1);
              }
              else
              {
                trace(serious, name, ms(m_fwd_toomanydest));
                if (*b->logincall) putf(ms(m_fwd_toomanydest));
                break;
              }
            }
          }
        }
        else
        {
          if (! boxindex)
            ff->dest = aboxdest;
          else
          {
            ff->dest = afp[boxindex - 1].dest
                       + strlen(afp[boxindex - 1].dest) + 1;
            destlen += 1;
          }
          *ff->dest = 0;
          *ff->call = 0;
          if (strlen(s + *word) <= 6) strcpy(ff->call, s + *word);
          else goto error;                      // Boxcall zu lang
          if (++boxindex == MAXFWD)
          {
            trace(serious, name, ms(m_fwd_toomanycalls));
            if (*b->logincall) putf(ms(m_fwd_toomanycalls));
            break;
          }
          ff = &afp[boxindex];
        }
      }
    }
    *ff->call = 0;
    s_fclose(f);
#ifdef DEBUG_AFWD
    trace(report, name, "%d partners", boxindex);
#endif
    if (*b->logincall) putf("%s: %d partners.\n", name, boxindex);
    afwdpartners = boxindex;
    if (! boxindex)
    {
      t_free(afp);
      t_free(aboxdest);
      afp = NULL;
      aboxdest = NULL;
    }
    return;
  }
  else
  {
    trace(serious, name, AFWDLISTNAME" not found");
    if (*b->logincall) putf("%s: "AFWDLISTNAME" not found.\n", name);
    return;
  }
error: //that should never happen
#ifdef __DOS16__
    sound(1000);
    wdelay(106);
    nosound();
#endif
    trace(serious, name, "line %d error", line);
    if (*b->logincall) putf("%s: line %d error.\n", name, line);
    s_fclose(f);
}
예제 #13
0
void afwdlist (char *)
//*************************************************************************
//
// afwd.bcm is generated here ..
//
//*************************************************************************
{
  char name[20];

  strcpy(name, "afwdlist");
  if (! m.hadrstore || ! m.autofwdtime) return; //afwd disabled
  // Alle boxen durchsuchen
//  trace(report, "afwdlist", "scanning HADR");
  unsigned int found = 0, i = 0;
  if (! (found = scan_hadr())) return;
  // Sort file by reversed short addr
  char linetmp[LINELEN+1];
  char *xx;
  afwd_data *adrs = (afwd_data*) t_malloc(sizeof(afwd_data) * found, "hadr");
  if (! adrs)
  {
    trace(serious, name, "out of memory");
    putf("not enough memory");
    return;
  }
#ifdef DEBUG_AFWD
  trace(report, name, "reading entries in memory");
#endif
  FILE *f = s_fopen(AFWDTMP, "srt");
  if (f)
  {
    while (fgets(linetmp, LINELEN, f))
    {
      //fwdcall, shortheader
      xx = strchr(linetmp, ' ');
      *xx++ = 0;
      strcpy(adrs[i].partner, linetmp);
      strcpy(adrs[i].shortaddr, reverse_addr(xx));
      i++;
    }
    s_fclose(f);
  }
  else
  {
    trace(serious, name, ms(m_filenotopen), AFWDTMP);
    putf(ms(m_filenotopen), AFWDTMP);
    t_free(adrs);
    return;
  }
#ifdef DEBUG_AFWD
  trace(report, name, "read %u", i);
  trace(report, name, "sorting ..");
#endif
  qsort(adrs, i, sizeof(afwd_data), data_cmp);
  found = process_afwd_data(adrs, found);
#ifdef DEBUG_AFWD
  trace(report, name, "writing "AFWDLISTNAME);
#endif
  f = s_fopen(AFWDLISTNAME, "lwt");
  if (! f)
  {
    trace(serious, name, ms(m_filenotopen), AFWDLISTNAME);
    putf(ms(m_filenotopen), AFWDLISTNAME);
    t_free(adrs);
    return;
  }
  fprintf(f, "; OpenBCM AutoFwd File !!! DO NOT EDIT !!!\n");
  fprintf(f, "; This file is generated automatically. (use %s for manual editing!)\n", FWDLISTNAME);
  write_afwd(f, adrs, found);
  s_fclose(f);
  t_free(adrs);
  initafwdlist();
}
예제 #14
0
static int scan_hadr ()
//*************************************************************************
//
// process HADR database, find entries newer than autofwdtime,
// write afwd1.tmp
//
//*************************************************************************
{
  hadr_t *ha;
  unsigned int count = 0, found = 0, i = 0;
  char boxcall[CALLEN+1];
  char *header;
  char shortheader[HADRESSLEN+1];
  char name[20];
  int num;

  strcpy(name, "afwdlist");
  FILE *f = s_fopen(HADRNAME, "lrb");
  if (! f)
  {
    trace(serious, name, ms(m_filenotopen), HADRNAME);
    putf(ms(m_filenotopen), HADRNAME);
    return 0;
  }
  FILE *g = s_fopen(AFWDTMP, "lwt");
  if (! g)
  {
    trace(serious, name, ms(m_filenotopen), AFWDTMP);
    putf(ms(m_filenotopen), AFWDTMP);
    s_fclose(f);
    return 0;
  }
  ha = (hadr_t*) t_malloc(sizeof (hadr_t), "hadr");
  setvbuf(f, NULL, _IOFBF, 4096); // buffer for increasing performance
  fseek(f, sizeof (hadr_t), SEEK_SET);
  while (fread(ha, sizeof(hadr_t), 1, f))
  {
    if (! *ha->adr) continue;
    if (! strcmp(ha->adr, m.boxadress)) continue;
    count++;
    if (! check_adr(ha->adr)) continue;
    if ((num = which_partner(NULL, ha)) == NOTFOUND) continue;
    // Forwardweg suchen
    //no hadr, only boxcall (corrupt R: lines etc.)
    //(should not pass through check_adr() anyway)
    if (! (header = strchr(ha->adr, '.'))) continue;
    i = header - ha->adr;
    strcpy(shortheader, ha->adr);
    strip_hadr(shortheader);
    if (i > CALLEN) i = CALLEN;
    strncpy(boxcall, ha->adr, i);
    boxcall[i] = 0;
    if (mbcallok(boxcall))
    {
      found++;
      // putf("%i) %s%s -> %s to %s\n", count, boxcall, header, shortheader, fwdcall);
      // Routerfile schreiben
      fprintf(g, "%s %s \n", ha->adjacent[num], shortheader);
    }
    waitfor(e_ticsfull);
    if (testabbruch()) break;
  }
  t_free(ha);
  s_fclose(f);
  s_fclose(g);
#ifdef DEBUG_AFWD
  trace(report, name, "%u searched,  %u found", count, found);
#endif
  putf("%u searched, %u found\n", count, found);
  return found;
}
예제 #15
0
void cfgflex (char * befbuf)
//*************************************************************************
//
// cfgflex
//
//*************************************************************************
{
  int a, i;
  int promptz = 0; // Zaehler der Nodeprompts
  char fn[20]; // Dateiname des Configfiles
  char fo[20]; // Dateiname des Antwortfiles
  char ziel[30]; // Nodecall
  char line[255]; // Noderueckgabe

  strcpy(fn, "cfgflex.bcm");
  strcpy(fo, "cfgflex.out");
  strncpy(ziel, befbuf, 29);
  ziel[29] = 0;
  trace(report, "cfgflex", "connect %s", ziel);
  timeout(1);
  lastcmd("Connect");
  if (makeconnect(m.mycall[1], ziel))
  {
    setsession();
    *b->logincall = 0;
    if (filetime(fn))
    {
      trace(report, "cfgflex", "sending %s", fn);
      FILE *f = s_fopen(fn, "lrt");
      lastcmd("TX cfg_file");
      while ((a = fgetc(f)) != EOF)
      {
        getclear_tnc();
        timeout(1);
        waitfor(e_ticsfull);
        putv(a);
        if (a == LF) promptz++; // zaehlt prompts vorwaerts
      }
      putv(LF);
      putv(LF);
      s_fclose(f);
      trace(report, "cfgflex", "receive %s", fo); // speichert Rueckgaben
      FILE *g = s_fopen(fo, "lwt");
      lastcmd("RX cfg_result");
      if (g) // JJ
      {
        while (promptz > 0)
        {
          getline(line, BUFLEN - 1, 1);
          if (! strncmp(line, "=>", 2))
            promptz--; // zaehlt prompts rueckwaerts
          if (! strncmp(line, "***", 3))
            promptz = 0; // link failure
          fprintf(g, "%s", line);
          fputc(LF, g);
        }
      }
      s_fclose(g);
    }
    lastcmd("Delay");
    for (i = 0; i < 100; i++)
    {
      wdelay(226);
      getclear_tnc();
    }
    mblogout(0);
    mbdisconnect(1); // wait for data to be sent
  }
}