OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [ada/] [g-socthi-mingw.adb] - Blame information for rev 706

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 706 jeremybenn
------------------------------------------------------------------------------
2
--                                                                          --
3
--                         GNAT COMPILER COMPONENTS                         --
4
--                                                                          --
5
--                    G N A T . S O C K E T S . T H I N                     --
6
--                                                                          --
7
--                                 B o d y                                  --
8
--                                                                          --
9
--                    Copyright (C) 2001-2011, AdaCore                      --
10
--                                                                          --
11
-- GNAT is free software;  you can  redistribute it  and/or modify it under --
12
-- terms of the  GNU General Public License as published  by the Free Soft- --
13
-- ware  Foundation;  either version 3,  or (at your option) any later ver- --
14
-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
15
-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
16
-- or FITNESS FOR A PARTICULAR PURPOSE.                                     --
17
--                                                                          --
18
-- As a special exception under Section 7 of GPL version 3, you are granted --
19
-- additional permissions described in the GCC Runtime Library Exception,   --
20
-- version 3.1, as published by the Free Software Foundation.               --
21
--                                                                          --
22
-- You should have received a copy of the GNU General Public License and    --
23
-- a copy of the GCC Runtime Library Exception along with this program;     --
24
-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
25
-- <http://www.gnu.org/licenses/>.                                          --
26
--                                                                          --
27
-- GNAT was originally developed  by the GNAT team at  New York University. --
28
-- Extensive contributions were provided by Ada Core Technologies Inc.      --
29
--                                                                          --
30
------------------------------------------------------------------------------
31
 
32
--  This package provides a target dependent thin interface to the sockets
33
--  layer for use by the GNAT.Sockets package (g-socket.ads). This package
34
--  should not be directly with'ed by an applications program.
35
 
36
--  This version is for NT
37
 
38
with Ada.Streams;             use Ada.Streams;
39
with Ada.Unchecked_Conversion;
40
with Interfaces.C.Strings;    use Interfaces.C.Strings;
41
with System;                  use System;
42
with System.Storage_Elements; use System.Storage_Elements;
43
 
44
package body GNAT.Sockets.Thin is
45
 
46
   use type C.unsigned;
47
   use type C.int;
48
 
49
   WSAData_Dummy : array (1 .. 512) of C.int;
50
 
51
   WS_Version : constant := 16#0202#;
52
   --  Winsock 2.2
53
 
54
   Initialized : Boolean := False;
55
 
56
   function Standard_Connect
57
     (S       : C.int;
58
      Name    : System.Address;
59
      Namelen : C.int) return C.int;
60
   pragma Import (Stdcall, Standard_Connect, "connect");
61
 
62
   function Standard_Select
63
     (Nfds      : C.int;
64
      Readfds   : access Fd_Set;
65
      Writefds  : access Fd_Set;
66
      Exceptfds : access Fd_Set;
67
      Timeout   : Timeval_Access) return C.int;
68
   pragma Import (Stdcall, Standard_Select, "select");
69
 
70
   type Error_Type is
71
     (N_EINTR,
72
      N_EBADF,
73
      N_EACCES,
74
      N_EFAULT,
75
      N_EINVAL,
76
      N_EMFILE,
77
      N_EWOULDBLOCK,
78
      N_EINPROGRESS,
79
      N_EALREADY,
80
      N_ENOTSOCK,
81
      N_EDESTADDRREQ,
82
      N_EMSGSIZE,
83
      N_EPROTOTYPE,
84
      N_ENOPROTOOPT,
85
      N_EPROTONOSUPPORT,
86
      N_ESOCKTNOSUPPORT,
87
      N_EOPNOTSUPP,
88
      N_EPFNOSUPPORT,
89
      N_EAFNOSUPPORT,
90
      N_EADDRINUSE,
91
      N_EADDRNOTAVAIL,
92
      N_ENETDOWN,
93
      N_ENETUNREACH,
94
      N_ENETRESET,
95
      N_ECONNABORTED,
96
      N_ECONNRESET,
97
      N_ENOBUFS,
98
      N_EISCONN,
99
      N_ENOTCONN,
100
      N_ESHUTDOWN,
101
      N_ETOOMANYREFS,
102
      N_ETIMEDOUT,
103
      N_ECONNREFUSED,
104
      N_ELOOP,
105
      N_ENAMETOOLONG,
106
      N_EHOSTDOWN,
107
      N_EHOSTUNREACH,
108
      N_WSASYSNOTREADY,
109
      N_WSAVERNOTSUPPORTED,
110
      N_WSANOTINITIALISED,
111
      N_WSAEDISCON,
112
      N_HOST_NOT_FOUND,
113
      N_TRY_AGAIN,
114
      N_NO_RECOVERY,
115
      N_NO_DATA,
116
      N_OTHERS);
