OUTPUT_FORMAT("pe-x86-64") 
ENTRY("loader")
SECTIONS 
{ 
    . = 0x100000;
    .text :
    { 
        code = .; 
        *(.text) 
        text_end = .;
    }
    .rodata : 
    { 
        rodata = text_end; 
        *(.rodata)
		*(.rdata)
        rodata_end  = .;      
    }    
    .data : 
    { 
        data = rodata_end; 
        *(.data) 
        data_end = .;
    } 
    .bss :  
    { 
        bss = data_end; 
        *(.bss) 
        bss__end = .;
    } 
    end = .; 
}
 

@echo off
set nasm="tools\nasm.exe"
set bochs="C:\Program Files (x86)\Bochs-2.5.1\bochs.exe"
set fat12maker="tools\fat12maker.exe"
set ld="..\MinGW64\bin\x86_64-w64-mingw32-ld.exe"
set cpp="..\MinGW64\bin\x86_64-w64-mingw32-g++.exe"
set objcopy="..\MinGW64\bin\x86_64-w64-mingw32-objcopy.exe"
set cpp_params=-I.\Kernel\ -nostdlib -nostartfiles -nodefaultlibs -masm=intel -fstrength-reduce -fomit-frame-pointer -finline-functions -nostdinc -fno-builtin

mkdir bin\

%nasm% -fbin bootloader\Stage_1.asm -o Stage_1.bin
if NOT %ERRORLEVEL%==0 goto error

%nasm% -fbin bootloader\Stage_2.asm -o Stage_2.bin
if NOT %ERRORLEVEL%==0 goto error

%cpp% %cpp_params% -c Kernel\kernel.cpp -o bin\kernel.o
%cpp% %cpp_params% -c Kernel\Drivers\screen.cpp -o bin\screen.o
%cpp% %cpp_params% -c Kernel\string.cpp -o bin\string.o
%cpp% %cpp_params% -c Kernel\io.cpp -o bin\io.o
%cpp% %cpp_params% -c Kernel\idt.cpp -o bin\idt.o
%nasm% -f win64 Kernel\Stage_3.asm -o bin\Stage_3.o
if NOT %ERRORLEVEL%==0 goto error

%ld% -nostdlib -nodefaultlibs -T linker.ld bin\Stage_3.o bin\kernel.o bin\idt.o bin\screen.o bin\string.o bin\io.o -o Kernel.out
%objcopy% -x -g -X -S -O binary Kernel.out kernel.bin

copy /b Stage_2.bin+kernel.bin Stage_2.bin
if NOT %ERRORLEVEL%==0 goto error

%fat12maker% -b Stage_1.bin -i Stage_2.bin -o Kernel.img
%bochs% -f bochsconf

goto fin

:error
echo Se produjo un error de compilacion
exit

:fin
echo Compilacion satisfactoria
rmdir /S /Q bin\

const char * interrupts_exceptions[] = {
	 "0 - Division by zero exception",
	 "1 - Debug exception",
	 "2 - Non maskable interrupt",
	 "3 - Breakpoint exception",
	 "4 - 'Into detected overflow",
	 "5 - Out of bounds exception",
	 "6 - Invalid opcode exception",
	 "7 - No coprocessor exception",
	 "8 - Double fault",
	 "9 - Coprocessor segment overrun",
	 "10 - Bad TSS",
	 "11 - Segment not present",
	 "12 - Stack fault",
	 "13 - General protection fault",
	 "14 - Page fault",
	 "15 - Unknown interrupt exception",
	 "16 - Coprocessor fault",
	 "17 - Alignment check exception",
	 "18 - Machine check exception",
	 "19 - Reserved exception",
	 "20 - Reserved exception",
	 "21 - Reserved exception",
	 "22 - Reserved exception",
	 "23 - Reserved exception",
	 "24 - Reserved exception",
	 "25 - Reserved exception",
	 "26 - Reserved exception",
	 "27 - Reserved exception",
	 "28 - Reserved exception",
	 "29 - Reserved exception",
	 "30 - Reserved exception" 
	 "31 - Reserved exception"};
 
