with Sockets.Multicast;
use Sockets, Sockets.Multicast;
 
procedure Main is
 
   Multi_Sock_Fd : Multicast_Socket_Fd :=
     Create_Multicast_Socket("224.1.0.0", 4161);
--     Create_Multicast_Socket(Argument(1), Integer'Value
--                             (Argument(2)));
 
   task Hello;
   task body Hello is
   begin
      loop
         delay 2.0;
         Put(Multi_Sock_Fd, "hello::=" & "denimes.net" );
 
      end loop;
   end Hello;
 
begin
   null
end main;

type Inet_Addr_Type (Family : Family_Type := Family_Inet) is private;
   --  An Internet address depends on an address family (IPv4 contains 4
   --  octets and Ipv6 contains 16 octets). Any_Inet_Addr is a special value
   --  treated like a wildcard enabling all addresses. No_Inet_Addr provides a
   --  special value to denote uninitialized inet addresses.
 
   Any_Inet_Addr : constant Inet_Addr_Type;
   No_Inet_Addr  : constant Inet_Addr_Type;
 
   type Sock_Addr_Type (Family : Family_Type := Family_Inet) is record
      Addr : Inet_Addr_Type (Family);   ----- C'EST LA, enfin, j'espere ??
      Port : Port_Type;
   end record;

-------------------------------------------------------------------------------
--  Description : envoye le message "Hello, my IP address is ", suivi de     --
--                l'image de l'adresse IP donnee en argument de ligne de     --
--                commande toute les 10 secondes pendant 35 secondes sur     --
--                le reseau Internet en multicast (tous les hotes du reseau. --
-------------------------------------------------------------------------------
 
with Text_Io;
with Ada.Command_Line;
with Gnat.Sockets;
use Gnat.Sockets;
with Ada.Exceptions;
use Ada.Exceptions;
procedure Main is
   type String_Access is access String;
   Internet_Address : Inet_Addr_Type := Inet_Addr(Ada.Command_Line.Argument(1));
   Multicast_Group : constant String := "239.255.128.128";
   Multicast_Port : Port_type := 55506;
 
 
   task Hello is
      entry Start;
      entry Stop;
   end Hello;
 
   task body Hello is
      End_Of_Hello : Boolean := false;
      Address : Sock_Addr_Type(Family_Inet);
      Socket  : Socket_Type;
      Channel : Stream_Access;
 
   begin
      accept Start;
      Address.Addr := Inet_Addr(Multicast_Group);
      Address.Port := Multicast_Port;
      Create_Socket(Socket, Family_Inet, Socket_datagram);
      Set_Socket_Option(Socket,
                        Socket_Level,
                        (Reuse_Address, True));
      Set_Socket_Option(Socket,
                        Ip_Protocol_For_Ip_Level,
                        (Add_Membership, Inet_Addr(Multicast_Group),
                         Any_Inet_Addr));
      Set_Socket_Option(Socket,
                        Ip_Protocol_For_Ip_Level,
                        (Multicast_Ttl, 1));
      Set_Socket_Option(Socket,
                        Ip_Protocol_For_Ip_Level,
                        (Multicast_loop, true));
 
      delay 0.2;
      Bind_Socket(Socket,Address);
      Channel := Stream(Socket);
      delay 0.2;
      while not End_Of_Hello Loop
         select
            accept Stop do
               Text_Io.Put_Line("Stop response" );
               End_Of_Hello := True;
 
            end Stop;
         or
            delay 0.0;
            Text_Io.Put_Line("Entree" );
            String'output(Channel,"Hello, my IP address is " );
            & Image(Internet_Address));
            Text_Io.Put_Line("Sortie" );
            delay 2.0;
         end select;
      end loop;
      Close_Socket(Socket);
   exception
      when Tasking_Error =>
         Close_Socket(Socket);
   end Hello;
 
