248 lines
8.6 KiB
Ada
248 lines
8.6 KiB
Ada
package body handlers is
|
|
task body handler is
|
|
socket : Socket_Type;
|
|
sel : access Gnat.Sockets.Selector_Type := new
|
|
Gnat.Sockets.Selector_Type;
|
|
working : Boolean := True;
|
|
subtype Socket_Index is Integer range 1 .. 1000;
|
|
root_path : constant String := "/var/www";
|
|
|
|
package Socket_Vector is new Ada.Containers.Vectors (
|
|
Element_Type => Socket_Type,
|
|
Index_Type => Socket_Index
|
|
);
|
|
|
|
v : Socket_Vector.Vector;
|
|
|
|
task watcher is
|
|
entry start;
|
|
end watcher;
|
|
|
|
task body watcher is
|
|
R : Socket_Set_Type;
|
|
W : Socket_Set_Type;
|
|
E : Socket_Set_Type;
|
|
status : Selector_Status;
|
|
active : Socket_Type;
|
|
unparsed: Unbounded_String;
|
|
begin
|
|
accept start;
|
|
Put_Line("start watcher");
|
|
Create_Selector (sel.all);
|
|
loop
|
|
Put_Line("Watch loop start");
|
|
Empty(R);
|
|
Empty(W);
|
|
Empty(E);
|
|
|
|
Put("There is ");
|
|
Put(v.Last_Index, Width => 0);
|
|
Put_Line(" sockets to watch");
|
|
|
|
Put_Line("setting to read sockets");
|
|
|
|
for id in 1..v.Last_Index loop
|
|
set(R, v.Element(id));
|
|
end loop;
|
|
|
|
Put_Line("start of check_selector");
|
|
|
|
Check_Selector(
|
|
sel.all,
|
|
R,
|
|
W,
|
|
E,
|
|
status,
|
|
Gnat.Sockets.Forever);
|
|
|
|
Put_Line("end of check_selector");
|
|
|
|
-- wychodzimy jedynie wtedy, gdy zmienna working
|
|
-- jest False. Inaczej to jedynie przeładowanie
|
|
-- socketów np. dodano nam socket do obserwacji
|
|
exit when status = Gnat.Sockets.Aborted
|
|
and not working;
|
|
|
|
if status /= Gnat.Sockets.Aborted then
|
|
Put_Line("Sending command to client handler");
|
|
Get(R, active);
|
|
Handler.command(active);
|
|
end if;
|
|
|
|
Put_Line("Watch loop end");
|
|
|
|
end loop;
|
|
Close_Selector (sel.all);
|
|
Put_Line("exit watcher");
|
|
end watcher;
|
|
|
|
procedure Handle_File(s: Socket_Type;
|
|
path: String;
|
|
finished: out Boolean) is
|
|
|
|
sz : Natural := Natural(Size(path));
|
|
subtype Content_Type is String (1 .. sz);
|
|
package dio is new Ada.Direct_IO(Content_Type);
|
|
File : dio.File_Type;
|
|
contents : Content_Type;
|
|
channel : Stream_Access := Stream(s);
|
|
begin
|
|
Put_Line("Handle_File start");
|
|
Put_Line("Path: " & path);
|
|
Put_Line("File size: " & Natural'Image(sz));
|
|
|
|
dio.Open(
|
|
File => File,
|
|
Mode => dio.In_File,
|
|
Name => path);
|
|
|
|
Put_Line("File opened");
|
|
|
|
String'Write(channel, "HTTP/1.0 200 OK" & newline);
|
|
String'Write(channel, "Server: Ada Server 0.1" &
|
|
newline);
|
|
|
|
Put_Line("Root path: " & root_path & path);
|
|
Put_Line("File size: " & Natural'Image(sz));
|
|
|
|
dio.Read (File, Item => contents);
|
|
Put_Line("Contents: " & contents & newline);
|
|
String'Write(channel, newline);
|
|
String'Write(channel, contents);
|
|
|
|
dio.Close(File);
|
|
Put_Line("Closed file");
|
|
|
|
Close_Socket(s);
|
|
Put_Line("Closed socket");
|
|
finished := True;
|
|
end Handle_File;
|
|
|
|
procedure Handle_Socket(s: Socket_Type; finished: out Boolean) is
|
|
subtype Line_Type is String (1 .. 4096);
|
|
channel : Stream_Access := Stream (s);
|
|
line : Line_Type;
|
|
elem_line : Stream_Element_Array (1 .. 4096);
|
|
last : Stream_Element_Offset;
|
|
|
|
package af renames Ada.Strings.Fixed;
|
|
|
|
function Convert is new Ada.Unchecked_Conversion (
|
|
Source => Stream_Element_Array,
|
|
Target => Line_Type
|
|
);
|
|
begin
|
|
Put_Line("Got command to execute");
|
|
channel := Stream (s);
|
|
Receive_Socket(s, elem_line, last);
|
|
line := Convert(elem_line);
|
|
Put("Odczytano: ");
|
|
Put(Integer(last), Width => 0);
|
|
Put_Line(" znakow");
|
|
if last >= 4 and line (1 .. 4) = "GET " then
|
|
Put_Line("GET Command: " & line);
|
|
|
|
declare
|
|
EOL : Integer := af.Index(line, newline);
|
|
HTTP_Version_Offset : Integer := af.Index(line, "HTTP/1.");
|
|
path : String := line (5..HTTP_Version_Offset - 2);
|
|
begin
|
|
if Exists (root_path & path) then
|
|
Put_Line("Kind: " & File_Kind'Image(Kind(root_path & path)));
|
|
if Kind(root_path & path) = Ordinary_File then
|
|
Put_Line("Full path: '" & root_path & path & "'");
|
|
handle_file(s,
|
|
root_path & path,
|
|
finished);
|
|
return;
|
|
else
|
|
-- pewnie katalog
|
|
if Exists(root_path & path & "index.html") then
|
|
handle_file(s,
|
|
root_path & path &
|
|
"index.html",
|
|
finished);
|
|
|
|
return;
|
|
end if;
|
|
|
|
if Exists(root_path & path & "index.htm") then
|
|
handle_file(s,
|
|
root_path & path &
|
|
"index.htm",
|
|
finished);
|
|
|
|
return;
|
|
end if;
|
|
|
|
String'Write(channel, "HTTP/1.0 200 OK" & newline);
|
|
String'Write(channel, "Server: Ada Server 0.1" &
|
|
newline & newline);
|
|
String'Write(channel, "<html><body>" &
|
|
"directory</body></html>" & newline);
|
|
end if;
|
|
else
|
|
String'Write (channel, "HTTP/1.0 404 NOT FOUND" &
|
|
newline);
|
|
String'Write (channel, "Server: Ada Server 0.1" &
|
|
newline & newline);
|
|
String'Write (channel, "<html><body>" &
|
|
"404 Error</body></html>");
|
|
end if;
|
|
end;
|
|
|
|
else
|
|
String'Write(channel, "Unknown" & newline);
|
|
end if;
|
|
Put_Line("Closing socket");
|
|
Close_Socket(s);
|
|
finished := True;
|
|
end Handle_Socket;
|
|
|
|
idx : Integer;
|
|
|
|
begin
|
|
accept start(id: Integer) do
|
|
idx := id;
|
|
end start;
|
|
|
|
Watcher.Start;
|
|
|
|
Put("start client handler with id: ");
|
|
Put(idx, Width => 0);
|
|
New_Line;
|
|
loop
|
|
select
|
|
accept handle(s: Socket_Type) do
|
|
socket := s;
|
|
v.Append(s);
|
|
end handle;
|
|
Abort_Selector(sel.all);
|
|
Put_Line("Socket consumed by client handler");
|
|
or
|
|
accept command(s: Socket_Type) do
|
|
declare
|
|
finished: Boolean;
|
|
begin
|
|
Handle_Socket(s, finished);
|
|
if finished then
|
|
v.Delete(v.Find_Index(s));
|
|
end if;
|
|
end;
|
|
end command;
|
|
or
|
|
accept stop do
|
|
Put_Line("Got command to stop");
|
|
working := False;
|
|
Abort_Selector(sel.all);
|
|
end stop;
|
|
exit;
|
|
or
|
|
terminate;
|
|
end select;
|
|
end loop;
|
|
Put_Line("end client handler");
|
|
end handler;
|
|
|
|
end handlers;
|