void idt::init_idt()
{
	idt_ptr = (idt_ptr_t*)IDT_ADDRESS;
	*idt_entries = (idt_entry_t*)IDT_ADDRESS;
 
	clean_gates();
	screen::kprintf("Exceptions pointer: 0x%p\n", ::interrupts_exceptions);
	screen::kprintf("String: %s\n", ::interrupts_exceptions[0]); //<--------------------------
 
	idt_set_gate(0, (QWORD)isr0, 0x08, 0x8E);
}
 

OUTPUT_FORMAT(binary)
ENTRY(loader)
SECTIONS 
{ 
    . = 0x100000;
    .text :
    { 
        code = .; 
        *(.text) 
        text_end = .;
    }
    .rodata : 
    { 
        rodata = text_end; 
        *(.rodata)
        rodata_end  = .;      
    }    
    .data : 
    { 
        data = rodata_end; 
        *(.data) 
        data_end = .;
    } 
    .bss :  
    { 
        bss = data_end; 
        *(.bss) 
        bss__end = .;
    } 
    end = .; 
}
 

CPP = g++
CPP_PARAMS = -I./Kernel/ -nostdlib -nostartfiles -nodefaultlibs -masm=intel -fstrength-reduce -fomit-frame-pointer -finline-functions -nostdinc -fno-builtin
OBJECTS = Stage_3.o kernel.o screen.o string.o io.o idt.o
FAT12MAKER = ./tools/fat12maker/fat12maker
 
 
all:
	nasm -fbin bootloader/Stage_1.asm -o Stage_1.bin
	nasm -fbin bootloader/Stage_2.asm -o Stage_2.o
 
	nasm -felf64 Kernel/Stage_3.asm -o Stage_3.o
	$(CPP) $(CPP_PARAMS) -c Kernel/kernel.cpp -o kernel.o
	$(CPP) $(CPP_PARAMS) -c Kernel/Drivers/screen.cpp -o screen.o
	$(CPP) $(CPP_PARAMS) -c Kernel/string.cpp -o string.o
	$(CPP) $(CPP_PARAMS) -c Kernel/io.cpp -o io.o
	$(CPP) $(CPP_PARAMS) -c Kernel/idt.cpp -o idt.o
 
	ld -nostdlib -nodefaultlibs -T linker-linux.ld $(OBJECTS) -o Kernel.o
	cat Stage_2.o Kernel.o > Stage_2.bin
	$(FAT12MAKER) -b Stage_1.bin -i Stage_2.bin -o Kernel.img
	bochs -f bochsconf-linux
 
clean:
	rm *.o
	rm *.bin
 

