Unix network programming volume 1

Đây là bộ sách tiếng anh cho dân công nghệ thông tin chuyên về bảo mật,lập trình.Thích hợp cho những ai đam mê về công nghệ thông tin,tìm hiểu về bảo mật và lập trình.

Trang 1

[ Team LiB ]

UNIX® Network Programming Volume 1, Third Edition: The Sockets Networking

API

By W Richard Stevens , Bill Fenner , Andrew M Rudoff

Publisher: Addison Wesley

Pub Date: November 21, 2003

ISBN: 0-13-141155-1

Pages: 1024

"Everyone will want this book because it provides a great mix of practical experience, historicalperspective, and a depth of understanding that only comes from being intimately involved inthe field I've already enjoyed and learned from reading this book, and surely you will too."-Sam Leffler

The classic guide to UNIX networking APIs now completely updated!

To build today's highly distributed, networked applications and services, you need deep

mastery of sockets and other key networking APIs One book delivers comprehensive, finish guidance for building robust, high-performance networked systems in any environment:

start-to-UNIX Network Programming, Volume 1, Third Edition

Building on the legendary work of W Richard Stevens, this edition has been fully updated bytwo leading network programming experts to address today's most crucial standards,

implementations, and techniques New topics include:

POSIX Single UNIX Specification Version 3

IPv6 APIs (including updated guidance on IPv6/IPv4 interoperability)

The new SCTP transport protocol

IPsec-based Key Management Sockets

FreeBSD 4.8/5.1, Red Hat Linux 9.x, Solaris 9, AIX 5.x, HP-UX, and Mac OS X

implementations

New network program debugging techniques

Trang 2

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

Source Specific Multicast API, the key enabler for widespread IP multicast deployment

The authors also update and extend Stevens' definitive coverage of these crucial UNIX

networking standards and techniques:

TCP and UDP transport

Sockets: elementary, advanced, routed, and raw

I/O: multiplexing, advanced functions, nonblocking, and signal-driven

Daemons and inetd

UNIX domain protocols

ioctl operations

Broadcasting and multicasting

Threads

Streams

Design: TCP iterative, concurrent, preforked, and prethreaded servers

Since 1990, network programmers have turned to one source for the insights and techniques

they need: W Richard Stevens' UNIX Network Programming Now, there's an edition

specifically designed for today's challenges-and tomorrow's

[ Team LiB ]

Trang 3

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

[ Team LiB ]

API

Changes from the Second Edition

Using This Book

Source Code and Errata Availability

Acknowledgments

Part 1: Introduction and TCP/IP

Chapter 1 Introduction

Section 1.1 Introduction

Section 1.2 A Simple Daytime Client

Section 1.3 Protocol Independence

Section 1.4 Error Handling: Wrapper Functions

Section 1.5 A Simple Daytime Server

Section 1.6 Roadmap to Client/Server Examples in the Text

Section 1.7 OSI Model

Section 1.8 BSD Networking History

Section 1.9 Test Networks and Hosts

Section 1.10 Unix Standards

Section 1.11 64-Bit Architectures

Trang 4

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

Section 2.4 Transmission Control Protocol (TCP)

Section 2.5 Stream Control Transmission Protocol (SCTP)

Section 2.6 TCP Connection Establishment and Termination

Section 2.7 TIME_WAIT State

Section 2.8 SCTP Association Establishment and Termination

Section 2.9 Port Numbers

Section 2.10 TCP Port Numbers and Concurrent Servers

Section 2.11 Buffer Sizes and Limitations

Section 2.12 Standard Internet Services

Section 2.13 Protocol Usage by Common Internet Applications

Section 2.14 Summary

Exercises

Part 2: Elementary Sockets

Chapter 3 Sockets Introduction

Section 3.2 Socket Address Structures

Section 3.3 Value-Result Arguments

Section 3.4 Byte Ordering Functions

Section 3.5 Byte Manipulation Functions

Section 3.6 inet_aton, inet_addr, and inet_ntoa Functions

Section 3.7 inet_pton and inet_ntop Functions

Section 3.8 sock_ntop and Related Functions

Section 3.9 readn, writen, and readline Functions

Exercises

Chapter 4 Elementary TCP Sockets

Section 4.2 socket Function

Section 4.3 connect Function

Section 4.4 bind Function

Section 4.5 listen Function

Section 4.6 accept Function

Section 4.7 fork and exec Functions

Section 4.8 Concurrent Servers

Section 4.9 close Function

Section 4.10 getsockname and getpeername Functions

Exercises

Chapter 5 TCP Client/Server Example

Section 5.2 TCP Echo Server: main Function

Section 5.3 TCP Echo Server: str_echo Function

Section 5.4 TCP Echo Client: main Function

Section 5.5 TCP Echo Client: str_cli Function

Section 5.6 Normal Startup

Section 5.7 Normal Termination

Section 5.8 POSIX Signal Handling

Section 5.9 Handling SIGCHLD Signals

Section 5.10 wait and waitpid Functions

Section 5.11 Connection Abort before accept Returns

Section 5.12 Termination of Server Process

Section 5.13 SIGPIPE Signal

Section 5.14 Crashing of Server Host

Section 5.15 Crashing and Rebooting of Server Host

Trang 5

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

Section 5.16 Shutdown of Server Host

Section 5.17 Summary of TCP Example

Section 5.18 Data Format

Exercises

Chapter 6 I/O Multiplexing: The select and poll Functions

Section 6.2 I/O Models

Section 6.3 select Function

Section 6.4 str_cli Function (Revisited)

Section 6.5 Batch Input and Buffering

Section 6.6 shutdown Function

Section 6.7 str_cli Function (Revisited Again)

Section 6.8 TCP Echo Server (Revisited)

Section 6.9 pselect Function

Section 6.10 poll Function

Section 6.11 TCP Echo Server (Revisited Again)

Exercises

Chapter 7 Socket Options

Section 7.2 getsockopt and setsockopt Functions

Section 7.3 Checking if an Option Is Supported and Obtaining the Default

Section 7.4 Socket States

Section 7.5 Generic Socket Options

Section 7.6 IPv4 Socket Options

Section 7.7 ICMPv6 Socket Option

Section 7.8 IPv6 Socket Options