117
 
118
   Error_Messages : constant array (Error_Type) of chars_ptr :=
119
     (N_EINTR =>
120
        New_String ("Interrupted system call"),
121
      N_EBADF =>
122
        New_String ("Bad file number"),
123
      N_EACCES =>
124
        New_String ("Permission denied"),
125
      N_EFAULT =>
126
        New_String ("Bad address"),
127
      N_EINVAL =>
128
        New_String ("Invalid argument"),
129
      N_EMFILE =>
130
        New_String ("Too many open files"),
131
      N_EWOULDBLOCK =>
132
        New_String ("Operation would block"),
133
      N_EINPROGRESS =>
134
        New_String ("Operation now in progress. This error is "
135
                    & "returned if any Windows Sockets API "
136
                    & "function is called while a blocking "
137
                    & "function is in progress"),
138
      N_EALREADY =>
139
        New_String ("Operation already in progress"),
140
      N_ENOTSOCK =>
141
        New_String ("Socket operation on nonsocket"),
142
      N_EDESTADDRREQ =>
143
        New_String ("Destination address required"),
144
      N_EMSGSIZE =>
145
        New_String ("Message too long"),
146
      N_EPROTOTYPE =>
147
        New_String ("Protocol wrong type for socket"),
148
      N_ENOPROTOOPT =>
149
        New_String ("Protocol not available"),
150
      N_EPROTONOSUPPORT =>
151
        New_String ("Protocol not supported"),
152
      N_ESOCKTNOSUPPORT =>
153
        New_String ("Socket type not supported"),
154
      N_EOPNOTSUPP =>
155
        New_String ("Operation not supported on socket"),
156
      N_EPFNOSUPPORT =>
157
        New_String ("Protocol family not supported"),
158
      N_EAFNOSUPPORT =>
159
        New_String ("Address family not supported by protocol family"),
160
      N_EADDRINUSE =>
161
        New_String ("Address already in use"),
162
      N_EADDRNOTAVAIL =>
163
        New_String ("Cannot assign requested address"),
164
      N_ENETDOWN =>
165
        New_String ("Network is down. This error may be "
166
                    & "reported at any time if the Windows "
167
                    & "Sockets implementation detects an "
168
                    & "underlying failure"),
169
      N_ENETUNREACH =>
170
        New_String ("Network is unreachable"),
171
      N_ENETRESET =>
172
        New_String ("Network dropped connection on reset"),
173
      N_ECONNABORTED =>
174
        New_String ("Software caused connection abort"),
175
      N_ECONNRESET =>
176
        New_String ("Connection reset by peer"),
177
      N_ENOBUFS =>
178
        New_String ("No buffer space available"),
179
      N_EISCONN  =>
180
        New_String ("Socket is already connected"),
181
      N_ENOTCONN =>
182
        New_String ("Socket is not connected"),
183
      N_ESHUTDOWN =>
184
        New_String ("Cannot send after socket shutdown"),
185
      N_ETOOMANYREFS =>
186
        New_String ("Too many references: cannot splice"),
187
      N_ETIMEDOUT =>
188
        New_String ("Connection timed out"),
189
      N_ECONNREFUSED =>
190
        New_String ("Connection refused"),
191
      N_ELOOP =>
192
        New_String ("Too many levels of symbolic links"),
193
      N_ENAMETOOLONG =>
194
        New_String ("File name too long"),
195
      N_EHOSTDOWN =>
196
        New_String ("Host is down"),
197
      N_EHOSTUNREACH =>
198
        New_String ("No route to host"),
199
      N_WSASYSNOTREADY =>
200
        New_String ("Returned by WSAStartup(), indicating that "
201
                    & "the network subsystem is unusable"),
202
      N_WSAVERNOTSUPPORTED =>
203
        New_String ("Returned by WSAStartup(), indicating that "
204
                    & "the Windows Sockets DLL cannot support "
205
                    & "this application"),
206
      N_WSANOTINITIALISED =>
207
        New_String ("Winsock not initialized. This message is "
208
                    & "returned by any function except WSAStartup(), "
209
                    & "indicating that a successful WSAStartup() has "
210
                    & "not yet been performed"),
211
      N_WSAEDISCON =>
212
        New_String ("Disconnected"),
213
      N_HOST_NOT_FOUND =>
214
        New_String ("Host not found. This message indicates "
215
                    & "that the key (name, address, and so on) was not found"),
216
      N_TRY_AGAIN =>
217
        New_String ("Nonauthoritative host not found. This error may "
218
                    & "suggest that the name service itself is not "
219
                    & "functioning"),
220
      N_NO_RECOVERY =>
221
        New_String ("Nonrecoverable error. This error may suggest that the "
222
                    & "name service itself is not functioning"),
223
      N_NO_DATA =>
224
        New_String ("Valid name, no data record of requested type. "
225
                    & "This error indicates that the key (name, address, "
226
                    & "and so on) was not found."),
227
      N_OTHERS =>
228
        New_String ("Unknown system error"));
