2. cnp3-ebook
3. exercises/sockets
4. English
5. Zen

4 ../../exercises/sockets.rst:96
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Networked applications were usually implemented by using the :term:`socket` :term:`API`. This API was designed when TCP/IP was first implemented in the `Unix BSD`_ operating system [Sechrest]_ [LFJLMT]_, and has served as the model for many APIs between applications and the networking stack in an operating system. Although the socket API is very popular, other APIs have also been developed. For example, the STREAMS API has been added to several Unix System V variants [Rago1993]_. The socket API is supported by most programming languages and several textbooks have been devoted to it. Users of the C language can consult [DC2009]_, [Stevens1998]_, [SFR2004]_ or [Kerrisk2010]_. The Java implementation of the socket API is described in [CD2008]_ and in the `Java tutorial <http://java.sun.com/docs/books/tutorial/networking/sockets/index.html>`_. In this section, we will use the C socket API to illustrate the key concepts. 929/10000 · 929
5 ../../exercises/sockets.rst:98
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The socket API is quite low-level and should be used only when you need a complete control of the network access. If your application simply needs, for instance, to retrieve data from a web server, there are much simpler and higher-level APIs. 243/10000 · 243
6 ../../exercises/sockets.rst:100
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — A detailed discussion of the socket API is outside the scope of this section and the references cited above provide a detailed discussion of all the details of the socket API. As a starting point, it is interesting to compare the socket API with the service primitives that we have discussed in the previous chapter. Let us first consider the connectionless service that consists of the following two primitives : 414/10000 · 414
7 ../../exercises/sockets.rst:102
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — `DATA.request(destination,message)` is used to send a message to a specified destination. In this socket API, this corresponds to the ``send`` method. 150/10000 · 150
8 ../../exercises/sockets.rst:103
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — `DATA.indication(message)` is issued by the transport service to deliver a message to the application. In the socket API, this corresponds to the return of the ``recv`` method that is called by the application. 210/10000 · 210
9 ../../exercises/sockets.rst:105
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The `DATA` primitives are exchanged through a service access point. In the socket API, the equivalent to the service access point is the `socket`. A `socket` is a data structure which is maintained by the networking stack and is used by the application every time it needs to send or receive data through the networking stack. 326/10000 · 326
10 ../../exercises/sockets.rst:108
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Sending data to a peer using a socket 37/10000 · 37
11 ../../exercises/sockets.rst:110
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — In order to reach a peer, a process must know its :term:`address`. An address is a value that identifies a peer in a given network. There exists many different kinds of address families. For example, some of them allow reaching a peer using the file system on the computer. Some others enable communicating with a remote peer through a network. The socket API provides generic functions: the peer address is taken as a ``struct sockaddr *``, which can point to any family of address. This is partly why sockets are a powerful abstraction. 538/10000 · 538
12 ../../exercises/sockets.rst:112
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The ``sendto`` system call allows to send data to a peer identified by its socket address through a given socket. 113/10000 · 113
13 ../../exercises/sockets.rst:118
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The first argument is the file descriptor of the socket that we use to perform the communication. ``buf`` is a buffer of length ``len`` containing the bytes to send to the peer. The usage of ``flags`` argument is out of the scope of this section and can be set to 0. ``dest_addr`` is the socket address of the destination to which we want to send the bytes, its length is passed using the ``addrlen`` argument. 410/10000 · 410
14 ../../exercises/sockets.rst:120
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — In the following example, a C program is sending the bytes ``'h'``, ``'e'``, ``'l'``, ``'l'`` and ``'o'`` to a remote process located at address ``peer_addr``, using the already created socket ``sock``. 202/10000 · 202
15 ../../exercises/sockets.rst:133
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — As the ``sendto`` function is generic, this function will work correctly independently from the fact that the peer's address is defined as a path on the computer filesystem or a network address. 194/10000 · 194
16 ../../exercises/sockets.rst:137
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Receiving data from a peer using a socket 41/10000 · 41
17 ../../exercises/sockets.rst:139
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Operating systems allow assigning an address to a socket using the ``bind`` system call. This is useful when you want to receive messages from another program to which you announced your socket address. Once the address is assigned to the socket, the program can receive data from others using system calls such as ``recv`` and ``read``. Note that we can use the ``read`` system call as the operating system provides a socket as a file descriptor. 447/10000 · 447
18 ../../exercises/sockets.rst:142
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The following program binds its socket to a given socket address and then waits for receiving new bytes, using the already created socket ``sock``. 147/10000 · 147
19 ../../exercises/sockets.rst:171
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Depending on the socket address family, the operating system might implicitly assign an address to an unbound socket upon a call to ``write``, ``send`` or ``sendto``. While this is a useful behavior, describing it precisely is out of the scope of this section. 260/10000 · 260
20 ../../exercises/sockets.rst:175
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — While the provided examples show the usage of a `char` array as the data buffer, implementers should **never** assume that it contains a string. C programs rely on the `char` type to refer to a 8-bit long value, and arbitrary binary values can be exchanged over the network (i.e., the ``\0`` value does not delimit the end of the data). 336/10000 · 336
21 ../../exercises/sockets.rst:177
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Using this code, the program will read and print an arbitrary message received from an arbitrary peer who knows the program's socket address. If we want to know the address of the peer that sent us the message, we can use the ``recvfrom`` system call. This is what a modified version of ``bind_and_receive_from_peer`` is doing below. 333/10000 · 333
22 ../../exercises/sockets.rst:215
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — This function is now using the ``recvfrom`` system call that will also provide the address of the peer who sent the message. As addresses are generic and can have different sizes, ``recvfrom`` also tells us the size of the address that it has written. 251/10000 · 251
23 ../../exercises/sockets.rst:218
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ``connect``: connecting a socket to a remote address 52/10000 · 52