Section 7.9 TCP Socket Options

Section 7.10 SCTP Socket Options

Section 8.2 recvfrom and sendto Functions

Section 8.3 UDP Echo Server: main Function

Section 8.4 UDP Echo Server: dg_echo Function

Section 8.5 UDP Echo Client: main Function

Section 8.6 UDP Echo Client: dg_cli Function

Section 8.7 Lost Datagrams

Section 8.8 Verifying Received Response

Section 8.9 Server Not Running

Section 8.10 Summary of UDP Example

Section 8.11 connect Function with UDP

Section 8.12 dg_cli Function (Revisited)

Section 8.13 Lack of Flow Control with UDP

Section 8.14 Determining Outgoing Interface with UDP

Section 8.15 TCP and UDP Echo Server Using select

Exercises

Chapter 9 Elementary SCTP Sockets

Trang 6

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

Section 9.3 sctp_bindx Function

Section 9.4 sctp_connectx Function

Section 9.5 sctp_getpaddrs Function

Section 9.6 sctp_freepaddrs Function

Section 9.7 sctp_getladdrs Function

Section 9.8 sctp_freeladdrs Function

Section 9.9 sctp_sendmsg Function

Section 9.10 sctp_recvmsg Function

Section 9.11 sctp_opt_info Function

Section 9.12 sctp_peeloff Function

Section 9.13 shutdown Function

Section 10.2 SCTP One-to-Many-Style Streaming Echo Server: main Function

Section 10.3 SCTP One-to-Many-Style Streaming Echo Client: main Function

Section 10.4 SCTP Streaming Echo Client: str_cli Function

Section 10.5 Exploring Head-of-Line Blocking

Section 10.6 Controlling the Number of Streams

Section 10.7 Controlling Termination

Exercises

Chapter 11 Name and Address Conversions

Section 11.2 Domain Name System (DNS)

Section 11.3 gethostbyname Function

Section 11.4 gethostbyaddr Function

Section 11.5 getservbyname and getservbyport Functions

Section 11.6 getaddrinfo Function

Section 11.7 gai_strerror Function

Section 11.8 freeaddrinfo Function

Section 11.9 getaddrinfo Function: IPv6

Section 11.10 getaddrinfo Function: Examples

Section 11.11 host_serv Function

Section 11.12 tcp_connect Function

Section 11.13 tcp_listen Function

Section 11.14 udp_client Function

Section 11.15 udp_connect Function

Section 11.16 udp_server Function

Section 11.17 getnameinfo Function

Section 11.18 Re-entrant Functions

Section 11.19 gethostbyname_r and gethostbyaddr_r Functions

Section 11.20 Obsolete IPv6 Address Lookup Functions

Section 11.21 Other Networking Information

Exercises

Part 3: Advanced Sockets

Chapter 12 IPv4 and IPv6 Interoperability

Section 12.2 IPv4 Client, IPv6 Server

Section 12.3 IPv6 Client, IPv4 Server

Section 12.4 IPv6 Address-Testing Macros

Trang 7

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

Section 12.5 Source Code Portability

Exercises

Chapter 13 Daemon Processes and the inetd Superserver

Section 13.2 syslogd Daemon

Section 13.3 syslog Function

Section 13.4 daemon_init Function

Section 13.5 inetd Daemon

Section 13.6 daemon_inetd Function

Exercises

Chapter 14 Advanced I/O Functions

Section 14.2 Socket Timeouts

Section 14.3 recv and send Functions

Section 14.4 readv and writev Functions

Section 14.5 recvmsg and sendmsg Functions

Section 14.6 Ancillary Data

Section 14.7 How Much Data Is Queued?

Section 14.8 Sockets and Standard I/O

Section 14.9 Advanced Polling

Exercises

Chapter 15 Unix Domain Protocols

Section 15.2 Unix Domain Socket Address Structure

Section 15.3 socketpair Function

Section 15.4 Socket Functions

Section 15.5 Unix Domain Stream Client/Server

Section 15.6 Unix Domain Datagram Client/Server

Section 15.7 Passing Descriptors

Section 15.8 Receiving Sender Credentials

Exercises

Chapter 16 Nonblocking I/O

Section 16.2 Nonblocking Reads and Writes: str_cli Function (Revisited)

Section 16.3 Nonblocking connect

Section 16.4 Nonblocking connect: Daytime Client

Section 16.5 Nonblocking connect: Web Client

Section 16.6 Nonblocking accept

Exercises

Chapter 17 ioctl Operations

Section 17.2 ioctl Function

Section 17.3 Socket Operations

Section 17.4 File Operations

Section 17.5 Interface Configuration

Section 17.6 get_ifi_info Function

Section 17.7 Interface Operations

Section 17.8 ARP Cache Operations

Trang 8

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

Exercises

Chapter 18 Routing Sockets

Section 18.2 Datalink Socket Address Structure

Section 18.3 Reading and Writing

Section 18.4 sysctl Operations

Section 18.5 get_ifi_info Function (Revisited)

Section 18.6 Interface Name and Index Functions

Exercises

Chapter 19 Key Management Sockets

Section 19.2 Reading and Writing

Section 19.3 Dumping the Security Association Database (SADB)

Section 19.4 Creating a Static Security Association (SA)

Section 19.5 Dynamically Maintaining SAs

Exercises

Chapter 20 Broadcasting

Section 20.2 Broadcast Addresses

Section 20.3 Unicast versus Broadcast

Section 20.4 dg_cli Function Using Broadcasting

Section 20.5 Race Conditions

Exercises

Chapter 21 Multicasting

Section 21.2 Multicast Addresses

Section 21.3 Multicasting versus Broadcasting on a LAN

Section 21.4 Multicasting on a WAN

Section 21.5 Source-Specific Multicast

Section 21.6 Multicast Socket Options

Section 21.7 mcast_join and Related Functions

Section 21.8 dg_cli Function Using Multicasting

Section 21.9 Receiving IP Multicast Infrastructure Session Announcements

Section 21.10 Sending and Receiving

Section 21.11 Simple Network Time Protocol (SNTP)

Exercises

Chapter 22 Advanced UDP Sockets

Section 22.2 Receiving Flags, Destination IP Address, and Interface Index

Section 22.3 Datagram Truncation