extern "C" void kmain(WORD Foo, WORD Foo2)
{
	char saludo[] = "Hello!\n";
	screen::clear_screen();
	screen::hide_cursor();
 
	screen::kprintf("Adios\n"); //No funciona
	screen::kprintf(saludo); //Funciona
 

[bits 16]
[ORG 0]
 
jmp short start
nop   ; No Operation (1 byte)
 
OEMLabel:                     db "KERNEL  "      ; 8 characters padded with spaces
BytesPerSector:                 dw 512            ; Bytes per sector
SectorsPerCluster:                db 1            ; Sectors per cluster
ReservedSectors:                dw 1            ; Reserved Sectors (for sector 0)
NumberOfFATs:                   db 2            ; Number of FAT´s
MaxRootEntries:                dw 224            ; Number of Root Entries
 
NumberOfSectors:                dw 2880            ; Number of sectors
DeviceDescriptor:                db 0xF0            ; Device Descriptor 0xF0 => 1.44 MB floppy image
SectorsPerFAT:                   dw 9            ; Sectors Per FAT
SectorsPerTrack:                dw 18            ; Sectors Per Track
Sides:                         dw 2            ; Sides of disk
HiddenSectors:                   dd 0            ; Number of Hidden Sectors
LengthOfSectors:               dd 0            ; Length of sectors
DriveNo:                      db 0            ; Drive Number (0 or 1)
Flags:                         db 0            ; Additional flags
Signature:                      db 0x14            ; Signature, some number of 1 byte
VolumeID:                     dd 0xAABBCCDD      ; Volume ID
VolumeLabel:                   db "DISCO TANIS "   ; 11 characters padded with spaces
FileSystem:                   db "FAT12   "      ; 8 characters padded with spaces
 
;**********************************************************;
; Entry Point
; Reset the floppy disk.
; Calculate the root directory CHS address and jump to 
; read_root_directory.
;**********************************************************;
start:
   jmp 07C0h:stage_1
 
stage_1:
   mov ax, cs
   mov ds, ax
   mov es, ax
 
   mov si, StringMsg
   call print_string
 
   xor ah, ah ; Ah = 0, reset function
   mov dl, BYTE [DriveNo]
   int 13h ; Reset Floppy Disk
 
   xor ax, ax
 
   add ax, WORD [SectorsPerFAT]
   mul BYTE [NumberOfFATs]
   add ax, WORD [ReservedSectors]
   ; AX = (SectorsPerFAT * NumberOfFATs) + ReservedSectors
 
   call lba2chs
 
   jmp short read_root_directory
 
read_root_directory:
   ; We have already calculated the CH = Cilynder, CL = sector and
   ; DH = Head.
   mov ax, 1000h
   mov es, ax
   mov bx, 0
 
   mov ah, 02h   ; Read mode
   mov al, 0Fh ; Sectors to read (512 bytes each sector)
   mov dl, BYTE [DriveNo]
 
   int 13h ;Call the interruption!
   jc .root_dir_read_error
 
   mov si, [1000h]
   mov dx, 512
   call print_n
 
        ...
 

;**********************************************************;
; Print a string in screen
; SI => String pointer
; DX => Number of characters to print
;**********************************************************;
print_n:
   push ax
   push bx
   push cx
 
   mov ah, 0Eh
 
   xor cx, cx
 
   .loop:
   mov al, [si]
   int 10h
   inc cx
   cmp cx, dx
   je short .end_loop
 
   inc si
   jmp short .loop
 
   .end_loop:
   pop ax
   pop bx
   pop cx
   ret
 

mov si, [1000h]
mov dx, 512
call print_n
 

/*
 * addFileFAT12()
 * Add file to our FAT12_t structure
*/
int addFileFAT12(char * fileName, FAT12_t * fat12)
{
	int result = 0;
	linked_list_t * l = NULL;
	directory_entry_t directoryEntry;
 
	if (fat12 == NULL)
		return FAT12_INVALID_FAT12_POINTER;
 
	if (fat12->active != 0)
		return FAT12_INACTIVE;
 
	result = getDirectoryEntry(fileName, fat12, &directoryEntry);
	if (result == DE_OK)
	{
		fat12->list.list = fat12->list.last;
 
		l = (linked_list_t*)malloc(sizeof(linked_list_t));
		if (l == NULL)
			return FAT12_LINKED_LIST_MALLOC_ERR;
 
		if (fat12->list.list == NULL)
			fat12->list.list = l;
		else
		{
			fat12->list.list->next = l;
			fat12->list.list = fat12->list.list->next;
		}		
 
		fat12->list.list->directoryEntry = directoryEntry;
 
		fat12->list.list->fileName = (char *)malloc(strlen(fileName) + 1);
		if (fat12->list.list->fileName == NULL)
			return FAT12_LINKED_LIST_FILENAME_MALLOC_ERR;
 
		strncpy(fat12->list.list->fileName, fileName, strlen(fileName) + 1);
		//fat12->list.list->fileName = strdup(fileName);
 
		fat12->list.list->next = NULL;
 
		if (fat12->list.first == NULL)
			fat12->list.first = fat12->list.list;
 
		fat12->list.last = fat12->list.list;
		fat12->NumberOfFiles++;
 
		return FAT12_OK;
	}
	else
		return result;
}
 
...
while (fat12->list.list != NULL)
{
	sectorsCount = (unsigned short)(fat12->list.list->directoryEntry.FileSize / fat12->boot_sector.BytesPerSector) + 1;		
	fat12->list.list->directoryEntry.StartingCluster = LBAAddress;
 
	printf("\nFile: %s, Size: %d bytes, Sectors count: %d, LBA Address: 0x%.4x", fat12->list.list->fileName,
		fat12->list.list->directoryEntry.FileSize, sectorsCount, LBAAddress);
 
	LBAAddress += sectorsCount;
 
	if (sectorsCountOfNextFile != -1) //Quiere decir que ya usamos un cluster
		sectorsCount--;
	sectorsCountOfNextFile = -1;
 
	fat12->list.list = fat12->list.list->next; //Preparamos el siguiente archivo
	while (sectorsCount > 0)
	{
		switch (sectorsCount)
		{
			case 1:
				sectorsCount = 0;
				fat_entry = 0x000FFF00;
 
				if (fat12->list.list != NULL)
				{					
					sectorsCountOfNextFile = (unsigned short)(fat12->list.list->directoryEntry.FileSize / fat12->boot_sector.BytesPerSector) + 1;
					if (sectorsCountOfNextFile == 1)
						fat_entry = 0xFFFFFF00;
					else
						fat_entry += (nextCluster + 1) << 20;
				}
				break;
			case 2:
				fat_entry = 0xFFF00000 + (nextCluster << 8);
				sectorsCount = 0;
				break;
			default:
				fat_entry = (unsigned long)((nextCluster + 1) << 20) + (nextCluster << 8);	
 
				sectorsCount -= 2;
				break;
		}
		nextCluster+=2;
 
		*fatTable++ = (unsigned char)((fat_entry & 0x0000FF00) >> 8);
		*fatTable++ = (unsigned char)((fat_entry & 0x00FF0000) >> 16);
		*fatTable++ = (unsigned char)((fat_entry & 0xFF000000) >> 24);
	}	
}
 
 

#include <iostream>
#include <Windows.h>
 
using namespace std;
 
void threadFunc()
{
double a = 0;
 
	for (unsigned long long i = 0;;i++)
	{
		a = (i * 17) - 32;
		if (a > 0)
			a = (sqrt(a) * 43) - 72;
	}
}
 
int main(int argc, char * argv[])
{
	SYSTEM_INFO sysInfo;
	DWORD dwThreadId;
 
	GetSystemInfo(&sysInfo);
	cout << "Numero de nucleos: " << sysInfo.dwNumberOfProcessors << endl << endl;
 
	BYTE coreToUse = 0; //Empieza en el 0
	HANDLE hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)threadFunc, NULL, 0, &dwThreadId);
 
	if (SetThreadAffinityMask(hThread, 1 << (coreToUse % 8)) != 0)
		cout << "ThreadAffinity se establecio con exito en el nucleo " << (int)coreToUse << endl;
	else
		cout << "ThreadAffinity error! El sistema repartira la carga del Thread!" << endl;
 
	cin.get();
 
	return 0;
}
 

