Using TCP Through Sockets

More documents

Recommendations

Info

when there is no data to be read yet, instead of waiting for data, read will return −1 and set errno to EAGAIN. In general, a read call to a non-blocking socket will return without error any time a call to a blocking socket would return immediately. Under this definition, data is available to be read when it has been loaded into a kernel buffer by the OS and is ready to be copied into the user-specified buffer. • write. Like read, write will return −1 with anerrno of EAGAIN if there is no buffer space available for the operating system to copy data to. If, however, there is some buffer space but not enough to contain the entire write request, write will take as much data as it can and return a value smaller than the length specified as its third argument. Code must handle such “short writes” by calling write again later on the rest of the data. • connect. A <strong>TCP</strong> connection request requires a response from the listening server. When called on a non-blocking socket, connect cannot wait for such a response before returning. For this reason, connect on a non-blocking socket usually returns −1 with errno set to EINPROGRESS. Occasionally, however, connect succeeds or fails immediately even on a non-blocking socket, so you must be prepared to handle this case. • accept. When there are connections to accept, accept will behave as usual. If there are no pending connections, however, accept will return −1 and set errno toEWOULDBLOCK. It’s worth noting that, on some operating systems, file descriptors returned by accept have O NONBLOCK clear, whether or not the listening socket is non-blocking. In a asynchronous servers, one often sets O NONBLOCK immediately on any file descriptors accept returns. 4.2 select: Finding out when sockets are ready O NONBLOCK allows an application to keep the CPU when an I/O system call would ordinarily block. However, programs can use several non-blocking file descriptors and still find none of them ready for I/O. Under such circumstances, programs need a way to avoid wasting CPU time by repeatedly polling individual file descriptors. The select system call solves this problem by letting applications sleep until one or more file descriptors in a set is ready for I/O. select usage • int select (int nfds, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *timeout); select takes pointers to sets of file descriptors and a timeout. It returns when one or more of the file descriptors are ready for I/O, or after the specified timeout. Before returning, select modifies the file descriptor sets so as to indicate which file descriptors actually are ready for I/O. select returns the number of ready file descriptors, or −1 on an error. 16
select represents sets of file descriptors as bit vectors—one bit per descriptor. The first bit of a vector is 1 if that set contains file descriptor 0, the second bit is 1 if it contains descriptor 1, and so on. The argument nfds specifies the number of bits in each of the bit vectors being passed in. Equivalently, nfds is one more than highest file descriptor number select must check on. These file descriptor sets are of type fd set. Several macros in system header files allow easy manipulation of this type. If fd is an integer containing a file descriptor, and fds is a variable of type fd set, the following macros can manipulate fds: – FD_ZERO (&fds); Clears all bits in a fds. – FD_SET (fd, &fds); Sets the bit corresponding to file descriptor fd in fds. – FD_CLR (fd, &fds); Clears the bit corresponding to file descriptor fd in fds. – FD_ISSET (fd, &fds); Returns a true if and only if the bit for file descriptor fd is set in fds. select takes three file descriptor sets as input. rfds specifies the set of file descriptors on which the process would like to perform a read or accept. wfds specifies the set of file descriptors on which the process would like to perform a write. efds is a set of file descriptors for which the process is interested in exceptional events such as the arrival of out of band data. In practice, people rarely use efds. Any of the fd set * arguments to select can be NULL to indicate an empty set. The argument timeout specifies the amount of time to wait for a file descriptor to become ready. It is a pointer to a structure of the following form: struct timeval { long tv_sec; /* seconds */ long tv_usec; /* and microseconds */ }; timeout can also be NULL, in which case select will wait indefinitely. Tips and subtleties File descriptor limits. Programmers using select may be tempted to write code capable of using arbitrarily many file descriptors. Be aware that the operating system limits the number of file descriptors a process can have. If you don’t bound the number of descriptors your program uses, you must be prepared for system calls like socket and accept to fail with errors like EMFILE. By default, a modern Unix system typically limits processes to 64 file 17
Page 1 and 2: Using TCP Through Sockets David Maz
Page 3 and 4: eturn; } while ((nread = read (fd,
Page 5 and 6: general, a client wishing to create
Page 7 and 8: #define FINGER_PORT 79 #define bzer
Page 9 and 10: they will operate). Following the b
Page 11 and 12: • int execl(char *path, char *arg
Page 13 and 14: } close (s); return -1; } return s;
Page 15: } } if (cs < 0) { perror ("accept")
Page 19 and 20: • void cb_add (int fd, int write,
Page 21 and 22: * Make file file descriptor nonbloc
Page 23 and 24: } xfree (fc->host); xfree (fc->user
Page 25 and 26: fc->fd = socket (AF_INET, SOCK_STRE
Page 27 and 28: libasync also provides three classe
Page 29 and 30: file descriptor into memory managed
Page 31 and 32: Sometimes you want to do something
Page 33 and 34: Note the only way to generate point
Page 35 and 36: • void tcp_nodelay (int fd) sets
Page 37 and 38: } switch (buf.tosuio ()->input (fd)

Using TCP Through Sockets

Create successful ePaper yourself

Delete template?

Save as template?