Section 22.4 When to Use UDP Instead of TCP

Section 22.5 Adding Reliability to a UDP Application

Section 22.6 Binding Interface Addresses

Section 22.7 Concurrent UDP Servers

Section 22.8 IPv6 Packet Information

Section 22.9 IPv6 Path MTU Control

Exercises

Chapter 23 Advanced SCTP Sockets

Trang 9

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

Section 23.2 An Autoclosing One-to-Many-Style Server

Section 23.3 Partial Delivery

Section 23.4 Notifications

Section 23.5 Unordered Data

Section 23.6 Binding a Subset of Addresses

Section 23.7 Determining Peer and Local Address Information

Section 23.8 Finding an Association ID Given an IP Address

Section 23.9 Heartbeating and Address Failure

Section 23.10 Peeling Off an Association

Section 23.11 Controlling Timing

Section 23.12 When to Use SCTP Instead of TCP

Exercises

Chapter 24 Out-of-Band Data

Section 24.2 TCP Out-of-Band Data

Section 24.3 sockatmark Function

Section 24.4 TCP Out-of-Band Data Recap

Exercises

Chapter 25 Signal-Driven I/O

Section 25.2 Signal-Driven I/O for Sockets

Section 25.3 UDP Echo Server Using SIGIO

Exercises

Chapter 26 Threads

Section 26.2 Basic Thread Functions: Creation and Termination

Section 26.3 str_cli Function Using Threads

Section 26.4 TCP Echo Server Using Threads

Section 26.5 Thread-Specific Data

Section 26.6 Web Client and Simultaneous Connections (Continued)

Section 26.7 Mutexes: Mutual Exclusion

Section 26.8 Condition Variables

Section 26.9 Web Client and Simultaneous Connections (Continued)

Exercises

Chapter 27 IP Options

Section 27.2 IPv4 Options

Section 27.3 IPv4 Source Route Options

Section 27.4 IPv6 Extension Headers

Section 27.5 IPv6 Hop-by-Hop Options and Destination Options

Section 27.6 IPv6 Routing Header

Section 27.7 IPv6 Sticky Options

Section 27.8 Historical IPv6 Advanced API

Trang 10

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

Section 28.4 Raw Socket Input

Section 28.5 ping Program

Section 28.6 traceroute Program

Section 28.7 An ICMP Message Daemon

Exercises

Chapter 29 Datalink Access

Section 29.2 BSD Packet Filter (BPF)

Section 29.3 Datalink Provider Interface (DLPI)

Section 29.4 Linux: SOCK_PACKET and PF_PACKET

Section 29.5 libpcap: Packet Capture Library

Section 29.6 libnet: Packet Creation and Injection Library

Section 29.7 Examining the UDP Checksum Field

Exercises

Chapter 30 Client/Server Design Alternatives

Section 30.2 TCP Client Alternatives

Section 30.3 TCP Test Client

Section 30.4 TCP Iterative Server

Section 30.5 TCP Concurrent Server, One Child per Client

Section 30.6 TCP Preforked Server, No Locking Around accept

Section 30.7 TCP Preforked Server, File Locking Around accept

Section 30.8 TCP Preforked Server, Thread Locking Around accept

Section 30.9 TCP Preforked Server, Descriptor Passing

Section 30.10 TCP Concurrent Server, One Thread per Client

Section 30.11 TCP Prethreaded Server, per-Thread accept

Section 30.12 TCP Prethreaded Server, Main Thread accept

Section 31.3 getmsg and putmsg Functions

Section 31.4 getpmsg and putpmsg Functions

Section 31.5 ioctl Function

Section 31.6 Transport Provider Interface (TPI)

Exercises

Appendix A IPv4, IPv6, ICMPv4, and ICMPv6

Section A.1 Introduction

Section A.2 IPv4 Header

Section A.3 IPv6 Header

Section A.4 IPv4 Addresses

Section A.5 IPv6 Addresses

Section A.6 Internet Control Message Protocols (ICMPv4 and ICMPv6)

Appendix B Virtual Networks

Section B.1 Introduction

Section B.2 The MBone

Section B.3 The 6bone

Section B.4 IPv6 Transition: 6to4

Appendix C Debugging Techniques

Section C.1 System Call Tracing

Trang 11

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

Section C.2 Standard Internet Services

Section C.3 sock Program

Section C.4 Small Test Programs

Section C.5 tcpdump Program

Section C.6 netstat Program

Section C.7 lsof Program

Appendix D Miscellaneous Source Code

Section D.1 unp.h Header

Section D.2 config.h Header

Section D.3 Standard Error Functions

Appendix E Solutions to Selected Exercises

Trang 12

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

[ Team LiB ]

Copyright

Many of the designations used by manufacturers and sellers to distinguish their products areclaimed as trademarks Where those designations appear in this book, and Addison-Wesleywas aware of a trademark claim, the designations have been printed with initial capital letters

or in all capitals

The authors and publisher have taken care in the preparation of this book, but make no

expressed or implied warranty of any kind and assume no responsibility for errors or

omissions No liability is assumed for incidental or consequential damages in connection with orarising out of the use of the information or programs contained herein

The publisher offers discounts on this book when ordered in quantity for bulk purchases andspecial sales For more information, please contact:

U.S Corporate and Government Sales

Visit Addison-Wesley on the Web: www.awprofessional.com

Library of Congress Cataloging-in-Publication Data

A CIP catalog record for this book can be obtained from the Library of Congress

or transmitted, in any form, or by any means, electronic, mechanical, photocopying, recording,

or otherwise, without the prior consent of the publisher Printed in the United States of

America Published simultaneously in Canada

For information on obtaining permission for use of material from this work, please submit awritten request to:

Pearson Education, Inc

Rights and Contracts Department

75 Arlington Street, Suite 300

Trang 13

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

Aloha nui loa.

[ Team LiB ]

Trang 14

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

[ Team LiB ]

Addison-Wesley Professional

Computing Series

Brian W Kernighan and Craig Partridge, Consulting Editors

Matthew H Austern, Generic Programming and the STL: Using and Extending the C++

Standard Template Library

David R Butenhof, Programming with POSIX® Threads

Brent Callaghan, NFS Illustrated

Tom Cargill, C++ Programming Style

