home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD2.bin / bbs / comm / amitcp-3.0ß2.lha / AmiTCP / src / amitcp / api / auto_socket.c < prev    next >
Text File  |  1994-02-28  |  46KB  |  1,140 lines
  1. /****** bsdsocket.library/accept ********************************************
  2. *
  3. *   NAME
  4. *        accept - accept a connection on a socket
  5. *
  6. *   SYNOPSIS
  7. *        #include <sys/types.h>
  8. *        #include <sys/socket.h>
  9. *
  10. *        ns = accept(s, addr, addrlen)
  11. *        D0          D0 A0    A1
  12. *
  13. *        long accept(long, struct sockaddr *, long *);
  14. *
  15. *   FUNCTION
  16.  
  17. *        The  argument  s  is a  socket  that  has  been created with
  18. *        socket(), bound to an  address  with bind(), and  is listen-
  19. *        ing for connections after a listen().  accept() extracts the
  20. *        first  connection  on  the  queue  of  pending  connections,
  21. *        creates a new socket with the same properties of s and allo-
  22. *        cates a new socket descriptor for the socket.  If no pending
  23. *        connections are present on the  queue, and the socket is not
  24. *        marked  as non-blocking, accept() blocks the caller  until a
  25. *        connection is present.  If the socket is marked non-blocking
  26. *        and  no  pending  connections  are  present  on  the  queue,
  27. *        accept() returns  an error as described below.  The accepted
  28. *        socket is used to read and write data to and from the socket
  29. *        which connected to  this one; it is not used to  accept more
  30. *        connections.  The original socket s remains open for accept-
  31. *        ing further connections.
  32. *
  33. *        The argument addr is a result parameter that  is  filled  in
  34. *        with  the  address of the connecting entity, as known to the
  35. *        communications layer.  The exact format of the addr  parame-
  36. *        ter  is  determined by the domain in which the communication
  37. *        is occurring.  The addrlen is a value-result  parameter;  it
  38. *        should  initially  contain the amount of space pointed to by
  39. *        addr; on return it will contain the actual length (in bytes)
  40. *        of   the   address   returned.    This  call  is  used  with
  41. *        connection-based socket types, currently with SOCK_STREAM.
  42. *
  43. *        It is possible to select() a socket  for  the  purposes  of
  44. *        doing an accept() by selecting it for read.
  45. *
  46. *   RETURN VALUES
  47. *        accept() returns a non-negative descriptor for the  accepted
  48. *        socket on success.  On failure, it returns -1 and sets errno
  49. *        to indicate the error.
  50. *
  51. *   ERRORS
  52. *        EBADF        - The descriptor is invalid.
  53. *
  54. *        EINTR        - The operation was interrupted by a break 
  55. *                       signal.
  56. * 
  57. *        EOPNOTSUPP   - The referenced socket is not of type
  58. *                       SOCK_STREAM.
  59. *
  60. *        EWOULDBLOCK  - The socket is marked non-blocking and no con-
  61. *                       nections are present to be accepted.
  62. *
  63. *   SEE ALSO
  64. *        bind(), connect(), listen(), select(), SetSocketSignals(),
  65. *        socket()
  66. *****************************************************************************
  67. *
  68. */
  69.  
  70. /****** bsdsocket.library/bind **********************************************
  71. *
  72. *   NAME
  73. *        bind - bind a name to a socket
  74. *
  75. *   SYNOPSIS
  76. *        #include <sys/types.h>
  77. *        #include <sys/socket.h>
  78. *
  79. *        success = bind(s, name, namelen)
  80. *        D0             D0 A0    D1
  81. *
  82. *        long bind(long, struct sockaddr *, long);
  83. *
  84. *   FUNCTION
  85. *        bind() assigns a name to an unnamed socket.  When  a  socket
  86. *        is created with socket(2) it exists in a name space (address
  87. *        family) but has no name assigned.  bind() requests that  the
  88. *        name pointed to by name be assigned to the socket.
  89. *
  90. *   RETURN VALUES
  91. *        0  - on success.
  92. *
  93. *        -1 - on failure and sets errno to indicate the error.
  94. *
  95. *   ERRORS
  96. *        EACCES            - The requested address is protected,  and
  97. *                            the  current user has inadequate permis-
  98. *                            sion to access it.
  99. *
  100. *        EADDRINUSE        - The specified address is already in use.
  101. *
  102. *        EADDRNOTAVAIL     - The specified address is  not  available
  103. *                            from the local machine.
  104. *
  105. *        EBADF             - s is not a valid descriptor.
  106. *
  107. *        EINVAL            - namelen is  not  the  size  of  a  valid
  108. *                            address  for  the specified address fam-
  109. *                            ily.
  110. *
  111. *                            The  socket  is  already  bound  to   an
  112. *                            address.
  113. *
  114. *   SEE ALSO
  115. *        connect(), getsockname(), listen(), socket()
  116. *
  117. *   NOTES
  118. *        The rules used in name binding  vary  between  communication
  119. *        domains.
  120. *****************************************************************************
  121. *
  122. */
  123.  
  124.  
  125. /****** bsdsocket.library/CloseSocket ***************************************
  126. *
  127. *   NAME
  128. *        CloseSocket - delete a socket descriptor
  129. *
  130. *   SYNOPSIS
  131. *        success = CloseSocket(s)
  132. *        D0                    D0
  133. *
  134. *        long CloseSocket(long);
  135. *
  136. *   FUNCTION 
  137. *        CloseSocket() deletes  a  descriptor  from the  library base
  138. *        socket reference table.   If s is the last reference  to the
  139. *        underlying object, then the object  will  be deactivated and
  140. *        socket  (see socket()),  associated naming  information  and
  141. *        queued data are discarded.
  142. *
  143. *        All sockets are automatically closed when the socket library
  144. *        is closed, but closing sockets as soon as possible is
  145. *        recommended to save system resources.
  146. *
  147. *   RETURN VALUES
  148. *         0   on success.
  149. *
  150. *        -1   on failure and sets errno to indicate the error.
  151. *
  152. *   ERRORS
  153. *        EBADF             - s is not an active socket descriptor.
  154. *
  155. *        EINTR             - linger on close was interrupted.
  156. *                            The socket is closed, however.
  157. *
  158. *   SEE ALSO
  159. *        accept(), SocketBaseTagList(), shutdown(), socket(),
  160. *        exec.library/CloseLibrary()
  161. *****************************************************************************
  162. *
  163. */
  164.  
  165.  
  166.  
  167. /****** bsdsocket.library/connect *******************************************
  168. *
  169. *   NAME
  170. *        connect - initiate a connection on a socket
  171. *   
  172. *   SYNOPSIS
  173. *        #include <sys/types.h>
  174. *        #include <sys/socket.h>
  175. *   
  176. *        success = connect(s, name, namelen)
  177. *        D0                D0 A0    D1
  178. *   
  179. *        long connect(long, struct sockaddr *, long);
  180. *   
  181. *   FUNCTION
  182. *        The parameter s is a socket.  If it  is of  type SOCK_DGRAM,
  183. *        then  this call specifies the peer with which the  socket is
  184. *        to be associated;  this address  is that  to which datagrams
  185. *        are  to be sent, and  the only address from which  datagrams
  186. *        are to be received.  If it is of type SOCK_STREAM, then this
  187. *        call attempts  to make a connection  to another socket.  The
  188. *        other socket is specified by name which is an address in the
  189. *        communications space of  the  socket.   Each  communications
  190. *        space interprets the  name parameter in  its  own way.  Gen-
  191. *        erally, stream sockets may successfully connect() only once;
  192. *        datagram sockets may use connect() multiple  times to change
  193. *        their association.  Datagram sockets may dissolve the  asso-
  194. *        ciation by connecting to  an invalid address, such as a null
  195. *        address.
  196. *   
  197. *   RETURN VALUES
  198. *         0   on success.
  199. *   
  200. *        -1   on failure and sets errno to indicate the error.
  201. *   
  202. *   ERRORS
  203. *        EADDRINUSE        - The address is already in use.
  204. *   
  205. *        EADDRNOTAVAIL     - The specified address is  not  available
  206. *                            on the remote machine.
  207. *   
  208. *        EAFNOSUPPORT      - Addresses in the specified address  fam-
  209. *                            ily cannot be used with this socket.
  210. *   
  211. *        EALREADY          - The socket is non-blocking and a  previ-
  212. *                            ous  connection attempt has not yet been
  213. *                            completed.
  214. *   
  215. *        EBADF             - s is not a valid descriptor.
  216. *   
  217. *        ECONNREFUSED      - The attempt to  connect  was  forcefully
  218. *                            rejected.   The  calling  program should
  219. *                            CloseSocket() the socket descriptor, and
  220. *