home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / fsrc1241.zip / request_manage.c < prev    next >
C/C++ Source or Header  |  1999-02-14  |  12KB  |  384 lines
  1. /*---------------------------------------------------------------------------+
  2.  | Titel: REQUEST_MANAGE.C                                                   |
  3.  +-----------------------------------------+---------------------------------+
  4.  | Erstellt von: Michael Hohner            | Am: 18.10.1995                  |
  5.  +-----------------------------------------+---------------------------------+
  6.  | System: OS/2 2.x/3.x                                                      |
  7.  +---------------------------------------------------------------------------+
  8.  | Beschreibung:                                                             |
  9.  |                                                                           |
  10.  |    Low-Level-Funktionen f. File-Requests von FleetStreet                  |
  11.  |                                                                           |
  12.  |                                                                           |
  13.  +---------------------------------------------------------------------------+
  14.  | Bemerkungen:                                                              |
  15.  +---------------------------------------------------------------------------*/
  16.  
  17. /*----------------------------- Header-Dateien ------------------------------*/
  18. #pragma strings(readonly)
  19.  
  20. #define INCL_PM
  21. #define INCL_BASE
  22. #include <os2.h>
  23. #include <stdio.h>
  24. #include <stdlib.h>
  25. #include <string.h>
  26. #include <ctype.h>
  27.  
  28. #include "main.h"
  29. #include "structs.h"
  30. #include "dump\expt.h"
  31.  
  32. #include "request_manage.h"
  33.  
  34. /*--------------------------------- Defines ---------------------------------*/
  35.  
  36. /*---------------------------------- Typen ----------------------------------*/
  37.  
  38. /*---------------------------- Globale Variablen ----------------------------*/
  39.  
  40. /*--------------------------- Funktionsprototypen ---------------------------*/
  41.  
  42. /*----------------------- interne Funktionsprototypen -----------------------*/
  43. static PRAMLIST AddSingleFiles(PRAMLIST pLine, char *pchLineText);
  44.  
  45. /*-----------------------------------------------------------------------------
  46.  | Funktionsname: AddNewFileList
  47.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  48.  | Beschreibung: Fuegt eine neue Liste in die Liste ein.
  49.  |
  50.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  51.  | Parameter: ppList: Zeiger auf Listenanfang
  52.  |            pNewList: Zeiger auf neue Knotendaten
  53.  |            pbDirty: Zeiger auf Dirty-Marke oder NULL
  54.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  55.  | Rückgabewerte: Zeiger auf neuen Knoten
  56.  |
  57.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  58.  | Sonstiges: Wenn pbDirty == NULL ist, wird auch das Dirty-Flag im neuen
  59.  |            Knoten nicht gesetzt.
  60.  +---------------------------------------------------------------------------*/
  61.  
  62. PFILELIST AddNewFileList(PFILELIST *ppList, PFILELIST pNewList, PBOOL pbDirty)
  63. {
  64.    PFILELIST pAddList=NULL;
  65.  
  66.    pAddList = calloc(1, sizeof(FILELIST));
  67.  
  68.    /* vorne einhaengen */
  69.    pAddList->next = *ppList;
  70.    if (*ppList)
  71.       (*ppList)->prev = pAddList;
  72.    *ppList = pAddList;
  73.  
  74.    /* Dirty setzen */
  75.    if (pbDirty)
  76.       *pbDirty = pAddList->bDirty = TRUE;
  77.  
  78.    /* Daten kopieren */
  79.    memcpy(pAddList->pchFileName, pNewList->pchFileName, LEN_PATHNAME);
  80.    memcpy(pAddList->pchAddress, pNewList->pchAddress, LEN_5DADDRESS);
  81.    memcpy(pAddList->pchDesc, pNewList->pchDesc, LEN_LISTDESC);
  82.  
  83.    return pAddList;
  84. }
  85.  
  86. /*-----------------------------------------------------------------------------
  87.  | Funktionsname: DeleteFileList
  88.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  89.  | Beschreibung: Löscht einen Knoten aus der Liste
  90.  |
  91.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  92.  | Parameter: ppList: Zeiger auf Listenanfang
  93.  |            pDelList: Zeiger auf zu löschenden Knoten
  94.  |            pbDirty: Zeiger auf Dirty-Flag
  95.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  96.  | Rückgabewerte:  TRUE  Erfolg
  97.  |                 FALSE Fehler
  98.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  99.  | Sonstiges: -
  100.  |
  101.  +---------------------------------------------------------------------------*/
  102.  
  103. BOOL DeleteFileList(PFILELIST *ppList, PFILELIST pDelList, PBOOL pbDirty)
  104. {
  105.    if (!pDelList || !ppList)
  106.       return FALSE;
  107.  
  108.    /* aushaengen */
  109.    if (pDelList->next)
  110.       pDelList->next->prev = pDelList->prev;
  111.    if (pDelList->prev)
  112.       pDelList->prev->next = pDelList->next;
  113.    if (*ppList == pDelList)
  114.       *ppList = pDelList->next;
  115.  
  116.    /* Speicher freigeben */
  117.    free(pDelList);
  118.  
  119.    /* Dirty setzen */
  120.    *pbDirty = TRUE;
  121.  
  122.    return TRUE;
  123. }
  124.  
  125. /*-----------------------------------------------------------------------------
  126.  | Funktionsname: ListReadThread
  127.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  128.  | Beschreibung: Liesst eine Fileliste ein und erzeugt eine String-Liste
  129.  |               mit dem Inhalt
  130.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  131.  | Parameter: Thread-Parameter-Block (FILELISTREAD)
  132.  |
  133.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  134.  | Rückgabewerte: -
  135.  |
  136.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  137.  | Sonstiges: Erfolgsmeldung des Threads wird in ulRetCode des Parameter-
  138.  |            Blocks abgelegt
  139.  +---------------------------------------------------------------------------*/
  140.  
  141. void _Optlink ListReadThread(PVOID pData)
  142. {
  143.    PFILELISTREAD pReadParam = pData;
  144.    FILE *pfList;
  145.    PRAMLIST pLast=NULL;
  146.    char pchLineBuff[300];
  147.    char *pchTemp;
  148.  
  149.    INSTALLEXPT("ReadFList");
  150.  
  151.    if (pfList = fopen(pReadParam->pList->pchFileName, "r"))
  152.    {
  153.       while (!feof(pfList) && !pReadParam->bStop)
  154.       {
  155.          if (fgets(pchLineBuff, sizeof(pchLineBuff), pfList))
  156.          {
  157.             /* \n am Ende entfernen */
  158.             if (pchTemp = strrchr(pchLineBuff, '\n'))
  159.                *pchTemp = 0;
  160.  
  161.             /* neue Zeile anhaengen */
  162.             if (pLast)
  163.             {
  164.                pLast->next = calloc(1, sizeof(RAMLIST));
  165.                pLast = pLast->next;
  166.             }
  167.             else
  168.                pLast = pReadParam->pReadList = calloc(1, sizeof(RAMLIST));
  169.  
  170.             pLast->pchLine = strdup(pchLineBuff);
  171.          }
  172.       }
  173.       if (ferror(pfList))
  174.          pReadParam->ulRetCode = FILELIST_READERR;
  175.  
  176.       fclose(pfList);
  177.    }
  178.    else
  179.       pReadParam->ulRetCode = FILELIST_NOTF;
  180.  
  181.    WinPostMsg(pReadParam->hwndNotify, REQM_LISTREAD, NULL, NULL);
  182.  
  183.    DEINSTALLEXPT;
  184.  
  185.    return;
  186. }
  187.  
  188. /*-----------------------------------------------------------------------------
  189.  | Funktionsname: MessageToFileList
  190.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  191.  | Beschreibung: Wandelt einen Message-Text in eine String-Liste um (wie
  192.  |               eine File-Liste)
  193.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  194.  | Parameter: pchMessageText: Zeiger auf den Text. Die Absätze sind mit \n
  195.  |                            getrennt
  196.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  197.  | Rückgabewerte: Zeiger auf Anfang der String-Liste
  198.  |
  199.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  200.  | Sonstiges:
  201.  |
  202.  +---------------------------------------------------------------------------*/
  203.  
  204. PRAMLIST MessageToFileList(char *pchMessageText)
  205. {
  206.    char *pchTemp = pchMessageText, *pchTemp2;
  207.    PRAMLIST pFirst=NULL, pLast=NULL;
  208.  
  209.    while (pchTemp)
  210.    {
  211.       /* Speicher holen */
  212.       if (pLast)
  213.       {
  214.          pLast->next = calloc(1, sizeof(RAMLIST));
  215.          pLast = pLast->next;
  216.       }
  217.       else
  218.          pLast = pFirst = calloc(1, sizeof(RAMLIST));
  219.  
  220.       pchTemp2 = strchr(pchTemp, '\n');
  221.  
  222.       if (pchTemp2)
  223.       {
  224.          /* Zeile in der Mitte kopieren */
  225.          int len = pchTemp2 - pchTemp;
  226.  
  227.          pLast->pchLine = malloc(len+1);
  228.          if (len)
  229.             memcpy(pLast->pchLine, pchTemp, len);
  230.          pLast->pchLine[len]=0;
  231.          pLast = AddSingleFiles(pLast, pLast->pchLine);
  232.       }
  233.       else
  234.       {
  235.          /* Zeile am Ende kopieren */
  236.          pLast->pchLine = strdup(pchTemp);
  237.          pLast = AddSingleFiles(pLast, pchTemp);
  238.       }
  239.  
  240.       if (pchTemp2)
  241.          pchTemp = pchTemp2+1;
  242.       else
  243.          pchTemp = NULL;
  244.    }
  245.  
  246.    return pFirst;
  247. }
  248.  
  249. #define SEPA_CHARS " \t,:;"
  250.  
  251. static PRAMLIST AddSingleFiles(PRAMLIST pLine, char *pchLineText)
  252. {
  253.    char *pchDup = strdup(pchLineText);
  254.  
  255.    if (pchDup)
  256.    {
  257.       char *pchWord;
  258.  
  259.       pchWord = strtok(pchDup, SEPA_CHARS);
  260.  
  261.       while (pchWord)
  262.       {
  263.          if (IsFileName(pchWord, TRUE))
  264.          {
  265.             pLine->next = calloc(1, sizeof(RAMLIST));
  266.             pLine = pLine->next;
  267.  
  268.             pLine->pchLine = strdup(pchWord);
  269.          }
  270.          pchWord = strtok(NULL, SEPA_CHARS);
  271.       }
  272.  
  273.       free(pchDup);
  274.    }
  275.  
  276.  
  277.    return pLine;
  278. }
  279.  
  280. /*-----------------------------------------------------------------------------
  281.  | Funktionsname: FreeFileList
  282.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  283.  | Beschreibung: Gibt den Speicher einer Stringliste frei
  284.  |
  285.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  286.  | Parameter: pList: Zeiger auf Anfang der Liste
  287.  |
  288.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  289.  | Rückgabewerte: -
  290.  |
  291.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  292.  | Sonstiges:
  293.  |
  294.  +---------------------------------------------------------------------------*/
  295.  
  296. void FreeFileList(PRAMLIST pList)
  297. {
  298.    PRAMLIST pNext;
  299.  
  300.    while (pList)
  301.    {
  302.       pNext = pList->next;
  303.       free(pList);
  304.       pList = pNext;
  305.    }
  306.  
  307.    return;
  308. }
  309.  
  310. /*-----------------------------------------------------------------------------
  311.  | Funktionsname: IsFileName
  312.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  313.  | Beschreibung: Prueft, ob ein Wort einen Filenamen darstellt
  314.  |
  315.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  316.  | Parameter: pchName: Wort
  317.  |            bDotRequired: Punkt muß in Name vorkommen
  318.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  319.  | Rückgabewerte: TRUE   ist Filename
  320.  |                FALSE  ist kein Filename
  321.  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  322.  | Sonstiges: -
  323.  |
  324.  +---------------------------------------------------------------------------*/
  325.  
  326. #define VALID_CHARS  ".$%'-_@{}~`!#()*?"
  327.  
  328. BOOL IsFileName(char *pchName, BOOL bDotRequired)
  329. {
  330.    char *pchTemp=pchName;
  331.    BOOL bHaveDot =FALSE;
  332.    int count_pre=0;
  333.    int count_post=0;
  334.  
  335.    while (*pchTemp == ' ')
  336.       pchTemp++;
  337.  
  338.    if ((pchTemp - pchName) > 5)  /* muß in den ersten 5 Zeichen beginnen */
  339.       return FALSE;
  340.  
  341.    while (*pchTemp)
  342.       if (isalnum(*pchTemp) ||
  343.           strchr(VALID_CHARS, *pchTemp))
  344.       {
  345.          if (*pchTemp == '.')
  346.          {
  347.             if (bHaveDot)
  348.                return FALSE; /* mehr als 1 Punkt */
  349.             else
  350.                bHaveDot = TRUE;
  351.          }
  352.          else
  353.             if (bHaveDot)
  354.                count_post++;
  355.             else
  356.                count_pre++;
  357.  
  358.          pchTemp++;
  359.       }
  360.       else
  361.          if (*pchTemp == ' ')
  362.          {
  363.             if ((count_post+count_pre) > 11)
  364.                return FALSE;
  365.             break;
  366.          }
  367.          else
  368.             return FALSE;
  369.  
  370.    if (count_pre && count_pre <=8 &&
  371.        count_post <=3)
  372.    {
  373.       if (bDotRequired && !count_post)
  374.          return FALSE;
  375.       else
  376.          return TRUE;
  377.    }
  378.    else
  379.       return FALSE;
  380. }
  381.  
  382. /*-------------------------------- Modulende --------------------------------*/
  383.  
  384.