/*
 *  ReactOS kernel
 *  Copyright (C) 2002 ReactOS Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
/* $Id: inicache.c 47686 2010-06-07 21:38:49Z spetreolle $
 * COPYRIGHT:       See COPYING in the top level directory
 * PROJECT:         ReactOS text-mode setup
 * FILE:            subsys/system/usetup/inicache.c
 * PURPOSE:         INI file parser that caches contents of INI file in memory
 * PROGRAMMER:      Royce Mitchell III
 *                  Eric Kohl
 */

/* INCLUDES *****************************************************************/

#include "usetup.h"

#define NDEBUG
#include <debug.h>

/* PRIVATE FUNCTIONS ********************************************************/

static PINICACHEKEY
IniCacheFreeKey(PINICACHEKEY Key)
{
  PINICACHEKEY Next;

  if (Key == NULL)
    {
      return(NULL);
    }

  Next = Key->Next;
  if (Key->Name != NULL)
    {
      RtlFreeHeap(ProcessHeap,
		  0,
		  Key->Name);
      Key->Name = NULL;
    }

  if (Key->Data != NULL)
    {
      RtlFreeHeap(ProcessHeap,
		  0,
		  Key->Data);
      Key->Data = NULL;
    }

  RtlFreeHeap(ProcessHeap,
	      0,
	      Key);

  return(Next);
}


static PINICACHESECTION
IniCacheFreeSection(PINICACHESECTION Section)
{
  PINICACHESECTION Next;

  if (Section == NULL)
    {
      return(NULL);
    }

  Next = Section->Next;
  while (Section->FirstKey != NULL)
    {
      Section->FirstKey = IniCacheFreeKey(Section->FirstKey);
    }
  Section->LastKey = NULL;

  if (Section->Name != NULL)
    {
      RtlFreeHeap(ProcessHeap,
		  0,
		  Section->Name);
      Section->Name = NULL;
    }

  RtlFreeHeap(ProcessHeap,
	      0,
	      Section);

  return(Next);
}


static PINICACHEKEY
IniCacheFindKey(PINICACHESECTION Section,
		PWCHAR Name,
		ULONG NameLength)
{
  PINICACHEKEY Key;

  Key = Section->FirstKey;
  while (Key != NULL)
    {
      if (NameLength == wcslen(Key->Name))
	{
	  if (_wcsnicmp(Key->Name, Name, NameLength) == 0)
	    break;
	}

      Key = Key->Next;
    }

  return(Key);
}


static PINICACHEKEY
IniCacheAddKey(PINICACHESECTION Section,
	       PCHAR Name,
	       ULONG NameLength,
	       PCHAR Data,
	       ULONG DataLength)
{
  PINICACHEKEY Key;
  ULONG i;

  Key = NULL;

  if (Section == NULL ||
      Name == NULL ||
      NameLength == 0 ||
      Data == NULL ||
      DataLength == 0)
    {
      DPRINT("Invalid parameter\n");
      return(NULL);
    }

  Key = (PINICACHEKEY)RtlAllocateHeap(ProcessHeap,
				      0,
				      sizeof(INICACHEKEY));
  if (Key == NULL)
    {
      DPRINT("RtlAllocateHeap() failed\n");
      return(NULL);
    }

  RtlZeroMemory(Key,
		sizeof(INICACHEKEY));


  Key->Name = (WCHAR*) RtlAllocateHeap(ProcessHeap,
			      0,
			      (NameLength + 1) * sizeof(WCHAR));
  if (Key->Name == NULL)
    {
      DPRINT("RtlAllocateHeap() failed\n");
      RtlFreeHeap(ProcessHeap,
		  0,
		  Key);
      return(NULL);
    }

  /* Copy value name */
  for (i = 0; i < NameLength; i++)
    {
      Key->Name[i] = (WCHAR)Name[i];
    }
  Key->Name[NameLength] = 0;


  Key->Data = (WCHAR*) RtlAllocateHeap(ProcessHeap,
			      0,
			      (DataLength + 1) * sizeof(WCHAR));
  if (Key->Data == NULL)
    {
      DPRINT("RtlAllocateHeap() failed\n");
      RtlFreeHeap(ProcessHeap,
		  0,
		  Key->Name);
      RtlFreeHeap(ProcessHeap,
		  0,
		  Key);
      return(NULL);
    }

  /* Copy value data */
  for (i = 0; i < DataLength; i++)
    {
      Key->Data[i] = (WCHAR)Data[i];
    }
  Key->Data[DataLength] = 0;


  if (Section->FirstKey == NULL)
    {
      Section->FirstKey = Key;
      Section->LastKey = Key;
    }
  else
    {
      Section->LastKey->Next = Key;
      Key->Prev = Section->LastKey;
      Section->LastKey = Key;
    }

  return(Key);
}

