Ignore:
Timestamp:
Nov 24, 2002, 9:45:05 PM (23 years ago)
Author:
umoeller
Message:

Sources as of 1.0.0.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/helpers/xprf.c

    r222 r229  
    155155 *
    156156 *      Private helper.
    157  */
    158 
    159 STATIC PXINIAPPDATA FindApp(PXINI pXIni,           // in: profile opened with xprfOpenProfile
    160                             const char *pcszApp)
     157 *
     158 *@@changed V1.0.0 (2002-09-17) [umoeller]: now returning APIRET
     159 */
     160
     161STATIC APIRET FindApp(PXINI pXIni,           // in: profile opened with xprfOpenProfile
     162                      const char *pcszApp,
     163                      PXINIAPPDATA *ppAppData)
    161164{
    162165    PLISTNODE pAppNode = lstQueryFirstNode(&pXIni->llApps);
    … …  
    165168        PXINIAPPDATA pAppDataThis = (PXINIAPPDATA)pAppNode->pItemData;
    166169        if (!strcmp(pAppDataThis->pszAppName, pcszApp))
    167             return (pAppDataThis);
     170        {
     171            *ppAppData = pAppDataThis;
     172            return NO_ERROR;
     173        }
    168174
    169175        pAppNode = pAppNode->pNext;
    170176    }
    171177
    172     return NULL;
     178    return PRFERR_INVALID_APP_NAME;
    173179}
    174180
    … …  
    181187 *
    182188 *      Private helper.
    183  */
    184 
    185 STATIC PXINIAPPDATA CreateApp(PXINI pXIni,         // in: profile opened with xprfOpenProfile
    186                               const char *pcszApp)
     189 *
     190 *@@changed V1.0.0 (2002-09-17) [umoeller]: now returning APIRET
     191 */
     192
     193STATIC APIRET CreateApp(PXINI pXIni,         // in: profile opened with xprfOpenProfile
     194                        const char *pcszApp,
     195                        PXINIAPPDATA *ppAppData)
    187196{
    188197    PXINIAPPDATA pAppData;
    … …  
    195204        // store in INI's apps list
    196205        lstAppendItem(&pXIni->llApps, pAppData);
    197         pXIni->cApps++;
    198     }
    199 
    200     return (pAppData);
     206
     207        *ppAppData = pAppData;
     208        return NO_ERROR;
     209    }
     210
     211    return ERROR_NOT_ENOUGH_MEMORY;
    201212}
    202213
    … …  
    208219 *
    209220 *      Private helper.
    210  */
    211 
    212 STATIC PXINIKEYDATA FindKey(PXINIAPPDATA pAppData,
    213                             const char *pcszKey)
     221 *
     222 *@@changed V1.0.0 (2002-09-17) [umoeller]: now returning APIRET
     223 */
     224
     225STATIC APIRET FindKey(PXINIAPPDATA pAppData,
     226                      const char *pcszKey,
     227                      PXINIKEYDATA *ppKeyData)
    214228{
    215229    PLISTNODE pKeyNode = lstQueryFirstNode(&pAppData->llKeys);
    … …  
    218232        PXINIKEYDATA pKeyDataThis = (PXINIKEYDATA)pKeyNode->pItemData;
    219233        if (!strcmp(pKeyDataThis->pszKeyName, pcszKey))
    220             return (pKeyDataThis);
     234        {
     235            *ppKeyData = pKeyDataThis;
     236            return NO_ERROR;
     237        }
    221238
    222239        pKeyNode = pKeyNode->pNext;
    223240    }
    224241
    225     return NULL;
     242    return PRFERR_INVALID_KEY_NAME;
    226243}
    227244
    … …  
    234251 *
    235252 *      Private helper.
    236  */
    237 
    238 STATIC PXINIKEYDATA CreateKey(PXINIAPPDATA pAppData,
    239                               const char *pcszKey,     // in: key name
    240                               PBYTE pbData,            // in: data for key
    241                               ULONG cbData)            // in: sizeof (*pbData)
     253 *
     254 *@@changed V1.0.0 (2002-09-17) [umoeller]: now returning APIRET
     255 */
     256
     257STATIC APIRET CreateKey(PXINIAPPDATA pAppData,
     258                        const char *pcszKey,        // in: key name
     259                        PBYTE pbData,               // in: data for key
     260                        ULONG cbData,               // in: sizeof (*pbData)
     261                        PXINIKEYDATA *ppKeyData)    // out: new key data
    242262{
    243263    PXINIKEYDATA pKeyData;
    … …  
    253273            lstAppendItem(&pAppData->llKeys, pKeyData);
    254274            pAppData->cKeys++;
     275
     276            *ppKeyData = pKeyData;
     277            return NO_ERROR;
    255278        }
    256279        else
    257         {
    258280            // malloc failed:
    259281            free(pKeyData);
    260             pKeyData = 0;
    261         }
    262     }
    263 
    264     return (pKeyData);
     282    }
     283
     284    return ERROR_NOT_ENOUGH_MEMORY;
    265285}
    266286
    … …  
    284304
    285305/*
     306 *@@ FreeKeyIfExists:
     307 *
     308 *@@added V1.0.0 (2002-09-17) [umoeller]
     309 */
     310
     311STATIC VOID FreeKeyIfExists(PXINI pXIni,         // in: profile opened with xprfOpenProfile
     312                            PXINIAPPDATA pAppData,
     313                            PCSZ pcszKey)
     314{
     315    // find key
     316    PXINIKEYDATA pKeyData;
     317
     318    if (!FindKey(pAppData,
     319                 pcszKey,
     320                 &pKeyData))
     321    {
     322        // key exists: kill that
     323        FreeKey(pKeyData);
     324        // and remove from app's keys list
     325        lstRemoveItem(&pAppData->llKeys, pKeyData);
     326        pAppData->cKeys--;
     327
     328        // rewrite profile on close
     329        pXIni->fDirty = TRUE;
     330    }
     331    // else key doesn't exist:
     332    // nothing to do
     333}
     334
     335/*
    286336 * FreeApp:
    287337 *      frees the specified application. Does not remove
    … …  
    319369 */
    320370
    321 STATIC BOOL FreeINI(PXINI pXIni)       // in: profile opened with xprfOpenProfile
    322 {
    323     BOOL brc = FALSE;
    324 
     371STATIC VOID FreeINI(PXINI pXIni)       // in: profile opened with xprfOpenProfile
     372{
    325373    if (pXIni)
    326374    {
    … …  
    338386        free(pXIni);
    339387    }
    340 
    341     return brc;
    342388}
    343389
    … …  
    354400 *
    355401 *      Private helper.
    356  */
    357 
    358 STATIC BOOL ReadINI(PXINI pXIni)       // in: profile opened with xprfOpenProfile
    359 {
    360     BOOL brc = FALSE;
     402 *
     403 *@@changed V1.0.0 (2002-09-17) [umoeller]: now returning APIRET
     404 */
     405
     406STATIC APIRET ReadINI(PXINI pXIni)      // in: profile opened with xprfOpenProfile
     407{
     408    APIRET      arc;
    361409    FILESTATUS3 fs3;
    362410
    363     if (DosProtectQueryFileInfo(pXIni->hFile,
    364                                 FIL_STANDARD,
    365                                 &fs3,
    366                                 sizeof(fs3),
    367                                 pXIni->hLock)
    368             == NO_ERROR)
     411    if (!(arc = DosQueryFileInfo(pXIni->hFile,
     412                                 FIL_STANDARD,
     413                                 &fs3,
     414                                 sizeof(fs3))))
    369415    {
    370416        PBYTE  pbFileData;
    371         if (pbFileData = (PBYTE)malloc(fs3.cbFile))
     417        if (!(pbFileData = (PBYTE)malloc(fs3.cbFile)))
     418            arc = ERROR_NOT_ENOUGH_MEMORY;
     419        else
    372420        {
    373421            ULONG ulSet = 0;
    374             APIRET arc = DosProtectSetFilePtr(pXIni->hFile,
    375                                               0,
    376                                               FILE_BEGIN,
    377                                               &ulSet,
    378                                               pXIni->hLock);
    379             if (    (arc == NO_ERROR)
    380                  && (ulSet == 0)
    381                )
     422
     423            if (!(arc = DosSetFilePtr(pXIni->hFile,
     424                                      0,
     425                                      FILE_BEGIN,
     426                                      &ulSet)))
    382427            {
    383428                ULONG cbRead = 0;
    384                 arc = DosProtectRead(pXIni->hFile,
    385                                      pbFileData,
    386                                      fs3.cbFile,
    387                                      &cbRead,
    388                                      pXIni->hLock);
    389                 if (    (arc == NO_ERROR)
    390                      && (cbRead == fs3.cbFile)
    391                    )
     429                if (!(arc = DosRead(pXIni->hFile,
     430                                    pbFileData,
     431                                    fs3.cbFile,
     432                                    &cbRead)))
    392433                {
    393                     PINIFILE_HEADER pHeader = (PINIFILE_HEADER)pbFileData;
    394                     if (pHeader->magic == 0xFFFFFFFF)
     434                    if (cbRead != fs3.cbFile)
     435                        arc = ERROR_NO_DATA;
     436                    else
    395437                    {
    396                         ULONG   ulAppOfs = pHeader->offFirstApp;
    397 
    398                         // it was a valid profile, so return TRUE
    399                         brc = TRUE;
    400 
    401                         // create-applications loop
    402                         while ((ulAppOfs) && (brc))
     438                        PINIFILE_HEADER pHeader = (PINIFILE_HEADER)pbFileData;
     439                        if (pHeader->magic == 0xFFFFFFFF)
    403440                        {
    404                             // application struct
    405                             PINIFILE_APP pApp = (PINIFILE_APP)(pbFileData + ulAppOfs);
    406                             ULONG   ulKeysOfs = pApp->offFirstKeyInApp;
    407                             PXINIAPPDATA pIniApp
    408                                 = CreateApp(pXIni,
    409                                             (PBYTE)(pbFileData + pApp->offAppName));
    410                             if (!pIniApp)
     441                            ULONG   ulAppOfs = pHeader->offFirstApp;
     442
     443                            // create-applications loop
     444                            while ((ulAppOfs) && (!arc))
    411445                            {
    412                                 brc = FALSE;
    413                                 break;
     446                                // application struct
     447                                PINIFILE_APP pApp = (PINIFILE_APP)(pbFileData + ulAppOfs);
     448                                ULONG   ulKeysOfs = pApp->offFirstKeyInApp;
     449                                PXINIAPPDATA pIniApp;
     450
     451                                if (arc = CreateApp(pXIni,
     452                                                    (PBYTE)(pbFileData + pApp->offAppName),
     453                                                    &pIniApp))
     454                                    break;
     455
     456                                // create-keys loop
     457                                while ((ulKeysOfs) && (!arc))
     458                                {
     459                                    PINIFILE_KEY pKey = (PINIFILE_KEY)(pbFileData + ulKeysOfs);
     460
     461                                    PXINIKEYDATA pIniKey;
     462
     463                                    if (arc = CreateKey(pIniApp,
     464                                                        (PSZ)(pbFileData + pKey->offKeyName),
     465                                                        (PBYTE)(pbFileData + pKey->offKeyData),
     466                                                        pKey->lenKeyData,
     467                                                        &pIniKey))
     468                                        break;
     469
     470                                    // next key; can be null
     471                                    ulKeysOfs = pKey->offNextKeyInApp;
     472                                }
     473
     474                                // next application; can be null
     475                                ulAppOfs = pApp->offNextApp;
    414476                            }
    415 
    416                             // create-keys loop
    417                             while ((ulKeysOfs) && (brc))
    418                             {
    419                                 PINIFILE_KEY pKey = (PINIFILE_KEY)(pbFileData + ulKeysOfs);
    420 
    421                                 PXINIKEYDATA pIniKey
    422                                     = CreateKey(pIniApp,
    423                                                 (PSZ)(pbFileData + pKey->offKeyName),
    424                                                 (PBYTE)(pbFileData + pKey->offKeyData),
    425                                                 pKey->lenKeyData);
    426 
    427                                 if (!pIniKey)
    428                                 {
    429                                     brc = FALSE;
    430                                     break;
    431                                 }
    432 
    433                                 // next key; can be null
    434                                 ulKeysOfs = pKey->offNextKeyInApp;
    435                             }
    436 
    437                             // next application; can be null
    438                             ulAppOfs = pApp->offNextApp;
    439477                        }
    440478                    }
    … …  
    446484    }
    447485
    448     return brc;
     486    return arc;
    449487}
    450488
    … …  
    455493 *
    456494 *      Private helper.
    457  */
    458 
    459 STATIC BOOL WriteINI(PXINI pXIni)      // in: profile opened with xprfOpenProfile
    460 {
    461     BOOL    brc = FALSE;
     495 *
     496 *@@changed V1.0.0 (2002-09-17) [umoeller]: now returning APIRET
     497 */
     498
     499STATIC APIRET WriteINI(PXINI pXIni)      // in: profile opened with xprfOpenProfile
     500{
     501    APIRET  arc = NO_ERROR;
    462502    ULONG   ulTotalFileSize = sizeof(INIFILE_HEADER);
    463503    ULONG   ulSet = 0;
    … …  
    471511    // go thru all apps
    472512    PLISTNODE pAppNode = lstQueryFirstNode(&pXIni->llApps);
     513
    473514    while (pAppNode)
    474515    {
    … …  
    501542    if (pbData2Write = (PBYTE)malloc(ulTotalFileSize))
    502543    {
    503         APIRET arc = NO_ERROR;
    504 
    505544        // set header in buffer
    506545        PINIFILE_HEADER pHeader = (PINIFILE_HEADER)pbData2Write;
    … …  
    512551
    513552        pHeader->magic = 0xFFFFFFFF;
    514         if (pXIni->cApps)
     553        if (lstCountItems(&pXIni->llApps))
    515554            // we have any applications:
    516555            pHeader->offFirstApp = sizeof(INIFILE_HEADER);
    … …  
    630669
    631670        // write out everything
    632         if (!(arc = DosProtectSetFilePtr(pXIni->hFile,
    633                                          0,
    634                                          FILE_BEGIN,
    635                                          &ulSet,
    636                                          pXIni->hLock)))
     671        if (!(arc = DosSetFilePtr(pXIni->hFile,
     672                                  0,
     673                                  FILE_BEGIN,
     674                                  &ulSet)))
    637675        {
    638676            ULONG cbWritten = 0;
    639             if (    (!(arc = DosProtectWrite(pXIni->hFile,
    640                                              pbData2Write,
    641                                              ulTotalFileSize,
    642                                              &cbWritten,
    643                                              pXIni->hLock)))
    644                  && (!(arc = DosProtectSetFileSize(pXIni->hFile,
    645                                                    ulTotalFileSize,
    646                                                    pXIni->hLock)))
    647                )
    648                 brc = TRUE;
     677            if (!(arc = DosWrite(pXIni->hFile,
     678                                 pbData2Write,
     679                                 ulTotalFileSize,
     680                                 &cbWritten)))
     681            {
     682                if (!(arc = DosSetFileSize(pXIni->hFile,
     683                                           ulTotalFileSize)))
     684                    ;
     685            }
    649686        }
    650687
    … …  
    652689    }
    653690
    654     return brc;
     691    return arc;
    655692}
    656693
    … …  
    688725    APIRET  arc = NO_ERROR;
    689726    PXINI   pXIni = NULL;
    690 
    691     if (pcszFilename)
    692         if (strlen(pcszFilename) < CCHMAXPATH - 1)
    693         {
    694             HFILE   hFile = NULLHANDLE;
    695             ULONG   ulAction = 0;
    696             FHLOCK  hLock = 0;
    697             arc = DosProtectOpen((PSZ)pcszFilename,
    698                                  &hFile,
    699                                  &ulAction,
    700                                  1024,          // initial size
    701                                  FILE_NORMAL,
    702                                  OPEN_ACTION_CREATE_IF_NEW
    703                                     | OPEN_ACTION_OPEN_IF_EXISTS,
    704                                  OPEN_FLAGS_FAIL_ON_ERROR
    705                                     | OPEN_FLAGS_NO_CACHE
    706                                     | OPEN_FLAGS_SEQUENTIAL
    707                                     | OPEN_SHARE_DENYREADWRITE
    708                                     | OPEN_ACCESS_READWRITE,
    709                                  NULL, // no EAs
    710                                  &hLock);
    711             if (arc == NO_ERROR)
     727    ULONG   ulFilenameLen;
     728
     729    if (    (!pcszFilename)
     730         || (!ppxini)
     731       )
     732        arc = ERROR_INVALID_PARAMETER;      // V1.0.0 (2002-09-17) [umoeller]
     733    else if (!(ulFilenameLen = strlen(pcszFilename)))
     734        arc = ERROR_INVALID_PARAMETER;      // V1.0.0 (2002-09-17) [umoeller]
     735    else if (ulFilenameLen >= CCHMAXPATH - 1)
     736        arc = ERROR_FILENAME_EXCED_RANGE;
     737    else
     738    {
     739        HFILE   hFile = NULLHANDLE;
     740        ULONG   ulAction = 0;
     741        // FHLOCK  hLock = 0;
     742
     743        if (!(arc = DosOpen((PSZ)pcszFilename,
     744                            &hFile,
     745                            &ulAction,
     746                            1024,          // initial size
     747                            FILE_NORMAL,
     748                            OPEN_ACTION_CREATE_IF_NEW
     749                               | OPEN_ACTION_OPEN_IF_EXISTS,
     750                            OPEN_FLAGS_FAIL_ON_ERROR
     751                               | OPEN_FLAGS_SEQUENTIAL
     752                               | OPEN_SHARE_DENYREADWRITE
     753                               | OPEN_ACCESS_READWRITE,
     754                            NULL)))
     755        {
     756            if (!(pXIni = (PXINI)malloc(sizeof(XINI))))
     757                arc = ERROR_NOT_ENOUGH_MEMORY;
     758            else
    712759            {
    713                 pXIni = (PXINI)malloc(sizeof(XINI));
    714                 if (!pXIni)
    715                     arc = ERROR_NOT_ENOUGH_MEMORY;
     760                // OK: initialize XINI
     761                memset(pXIni, 0, sizeof(XINI));
     762                memcpy(pXIni->acMagic, XINI_MAGIC_BYTES, sizeof(XINI_MAGIC_BYTES));
     763                memcpy(pXIni->szFilename,
     764                       pcszFilename,
     765                       ulFilenameLen + 1);
     766                pXIni->hFile = hFile;
     767                // pXIni->hLock = hLock;
     768
     769                lstInit(&pXIni->llApps, FALSE);
     770
     771                if (ulAction == FILE_CREATED)
     772                    // file newly created: rewrite on close
     773                    pXIni->fDirty = TRUE;
    716774                else
     775                    // file existed: read data
     776                    if (arc = ReadINI(pXIni))
     777                        // error:
     778                        FreeINI(pXIni);
     779            }
     780
     781            if (!arc)
     782                *ppxini = pXIni;
     783            else
     784                DosClose(hFile);
     785        }
     786    }
     787
     788    return arc;
     789}
     790
     791/*
     792 *@@ xprfQueryProfileSize:
     793 *      returns the size of INI data, similarly to
     794 *      what PrfQueryProfileSize does.
     795 *
     796 *      If (pszAppName == NULL), this returns the size of
     797 *      the buffer required to hold the enumerated list
     798 *      of application names. pszKey is then ignored.
     799 *
     800 *      Otherwise, if (pszKeyName == NULL), this returns
     801 *      the size of the buffer required to hold the
     802 *      enumerated list of _key_ names for the given
     803 *      application.
     804 *
     805 *      If both pszAppName and pszKeyName are not NULL, this
     806 *      returns the data size of the given key.
     807 *
     808 *      Returns:
     809 *
     810 *      --  NO_ERROR
     811 *
     812 *@@added V1.0.0 (2002-09-17) [umoeller]
     813 */
     814
     815APIRET xprfQueryProfileSize(PXINI pXIni,          // in: profile opened with xprfOpenProfile
     816                            PCSZ pszAppName,      // in: application name or NULL
     817                            PCSZ pszKeyName,      // in: key name or NULL
     818                            PULONG pulDataLen)    // out: size of requested data
     819{
     820    APIRET  arc = NO_ERROR;
     821    ULONG   ulDataLen = 0;
     822
     823    if (!pszAppName)
     824    {
     825        PLISTNODE pAppNode = lstQueryFirstNode(&pXIni->llApps);
     826        while (pAppNode)
     827        {
     828            PXINIAPPDATA pAppDataThis = (PXINIAPPDATA)pAppNode->pItemData;
     829            ulDataLen += strlen(pAppDataThis->pszAppName) + 1;
     830            pAppNode = pAppNode->pNext;
     831        }
     832
     833        // extra byte for terminating extra null
     834        ++ulDataLen;
     835    }
     836    else
     837    {
     838        // app specified:
     839        PXINIAPPDATA pAppData;
     840
     841        if (!(arc = FindApp(pXIni,
     842                            pszAppName,
     843                            &pAppData)))
     844        {
     845            // app exists:
     846
     847            if (!pszKeyName)
     848            {
     849                // app != NULL, but key == NULL:
     850                // return size of keys list
     851                PLISTNODE pKeyNode = lstQueryFirstNode(&pAppData->llKeys);
     852                while (pKeyNode)
    717853                {
    718                     // OK: initialize XINI
    719                     memset(pXIni, 0, sizeof(XINI));
    720                     memcpy(pXIni->acMagic, XINI_MAGIC_BYTES, sizeof(XINI_MAGIC_BYTES));
    721                     strcpy(pXIni->szFilename, pcszFilename);
    722                     pXIni->hFile = hFile;
    723                     pXIni->hLock = hLock;
    724 
    725                     lstInit(&pXIni->llApps, FALSE);
    726 
    727                     if (ulAction == FILE_CREATED)
    728                         // file newly created: rewrite on close
    729                         pXIni->fDirty = TRUE;
     854                    PXINIKEYDATA pKeyDataThis = (PXINIKEYDATA)pKeyNode->pItemData;
     855                    ulDataLen += strlen(pKeyDataThis->pszKeyName) + 1;
     856                    pKeyNode = pKeyNode->pNext;
     857                }
     858
     859                // extra byte for terminating extra null
     860                ++ulDataLen;
     861            }
     862            else
     863            {
     864                // both app and key specified:
     865                PXINIKEYDATA pKeyData;
     866                if (!(arc = FindKey(pAppData,
     867                                    pszKeyName,
     868                                    &pKeyData)))
     869                    ulDataLen = pKeyData->cbData;
     870            }
     871        }
     872    }
     873
     874    if (pulDataLen)
     875        *pulDataLen = ulDataLen;
     876
     877    return arc;
     878}
     879
     880/*
     881 *@@ xprfQueryProfileData:
     882 *      reads data from the given XINI, similarly to
     883 *      what PrfQueryProfileData does.
     884 *
     885 *      If (pszAppName == NULL), this returns the
     886 *      enumerated list of application names.
     887 *      pszKey is then ignored. *pulBufferMax
     888 *      receives the total size of the list excluding
     889 *      the final NULL character.
     890 *
     891 *      Otherwise, if (pszKeyName == NULL), this the
     892 *      enumerated list of _key_ names for the given
     893 *      application. *pulBufferMax receives the total
     894 *      size of the list excluding the final NULL character.
     895 *
     896 *      If both pszAppName and pszKeyName are not NULL,
     897 *      this returns the data of the given key.
     898 *      pulBufferMax receives the bytes copied.
     899 *
     900 *      Returns:
     901 *
     902 *      --  NO_ERROR
     903 */
     904
     905APIRET xprfQueryProfileData(PXINI pXIni,          // in: profile opened with xprfOpenProfile
     906                            PCSZ pszAppName,      // in: application name
     907                            PCSZ pszKeyName,      // in: key name or NULL
     908                            PVOID pBuffer,        // in: buffer to receive data
     909                            PULONG pulBufferMax)  // in: buffer size, out: size of written data
     910{
     911    APIRET  arc = NO_ERROR;
     912    ULONG   ulDataLen = 0;
     913
     914    if (!pszAppName)
     915    {
     916        PLISTNODE pAppNode = lstQueryFirstNode(&pXIni->llApps);
     917        PBYTE   pbTarget = (PSZ)pBuffer;
     918        ULONG   cbCopied = 0;
     919        while (pAppNode)
     920        {
     921            PXINIAPPDATA pAppDataThis = (PXINIAPPDATA)pAppNode->pItemData;
     922            ULONG   cbThis = strlen(pAppDataThis->pszAppName) + 1;
     923            if (cbCopied + cbThis > *pulBufferMax)
     924                break;
     925            else
     926            {
     927                memcpy(pbTarget + cbCopied,
     928                       pAppDataThis->pszAppName,
     929                       cbThis);
     930                cbCopied += cbThis;
     931            }
     932
     933            pAppNode = pAppNode->pNext;
     934        }
     935
     936        // extra byte for terminating extra null
     937        pbTarget[cbCopied] = '\0';
     938        ulDataLen = cbCopied;       // PMREF says terminating null is not counted
     939    }
     940    else
     941    {
     942        // app specified:
     943        PXINIAPPDATA pAppData;
     944
     945        if (!(arc = FindApp(pXIni,
     946                            pszAppName,
     947                            &pAppData)))
     948        {
     949            // app exists:
     950
     951            if (!pszKeyName)
     952            {
     953                // app != NULL, but key == NULL:
     954                // return size of keys list
     955                PLISTNODE pKeyNode = lstQueryFirstNode(&pAppData->llKeys);
     956                PBYTE   pbTarget = (PSZ)pBuffer;
     957                ULONG   cbCopied = 0;
     958                while (pKeyNode)
     959                {
     960                    PXINIKEYDATA pKeyDataThis = (PXINIKEYDATA)pKeyNode->pItemData;
     961                    ULONG   cbThis = strlen(pKeyDataThis->pszKeyName) + 1;
     962                    if (cbCopied + cbThis > *pulBufferMax)
     963                        break;
    730964                    else
    731                         // file existed: read data
    732                         if (!ReadINI(pXIni))
    733                         {
    734                             // error:
    735                             FreeINI(pXIni);
    736                             pXIni = NULL;
    737                             arc = PRFERR_READ;
    738                         }
    739 
    740                     if ((pXIni) && (ppxini))
    741                         *ppxini = pXIni;
     965                    {
     966                        memcpy(pbTarget + cbCopied,
     967                               pKeyDataThis->pszKeyName,
     968                               cbThis);
     969                        cbCopied += cbThis;
     970                    }
     971
     972                    pKeyNode = pKeyNode->pNext;
     973                }
     974
     975                // extra byte for terminating extra null
     976                pbTarget[cbCopied] = '\0';
     977                ulDataLen = cbCopied;       // PMREF says terminating null is not counted
     978            }
     979            else
     980            {
     981                // both app and key specified:
     982                PXINIKEYDATA pKeyData;
     983                if (!(arc = FindKey(pAppData,
     984                                    pszKeyName,
     985                                    &pKeyData)))
     986                {
     987                    ulDataLen = min(pKeyData->cbData,
     988                                    *pulBufferMax);
     989                    memcpy(pBuffer,
     990                           pKeyData->pbData,
     991                           ulDataLen);
    742992                }
    743993            }
    744994        }
     995    }
     996
     997    if (pulBufferMax)
     998        *pulBufferMax = ulDataLen;
    745999
    7461000    return arc;
    7471001}
    748 
    749 /*
    750  *@@ xprfQueryProfileData:
    751  *      similar to PrfQueryProfileData.
    752  *
    753  *      @@todo: Still to be written.
    754  */
    755 
    756 /* BOOL xprfQueryProfileData(PXINI hIni,            // in: profile opened with xprfOpenProfile
    757                           const char *pcszApp,
    758                           const char *pcszKey,
    759                           PVOID pBuffer,
    760                           PULONG pulBufferMax)
    761 {
    762     BOOL brc = FALSE;
    763 
    764     return brc;
    765 } */
    7661002
    7671003/*
    … …  
    7921028 *      as "dirty" so that the file will be rewritten
    7931029 *      on xprfCloseProfile.
    794  */
    795 
    796 BOOL xprfWriteProfileData(PXINI hIni,           // in: profile opened with xprfOpenProfile
    797                           const char *pcszApp,  // in: application name
    798                           const char *pcszKey,  // in: key name or NULL
    799                           PVOID pData,          // in: data to write or NULL
    800                           ULONG ulDataLen)      // in: sizeof(*pData) or null
    801 {
    802     BOOL brc = FALSE;
    803 
    804     if (hIni)
    805     {
    806         PXINI pXIni = (PXINI)hIni;
    807         if (memcmp(pXIni->acMagic, XINI_MAGIC_BYTES, sizeof(XINI_MAGIC_BYTES))
    808                         == 0)
    809         {
    810             // check if application exists
    811             PXINIAPPDATA pAppData = FindApp(pXIni,
    812                                             pcszApp);
    813 
    814             // now check: does caller want entire application deleted?
    815             if (!pcszKey)
     1030 *
     1031 *      Returns:
     1032 *
     1033 *      --  NO_ERROR
     1034 */
     1035
     1036APIRET xprfWriteProfileData(PXINI pXIni,          // in: profile opened with xprfOpenProfile
     1037                            const char *pcszApp,  // in: application name
     1038                            const char *pcszKey,  // in: key name or NULL
     1039                            PVOID pData,          // in: data to write or NULL
     1040                            ULONG ulDataLen)      // in: sizeof(*pData) or null
     1041{
     1042    APIRET  arc = NO_ERROR;
     1043
     1044    if (    (!pXIni)
     1045         || (memcmp(pXIni->acMagic, XINI_MAGIC_BYTES, sizeof(XINI_MAGIC_BYTES)))
     1046       )
     1047        arc = ERROR_INVALID_PARAMETER;
     1048    else
     1049    {
     1050        // check if application exists
     1051        PXINIAPPDATA pAppData;
     1052
     1053        if (FindApp(pXIni,
     1054                    pcszApp,
     1055                    &pAppData))
     1056            // not found:
     1057            pAppData = NULL;
     1058
     1059        // now check: does caller want entire application deleted?
     1060        if (!pcszKey)
     1061        {
     1062            // yes, delete application: did we find it?
     1063            if (pAppData)
    8161064            {
    817                 // yes, delete application: did we find it?
     1065                // yes: kill that
     1066                FreeApp(pAppData);
     1067                // and remove from list
     1068                lstRemoveItem(&pXIni->llApps, pAppData);
     1069
     1070                // rewrite profile on close
     1071                pXIni->fDirty = TRUE;
     1072            }
     1073            // else application doesn't exist:
     1074            // nothing to do return NO_ERROR
     1075        }
     1076        else
     1077        {
     1078            // caller has specified key:
     1079            // does caller want a key to be deleted?
     1080            if (!ulDataLen)
     1081            {
     1082                // yes: delete key:
    8181083                if (pAppData)
    8191084                {
    820                     // yes: kill that
    821                     FreeApp(pAppData);
    822                     // and remove from list
    823                     brc = lstRemoveItem(&pXIni->llApps, pAppData);
    824                     pXIni->cApps--;
    825                     // rewrite profile on close
    826                     pXIni->fDirty = TRUE;
     1085                    // app exists:
     1086                    FreeKeyIfExists(pXIni,
     1087                                    pAppData,
     1088                                    pcszKey);
    8271089                }
    828                 else
    829                     // application doesn't exist:
    830                     brc = TRUE;
     1090                // else app doesn't even exist:
     1091                // nothing to do, return NO_ERROR
    8311092            }
    8321093            else
    8331094            {
    834                 // caller has specified key:
    835                 // does caller want a key to be deleted?
    836                 if (!ulDataLen)
     1095                // key and data specified: let's add something...
     1096
     1097                if (!pAppData)
     1098                    // app doesn't exist yet:
     1099                    // create
     1100                    arc = CreateApp(pXIni,
     1101                                    pcszApp,
     1102                                    &pAppData);
     1103
     1104                if (!arc)
    8371105                {
    838                     // yes: delete key:
    839                     if (pAppData)
    840                     {
    841                         // app exists:
    842                         // find key
    843                         PXINIKEYDATA pKeyData = FindKey(pAppData,
    844                                                         pcszKey);
    845                         if (pKeyData)
    846                         {
    847                             // key exists: kill that
    848                             FreeKey(pKeyData);
    849                             // and remove from app's keys list
    850                             brc = lstRemoveItem(&pAppData->llKeys, pKeyData);
    851                             pAppData->cKeys--;
    852                             // rewrite profile on close
    853                             pXIni->fDirty = TRUE;
    854                         }
    855                         else
    856                             // key doesn't even exist:
    857                             brc = TRUE;
    858                     }
    859                     else
    860                         // app doesn't even exist:
    861                         brc = TRUE;
    862                 }
    863                 else
    864                 {
    865                     // key and data specified: let's add something...
    866 
    867                     if (!pAppData)
    868                         // app doesn't exist yet:
    869                         // create
    870                         pAppData = CreateApp(pXIni,
    871                                              pcszApp);
    872 
    873                     if (pAppData)
    874                     {
    875                         // found or created app:
    876                         // check if key exists
    877                         PXINIKEYDATA pKeyData = FindKey(pAppData,
    878                                                         pcszKey);
    879                         if (!pKeyData)
    880                             // doesn't exist yet:
    881                             // create
    882                             pKeyData = CreateKey(pAppData,
    883                                                  pcszKey,
    884                                                  (PBYTE)pData,
    885                                                  ulDataLen);
    886 
    887                         if (pKeyData)
    888                         {
    889                            // mark as dirty
    890                            pXIni->fDirty = TRUE;
    891                            brc = TRUE;
    892                         }
    893                     }
     1106                    // found or created app:
     1107
     1108                    // delete existing key if it exists
     1109                    PXINIKEYDATA pKeyData;
     1110
     1111                    FreeKeyIfExists(pXIni,
     1112                                    pAppData,
     1113                                    pcszKey);
     1114
     1115                    // now create new key
     1116                    if (!(arc = CreateKey(pAppData,
     1117                                          pcszKey,
     1118                                          (PBYTE)pData,
     1119                                          ulDataLen,
     1120                                          &pKeyData)))
     1121                       // mark as dirty
     1122                       pXIni->fDirty = TRUE;
    8941123                }
    8951124            }
    … …  
    8971126    }
    8981127
    899     return brc;
     1128    return arc;
    9001129}
    9011130
    … …  
    9091138 *      You cannot specify HINI_SYSTEM or HINI_USER for
    9101139 *      hINi.
    911  */
    912 
    913 BOOL xprfCloseProfile(PXINI hIni)       // in: profile opened with xprfOpenProfile
    914 {
    915     BOOL brc = FALSE;
    916 
    917     if (hIni)
    918     {
    919         PXINI pXIni = (PXINI)hIni;
    920         if (memcmp(pXIni->acMagic, XINI_MAGIC_BYTES, sizeof(XINI_MAGIC_BYTES))
    921                         == 0)
    922         {
    923             brc = TRUE;
    924 
    925             if (pXIni->fDirty)
    926                 brc = WriteINI(pXIni);
    927 
    928             if (brc)
     1140 *
     1141 *      Returns:
     1142 *
     1143 *      --  NO_ERROR
     1144 */
     1145
     1146APIRET xprfCloseProfile(PXINI pXIni)       // in: profile opened with xprfOpenProfile
     1147{
     1148    APIRET  arc = NO_ERROR;
     1149
     1150    if (    (!pXIni)
     1151         || (memcmp(pXIni->acMagic, XINI_MAGIC_BYTES, sizeof(XINI_MAGIC_BYTES)))
     1152       )
     1153        arc = ERROR_INVALID_PARAMETER;
     1154    else
     1155    {
     1156        if (pXIni->fDirty)
     1157            arc = WriteINI(pXIni);
     1158
     1159        if (!arc)
     1160        {
     1161            if (!(arc = DosClose(pXIni->hFile)))
    9291162            {
    930                 APIRET arc = DosProtectClose(pXIni->hFile,
    931                                              pXIni->hLock);
    932                 if (arc == NO_ERROR)
    933                 {
    934                     pXIni->hFile = 0;
    935                     pXIni->hLock = 0;
    936 
    937                     FreeINI(pXIni);
    938                 }
    939                 else
    940                     brc = FALSE;
     1163                pXIni->hFile = 0;
     1164
     1165                FreeINI(pXIni);
    9411166            }
    9421167        }
    9431168    }
    9441169
    945     return brc;
    946 }
    947 
    948 
     1170    return arc;
     1171}
     1172
     1173/*
     1174 *@@ xprfQueryKeysForApp:
     1175 *      the equivalent of prfhQueryKeysForApp for
     1176 *      XINI files.
     1177 *
     1178 *@@added V1.0.0 (2002-09-17) [umoeller]
     1179 */
     1180
     1181APIRET xprfQueryKeysForApp(PXINI hIni,      // in: INI handle
     1182                           PCSZ pcszApp,    // in: application to query list for (or NULL for applications list)
     1183                           PSZ *ppszKeys)   // out: keys list (newly allocated)
     1184{
     1185    APIRET  arc = NO_ERROR;
     1186    PSZ     pKeys = NULL;
     1187    ULONG   ulSizeOfKeysList = 0;
     1188
     1189    // get size of keys list for pszApp
     1190    if (!xprfQueryProfileSize(hIni, pcszApp, NULL, &ulSizeOfKeysList))
     1191        arc = PRFERR_KEYSLIST;
     1192    else
     1193    {
     1194        if (ulSizeOfKeysList == 0)
     1195            ulSizeOfKeysList = 1;    // V0.9.19 (2002-04-11) [pr]
     1196
     1197        if (!(pKeys = (PSZ)malloc(ulSizeOfKeysList)))
     1198            arc = ERROR_NOT_ENOUGH_MEMORY;
     1199        else
     1200        {
     1201            *pKeys = 0;
     1202            if (!xprfQueryProfileData(hIni, pcszApp, NULL, pKeys, &ulSizeOfKeysList))
     1203                arc = PRFERR_KEYSLIST;
     1204        }
     1205    }
     1206
     1207    if (!arc)       // V0.9.12 (2001-05-12) [umoeller]
     1208        *ppszKeys = pKeys;
     1209    else
     1210        if (pKeys)
     1211            free(pKeys);
     1212
     1213    return arc;
     1214}
     1215
Note: See TracChangeset for help on using the changeset viewer.