#include <Windows.h>
//#include "core.h"
#include <curl/curl.h>
 
extern "C" __declspec(dllexport) int StartXModule();
 
BOOL APIENTRY DllMain( HANDLE hModule,
                        DWORD  ul_reason_for_call,
                        LPVOID lpReserved )
{
    return TRUE;
}
 
 
int StartXModule()
{
	curl_global_init(CURL_GLOBAL_DEFAULT);
	return 0;
}
 

[DllImport("x-module.dll")]
        private static extern int StartXModule();
 
        private void FMain_Load(object sender, EventArgs e)
        {
            PMain.BackColor = System.Drawing.ColorTranslator.FromWin32(0x00373737);
            //for (int i = 0; i < 30; i++)
            //    listBoxX1.Items.Add("qdwqdqw");
            StartXModule();
        }
 

(*
 * PEFileSize function, inspired by The Swash
 * by Khronos
*)
 
function PEFileSize(FileName: string): Cardinal;
var
i: integer;
FileStream: TFileStream;
IDH: IMAGE_DOS_HEADER;
INH: IMAGE_NT_HEADERS;
ISH: IMAGE_SECTION_HEADER;
begin
result:= 0;
  try
    FileStream:= TFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
    FileStream.Read(IDH, SizeOf(IDH));
    if IDH.e_magic = IMAGE_DOS_SIGNATURE then
      begin
        FileStream.Seek(IDH._lfanew, 0);
        FileStream.Read(INH, SizeOf(INH));
        if INH.Signature = IMAGE_NT_SIGNATURE then
          begin
            for I := 0 to INH.FileHeader.NumberOfSections - 1 do
              begin
                FileStream.Seek(IDH._lfanew + SizeOf(INH) + SizeOf(ISH) * i, 0);
                FileStream.Read(ISH, SizeOf(ISH));
                result:= result + ISH.SizeOfRawData;
              end;
            result:= result + INH.OptionalHeader.SizeOfHeaders;
          end;
      end;
  finally
    FileStream.Free;
  end;