#if 0
static PINICACHESECTION
IniCacheFindSection(PINICACHE Cache,
		    PWCHAR Name,
		    ULONG NameLength)
{
  PINICACHESECTION Section = NULL;

  if (Cache == NULL || Name == NULL || NameLength == 0)
    {
      return(NULL);
    }

  Section = Cache->FirstSection;

  /* iterate through list of sections */
  while (Section != NULL)
    {
      if (NameLength == wcslen(Section->Name))
	{
	  /* are the contents the same too? */
	  if (_wcsnicmp(Section->Name, Name, NameLength) == 0)
	    break;
	}

      /* get the next section*/
      Section = Section->Next;
    }

  return(Section);
}
#endif

static PINICACHESECTION
IniCacheAddSection(PINICACHE Cache,
		   PCHAR Name,
		   ULONG NameLength)
{
  PINICACHESECTION Section = NULL;
  ULONG i;

  if (Cache == NULL || Name == NULL || NameLength == 0)
    {
      DPRINT("Invalid parameter\n");
      return(NULL);
    }

  Section = (PINICACHESECTION)RtlAllocateHeap(ProcessHeap,
					      0,
					      sizeof(INICACHESECTION));
  if (Section == NULL)
    {
      DPRINT("RtlAllocateHeap() failed\n");
      return(NULL);
    }
  RtlZeroMemory(Section,
		sizeof(INICACHESECTION));

  /* Allocate and initialize section name */
  Section->Name = (WCHAR*) RtlAllocateHeap(ProcessHeap,
				  0,
				  (NameLength + 1) * sizeof(WCHAR));
  if (Section->Name == NULL)
    {
      DPRINT("RtlAllocateHeap() failed\n");
      RtlFreeHeap(ProcessHeap,
		  0,
		  Section);
      return(NULL);
    }

  /* Copy section name */
  for (i = 0; i < NameLength; i++)
    {
      Section->Name[i] = (WCHAR)Name[i];
    }
  Section->Name[NameLength] = 0;

  /* Append section */
  if (Cache->FirstSection == NULL)
    {
      Cache->FirstSection = Section;
      Cache->LastSection = Section;
    }
  else
    {
      Cache->LastSection->Next = Section;
      Section->Prev = Cache->LastSection;
      Cache->LastSection = Section;
    }

  return(Section);
}


static PCHAR
IniCacheSkipWhitespace(PCHAR Ptr)
{
  while (*Ptr != 0 && isspace(*Ptr))
    Ptr++;

  return((*Ptr == 0) ? NULL : Ptr);
}


static PCHAR
IniCacheSkipToNextSection(PCHAR Ptr)
{
  while (*Ptr != 0 && *Ptr != '[')
    {
      while (*Ptr != 0 && *Ptr != L'\n')
	{
	  Ptr++;
	}
      Ptr++;
    }

  return((*Ptr == 0) ? NULL : Ptr);
}


static PCHAR
IniCacheGetSectionName(PCHAR Ptr,
		       PCHAR *NamePtr,
		       PULONG NameSize)
{
  ULONG Size = 0;
  CHAR Name[256];

  *NamePtr = NULL;
  *NameSize = 0;

  /* skip whitespace */
  while (*Ptr != 0 && isspace(*Ptr))
    {
      Ptr++;
    }

  *NamePtr = Ptr;

  while (*Ptr != 0 && *Ptr != ']')
    {
      Size++;
      Ptr++;
    }

  Ptr++;

  while (*Ptr != 0 && *Ptr != L'\n')
    {
      Ptr++;
    }
  Ptr++;

  *NameSize = Size;

  strncpy(Name, *NamePtr, Size);
  Name[Size] = 0;

  DPRINT("SectionName: '%s'\n", Name);

  return(Ptr);
}