William R Cheswick/Steven M Bellovin/Aviel D Rubin, Firewalls and Internet Security, Second

Edition: Repelling the Wily Hacker

David A Curry, UNIX® System Security: A Guide for Users and System Administrators

Stephen C Dewhurst, C++ Gotchas: Avoiding Common Problems in Coding and Design

Erich Gamma/Richard Helm/Ralph Johnson/John Vlissides, Design Patterns: Elements of

Reusable Object-Oriented Software

Erich Gamma/Richard Helm/Ralph Johnson/John Vlissides, Design Patterns CD: Elements of

Reusable Object-Oriented Software

Peter Haggar, Practical Java™ Programming Language Guide

David R Hanson, C Interfaces and Implementations: Techniques for Creating Reusable

Software

Mark Harrison/Michael McLennan, Effective Tcl/Tk Programming: Writing Better Programs with

Tcl and Tk

Michi Henning/Steve Vinoski, Advanced CORBA® Programming with C++

Brian W Kernighan/Rob Pike, The Practice of Programming

S Keshav, An Engineering Approach to Computer Networking: ATM Networks, the Internet,

and the Telephone Network

John Lakos, Large-Scale C++ Software Design

Scott Meyers, Effective C++ CD: 85 Specific Ways to Improve Your Programs and Designs Scott Meyers, Effective C++, Second Edition: 50 Specific Ways to Improve Your Programs and

Trang 15

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

David R Musser/Gillmer J Derge/Atul Saini, STL Tutorial and Reference Guide, Second Edition:

C++ Programming with the Standard Template Library

John K Ousterhout, Tcl and the Tk Toolkit

Craig Partridge, Gigabit Networking

Radia Perlman, Interconnections, Second Edition: Bridges, Routers, Switches, and

Internetworking Protocols

Stephen A Rago, UNIX® System V Network Programming

Curt Schimmel, UNIX® Systems for Modern Architectures: Symmetric Multiprocessing and

Caching for Kernel Programmers

W Richard Stevens/Bill Fenner/Andrew M Rudoff, UNIX Network Programming Volume 1,

Third Edition: The Sockets Networking API

W Richard Stevens, Advanced Programming in the UNIX® Environment

W Richard Stevens, TCP/IP Illustrated, Volume 1: The Protocols

W Richard Stevens, TCP/IP Illustrated, Volume 3: TCP for Transactions, HTTP, NNTP, and the

UNIX® Domain Protocols

W Richard Stevens/Gary R Wright, TCP/IP Illustrated Volumes 1-3 Boxed Set

John Viega/Gary McGraw, Building Secure Software: How to Avoid Security Problems the Right

Way

Gary R Wright/W Richard Stevens, TCP/IP Illustrated, Volume 2: The Implementation

Ruixi Yuan/ W Timothy Strayer, Virtual Private Networks: Technologies and Solutions

Visit www.awprofessional.com/series/professionalcomputing for more information about these titles.

[ Team LiB ]

Trang 16

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

[ Team LiB ]

Foreword

When the original text of this book arrived in 1990, it was quickly recognized as the definitivereference for programmers to learn network programming techniques Since then, the art ofcomputer networking has changed dramatically All it takes is a look at the return address forcomments from the original text ("uunet!hsi!netbook") to make this clear (How many readerswill even recognize this as an address in the UUCP dialup network that was commonplace inthe 1980s?)

Today, UUCP networks are a rarity and new technologies such as wireless networks are

becoming ubiquitous! With these changes, new network protocols and programming paradigmshave been developed But, programmers have lacked a good reference from which to learn theintricacies of these new techniques

This book fills that void Readers who have a dog-eared copy of the original book will want anew copy for the updated programming techniques and the substantial new material describingnext-generation protocols such as IPv6 Everyone will want this book because it provides agreat mix of practical experience, historical perspective, and a depth of understanding that onlycomes from being intimately involved in the field

I've already enjoyed and learned from reading this book, and surely you will, too

Sam Leffler

[ Team LiB ]

Trang 17

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

Changes from the Second Edition

Using This Book

Source Code and Errata Availability

Acknowledgments

[ Team LiB ]

Trang 18

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

[ Team LiB ]

Introduction

This book is for people who want to write programs that communicate with each other using anapplication program interface (API) known as sockets Some readers may be very familiar withsockets already, as that model has become synonymous with network programming Othersmay need an introduction to sockets from the ground up The goal of this book is to offerguidance on network programming for beginners as well as professionals, for those developingnew network-aware applications as well as those maintaining existing code, and for people whosimply want to understand how the networking components of their system function

All the examples in this text are actual, runnable code tested on Unix systems However, manynon-Unix systems support the sockets API and the examples are largely operating system-independent, as are the general concepts we present Virtually every operating system (OS)provides numerous network-aware applications such as Web browsers, email clients, and file-

sharing servers We discuss the usual partitioning of these applications into client and server

and write our own small examples of these many times throughout the text

Presenting this material in a Unix-oriented fashion has the natural side effect of providingbackground on Unix itself, and on TCP/IP as well Where more extensive background may beinteresting, we refer the reader to other texts Four texts are so commonly mentioned in thisbook that we've assigned them the following abbreviations:

APUE: Advanced Programming in the UNIX Environment [Stevens 1992]

TCPv1: TCP/IP Illustrated, Volume 1 [Stevens 1994]

TCPv2: TCP/IP Illustrated, Volume 2 [Wright and Stevens 1995]

TCPv3: TCP/IP Illustrated, Volume 3 [Stevens 1996]

TCPv2 contains a high level of detail very closely related to the material in this book, as itdescribes and presents the actual 4.4BSD implementation of the network programming

functions for the sockets API (socket, bind, connect, and so on) If one understands the

implementation of a feature, the use of that feature in an application makes more sense

[ Team LiB ]

Trang 19

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

[ Team LiB ]

Changes from the Second Edition

Sockets have been around, more or less in their current form, since the 1980s, and it is atribute to their initial design that they have continued to be the network API of choice

Therefore, it may come as a surprise to learn that quite a bit has changed since the secondedition of this book was published in 1998 The changes we've made to the text are

summarized as follows:

This new edition contains updated information on IPv6, which was only in draft form atthe time of publication of the second edition and has evolved somewhat