229
 
230
   ---------------
231
   -- C_Connect --
232
   ---------------
233
 
234
   function C_Connect
235
     (S       : C.int;
236
      Name    : System.Address;
237
      Namelen : C.int) return C.int
238
   is
239
      Res : C.int;
240
 
241
   begin
242
      Res := Standard_Connect (S, Name, Namelen);
243
 
244
      if Res = -1 then
245
         if Socket_Errno = SOSC.EWOULDBLOCK then
246
            Set_Socket_Errno (SOSC.EINPROGRESS);
247
         end if;
248
      end if;
249
 
250
      return Res;
251
   end C_Connect;
252
 
253
   ------------------
254
   -- Socket_Ioctl --
255
   ------------------
256
 
257
   function Socket_Ioctl
258
     (S   : C.int;
259
      Req : C.int;
260
      Arg : access C.int) return C.int
261
   is
262
   begin
263
      return C_Ioctl (S, Req, Arg);
264
   end Socket_Ioctl;
265
 
266
   ---------------
267
   -- C_Recvmsg --
268
   ---------------
269
 
270
   function C_Recvmsg
271
     (S     : C.int;
272
      Msg   : System.Address;
273
      Flags : C.int) return System.CRTL.ssize_t
274
   is
275
      use type C.size_t;
276
 
277
      Fill  : constant Boolean :=
278
                SOSC.MSG_WAITALL /= -1
279
                  and then (C.unsigned (Flags) and SOSC.MSG_WAITALL) /= 0;
280
      --  Is the MSG_WAITALL flag set? If so we need to fully fill all vectors
281
 
282
      Res   : C.int;
283
      Count : C.int := 0;
284
 
285
      MH : Msghdr;
286
      for MH'Address use Msg;
287
 
288
      Iovec : array (0 .. MH.Msg_Iovlen - 1) of Vector_Element;
289
      for Iovec'Address use MH.Msg_Iov;
290
      pragma Import (Ada, Iovec);
291
 
292
      Iov_Index     : Integer;
293
      Current_Iovec : Vector_Element;
294
 
295
      function To_Access is new Ada.Unchecked_Conversion
296
                                  (System.Address, Stream_Element_Reference);
297
      pragma Warnings (Off, Stream_Element_Reference);
298
 
299
      Req : Request_Type (Name => N_Bytes_To_Read);
300
 
301
   begin
302
      --  Windows does not provide an implementation of recvmsg(). The spec for
303
      --  WSARecvMsg() is incompatible with the data types we define, and is
304
      --  available starting with Windows Vista and Server 2008 only. So,
305
      --  we use C_Recv instead.
306
 
307
      --  Check how much data are available
308
 
309
      Control_Socket (Socket_Type (S), Req);
310
 
311
      --  Fill the vectors
312
 
313
      Iov_Index := -1;
314
      Current_Iovec := (Base => null, Length => 0);
315
 
316
      loop
317
         if Current_Iovec.Length = 0 then
318
            Iov_Index := Iov_Index + 1;