static PCHAR
IniCacheGetKeyName(PCHAR Ptr,
		   PCHAR *NamePtr,
		   PULONG NameSize)
{
  ULONG Size = 0;

  *NamePtr = NULL;
  *NameSize = 0;

  while(Ptr && *Ptr)
  {
    *NamePtr = NULL;
    *NameSize = 0;
    Size = 0;

    /* skip whitespace and empty lines */
    while (isspace(*Ptr) || *Ptr == '\n' || *Ptr == '\r')
    {
      Ptr++;
    }
    if (*Ptr == 0)
    {
      continue;
    }

    *NamePtr = Ptr;

    while (*Ptr != 0 && !isspace(*Ptr) && *Ptr != '=' && *Ptr != ';')
    {
      Size++;
      Ptr++;
    }
    if (*Ptr == ';')
    {
      while (*Ptr != 0 && *Ptr != '\r' && *Ptr != '\n')
      {
	Ptr++;
      }
    }
    else
    {
      *NameSize = Size;
      break;
    }
  }

  return(Ptr);
}


static PCHAR
IniCacheGetKeyValue(PCHAR Ptr,
		    PCHAR *DataPtr,
		    PULONG DataSize,
		    BOOLEAN String)
{
  ULONG Size = 0;

  *DataPtr = NULL;
  *DataSize = 0;

  /* Skip whitespace */
  while (*Ptr != 0 && isspace(*Ptr))
    {
      Ptr++;
    }

  /* Check and skip '=' */
  if (*Ptr != '=')
    {
      return(NULL);
    }
  Ptr++;

  /* Skip whitespace */
  while (*Ptr != 0 && isspace(*Ptr))
    {
      Ptr++;
    }

  if (*Ptr == '"' && String)
    {
      Ptr++;

      /* Get data */
      *DataPtr = Ptr;
      while (*Ptr != '"')
	{
	  Ptr++;
	  Size++;
	}
      Ptr++;
      while (*Ptr && *Ptr != '\r' && *Ptr != '\n')
	{
	  Ptr++;
	}
    }
  else
    {
      /* Get data */
      *DataPtr = Ptr;
      while (*Ptr != 0 && *Ptr != '\r' && *Ptr != ';')
	{
	  Ptr++;
	  Size++;
	}
    }

  /* Skip to next line */
  if (*Ptr == '\r')
    Ptr++;
  if (*Ptr == '\n')
    Ptr++;

  *DataSize = Size;

  return(Ptr);
}




/* PUBLIC FUNCTIONS *********************************************************/