The descriptions of functions and the examples have all been updated to reflect the most

recent POSIX specification (POSIX 1003.1-2001), also known as the Single Unix

Specification Version 3.

The coverage of the X/Open Transport Interface (XTI) has been dropped That API hasfallen out of common use and even the most recent POSIX specification does not bother

to cover it

The coverage of TCP for transactions (T/TCP) has been dropped

Three chapters have been added to describe a relatively new transport protocol, SCTP.This reliable, message-oriented protocol provides multiple streams between endpointsand transport-level support for multihoming It was originally designed for transport oftelephony signaling across the Internet, but provides some features that many

applications could take advantage of

A chapter has been added on key management sockets, which may be used with Internet

Protocol Security (IPsec) and other network security services

The machines used, as well as the versions of their variants of Unix, have all been

updated, and the examples have been updated to reflect how these machines behave Inmany cases, examples were updated because OS vendors fixed bugs or added features,but as one might expect, we've discovered the occasional new bug here and there Themachines used for testing the examples in this book were:

Apple Power PC running MacOS/X 10.2.6

HP PA-RISC running HP-UX 11i

IBM Power PC running AIX 5.1

Intel x86 running FreeBSD 4.8

Intel x86 running Linux 2.4.7

Sun SPARC running FreeBSD 5.1

Sun SPARC running Solaris 9

See Figure 1.16 for details on how these machines were used

Volume 2 of this UNIX Network Programming series, subtitled Interprocess Communications ,

builds on the material presented here to cover message passing, synchronization, shared

Trang 20

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

[ Team LiB ]

Trang 21

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

[ Team LiB ]

Using This Book

This text can be used as either a tutorial on network programming or as a reference for

experienced programmers When used as a tutorial or for an introductory class on networkprogramming, the emphasis should be on Part 2, "Elementary Sockets" (Chapters 3 through

11), followed by whatever additional topics are of interest Part 2 covers the basic socketfunctions for both TCP and UDP, along with SCTP, I/O multiplexing, socket options, and basicname and address conversions Chapter 1 should be read by all readers, especially Section 1.4,which describes some wrapper functions used throughout the text Chapter 2 and perhapsAppendix A should be referred to as necessary, depending on the reader's background Most ofthe chapters in Part 3, "Advanced Sockets," can be read independently of the others in thatpart of the book

To aid in the use of this book as a reference, a thorough index is provided, along with

summaries on the end papers of where to find detailed descriptions of all the functions andstructures To help those reading topics in a random order, numerous references to relatedtopics are provided throughout the text

[ Team LiB ]

Trang 22

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

[ Team LiB ]

Source Code and Errata Availability

The source code for all the examples that appear in the book is available on the Web at

www.unpbook.com The best way to learn network programming is to take these programs,

modify them, and enhance them Actually writing code of this form is the only way to reinforce

the concepts and techniques Numerous exercises are also provided at the end of each

chapter, and most answers are provided in Appendix E

A current errata for the book is also available from the same Web site

[ Team LiB ]

Trang 23

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

housemate, Christopher Boyd for letting him off all his household chores while working in thetreehouse on this project Thanks are also due to his friend, Jerry Winner, whose prodding andencouragement were invaluable Likewise, Andy Rudoff wants to specifically thank his wife,Ellen, and girls, Jo and Katie, for their understanding and encouragement throughout thisproject We simply could not have done this without all of you

Randall Stewart with Cisco Systems, Inc provided much of the SCTP material and deserves aspecial acknowledgment for this much-valued contribution The coverage of this new andinteresting topic simply would not exist without Randall's work

The feedback from our reviewers was invaluable for catching errors, pointing out areas thatrequired more explanation, and suggesting improvements to our text and code examples Theauthors would like to thank: James Carlson, Wu-Chang Feng, Rick Jones, Brian Kernighan,Sam Leffler, John McCann, Craig Metz, Ian Lance Taylor, David Schwartz, and Gary Wright.Numerous individuals and their organizations went beyond the normal call of duty to provideeither a loaner system, software, or access to a system, all of which were used to test some ofthe examples in the text

Jessie Haug of IBM Austin provided an AIX system and compilers

Rick Jones and William Gilliam of Hewlett-Packard provided access to multiple systemsrunning HP-UX

The staff at Addison Wesley has been a true pleasure to work with: Noreen Regina, KathleenCaren, Dan DePasquale, Anthony Gemellaro, and a very special thanks to our editor, MaryFranz