end;
 

procedure DownloadFile(URL: AnsiString; FileName: String; StartDownload: TOnStartDownload;  
          Progress: TOnProgress; FinishDownload: TOnFinishDownload);

unit URLDown;
 
(*
 * *****************************************************************************
 * ***************************   Unidad URLDown  *******************************
 *    Esta unidad contiene la función DownloadFile, una función que
 * descarga un archivo desde una dirección URL. Esta función se ejecuta en
 * otro thread, por lo que no "congela" la aplicación ni causa inastabilidad.
 * Además, cuenta con 3 eventos: OnStartDownload, OnProgress y OnFinishDownload.
 *
 * Autor: Khronos
 * Email: khronos14@hotmail.com
 * Blog: khronos14.blogspot.com
 *******************************************************************************
*)
 
interface
 
uses SysUtils, Classes, Windows, WinSock;
 
{$DEFINE OBJECT_FUNCTIONS}
(*
  Si borras la definición OBJECT_FUNCTIONS, los eventos
  de la función DownloadFile no serán de tipo objeto.
  Para emplear esta función en modo consola o sin clases,
  comenta esta definición.
*)
 
const
  SZBUFFER_SIZE   = 2048; //Este es el tamaño del buffer de descarga
 
  URLDOWN_OK                    = 0;
  URLDOWN_INVALID_HOST          = 1;
  URLDOWN_CONNECT_ERROR         = 2;
  URLDOWN_DOWNLOAD_ERROR        = 3;
  URLDOWN_UNKNOWN_ERROR         = $FD;
 
type
  TOnStartDownload = procedure(FileSize: int64) {$IFDEF OBJECT_FUNCTIONS}of object{$ENDIF};
  TOnProgress = procedure(Progress: int64) {$IFDEF OBJECT_FUNCTIONS}of object{$ENDIF};
  TOnFinishDownload = procedure(ErrorCode: byte) {$IFDEF OBJECT_FUNCTIONS}of object{$ENDIF};
 
  TDownloadVars = record
    URL: AnsiString;
    FileName: String;
    OnStartDownload: TOnStartDownload;
    OnProgress: TOnProgress;
    OnFinishDownload: TOnFinishDownload;
  end;
  PDownloadVars = ^TDownloadVars;
 
procedure DownloadFile(URL: AnsiString; FileName: String; StartDownload: TOnStartDownload;
          Progress: TOnProgress; FinishDownload: TOnFinishDownload); stdcall;
 