NTSTATUS
IniCacheLoad(PINICACHE *Cache,
	     PUNICODE_STRING FileName,
	     BOOLEAN String)
{
  OBJECT_ATTRIBUTES ObjectAttributes;
  FILE_STANDARD_INFORMATION FileInfo;
  IO_STATUS_BLOCK IoStatusBlock;
  HANDLE FileHandle;
  NTSTATUS Status;
  PCHAR FileBuffer;
  ULONG FileLength;
  PCHAR Ptr;
  LARGE_INTEGER FileOffset;

  PINICACHESECTION Section;
  PINICACHEKEY Key;

  PCHAR SectionName;
  ULONG SectionNameSize;

  PCHAR KeyName;
  ULONG KeyNameSize;

  PCHAR KeyValue;
  ULONG KeyValueSize;

  *Cache = NULL;

  /* Open ini file */
  InitializeObjectAttributes(&ObjectAttributes,
			     FileName,
			     0,
			     NULL,
			     NULL);

  Status = NtOpenFile(&FileHandle,
		      GENERIC_READ | SYNCHRONIZE,
		      &ObjectAttributes,
		      &IoStatusBlock,
		      FILE_SHARE_READ,
		      FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE);
  if (!NT_SUCCESS(Status))
    {
      DPRINT("NtOpenFile() failed (Status %lx)\n", Status);
      return(Status);
    }

  DPRINT("NtOpenFile() successful\n");

  /* Query file size */
  Status = NtQueryInformationFile(FileHandle,
				  &IoStatusBlock,
				  &FileInfo,
				  sizeof(FILE_STANDARD_INFORMATION),
				  FileStandardInformation);
   if (!NT_SUCCESS(Status))
    {
      DPRINT("NtQueryInformationFile() failed (Status %lx)\n", Status);
      NtClose(FileHandle);
      return(Status);
    }

  FileLength = FileInfo.EndOfFile.u.LowPart;

  DPRINT("File size: %lu\n", FileLength);

  /* Allocate file buffer */
  FileBuffer = (CHAR*) RtlAllocateHeap(ProcessHeap,
			       0,
			       FileLength + 1);
  if (FileBuffer == NULL)
    {
      DPRINT1("RtlAllocateHeap() failed\n");
      NtClose(FileHandle);
      return(STATUS_INSUFFICIENT_RESOURCES);
    }

  /* Read file */
  FileOffset.QuadPart = 0ULL;
  Status = NtReadFile(FileHandle,
		      NULL,
		      NULL,
		      NULL,
		      &IoStatusBlock,
		      FileBuffer,
		      FileLength,
		      &FileOffset,
		      NULL);

  /* Append string terminator */
  FileBuffer[FileLength] = 0;

  NtClose(FileHandle);

  if (!NT_SUCCESS(Status))
    {
      DPRINT("NtReadFile() failed (Status %lx)\n", Status);
      RtlFreeHeap(ProcessHeap,
		  0,
		  FileBuffer);
      return(Status);
    }


  /* Allocate inicache header */
  *Cache = (PINICACHE)RtlAllocateHeap(ProcessHeap,
				      0,
				      sizeof(INICACHE));
  if (*Cache == NULL)
    {
      DPRINT("RtlAllocateHeap() failed\n");
      return(STATUS_INSUFFICIENT_RESOURCES);
    }

  /* Initialize inicache header */
  RtlZeroMemory(*Cache,
		sizeof(INICACHE));

  /* Parse ini file */
  Section = NULL;
  Ptr = FileBuffer;
  while (Ptr != NULL && *Ptr != 0)
    {
      Ptr = IniCacheSkipWhitespace(Ptr);
      if (Ptr == NULL)
	continue;

      if (*Ptr == '[')
	{
	  Section = NULL;
	  Ptr++;

	  Ptr = IniCacheGetSectionName(Ptr,
				       &SectionName,
				       &SectionNameSize);

	  DPRINT1("[%.*s]\n", SectionNameSize, SectionName);

	  Section = IniCacheAddSection(*Cache,
				       SectionName,
				       SectionNameSize);
	  if (Section == NULL)
	    {
	      DPRINT("IniCacheAddSection() failed\n");
	      Ptr = IniCacheSkipToNextSection(Ptr);
	      continue;
	    }
	}
      else
	{
	  if (Section == NULL)
	    {
	      Ptr = IniCacheSkipToNextSection(Ptr);
	      continue;
	    }

	  Ptr = IniCacheGetKeyName(Ptr,
				   &KeyName,
				   &KeyNameSize);

	  Ptr = IniCacheGetKeyValue(Ptr,
				    &KeyValue,
				    &KeyValueSize,
				    String);

	  DPRINT1("'%.*s' = '%.*s'\n", KeyNameSize, KeyName, KeyValueSize, KeyValue);

	  Key = IniCacheAddKey(Section,
			       KeyName,
			       KeyNameSize,
			       KeyValue,
			       KeyValueSize);
	  if (Key == NULL)
	    {
	      DPRINT("IniCacheAddKey() failed\n");
	    }
	}
    }

  /* Free file buffer */
  RtlFreeHeap(ProcessHeap,
	      0,
	      FileBuffer);

  return(Status);
}


VOID
IniCacheDestroy(PINICACHE Cache)
{
  if (Cache == NULL)
    {
      return;
    }

  while (Cache->FirstSection != NULL)
    {
      Cache->FirstSection = IniCacheFreeSection(Cache->FirstSection);
    }
  Cache->LastSection = NULL;

  RtlFreeHeap(ProcessHeap,
	      0,
	      Cache);
}