In a trend that Rich Stevens instituted (but contrary to popular fads), we produced ready copy of the book using the wonderful Groff package written by James Clark, created theillustrations using the gpic program (using many of Gary Wright's macros), produced thetables using the gtbl program, performed all the indexing, and did the final page layout DaveHanson's loom program and some scripts by Gary Wright were used to include the source code

camera-in the book A set of awk scripts written by Jon Bentley and Brian Kernighan helped in

producing the final index

The authors welcome electronic mail from any readers with comments, suggestions, or bugfixes

Bill Fenner

Woodside, California

Andrew M Rudoff

Boulder, Colorado

Trang 24

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

authors@unpbook.com

http://www.unpbook.com

[ Team LiB ]

Trang 25

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

Trang 26

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

[ Team LiB ]

Chapter 1 Introduction

Section 1.2 A Simple Daytime Client

Section 1.3 Protocol Independence

Section 1.4 Error Handling: Wrapper Functions

Section 1.5 A Simple Daytime Server

Section 1.6 Roadmap to Client/Server Examples in the Text

Section 1.7 OSI Model

Section 1.8 BSD Networking History

Section 1.9 Test Networks and Hosts

Section 1.10 Unix Standards

Section 1.11 64-Bit Architectures

Exercises

[ Team LiB ]

Trang 27

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

[ Team LiB ]

1.1 Introduction

When writing programs that communicate across a computer network, one must first invent a

protocol, an agreement on how those programs will communicate Before delving into the

design details of a protocol, high-level decisions must be made about which program is

expected to initiate communication and when responses are expected For example, a Web

server is typically thought of as a long-running program (or daemon) that sends network

messages only in response to requests coming in from the network The other side of theprotocol is a Web client, such as a browser, which always initiates communication with the

server This organization into client and server is used by most network-aware applications.

Deciding that the client always initiates requests tends to simplify the protocol as well as theprograms themselves Of course, some of the more complex network applications also require

asynchronous callback communication, where the server initiates a message to the client But

it is far more common for applications to stick to the basic client/server model shown in Figure1.1

Figure 1.1 Network application: client and server.

Clients normally communicate with one server at a time, although using a Web browser as anexample, we might communicate with many different Web servers over, say, a 10-minute timeperiod But from the server's perspective, at any given point in time, it is not unusual for aserver to be communicating with multiple clients We show this in Figure 1.2 Later in this text,

we will cover several different ways for a server to handle multiple clients at the same time

Figure 1.2 Server handling multiple clients at the same time.

The client application and the server application may be thought of as communicating via anetwork protocol, but actually, multiple layers of network protocols are typically involved Inthis text, we focus on the TCP/IP protocol suite, also called the Internet protocol suite Forexample, Web clients and servers communicate using the Transmission Control Protocol, orTCP TCP, in turn, uses the Internet Protocol, or IP, and IP communicates with a datalink layer

Trang 28

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

arrangement shown in Figure 1.3

Figure 1.3 Client and server on the same Ethernet communicating

using TCP.

Even though the client and server communicate using an application protocol, the transportlayers communicate using TCP Note that the actual flow of information between the client andserver goes down the protocol stack on one side, across the network, and up the protocol stack

on the other side Also note that the client and server are typically user processes, while theTCP and IP protocols are normally part of the protocol stack within the kernel We have labeledthe four layers on the right side of Figure 1.3

TCP and IP are not the only protocols that we will discuss Some clients and servers use theUser Datagram Protocol (UDP) instead of TCP, and we will discuss both protocols in more detail

in Chapter 2 Furthermore, we have used the term "IP," but the protocol, which has been in

use since the early 1980s, is officially called IP version 4 (IPv4) A new version, IP version 6

(IPv6) was developed during the mid-1990s and could potentially replace IPv4 in the years tocome This text covers the development of network applications using both IPv4 and IPv6.Appendix A provides a comparison of IPv4 and IPv6, along with other protocols that we willdiscuss

The client and server need not be attached to the same local area network (LAN) as we show

in Figure 1.3 For instance, in Figure 1.4, we show the client and server on different LANs, with

both LANs connected to a wide area network (WAN) using routers.

Figure 1.4 Client and server on different LANs connected through a

WAN.

Trang 29

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

Routers are the building blocks of WANs The largest WAN today is the Internet Many

companies build their own WANs and these private WANs may or may not be connected to theInternet

The remainder of this chapter provides an introduction to the various topics that are covered indetail later in the text We start with a complete example of a TCP client, albeit a simple one,that demonstrates many of the function calls and concepts that we will encounter throughoutthe text This client works with IPv4 only, and we show the changes required to work withIPv6 A better solution is to write protocol-independent clients and servers, and we will discussthis in Chapter 11 This chapter also shows a complete TCP server that works with our client

To simplify all our code, we define our own wrapper functions for most of the system functionsthat we call throughout the text We can use these wrapper functions most of the time tocheck for an error, print an appropriate message, and terminate when an error occurs We alsoshow the test network, hosts, and routers used for most examples in the text, along with theirhostnames, IP addresses, and operating systems

Most discussions of Unix these days include the term "X," which is the standard that mostvendors have adopted We describe the history of POSIX and how it affects the ApplicationProgramming Interfaces (APIs) that we describe in this text, along with the other players in thestandards arena

[ Team LiB ]

Trang 30

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

[ Team LiB ]

1.2 A Simple Daytime Client

Let's consider a specific example to introduce many of the concepts and terms that we willencounter throughout the book Figure 1.5 is an implementation of a TCP time-of-day client.This client establishes a TCP connection with a server and the server simply sends back thecurrent time and date in a human-readable format

Figure 1.5 TCP daytime client.

9 err_quit("usage: a.out <IPaddress>");

10 if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)

11 err_sys("socket error");

12 bzero(&servaddr, sizeof(servaddr));

13 servaddr.sin_family = AF_INET;

14 servaddr.sin_port = htons(13); /* daytime server */

15 if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0)

16 err_quit("inet_pton error for %s", argv[1]);

17 if (connect(sockfd, (SA *) &servaddr, sizeof(servaddr)) < 0)

18 err_sys("connect error");