implementation
 
 
function GetDomainName(const URL: AnsiString): AnsiString;
var
P1: integer;
begin
  P1:= Pos('http://', URL);
  if P1 > 0 then
   begin
     result:= Copy(URL, P1 + 7, Length(URL) - P1 - 6);
     P1:= Pos('/', result);
     if P1 > 0 then
       result:= Copy(result, 0, P1 - 1);
   end else
     begin
       P1:= Pos('/', URL);
       if P1 > 0 then
         result:= Copy(URL, 0, P1 - 1)
       else result:= URL;
     end;
end;
 
function GetFileWeb(const URL: AnsiString): AnsiString;
var
P1: integer;
begin
  P1:= Pos('http://', URL);
  if P1 > 0 then
   begin
     result:= Copy(URL, P1 + 7, Length(URL) - P1 - 6);
     P1:= Pos('/', result);
     if P1 > 0 then
       result:= Copy(result, P1, Length(result) - P1 + 1);
   end else
     begin
       P1:= Pos('/', URL);
       if P1 > 0 then
         result:= Copy(URL, P1, Length(URL) - P1 + 1)
       else result:= URL;
     end;
  if result = GetDomainName(URL) then
    result:= '/';
end;
 
procedure CleanHttp(var Mem: TMemoryStream);
var
i: integer;
Separator: array [0..3] of AnsiChar;
Mem2: TMemoryStream;
begin
 if Assigned(Mem) then
   begin
     for i := 0 to Mem.Size - 1 do
       begin
         Mem.Seek(i, 0);
         Mem.Read(Separator, 4);
         if (Separator[0] = #13) and (Separator[1] = #10) and (Separator[2] = #13)
             and (Separator[3] = #10) then
               begin
                 Mem2:= TMemoryStream.Create;
                 Mem.Seek(i + 4, 0);
                 Mem2.CopyFrom(Mem, Mem.Size - I - 4);
                 Mem:= Mem2;
                 break;
               end;
       end;
   end;
end;
 
function SendQuery(Socket: TSocket; RHost: sockaddr_in; Query: AnsiString): boolean;
begin
if Connect(Socket, PSockAddrIn(@RHost)^, Sizeof(RHost)) = 0 then
  begin
    send(Socket, Pointer(Query)^, Length(Query), 0);
    result:= true;
  end else
    result:= false;
end;
 
function CreateQuery(URL: AnsiString): AnsiString;
begin
  result:= 'GET ' + GetFileWeb(URL) + ' HTTP/1.0' + #13#10 +
    'Host: ' + GetDomainName(URL) +  #13#10 +
    'User-Agent: Khronos' + #13#10#13#10;
end;
 
function GetContentLength(szBuff: AnsiString; Size: Cardinal): int64;
var
dwStart, dwEnd: integer;
ContentLength: AnsiString;
begin
Result:= 0;
  dwStart:= Pos('Content-Length: ', szBuff);
  if dwStart <> 0 then
    begin
      dwStart:= dwStart + StrLen('Content-Length: ');
      dwEnd:= dwStart;
      repeat
        Inc(dwEnd);
      until (szBuff[dwEnd] = #0) or (szBuff[dwEnd] = #13) or (dwEnd = Size);
      ContentLength:= Copy(szBuff, dwStart, dwEnd - dwStart);
      if TryStrToInt64(ContentLength, Result) = false then
        result:= -1;
    end;
  dwStart:= Pos(#13#10#13#10, szBuff);
end;
 
function InitializeWinSock(Host: AnsiString; var Socket: TSocket; var RHost: sockaddr_in): boolean;
var
WSA: TWSAData;
Addr: u_long;
Hostent: PHostent;
Ip: ^Integer;
begin
If WSAStartup(MakeWord(2,2), WSA) = 0 then
  begin
     Socket:= WinSock.SOCKET(AF_INET, SOCK_STREAM, 0);
     if Socket <> INVALID_SOCKET then
        begin
          Hostent:= GetHostByName(PAnsiChar(GetDomainName(Host)));
          if Hostent <> nil then
            begin
              Ip:= @Hostent.h_addr_list^[0];
              RHost.sin_family:= AF_INET;
              RHost.sin_port:= htons(80);
              RHost.sin_addr.S_addr:= ip^;
              result:= true;
           end;
        end;
  end else
    result:= false;
end;
 
function ProcessDownload(Socket: TSocket; FileName: WideString; StartDownload: TOnStartDownload;
          Progress: TOnProgress; FinishDownload: TOnFinishDownload): boolean;
var
szBuffer: array [0..SZBUFFER_SIZE] of AnsiChar;
Stream: TMemoryStream;
ContentLength, ReturnCode: integer;
begin
result:= false;
    try
      Stream:= TMemoryStream.Create;
      ContentLength:= 0;
      repeat
        FillChar(szBuffer, SZBUFFER_SIZE, 0);
        ReturnCode:= recv(Socket, szBuffer, SZBUFFER_SIZE, 0);
        if (ContentLength = 0) and (ReturnCode > 0) then
          begin
            ContentLength:= GetContentLength(szBuffer, ReturnCode);
            if Assigned(StartDownload) then
              StartDownload(ContentLength);
          end;
        if ReturnCode > 0 then
          begin
            Stream.Write(szBuffer, ReturnCode);
            if Assigned(Progress) then
                Progress(Stream.Position);
          end;
      until ReturnCode <= 0;
      if Stream.Size > 0 then
        begin
          CleanHttp(Stream);
          Stream.SaveToFile(FileName);
          if Assigned(FinishDownload) then
            FinishDownload(URLDOWN_OK);
          result:= true;
        end;
    finally
      Stream.Free;
    end;
end;
 
procedure Download(P: Pointer);
var
Query: AnsiString;
Socket: TSocket;
RHost: sockaddr_in;
begin
  try
    if InitializeWinSock(TDownloadVars(P^).URL, Socket, RHost) then
      begin
        Query:= CreateQuery(TDownloadVars(P^).URL);
        if SendQuery(Socket, RHost, Query) then
          begin
            If ProcessDownload(Socket, TDownloadVars(P^).FileName, TDownloadVars(P^).OnStartDownload,
                TDownloadVars(P^).OnProgress, TDownloadVars(P^).OnFinishDownload) = false then
                if Assigned(TDownloadVars(P^).OnFinishDownload) then
                  TDownloadVars(P^).OnFinishDownload(URLDOWN_DOWNLOAD_ERROR);
            ShutDown(Socket, SD_BOTH);
            CloseSocket(Socket);
          end else
            if Assigned(TDownloadVars(P^).OnFinishDownload) then
              TDownloadVars(P^).OnFinishDownload(URLDOWN_CONNECT_ERROR);
      end else
        if Assigned(TDownloadVars(P^).OnFinishDownload) then
          TDownloadVars(P^).OnFinishDownload(URLDOWN_INVALID_HOST);
 
    WSACleanUp();
    Dispose(PDownloadVars(P));
  Except on Exception do
    begin
      if Assigned(TDownloadVars(P^).OnFinishDownload) then
          TDownloadVars(P^).OnFinishDownload(URLDOWN_UNKNOWN_ERROR);
    end;
  end;
end;
 
procedure DownloadFile(URL: AnsiString; FileName: String; StartDownload: TOnStartDownload;
          Progress: TOnProgress; FinishDownload: TOnFinishDownload);
var
DownloadVars: ^TDownloadVars;
begin
  New(DownloadVars);
  DownloadVars^.URL:= URL;
  DownloadVars^.FileName:= FileName;
  DownloadVars^.OnStartDownload:= StartDownload;
  DownloadVars^.OnProgress:= Progress;
  DownloadVars^.OnFinishDownload:= FinishDownload;
 
  BeginThread(nil, 0, @Download, DownloadVars, 0, PDWORD(0)^);
end;
 
 
end.