PINICACHESECTION
IniCacheGetSection(PINICACHE Cache,
		   PWCHAR Name)
{
  PINICACHESECTION Section = NULL;

  if (Cache == NULL || Name == NULL)
    {
      DPRINT("Invalid parameter\n");
      return(NULL);
    }

  /* Iterate through list of sections */
  Section = Cache->FirstSection;
  while (Section != NULL)
    {
      DPRINT("Comparing '%S' and '%S'\n", Section->Name, Name);

      /* Are the section names the same? */
      if (_wcsicmp(Section->Name, Name) == 0)
	return(Section);

      /* Get the next section */
      Section = Section->Next;
    }

  DPRINT("Section not found\n");

  return(NULL);
}


NTSTATUS
IniCacheGetKey(PINICACHESECTION Section,
	       PWCHAR KeyName,
	       PWCHAR *KeyData)
{
  PINICACHEKEY Key;

  if (Section == NULL || KeyName == NULL || KeyData == NULL)
    {
      DPRINT("Invalid parameter\n");
      return(STATUS_INVALID_PARAMETER);
    }

  *KeyData = NULL;

  Key = IniCacheFindKey(Section, KeyName, wcslen(KeyName));
  if (Key == NULL)
    {
      return(STATUS_INVALID_PARAMETER);
    }

  *KeyData = Key->Data;

  return(STATUS_SUCCESS);
}


PINICACHEITERATOR
IniCacheFindFirstValue(PINICACHESECTION Section,
		       PWCHAR *KeyName,
		       PWCHAR *KeyData)
{
  PINICACHEITERATOR Iterator;
  PINICACHEKEY Key;

  if (Section == NULL || KeyName == NULL || KeyData == NULL)
    {
      DPRINT("Invalid parameter\n");
      return(NULL);
    }

  Key = Section->FirstKey;
  if (Key == NULL)
    {
      DPRINT("Invalid parameter\n");
      return(NULL);
    }

  *KeyName = Key->Name;
  *KeyData = Key->Data;

  Iterator = (PINICACHEITERATOR)RtlAllocateHeap(ProcessHeap,
						0,
						sizeof(INICACHEITERATOR));
  if (Iterator == NULL)
    {
      DPRINT("RtlAllocateHeap() failed\n");
      return(NULL);
    }

  Iterator->Section = Section;
  Iterator->Key = Key;

  return(Iterator);
}


BOOLEAN
IniCacheFindNextValue(PINICACHEITERATOR Iterator,
		      PWCHAR *KeyName,
		      PWCHAR *KeyData)
{
  PINICACHEKEY Key;

  if (Iterator == NULL || KeyName == NULL || KeyData == NULL)
    {
      DPRINT("Invalid parameter\n");
      return(FALSE);
    }

  Key = Iterator->Key->Next;
  if (Key == NULL)
    {
      DPRINT("No more entries\n");
      return(FALSE);
    }

  *KeyName = Key->Name;
  *KeyData = Key->Data;

  Iterator->Key = Key;

  return(TRUE);
}


VOID
IniCacheFindClose(PINICACHEITERATOR Iterator)
{
  if (Iterator == NULL)
    return;

  RtlFreeHeap(ProcessHeap,
	      0,
	      Iterator);
}