19 while ( (n = read(sockfd, recvline, MAXLINE)) > 0) {

20 recvline[n] = 0; /* null terminate */

21 if (fputs(recvline, stdout) == EOF)

The horizontal rules at the beginning and end of a code fragment specify the source code

Trang 31

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

filename: the file daytimetcpcli.c in the directory intro for this example Since thesource code for all the examples in the text is freely available (see the Preface), this letsyou locate the appropriate source file Compiling, running, and especially modifying theseprograms while reading this text is an excellent way to learn the concepts of networkprogramming

Throughout the text, we will use indented, parenthetical notes such as this to describeimplementation details and historical points

If we compile the program into the default a.out file and execute it, we will have the followingoutput:

Whenever we display interactive input and output, we will show our typed input in bold

and the computer output like this Comments are added on the right side in italics We

will always include the name of the system as part of the shell prompt (solaris in thisexample) to show on which host the command was run Figure 1.16 shows the systemsused to run most of the examples in this book The hostnames usually describe theoperating system (OS) as well

There are many details to consider in this 27-line program We mention them briefly here, incase this is your first encounter with a network program, and provide more information onthese topics later in the text

Include our own header

1 We include our own header, unp.h, which we will show in Section D.1 This header includesnumerous system headers that are needed by most network programs and defines variousconstants that we use (e.g., MAXLINE)

Command-line arguments

2–3 This is the definition of the main function along with the command-line arguments Wehave written the code in this text assuming an American National Standards Institute (ANSI) Ccompiler (also referred to as an ISO C compiler)

Create TCP socket

10–11 The socket function creates an Internet (AF_INET) stream (SOCK_STREAM) socket, which

is a fancy name for a TCP socket The function returns a small integer descriptor that we canuse to identify the socket in all future function calls (e.g., the calls to connect and read thatfollow)

The if statement contains a call to the socket function, an assignment of the returnvalue to the variable named sockfd, and then a test of whether this assigned value isless than 0 While we could break this into two C statements,

Trang 32

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

if (sockfd < 0)

it is a common C idiom to combine the two lines The set of parentheses around thefunction call and assignment is required, given the precedence rules of C (the less-thanoperator has a higher precedence than assignment) As a matter of coding style, theauthors always place a space between the two opening parentheses, as a visual indicatorthat the left-hand side of the comparison is also an assignment (This style is copied fromthe Minix source code [Tanenbaum 1987].) We use this same style in the while

statement later in the program

We will encounter many different uses of the term "socket." First, the API that we are using is

called the sockets API In the preceding paragraph, we referred to a function named socket

that is part of the sockets API In the preceding paragraph, we also referred to a TCP socket,which is synonymous with a TCP endpoint

If the call to socket fails, we abort the program by calling our own err_sys function It printsour error message along with a description of the system error that occurred (e.g., "Protocolnot supported" is one possible error from socket) and terminates the process This function,and a few others of our own that begin with err_, are called throughout the text We willdescribe them in Section D.3

Specify server's IP address and port

12–16 We fill in an Internet socket address structure (a sockaddr_in structure named

servaddr) with the server's IP address and port number We set the entire structure to 0 using

bzero, set the address family to AF_INET, set the port number to 13 (which is the well-knownport of the daytime server on any TCP/IP host that supports this service, as shown in Figure2.18), and set the IP address to the value specified as the first command-line argument

(argv[1]) The IP address and port number fields in this structure must be in specific formats:

We call the library function htons ("host to network short") to convert the binary port number,and we call the library function inet_pton ("presentation to numeric") to convert the ASCIIcommand-line argument (such as 206.62.226.35 when we ran this example) into the properformat

bzero is not an ANSI C function It is derived from early Berkeley networking code.Nevertheless, we use it throughout the text, instead of the ANSI C memset function,because bzero is easier to remember (with only two arguments) than memset (with threearguments) Almost every vendor that supports the sockets API also provides bzero, and

if not, we provide a macro definition of it in our unp.h header

Indeed, the author of TCPv3 made the mistake of swapping the second and third

arguments to memset in 10 occurrences in the first printing A C compiler cannot catchthis error because both arguments are of the same type (Actually, the second argument

is an int and the third argument is size_t, which is typically an unsigned int, but thevalues specified, 0 and 16, respectively, are still acceptable for the other type of

argument.) The call to memset still worked, but did nothing The number of bytes toinitialize was specified as 0 The programs still worked, because only a few of the socketfunctions actually require that the final 8 bytes of an Internet socket address structure beset to 0 Nevertheless, it was an error, and one that could be avoided by using bzero,because swapping the two arguments to bzero will always be caught by the C compiler iffunction prototypes are used

This may be your first encounter with the inet_pton function It is new with IPv6 (which

we will talk more about in Appendix A) Older code uses the inet_addr function to

convert an ASCII dotted-decimal string into the correct format, but this function hasnumerous limitations that inet_pton corrects Do not worry if your system does not

Trang 33

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

(yet) support this function; we will provide an implementation of it in Section 3.7

Establish connection with server

17–18 The connect function, when applied to a TCP socket, establishes a TCP connection withthe server specified by the socket address structure pointed to by the second argument Wemust also specify the length of the socket address structure as the third argument to connect,and for Internet socket address structures, we always let the compiler calculate the lengthusing C's sizeof operator

In the unp.h header, we #define SA to be struct sockaddr, that is, a generic socketaddress structure Everytime one of the socket functions requires a pointer to a socketaddress structure, that pointer must be cast to a pointer to a generic socket addressstructure This is because the socket functions predate the ANSI C standard, so the void

* pointer type was not available in the early 1980s when these functions were developed.The problem is that "struct sockaddr" is 15 characters and often causes the sourcecode line to extend past the right edge of the screen (or page, in the case of a book), so

we shorten it to SA We will talk more about generic socket address structures whenexplaining Figure 3.3

Read and display server's reply

19–25 We read the server's reply and display the result using the standard I/O fputs function

We must be careful when using TCP because it is a byte-stream protocol with no record

boundaries The server's reply is normally a 26-byte string of the form

Mon May 26 20 : 58 : 40 2003\r\n

where \r is the ASCII carriage return and \n is the ASCII linefeed With a byte-stream

protocol, these 26 bytes can be returned in numerous ways: a single TCP segment containingall 26 bytes of data, in 26 TCP segments each containing 1 byte of data, or any other

combination that totals to 26 bytes Normally, a single segment containing all 26 bytes of data

is returned, but with larger data sizes, we cannot assume that the server's reply will be

returned by a single read Therefore, when reading from a TCP socket, we always need to code

the read in a loop and terminate the loop when either read returns 0 (i.e., the other end

closed the connection) or a value less than 0 (an error)

In this example, the end of the record is being denoted by the server closing the connection.This technique is also used by version 1.0 of the Hypertext Transfer Protocol (HTTP) Othertechniques are available For example, the Simple Mail Transfer Protocol (SMTP) marks the end

of a record with the two-byte sequence of an ASCII carriage return followed by an ASCIIlinefeed Sun Remote Procedure Call (RPC) and the Domain Name System (DNS) place abinary count containing the record length in front of each record that is sent when using TCP.The important concept here is that TCP itself provides no record markers: If an applicationwants to delineate the ends of records, it must do so itself and there are a few common ways

to accomplish this

Trang 34

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

26exit terminates the program Unix always closes all open descriptors when a process

terminates, so our TCP socket is now closed

As we mentioned, the text will go into much more detail on all the points we just described

[ Team LiB ]

Trang 35

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

[ Team LiB ]

1.3 Protocol Independence

Our program in Figure 1.5 is protocol-dependent on IPv4 We allocate and initialize a

sockaddr_in structure, we set the family of this structure to AF_INET, and we specify the firstargument to socket as AF_INET

To modify the program to work under IPv6, we must change the code Figure 1.6 shows aversion that works under IPv6, with the changes highlighted in bold

Figure 1.6 Version of Figure 1.5 for IPv6.

9 err_quit("usage: a.out <IPaddress>");

10 if ( (sockfd = socket(AF_INET6, SOCK_STREAM, 0)) < 0)

11 err_sys("socket error");

12 bzero(&servaddr, sizeof(servaddr));

13 servaddr.sin6_family = AF_INET6;

14 servaddr.sin6_port = htons(13); /* daytime server */

15 if (inet_pton(AF_INET6, argv[1], &servaddr.sin6_addr) <= 0)

16 err_quit("inet_pton error for %s", argv[1]);

17 if (connect(sockfd, (SA *) &servaddr, sizeof(servaddr)) < 0)

18 err_sys("connect error");

19 while ( (n = read(sockfd, recvline, MAXLINE)) > 0) {

20 recvline[n] = 0; /* null terminate */

21 if (fputs(recvline, stdout) == EOF)

Only five lines are changed, but what we now have is another protocol-dependent program;

this time, it is dependent on IPv6 It is better to make a program protocol-independent Figure11.11 will show a version of this client that is protocol-independent by using the getaddrinfo

function (which is called by tcp_connect)

Trang 36

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

dotted-decimal number (e.g., 206.168.112.219 for the IPv4 version) Humans work better withnames instead of numbers (e.g., www.unpbook.com) In Chapter 11, we will discuss the

functions that convert between hostnames and IP addresses, and between service names andports We purposely put off the discussion of these functions and continue using IP addressesand port numbers so we know exactly what goes into the socket address structures that wemust fill in and examine This also avoids complicating our discussion of network programmingwith the details of yet another set of functions

[ Team LiB ]

Trang 37

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

[ Team LiB ]

1.4 Error Handling: Wrapper Functions

In any real-world program, it is essential to check every function call for an error return In

Figure 1.5, we check for errors from socket, inet_pton, connect, read, and fputs, and whenone occurs, we call our own functions, err_quit and err_sys, to print an error message andterminate the program We find that most of the time, this is what we want to do

Occasionally, we want to do something other than terminate when one of these functionsreturns an error, as in Figure 5.12, when we must check for an interrupted system call

Since terminating on an error is the common case, we can shorten our programs by defining a

wrapper function that performs the actual function call, tests the return value, and terminates

on an error The convention we use is to capitalize the name of the function, as in

sockfd = Socket(AF_INET, SOCK_STREAM, 0);

Our wrapper function is shown in Figure 1.7

Figure 1.7 Our wrapper function for the socket function.

When describing the source code that is presented in the text, we always refer to the lowest level function being called (e.g., socket), not the wrapper function (e.g., Socket).While these wrapper functions might not seem like a big savings, when we discuss threads inChapter 26, we will find that thread functions do not set the standard Unix errno variable when

an error occurs; instead, the errno value is the return value of the function This means thatevery time we call one of the pthread_ functions, we must allocate a variable, save the returnvalue in that variable, and then set errno to this value before calling err_sys To avoid

cluttering the code with braces, we can use C's comma operator to combine the assignmentinto errno and the call of err_sys into a single statement, as in the following:

Trang 38

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

int n;

if ( (n = pthread_mutex_lock(&ndone_mutex)) != 0)

errno = n, err_sys("pthread_mutex_lock error");

Alternately, we could define a new error function that takes the system's error number as anargument But, we can make this piece of code much easier to read as just

Pthread_mutex_lock(&ndone_mutex);

by defining our own wrapper function, as shown in Figure 1.8

Figure 1.8 Our wrapper function for pthread_mutex_lock.

run-Our choice of capitalizing the first character of a function name is a compromise Manyother styles were considered: prefixing the function name with an "e" (as done on p 182

of [Kernighan and Pike 1984]), appending "_e" to the function name, and so on Our styleseems the least distracting while still providing a visual indication that some other

function is really being called

This technique has the side benefit of checking for errors from functions whose errorreturns are often ignored: close and listen, for example

Throughout the rest of this book, we will use these wrapper functions unless we need to checkfor an explicit error and handle it in some way other than terminating the process We do notshow the source code for all our wrapper functions, but the code is freely available (see thePreface)

Trang 39

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

Unix errno Value

When an error occurs in a Unix function (such as one of the socket functions), the globalvariable errno is set to a positive value indicating the type of error and the function normallyreturns –1 Our err_sys function looks at the value of errno and prints the correspondingerror message string (e.g., "Connection timed out" if errno equals ETIMEDOUT)

The value of errno is set by a function only if an error occurs Its value is undefined if thefunction does not return an error All of the positive error values are constants with all-

uppercase names beginning with "E," and are normally defined in the <sys/errno.h> header

No error has a value of 0

Storing errno in a global variable does not work with multiple threads that share all globalvariables We will talk about solutions to this problem in Chapter 26

Throughout the text, we will use phrases such as "the connect function returns ECONNREFUSED"

as shorthand to mean that the function returns an error (typically with a return value of –1),with errno set to the specified constant

[ Team LiB ]

Trang 40

[ Team LiB ]

API

ISBN: 0-13-141155-1

Pages: 1024

implementations

[ Team LiB ]

1.5 A Simple Daytime Server

We can write a simple version of a TCP daytime server, which will work with the client fromSection 1.2 We use the wrapper functions that we described in the previous section and showthis server in Figure 1.9

Figure 1.9 TCP daytime server.

6 int listenfd, connfd;

7 struct sockaddr_in servaddr;

14 servaddr.sin_port = htons(13); /* daytime server */

15 Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));

16 Listen(listenfd, LISTENQ);

17 for ( ; ; ) {

18 connfd = Accept(listenfd, (SA *) NULL, NULL);

19 ticks = time(NULL);

20 snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks));

21 Write(connfd, buff, strlen(buff));

22 Close(connfd);

23 }

24 }

Create a TCP socket

10 The creation of the TCP socket is identical to the client code

Bind server's well-known port to socket

11–15 The server's well-known port (13 for the daytime service) is bound to the socket byfilling in an Internet socket address structure and calling bind We specify the IP address as

Tiêu đề	Unix Network Programming Volume 1
Tác giả	W. Richard Stevens, Bill Fenner, Andrew M. Rudoff
Trường học	Wesley
Chuyên ngành	Computer Science
Thể loại	Sách hướng dẫn về lập trình mạng Unix
Năm xuất bản	2003
Thành phố	Unknown

Định dạng
Số trang	1.138
Dung lượng	13,7 MB