319
            exit when Iov_Index > Integer (Iovec'Last);
320
            Current_Iovec := Iovec (SOSC.Msg_Iovlen_T (Iov_Index));
321
         end if;
322
 
323
         Res :=
324
           C_Recv
325
            (S,
326
             Current_Iovec.Base.all'Address,
327
             C.int (Current_Iovec.Length),
328
             Flags);
329
 
330
         if Res < 0 then
331
            return System.CRTL.ssize_t (Res);
332
 
333
         elsif Res = 0 and then not Fill then
334
            exit;
335
 
336
         else
337
            pragma Assert (Stream_Element_Count (Res) <= Current_Iovec.Length);
338
 
339
            Count := Count + Res;
340
            Current_Iovec.Length :=
341
              Current_Iovec.Length - Stream_Element_Count (Res);
342
            Current_Iovec.Base :=
343
              To_Access (Current_Iovec.Base.all'Address
344
                + Storage_Offset (Res));
345
 
346
            --  If all the data that was initially available read, do not
347
            --  attempt to receive more, since this might block, or merge data
348
            --  from successive datagrams for a datagram-oriented socket. We
349
            --  still try to receive more if we need to fill all vectors
350
            --  (MSG_WAITALL flag is set).
351
 
352
            exit when Natural (Count) >= Req.Size
353
              and then
354
 
355
                --  Either we are not in fill mode
356
 
357
                (not Fill
358
 
359
                  --  Or else last vector filled
360
 
361
                  or else (Interfaces.C.size_t (Iov_Index) = Iovec'Last
362
                            and then Current_Iovec.Length = 0));
363
         end if;
364
      end loop;
365
 
366
      return System.CRTL.ssize_t (Count);
367
   end C_Recvmsg;
368
 
369
   --------------
370
   -- C_Select --
371
   --------------
372
 
373
   function C_Select
374
     (Nfds      : C.int;
375
      Readfds   : access Fd_Set;
376
      Writefds  : access Fd_Set;
377
      Exceptfds : access Fd_Set;
378
      Timeout   : Timeval_Access) return C.int
379
   is
380
      pragma Warnings (Off, Exceptfds);
381
 
382
      Original_WFS : aliased constant Fd_Set := Writefds.all;
383
 
384
      Res  : C.int;
385
      S    : aliased C.int;
386
      Last : aliased C.int;
387
 
388
   begin
389
      --  Asynchronous connection failures are notified in the exception fd
390
      --  set instead of the write fd set. To ensure POSIX compatibility, copy
391
      --  write fd set into exception fd set. Once select() returns, check any
392
      --  socket present in the exception fd set and peek at incoming
393
      --  out-of-band data. If the test is not successful, and the socket is
394
      --  present in the initial write fd set, then move the socket from the
395
      --  exception fd set to the write fd set.
396
 
397
      if Writefds /= No_Fd_Set_Access then
398
 
399
         --  Add any socket present in write fd set into exception fd set
400
 
401
         declare
402
            WFS : aliased Fd_Set := Writefds.all;
403
         begin
404
            Last := Nfds - 1;
405
            loop
406
               Get_Socket_From_Set
407
                 (WFS'Access, S'Unchecked_Access, Last'Unchecked_Access);
408
               exit when S = -1;
409
               Insert_Socket_In_Set (Exceptfds, S);
410
            end loop;
411
         end;
412
      end if;
413
 
414
      Res := Standard_Select (Nfds, Readfds, Writefds, Exceptfds, Timeout);
415
 
416
      if Exceptfds /= No_Fd_Set_Access then
417
         declare
418
            EFSC    : aliased Fd_Set := Exceptfds.all;
419
            Flag    : constant C.int := SOSC.MSG_PEEK + SOSC.MSG_OOB;
420
            Buffer  : Character;
421
            Length  : C.int;
422
            Fromlen : aliased C.int;
423
 
424
         begin
425
            Last := Nfds - 1;
426
            loop
427
               Get_Socket_From_Set
428
                 (EFSC'Access, S'Unchecked_Access, Last'Unchecked_Access);
429
 
430
               --  No more sockets in EFSC
431
 
432
               exit when S = -1;
433
 
434
               --  Check out-of-band data
435
 
436
               Length :=
437
                 C_Recvfrom
438
                  (S, Buffer'Address, 1, Flag,
439
                   From    => System.Null_Address,
440
                   Fromlen => Fromlen'Unchecked_Access);
441
               --  Is Fromlen necessary if From is Null_Address???
442
 
443
               --  If the signal is not an out-of-band data, then it
444
               --  is a connection failure notification.
445
 
446
               if Length = -1 then
447
                  Remove_Socket_From_Set (Exceptfds, S);
448
 
449
                  --  If S is present in the initial write fd set, move it from
450
                  --  exception fd set back to write fd set. Otherwise, ignore
451
                  --  this event since the user is not watching for it.
452
 
453
                  if Writefds /= No_Fd_Set_Access
454
                    and then (Is_Socket_In_Set (Original_WFS'Access, S) /= 0)
455
                  then
456
                     Insert_Socket_In_Set (Writefds, S);
457
                  end if;
458
               end if;
459
            end loop;
460
         end;
461
      end if;
462
      return Res;
463
   end C_Select;
464
 
465
   ---------------
466
   -- C_Sendmsg --
467
   ---------------
468
 
469
   function C_Sendmsg
470
     (S     : C.int;
471
      Msg   : System.Address;
472
      Flags : C.int) return System.CRTL.ssize_t
473
   is
474
      use type C.size_t;
475
 
476
      Res   : C.int;
477
      Count : C.int := 0;
478
 
479
      MH : Msghdr;
480
      for MH'Address use Msg;
481
 
482
      Iovec : array (0 .. MH.Msg_Iovlen - 1) of Vector_Element;
483
      for Iovec'Address use MH.Msg_Iov;
484
      pragma Import (Ada, Iovec);
485
 
486
   begin
487
      --  Windows does not provide an implementation of sendmsg(). The spec for
488
      --  WSASendMsg() is incompatible with the data types we define, and is
489
      --  available starting with Windows Vista and Server 2008 only. So
490
      --  use C_Sendto instead.
491
 
492
      for J in Iovec'Range loop
493
         Res :=
494
           C_Sendto
495
            (S,
496
             Iovec (J).Base.all'Address,
497
             C.int (Iovec (J).Length),
498
             Flags => Flags,
499
             To    => MH.Msg_Name,
500
             Tolen => C.int (MH.Msg_Namelen));
501
 
502
         if Res < 0 then
503
            return System.CRTL.ssize_t (Res);
504
         else
505
            Count := Count + Res;
506
         end if;
507
 
508
         --  Exit now if the buffer is not fully transmitted
509
 
510
         exit when Stream_Element_Count (Res) < Iovec (J).Length;
511
      end loop;
512
 
513
      return System.CRTL.ssize_t (Count);
514
   end C_Sendmsg;
515
 
516
   --------------
517
   -- Finalize --
518
   --------------
519
 
520
   procedure Finalize is
521
   begin
522
      if Initialized then
523
         WSACleanup;
524
         Initialized := False;
525
      end if;
526
   end Finalize;
527
 
528
   -------------------------
529
   -- Host_Error_Messages --
530
   -------------------------
531
 
532
   package body Host_Error_Messages is
533
 
534
      --  On Windows, socket and host errors share the same code space, and
535
      --  error messages are provided by Socket_Error_Message, so the default
536
      --  separate body for Host_Error_Messages is not used in this case.
537
 
538
      function Host_Error_Message
539
        (H_Errno : Integer) return C.Strings.chars_ptr
540
         renames Socket_Error_Message;
541
 
542
   end Host_Error_Messages;
543
 
544
   ----------------
545
   -- Initialize --
546
   ----------------
547
 
548
   procedure Initialize is
549
      Return_Value : Interfaces.C.int;
550
   begin
551
      if not Initialized then
552
         Return_Value := WSAStartup (WS_Version, WSAData_Dummy'Address);
553
         pragma Assert (Return_Value = 0);
554
         Initialized := True;
555
      end if;
556
   end Initialize;
557
 
558
   --------------------
559
   -- Signalling_Fds --
560
   --------------------
561
 
562
   package body Signalling_Fds is separate;
563
 
564
   --------------------------
565
   -- Socket_Error_Message --
566
   --------------------------
567
 
568
   function Socket_Error_Message
569
     (Errno : Integer) return C.Strings.chars_ptr
570
   is
571
      use GNAT.Sockets.SOSC;
572
 
573
   begin
574
      case Errno is
575
         when EINTR =>           return Error_Messages (N_EINTR);
576
         when EBADF =>           return Error_Messages (N_EBADF);
577
         when EACCES =>          return Error_Messages (N_EACCES);
578
         when EFAULT =>          return Error_Messages (N_EFAULT);
579
         when EINVAL =>          return Error_Messages (N_EINVAL);
580
         when EMFILE =>          return Error_Messages (N_EMFILE);
581
         when EWOULDBLOCK =>     return Error_Messages (N_EWOULDBLOCK);
582
         when EINPROGRESS =>     return Error_Messages (N_EINPROGRESS);
583
         when EALREADY =>        return Error_Messages (N_EALREADY);
584
         when ENOTSOCK =>        return Error_Messages (N_ENOTSOCK);
585
         when EDESTADDRREQ =>    return Error_Messages (N_EDESTADDRREQ);
586
         when EMSGSIZE =>        return Error_Messages (N_EMSGSIZE);
587
         when EPROTOTYPE =>      return Error_Messages (N_EPROTOTYPE);
588
         when ENOPROTOOPT =>     return Error_Messages (N_ENOPROTOOPT);
589
         when EPROTONOSUPPORT => return Error_Messages (N_EPROTONOSUPPORT);
590
         when ESOCKTNOSUPPORT => return Error_Messages (N_ESOCKTNOSUPPORT);
591
         when EOPNOTSUPP =>      return Error_Messages (N_EOPNOTSUPP);
592
         when EPFNOSUPPORT =>    return Error_Messages (N_EPFNOSUPPORT);
593
         when EAFNOSUPPORT =>    return Error_Messages (N_EAFNOSUPPORT);
594
         when EADDRINUSE =>      return Error_Messages (N_EADDRINUSE);
595
         when EADDRNOTAVAIL =>   return Error_Messages (N_EADDRNOTAVAIL);
596
         when ENETDOWN =>        return Error_Messages (N_ENETDOWN);
597
         when ENETUNREACH =>     return Error_Messages (N_ENETUNREACH);
598
         when ENETRESET =>       return Error_Messages (N_ENETRESET);
599
         when ECONNABORTED =>    return Error_Messages (N_ECONNABORTED);
600
         when ECONNRESET =>      return Error_Messages (N_ECONNRESET);
601
         when ENOBUFS =>         return Error_Messages (N_ENOBUFS);
602
         when EISCONN =>         return Error_Messages (N_EISCONN);
603
         when ENOTCONN =>        return Error_Messages (N_ENOTCONN);
604
         when ESHUTDOWN =>       return Error_Messages (N_ESHUTDOWN);
605
         when ETOOMANYREFS =>    return Error_Messages (N_ETOOMANYREFS);
606
         when ETIMEDOUT =>       return Error_Messages (N_ETIMEDOUT);
607
         when ECONNREFUSED =>    return Error_Messages (N_ECONNREFUSED);
608
         when ELOOP =>           return Error_Messages (N_ELOOP);
609
         when ENAMETOOLONG =>    return Error_Messages (N_ENAMETOOLONG);
610
         when EHOSTDOWN =>       return Error_Messages (N_EHOSTDOWN);
611
         when EHOSTUNREACH =>    return Error_Messages (N_EHOSTUNREACH);
612
 
613
         --  Windows-specific error codes
614
 
615
         when WSASYSNOTREADY =>  return Error_Messages (N_WSASYSNOTREADY);
616
         when WSAVERNOTSUPPORTED =>
617
                                 return Error_Messages (N_WSAVERNOTSUPPORTED);
618
         when WSANOTINITIALISED =>
619
                                 return Error_Messages (N_WSANOTINITIALISED);
620
         when WSAEDISCON =>      return Error_Messages (N_WSAEDISCON);
621
 
622
         --  h_errno values
623
 
624
         when HOST_NOT_FOUND =>  return Error_Messages (N_HOST_NOT_FOUND);
625
         when TRY_AGAIN =>       return Error_Messages (N_TRY_AGAIN);
626
         when NO_RECOVERY =>     return Error_Messages (N_NO_RECOVERY);
627
         when NO_DATA =>         return Error_Messages (N_NO_DATA);
628
 
629
         when others =>          return Error_Messages (N_OTHERS);
630
      end case;
631
   end Socket_Error_Message;
632
 
633
end GNAT.Sockets.Thin;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.