PINICACHEKEY
IniCacheInsertKey(PINICACHESECTION Section,
		  PINICACHEKEY AnchorKey,
		  INSERTATION_TYPE InsertationType,
		  PWCHAR Name,
		  PWCHAR Data)
{
  PINICACHEKEY Key;

  Key = NULL;

  if (Section == NULL ||
      Name == NULL ||
      *Name == 0 ||
      Data == NULL ||
      *Data == 0)
    {
      DPRINT("Invalid parameter\n");
      return(NULL);
    }

  /* Allocate key buffer */
  Key = (PINICACHEKEY)RtlAllocateHeap(ProcessHeap,
				      0,
				      sizeof(INICACHEKEY));
  if (Key == NULL)
    {
      DPRINT("RtlAllocateHeap() failed\n");
      return(NULL);
    }
  RtlZeroMemory(Key,
		sizeof(INICACHEKEY));

  /* Allocate name buffer */
  Key->Name = (WCHAR*) RtlAllocateHeap(ProcessHeap,
			      0,
			      (wcslen(Name) + 1) * sizeof(WCHAR));
  if (Key->Name == NULL)
    {
      DPRINT("RtlAllocateHeap() failed\n");
      RtlFreeHeap(ProcessHeap,
		  0,
		  Key);
      return(NULL);
    }

  /* Copy value name */
  wcscpy(Key->Name, Name);

  /* Allocate data buffer */
  Key->Data = (WCHAR*) RtlAllocateHeap(ProcessHeap,
			      0,
			      (wcslen(Data) + 1) * sizeof(WCHAR));
  if (Key->Data == NULL)
    {
      DPRINT("RtlAllocateHeap() failed\n");
      RtlFreeHeap(ProcessHeap,
		  0,
		  Key->Name);
      RtlFreeHeap(ProcessHeap,
		  0,
		  Key);
      return(NULL);
    }

  /* Copy value data */
  wcscpy(Key->Data, Data);

  /* Insert key into section */
  if (Section->FirstKey == NULL)
    {
      Section->FirstKey = Key;
      Section->LastKey = Key;
    }
  else if ((InsertationType == INSERT_FIRST) ||
	   ((InsertationType == INSERT_BEFORE) && ((AnchorKey == NULL) || (AnchorKey == Section->FirstKey))))
    {
      /* Insert at the head of the list */
      Section->FirstKey->Prev = Key;
      Key->Next = Section->FirstKey;
      Section->FirstKey = Key;
    }
  else if ((InsertationType == INSERT_BEFORE) && (AnchorKey != NULL))
    {
      /* Insert before the anchor key */
      Key->Next = AnchorKey;
      Key->Prev = AnchorKey->Prev;
      AnchorKey->Prev->Next = Key;
      AnchorKey->Prev = Key;
    }
  else if ((InsertationType == INSERT_LAST) ||
	   ((InsertationType == INSERT_AFTER) && ((AnchorKey == NULL) || (AnchorKey == Section->LastKey))))
    {
      Section->LastKey->Next = Key;
      Key->Prev = Section->LastKey;
      Section->LastKey = Key;
    }
  else if ((InsertationType == INSERT_AFTER) && (AnchorKey != NULL))
    {
      /* Insert before the anchor key */
      Key->Next = AnchorKey->Next;
      Key->Prev = AnchorKey;
      AnchorKey->Next->Prev = Key;
      AnchorKey->Next = Key;
    }

  return(Key);
}


PINICACHE
IniCacheCreate(VOID)
{
  PINICACHE Cache;

  /* Allocate inicache header */
  Cache = (PINICACHE)RtlAllocateHeap(ProcessHeap,
				     0,
				     sizeof(INICACHE));
  if (Cache == NULL)
    {
      DPRINT("RtlAllocateHeap() failed\n");
      return(NULL);
    }

  /* Initialize inicache header */
  RtlZeroMemory(Cache,
		sizeof(INICACHE));

  return(Cache);
}