begin
   Initialize;
 
   Text_Io.Put_line("Program begining." );
   Text_Io.New_Line;
 
   Hello.Start;
   delay 10.0;
   Text_Io.Put_Line("Call Stop" );
   Hello.Stop;
 
   Text_Io.New_Line;
   Text_Io.Put_line("Program terminated." );
 
   Finalize;
   abort Hello;
exception
   when E : others =>
      Text_Io.Put_Line(Exception_Name(E) & ": " & Exception_Message(E));
end Main;

----------------------
   -- Call_Synchronous --
   ----------------------
 
   --  Called from Call_Simple and Task_Entry_Call.
 
   procedure Call_Synchronous
     (Acceptor              : Task_ID;
      E                     : Task_Entry_Index;
      Uninterpreted_Data    : System.Address;
      Mode                  : Call_Modes;
      Rendezvous_Successful : out Boolean)
   is
      Self_Id    : constant Task_ID := STPO.Self;
      Level      : ATC_Level;
      Entry_Call : Entry_Call_Link;
 
   begin
      pragma Assert (Mode /= Asynchronous_Call);
 
      Local_Defer_Abort (Self_Id);
      Self_Id.ATC_Nesting_Level := Self_Id.ATC_Nesting_Level + 1;
      pragma Debug
        (Debug.Trace (Self_Id, "CS: entered ATC level: " &
         ATC_Level'Image (Self_Id.ATC_Nesting_Level), 'A'));
      Level := Self_Id.ATC_Nesting_Level;
      Entry_Call := Self_Id.Entry_Calls (Level)'Access;
      Entry_Call.Next := null;
      Entry_Call.Mode := Mode;
      Entry_Call.Cancellation_Attempted := False;
 
      if Parameters.Runtime_Traces then
         Send_Trace_Info (W_Call, Acceptor, Entry_Index (E));
      end if;
 
      --  If this is a call made inside of an abort deferred region,
      --  the call should be never abortable.
 
      if Self_Id.Deferral_Level > 1 then
         Entry_Call.State := Never_Abortable;
      else
         Entry_Call.State := Now_Abortable;
      end if;
 
      Entry_Call.E := Entry_Index (E);
      Entry_Call.Prio := Get_Priority (Self_Id);
      Entry_Call.Uninterpreted_Data := Uninterpreted_Data;
      Entry_Call.Called_Task := Acceptor;
      Entry_Call.Exception_To_Raise := Ada.Exceptions.Null_Id;
 
      --  Note: the caller will undefer abort on return (see WARNING above)
 
      if Single_Lock then
         Lock_RTS;
      end if;
 
      if not Task_Do_Or_Queue
        (Self_Id, Entry_Call, With_Abort => True)
      then
         Self_Id.ATC_Nesting_Level := Self_Id.ATC_Nesting_Level - 1;
 
         if Single_Lock then
            Unlock_RTS;
         end if;
 
         if Parameters.Runtime_Traces then
            Send_Trace_Info (E_Missed, Acceptor);
         end if;
 
         Initialization.Undefer_Abort (Self_Id);
         pragma Debug
           (Debug.Trace (Self_Id, "CS: exited to ATC level: " &
            ATC_Level'Image (Self_Id.ATC_Nesting_Level), 'A'));
         raise Tasking_Error;
      end if;
 
      STPO.Write_Lock (Self_Id);
      pragma Debug
        (Debug.Trace (Self_Id, "Call_Synchronous: wait", 'R'));
      Entry_Calls.Wait_For_Completion (Entry_Call);
      pragma Debug
        (Debug.Trace (Self_Id, "Call_Synchronous: done waiting", 'R'));
      Rendezvous_Successful := Entry_Call.State = Done;
      STPO.Unlock (Self_Id);
 
      if Single_Lock then
         Unlock_RTS;
      end if;
 
      Local_Undefer_Abort (Self_Id);
      Entry_Calls.Check_Exception (Self_Id, Entry_Call);
   end Call_Synchronous;

with GNAT.Sockets; use GNAT.Sockets;
 
     with Ada.Text_IO;
     with Ada.Exceptions; use Ada.Exceptions;
 
     procedure Main_2 Is
        Group : constant String := "239.255.128.128";
        --  Multicast group: administratively scoped IP address
        task Pong is
           entry Start;
           entry Stop;
        end Pong;
 
        task body Pong is
           Address  : Sock_Addr_Type;
           Socket   : Socket_Type;
           Channel  : Stream_Access;
           End_Of_Hello : Boolean := False;
 
        begin
           accept Start;
           Create_Socket (Socket, Family_Inet, Socket_Datagram);
           Set_Socket_Option
             (Socket,
              Socket_Level,
              (Reuse_Address, True));
           Set_Socket_Option
             (Socket,
              IP_Protocol_For_IP_Level,
              (Add_Membership, Inet_Addr (Group), Any_Inet_Addr));
           Set_Socket_Option
             (Socket,
              IP_Protocol_For_IP_Level,
          (Multicast_TTL, 1));
           Set_Socket_Option
             (Socket,
              IP_Protocol_For_IP_Level,
              (Multicast_Loop, True));
           Address.Addr := Any_Inet_Addr;
           Address.Port := 55505;
           Bind_Socket (Socket, Address);
           Address.Addr := Inet_Addr (Group);
           Address.Port := 55506;
           Channel := Stream (Socket, Address);
           while not End_Of_Hello Loop
              select
                 accept Stop do
                    End_Of_Hello := True;
                 end Stop;
              or
                 delay 0.0;
                 declare
                    Message : String := "Hello, my IP address is ";
                 begin
                    String'Output (Channel, Message);
                 end;
              end select;
              delay(2.0);
           end loop;
           Close_Socket (Socket);
        exception when E : others =>
           Ada.Text_IO.Put_Line
             (Exception_Name (E) & ": " & Exception_Message (E));
       end Pong;
 
begin
        Initialize (Process_Blocking_IO => False);
        Pong.Start;
        delay 1.0;
        Pong.Stop;
        Finalize;
        Ada.Text_Io.Put("Please wait 5 seconds ..." );
        delay(5.0);        
end main_2;

with GNAT.Sockets; use GNAT.Sockets;
with Demon;
with Ada.Command_Line;
use Ada.Command_Line;
with Ada.Text_IO;
with Ada.Exceptions; use Ada.Exceptions;
 
procedure main is
 
   Group : constant String := "239.255.128.128";
 
   task Ping is
      entry Start;
      entry Stop;
   end Ping;
 
 
   task body Ping is
      ...
      ...
   end Ping;
 
begin
   if Ada.Command_Line.Argument_Count > 0 and then
     Ada.Command_Line.Argument(1) = "stop" then
      Demon.Start_Stop := True;
      abort Ping;
   else
      Demon.Start_Stop := false;
      Initialize (Process_Blocking_IO => false);
      Ping.Start;
      while not Demon.Start_Stop loop
         null;
         delay 0.5;
      end loop;
      Ping.Stop;
      Finalize;
   end if;
end main;

package Demon is
   pragma Shared_Passive(Demon);
   Start_Stop : Boolean := False;
end Demon;

with GNAT.Sockets; use GNAT.Sockets;
with Demon;
with Ada.Command_Line;
use Ada.Command_Line;
with Ada.Text_IO;
with Ada.Exceptions; use Ada.Exceptions;
 
procedure main is
 
        task Pong is
           entry Start;
           entry Stop;
        end Pong;
 
        task body Pong is
           Address  : Sock_Addr_Type;
           Server   : Socket_Type;
           Channel  : Stream_Access;
           End_Of_Server : Boolean := False;
        begin
           accept Start;
           Address.Addr := Addresses (Get_Host_By_Name (Host_Name), 1);
           Address.Port := 5876;
           Create_Socket (Server);
           Set_Socket_Option
             (Server,
              Socket_Level,
              (Reuse_Address, True));
           Bind_Socket (Server, Address);
           Listen_Socket (Server);
             Channel := Stream (server);
           delay 0.2;
           while not End_Of_Server loop
              select
                 accept Stop do
                    End_Of_Server := True;
                 end Stop;
              or
                 delay 0.0;
                   declare
                      Message : String := String'Input (Channel);
 
                   begin
                      Ada.Text_IO.Put_Line("Message from " &
                                           Image(Get_Address(channel)) & " ::=" );
                      Ada.Text_IO.Put_Line (Message);
                   end;
              end select;
           end loop;
           Close_Socket (Server);
        end Pong;
 
 
begin
   if Ada.Command_Line.Argument_Count > 0 and then
     Ada.Command_Line.Argument(1) = "stop" then
      Demon.Start_Stop := True;
      abort pong;
   else
      Demon.Start_Stop := false;
      Initialize (Process_Blocking_IO => false);
      Pong.Start;
      while not Demon.Start_Stop loop
         null;
         delay 0.5;
      end loop;
      Pong.Stop;
      Finalize;
   end if;
end main;

with GNAT.Sockets; use GNAT.Sockets;
With Ada.Command_Line;
with Ada.Text_IO;
with Ada.Exceptions; use Ada.Exceptions;
 
procedure main is
 
 
   task Pong is
      entry Start;
           entry Stop;
        end Pong;
 
        task body Pong is
           Address  : Sock_Addr_Type;
           Socket   : Socket_Type;
           server   : Socket_Type;
           Channel  : Stream_Access;
 
        begin
           accept Start;
           Address.Addr := Addresses (Get_Host_By_Name ("denimes.net" ), 1);
           Address.Port := 5876;
 
           Create_Socket (socket);
           Set_Socket_Option
             (socket,
              Socket_Level,
              (Reuse_Address, True));
       
           Connect_Socket(Socket, Address);
           Channel := Stream (Socket);
           delay 0.2;
           declare
              Message : String := );
           begin
                            String'output (Channel, message);
           end;
           Close_Socket (Socket);
           accept Stop;
        exception when E : others =>
           Ada.Text_IO.Put_Line
             (Exception_Name (E) & ": " & Exception_Message (E));
        end Pong;
 
     begin
        Initialize (Process_Blocking_IO => False);
        Pong.Start;
        Pong.Stop;
        Finalize;
   end main;

-- Je cre et j'initialise 2 taches serveur_enfants qui attendent stop ou init et
--qui a  leur tour cre une taches qui ecoute sur le port 5876 qui attend init et
--qui sera avorte a l'apelle de stop du serveur_enfant. j'appelle init, j'attend 
--2 secondes et j'appelle stop 
with Text_Io;
use Text_Io;
with Gnat.Sockets;
use Gnat.Sockets;
with Ada.Exceptions;
use Ada.Exceptions;
procedure Main is
 
   task type T_T_Listen is
      entry Init(Socket : in out Socket_Type;
                 Server : Socket_Type);
   end T_T_Listen;
 
   task body T_T_listen is
      Is_Init : Boolean := False;
      Serv : Socket_Type;
      Sock : Socket_Type;
      Address: Sock_Addr_Type;
      Channel : Stream_Access;
   begin
      loop
         select
            when not Is_Init =>
            accept Init(Socket : in out Socket_Type;
                        Server : Socket_Type) do
               if Socket = No_socket then
                  raise Program_Error;
               end if;
               Serv := Server;
               Sock := Socket;
               Address.Addr := Addresses(Get_Host_By_Name(Host_Name));
               Address.Port := 5876;
               Bind_socket(Server, Address);
               Is_Init := True;
            end Init;
         or
            delay 0.0;
            if Is_Init then
               Listen_Socket(Serv);
               Accept_Socket(Serv, Sock, Address);
               Channel := Stream(Sock);
               Text_Io.Put_Line("Message from " & Image(Get_Address(Channel)));
               Text_Io.Put(String'Input(Channel));
            end if;
         end select;
      end loop;
   exception
      when E : Program_Error =>
         Text_Io.Put_Line(Exception_Name(E) & ": " & Exception_Message(E));
   end T_T_Listen;
 
   task type T_T_Server_Child is
      entry Init;
      entry Stop;
   end T_T_Server_Child;
 
   task body T_T_Server_Child is
      Server : Socket_Type;
      Socket : Socket_Type;
      Listened : T_T_Listen;
      Is_Init : Boolean := False;
      End_Of_Child : Boolean := False;
   begin
      while not End_Of_Child loop
         select
            accept Stop do
               abort Listened;
               Close_socket(Server);
               Close_socket(Socket);
               End_Of_Child := True;
            end Stop;
         or
            when not Is_Init =>
            accept Init do
               Create_Socket(Server);
               Listened.Init(Socket,Server);
               Is_Init := true;
            end Init;
         end select;
      end loop;
   end T_T_Server_Child;
 
   The_World : array(1..2) of T_T_Server_Child;
 
begin
   for Server in The_World'Range loop
      The_World(Server).Init;
   end loop;
   delay 2.0;
   for Server in The_World'Range loop
      The_World(Server).Stop;
   end loop;
end Main;

type Listened_Access is access T_T_Listen;
 
   task body T_T_Server_Child is
      Listened : Listened_Access;
      Is_Init : Boolean := False;
      End_Of_Child : Boolean := False;
   begin
      while not End_Of_Child loop
         select
            when Is_Init =>
            accept Stop do
               abort Listened.all;
               End_Of_Child := True;
            end Stop;
         or
            when not Is_Init =>
               accept Init(Id : Natural) do
                  Listened := new T_T_Listen;
               Listened.all.Init(Id);
               Is_Init := True;
               end Init;
         or
            delay 0.0;
              null;
         end select;
      end loop;
   end T_T_Server_Child;

type child_Access is access all T_T_Server_Child;
 
   type Server_Access is access all T_T_Server_Child;
 
   package P_Server_Access_Convertion is 
      new Address_To_Access_Conversions(T_T_Server_child);
   use P_Server_Access_Convertion;
 
 
      type Server_Child_Threaded is
      record
         Id : Task_Id;
         Child : object_pointer;
         S_address : System.Address;
      end record;
 
   The_World : array(1..2) of Server_Child_threaded;
 
begin
   Text_Io.Put_Line("Begin ..." );
   for id in The_World'Range loop
      
      Text_Io.Put_Line("entering The world ..." );
      
      The_World(id).Child := new T_T_Server_Child;
      
      The_World(id).S_Address := 
    Create_Thread(To_Address(The_World(id).child),null,2048,14);
      
      The_World(id).Child.Init(Id);
      
      Text_Io.Put_Line("exiting The world ..." );
   end loop;
   
   delay 100.0;
   
   for id in 1..The_World'length loop
      The_World(id).Child.Stop;
   end loop;
   
end Main;

task Mode_Connection_Reseau is
            entry Recevoir(Un : in Character);
         end Mode_Connection_Reseau;
         task body Mode_Connection_Reseau is
            type T_Cmd is (Null_Item, Quit,
                           Connect, Deconnect,
                           Send_Real, Send_Prev, receive);
            function Value(Command : String) return T_Cmd is
               First_Space : positive := 1;
            begin
               while Command(First_Space) /= ' ' and then
                 First_space < Command'Length loop
                  First_Space := First_Space + 1;
               end loop;
               return T_Cmd'Value(Command(Index_Non_Blank(Command)..First_Space));
            exception
               when others =>
                  return Null_Item;
            end Value;
 
            Server_Name : String_Access;
            Address : Sock_Addr_Type;
            Port : Port_Type := 5876;
            Socket : Socket_Type;
            Channel : Stream_Access;
            Connected : Boolean := False;
            Command : T_Cmd;
            Line : String(1..256) := (others => Ascii.Nul);
            Last : Natural := 0;
         begin
            loop
               begin
                  Initialize;
                  while not End_Of_Program loop
                     select
                        accept
                          Recevoir(Un : in Character) do
                           case Un is
                              when Character'Val(10) =>
                                 if Last /= 0 then
                                    case Line(1) is
                                       when others =>
                                          Command := Value(Line(1..Last));
                                          case Command is
                                             when Null_Item =>
                                                declare
                                                   Char : Character;
                                                begin
                                                   New_Line;
                                                   Res := System(Line(1..Last) & Ascii.nul);
                                                   Put("(press any key to continu)" );
                                                   Get_Immediate(Char);
                                                end;
                                             when Quit =>
                                                if Data /= null then
                                                   P_Reel.Save(Data.all);
                                                end if;
                                                if Echeances /= null then
                                                   P_Previsionnel.Save(Prev.all);
                                                end if;
                                                Close_Socket(Socket);
                                                End_Of_Program := True;
                                             when Connect =>
                                                if not Connected then
                                                   Server_Name := new String'
                                                     (Line(Index(Line," " )+1..Last));
                                                   Address.Addr :=
                                                     Addresses(Get_Host_By_Name(Server_Name.all));
                                                   Address.Port := Port;
                                                   Create_Socket(Socket);
                                                   Set_Socket_Option
                                                     (socket,
                                                      Socket_Level,
                                                      (Reuse_Address, True));
                                                   Put_Line("Please, wait 10 seceonds." );
                                                   Connect_Socket(Socket, Address);
                                                   Channel := Stream (Socket);
                                                   Connected := True;
                                                end if;
                                             when Deconnect =>
                                                Close_Socket(Socket);
                                                Connected := False;
 
                                             when Send_Real =>
                                                null;
                                             when Send_Prev =>
                                                null;
                                             when Receive =>
                                                null;
                                          end case;
                                    end case;
                                 end if;
                                 Last := 0;
                                 Line := (others => Ascii.Nul);
                              when Ascii.Del | Ascii.Bs =>
                                 if last /= 0 then
                                    Line(last) := ' ' ;
                                    last := last - 1 ;
 
                                 else
                                      Put(Ascii.Bel);
                                 end if;
                              when others =>
                                 Last := Last + 1;
                                 Line(Last) := Un;
                           end case;
                        end Recevoir;
                     or
                        delay(0.0);
                        if Mode = Connection_reseau then
                           Res := System("clear" & Ascii.Nul);
                           Put_line("--------------------------------------------------------------------------------" );
                           Put_line("--                         Mode connection_reseau                             --" );
                           Put_line("--------------------------------------------------------------------------------" );
                           Put_line("Connected : " & Boolean'Image(Connected));
                           New_Line(19);
                           Put(Line(1..Last));
                           delay 0.075;
                        end if;
                     end select;
                  end loop;
                  Finalize;
               exception
                  when E : Gnat.Sockets.Host_error =>
                     Put_Line
                       (Exception_Name (E) &
                        ": " &
                        Exception_Message (E));
                     delay(5.0);
               end;
               exit;
            end loop;
         end Mode_Connection_reseau;

when Send_Real =>
        for I in 1..Nombre_D_Operation(1) loop
             Lire_Operation(1,Operation,I);
             T_operation'Output(Channel,Operation);
        end loop;

with GNAT.Sockets; use GNAT.Sockets;
with Ada.Text_IO;
with Ada.Exceptions; use Ada.Exceptions;
with P_Types_Banquaire;
use P_Types_Banquaire;
procedure main is
 
        task Pong is
           entry Start;
        end Pong;
 
        task body Pong is
           Address  : Sock_Addr_Type;
           Server   : Socket_Type;
           Socket   : Socket_Type;
           Channel  : Stream_Access;
           End_Of_Server : Boolean := False;
        begin
           accept Start;
 
           Address.Addr := Addresses (Get_Host_By_Name (Host_name), 1);
 
           Address.Port := 5876;
           Ada.Text_Io.Put_Line("Address is " & Image(Address));
 
           Create_Socket (Server);
 
           Set_Socket_Option
             (Server,
              Socket_Level,
              (Reuse_Address, True));
           Bind_Socket (Server, Address);
           delay 0.2;
           Listen_Socket (Server);
           loop
              Accept_Socket(Server,Socket,address);
              Channel := Stream (socket);
              loop
                 declare
                    Message : T_operation := T_operation'Input (Channel);
                 begin
                    Ada.Text_IO.Put_Line("Message from " &
                                         Image(Get_Address(channel)) & " ::=" );
                    Ada.Text_IO.Put_Line (Message.libelle);
                 end;
              end loop;
           end loop;
           Close_Socket (Server);
        end Pong;
begin
      Initialize (Process_Blocking_IO => false);
      Pong.Start;
      Finalize;
end main;

type Server_Access is access all Pong;
        Server : Server_Access;
        Current_Task_id : Task_Id := Null_Task_Id;
begin
   loop
      if Current_Task_Id = Null_Task_Id or else
--        Is_terminated(Current_Task_Id) then
         not Is_Callable(Current_Task_Id) then
         Server := new Pong;
         Initialize (Process_Blocking_IO => false);
         Server.all.Get_Id(Current_Task_Id);
         Server.all.Start;
         Finalize;
      end if;
      delay(1.0);
   end loop;
end main;

with Ada.Text_Io;
use Ada.Text_Io;
with Ada.Task_Identification;
use Ada.Task_Identification;
with GNAT.Sockets; use GNAT.Sockets;
with Ada.Exceptions; use Ada.Exceptions;
with P_Types_Banquaire;
use P_Types_Banquaire;
with Ada.Unchecked_Deallocation;
procedure main is
 
 
   task type Pong is
      entry Start(Socket : in out Socket_Type);
   end Pong;
   task body Pong is
      Channel  : Stream_Access;
      Nombre_D_Operation : positive;
   begin
      accept Start(Socket : in out Socket_Type) do
      Channel := Stream (socket);
      Nombre_D_Operation := positive'Input(Channel);
      for I in 1..Nombre_D_Operation loop
         declare
            Message : T_operation := T_operation'Input (Channel);
         begin
            Ada.Text_IO.Put_Line("Message from " &
                                 Image(Get_Address(channel)) & " ::=" );
            Ada.Text_IO.Put_Line (Message.libelle);
         end;
      end loop;
      end Start;
   end Pong;
   type Serv_Access is access Pong;
   Serv : Serv_access;
   Address  : Sock_Addr_Type;
   Server   : Socket_Type;
   Socket   : Socket_Type;
begin
   Serv := new Pong;
   Address.Addr := Addresses (Get_Host_By_Name (Host_name), 1);
   Address.Port := 5876;
   Create_Socket (Server);
   Set_Socket_Option
     (Server,
      Socket_Level,
      (Reuse_Address, True));
   Initialize (Process_Blocking_IO => false);
   Bind_Socket (Server, Address);
   delay 0.2;
   Ada.Text_Io.Put_Line("Listen ..." );
   Listen_Socket (Server);
   Ada.Text_Io.Put_Line("Accetp ..." );
   Accept_Socket(Server,Socket,address);
   Put_Line("Starting server ... " );
   Ada.Text_Io.Put_Line("Address is " & Image(Address));
   Serv.Start(Socket);
   loop
      Close_Socket(Socket);
      delay 0.2;
      Ada.Text_Io.Put_Line("Listen ..." );
      Listen_Socket (Server);
      Ada.Text_Io.Put_Line("Accept ..." );
      Accept_Socket(Server,Socket,address);
      Put_Line("Starting server ... " );
      Ada.Text_Io.Put_Line("Address is " & Image(Address));
      Serv := new Pong;
      Serv.Start(Socket);
      delay(2.0);
   end loop;
   Close_Socket(Server);
   Finalize;
end main;