NTSTATUS
IniCacheSave(PINICACHE Cache,
	     PWCHAR FileName)
{
  UNICODE_STRING Name;
  PINICACHESECTION Section;
  PINICACHEKEY Key;
  ULONG BufferSize;
  PCHAR Buffer;
  PCHAR Ptr;
  ULONG Len;
  NTSTATUS Status;

  OBJECT_ATTRIBUTES ObjectAttributes;
  IO_STATUS_BLOCK IoStatusBlock;
  LARGE_INTEGER Offset;
  HANDLE FileHandle;


  /* Calculate required buffer size */
  BufferSize = 0;
  Section = Cache->FirstSection;
  while (Section != NULL)
    {
      BufferSize += (Section->Name ? wcslen(Section->Name) : 0)
		    + 4; /* "[]\r\n" */

      Key = Section->FirstKey;
      while (Key != NULL)
	{
	  BufferSize += wcslen(Key->Name)
			+ (Key->Data ? wcslen(Key->Data) : 0)
			+ 3; /* "=\r\n" */
	  Key = Key->Next;
	}

      Section = Section->Next;
      if (Section != NULL)
	BufferSize += 2; /* extra "\r\n" at end of each section */
    }
  BufferSize++; /* Null-terminator */

  DPRINT("BufferSize: %lu\n", BufferSize);

  /* Allocate file buffer */
  Buffer = (CHAR*) RtlAllocateHeap(ProcessHeap,
			   0,
			   BufferSize);
  if (Buffer == NULL)
    {
      DPRINT1("RtlAllocateHeap() failed\n");
      return(STATUS_INSUFFICIENT_RESOURCES);
    }
  RtlZeroMemory(Buffer, BufferSize);

  /* Fill file buffer */
  Ptr = Buffer;
  Section = Cache->FirstSection;
  while (Section != NULL)
    {
      Len = sprintf(Ptr, "[%S]\r\n", Section->Name);
      Ptr += Len;

      Key = Section->FirstKey;
      while (Key != NULL)
	{
	  Len = sprintf(Ptr, "%S=%S\r\n", Key->Name, Key->Data);
	  Ptr += Len;
	  Key = Key->Next;
	}

      Section = Section->Next;
      if (Section != NULL)
	{
	  Len = sprintf(Ptr, "\r\n");
	  Ptr += Len;
	}
    }

  /* Create ini file */
  RtlInitUnicodeString(&Name,
		       FileName);

  InitializeObjectAttributes(&ObjectAttributes,
			     &Name,
			     0,
			     NULL,
			     NULL);

  Status = NtCreateFile(&FileHandle,
			GENERIC_WRITE,
			&ObjectAttributes,
			&IoStatusBlock,
			NULL,
			FILE_ATTRIBUTE_NORMAL,
			0,
			FILE_SUPERSEDE,
			FILE_SYNCHRONOUS_IO_NONALERT | FILE_SEQUENTIAL_ONLY,
			NULL,
			0);
  if (!NT_SUCCESS(Status))
    {
      DPRINT("NtCreateFile() failed (Status %lx)\n", Status);
      RtlFreeHeap(ProcessHeap,
		  0,
		  Buffer);
      return(Status);
    }

  Offset.QuadPart = 0LL;
  Status = NtWriteFile(FileHandle,
		       NULL,
		       NULL,
		       NULL,
		       &IoStatusBlock,
		       Buffer,
		       BufferSize,
		       &Offset,
		       NULL);
  if (!NT_SUCCESS(Status))
    {
      DPRINT("NtWriteFile() failed (Status %lx)\n", Status);
      NtClose(FileHandle);
      RtlFreeHeap(ProcessHeap,
		  0,
		  Buffer);
      return(Status);
    }

  NtClose(FileHandle);

  RtlFreeHeap(ProcessHeap,
	      0,
	      Buffer);

  return(STATUS_SUCCESS);
}


PINICACHESECTION
IniCacheAppendSection(PINICACHE Cache,
		      PWCHAR Name)
{
  PINICACHESECTION Section = NULL;

  if (Cache == NULL || Name == NULL || *Name == 0)
    {
      DPRINT("Invalid parameter\n");
      return(NULL);
    }

  Section = (PINICACHESECTION)RtlAllocateHeap(ProcessHeap,
					      0,
					      sizeof(INICACHESECTION));
  if (Section == NULL)
    {
      DPRINT("RtlAllocateHeap() failed\n");
      return(NULL);
    }
  RtlZeroMemory(Section,
		sizeof(INICACHESECTION));

  /* Allocate and initialize section name */
  Section->Name = (WCHAR*) RtlAllocateHeap(ProcessHeap,
				  0,
				  (wcslen(Name) + 1) * sizeof(WCHAR));
  if (Section->Name == NULL)
    {
      DPRINT("RtlAllocateHeap() failed\n");
      RtlFreeHeap(ProcessHeap,
		  0,
		  Section);
      return(NULL);
    }

  /* Copy section name */
  wcscpy(Section->Name, Name);

  /* Append section */
  if (Cache->FirstSection == NULL)
    {
      Cache->FirstSection = Section;
      Cache->LastSection = Section;
    }
  else
    {
      Cache->LastSection->Next = Section;
      Section->Prev = Cache->LastSection;
      Cache->LastSection = Section;
    }

  return(Section);
}

/* EOF */
