C语言套接字编程详解：Beej's Guide权威教程

需积分: 9 72 浏览量更新于2024-07-24 收藏 301KB PDF 举报

"Beej's Guide to Network Programming" 是由 Brian "Beej Jorgensen" Hall 编写的权威指南，专注于使用 C 语言进行网络编程，特别是涉及 Internet Sockets 的内容。该教程旨在为网络编程初学者提供深入且详尽的教学，适合对计算机通信、套接字原理感兴趣的开发者。该书从第 1 章开始，通过简短的介绍部分，明确了目标受众，包括对编程基础有一定了解的读者，并提到了平台兼容性，如 Solaris/SunOS 和 Windows 程序员可能需要注意的事项。书中还强调了电子邮件交流政策、文档的镜像和翻译政策，以及版权和分发规定。在第 2 章，作者解释了什么是套接字，区分了两种类型的 Internet Sockets：流式套接字（用于面向连接的通信）和数据报套接字（无连接的通信）。随后，第 3 章讨论了套接字编程中的数据处理和结构，包括如何转换本地数据类型以及处理 IP 地址。第 4 章为核心内容，涵盖了系统调用的重要性，如 `socket()` 函数用于获取文件描述符，`bind()` 设置套接字绑定到特定端口，`connect()` 建立连接，`listen()` 和 `accept()` 分别用于监听和接受连接请求。`send()` 和 `recv()` 用于双向通信，而 `sendto()` 和 `recvfrom()` 则是针对数据报套接字的无连接发送和接收。此外，还有 `close()` 和 `shutdown()` 关闭套接字和停止通信，以及 `getpeername()` 获取连接对方的地址和 `gethostname()` 查询本地主机名。 DNS（域名系统）部分则介绍了如何通过域名查找 IP 地址，这对于处理网络地址时必不可少。整个指南以实践为导向，理论与示例紧密结合，让读者能够迅速掌握 C 语言网络编程的基本技能。 "Beej's Guide to Network Programming" 是一个全面的教程，对于希望通过 C 语言进行网络编程的学习者来说，无论是理解套接字工作原理，还是学习实际操作技巧，都是一份极具价值的资源。

4. System Calls or Bust

This is the section where we get into the system calls that allow you to access the network

functionality of a Unix box. When you call one of these functions, the kernel takes over and does all

the work for you automagically.

The place most people get stuck around here is what order to call these things in. In that, the

man pages are no use, as you've probably discovered. Well, to help with that dreadful situation, I've

tried to lay out the system calls in the following sections in exactly (approximately) the same order

that you'll need to call them in your programs.

That, coupled with a few pieces of sample code here and there, some milk and cookies (which

I fear you will have to supply yourself), and some raw guts and courage, and you'll be beaming data

around the Internet like the Son of Jon Postel!

4.1. socket()—Get the File Descriptor!

I guess I can put it off no longer—I have to talk about the socket() system call. Here's the

breakdown:

#include <sys/types.h>

#include <sys/socket.h>

int socket(int domain, int type, int protocol);

But what are these arguments? First, domain should be set to “PF_INET”. Next, the type

argument tells the kernel what kind of socket this is: SOCK_STREAM or SOCK_DGRAM. Finally, just

set protocol to “0” to have socket() choose the correct protocol based on the type. (Notes:

there are many more domains than I've listed. There are many more types than I've listed. See the

socket() man page. Also, there's a “better” way to get the protocol, but specifying 0 works in

99.9% of all cases. See the getprotobyname() man page if you're curious.)

socket() simply returns to you a socket descriptor that you can use in later system calls, or

-1 on error. The global variable errno is set to the error's value (see the perror() man page.)

(This PF_INET thing is a close relative of the AF_INET that you used when initializing the

sin_family field in your struct sockaddr_in. In fact, they're so closely related that they

actually have the same value, and many programmers will call socket() and pass AF_INET as the

first argument instead of PF_INET. Now, get some milk and cookies, because it's times for a story.

Once upon a time, a long time ago, it was thought that maybe a address family (what the “AF”

in “AF_INET” stands for) might support several protocols that were referred to by their protocol

family (what the “PF” in “PF_INET” stands for). That didn't happen. And they all lived happily ever

after, The End. So the most correct thing to do is to use AF_INET in your struct sockaddr_in

and PF_INET in your call to socket().)

Fine, fine, fine, but what good is this socket? The answer is that it's really no good by itself,

and you need to read on and make more system calls for it to make any sense.

4.2. bind()—What port am I on?

Once you have a socket, you might have to associate that socket with a port on your local

machine. (This is commonly done if you're going to listen() for incoming connections on a

specific port—MUDs do this when they tell you to “telnet to x.y.z port 6969”.) The port number

Beej's Guide to Network Programming 13

is used by the kernel to match an incoming packet to a certain process's socket descriptor. If you're

going to only be doing a connect(), this may be unnecessary. Read it anyway, just for kicks.

Here is the synopsis for the bind() system call:

#include <sys/types.h>

#include <sys/socket.h>

int bind(int sockfd, struct sockaddr *my_addr, int addrlen);

sockfd is the socket file descriptor returned by socket(). my_addr is a pointer to a struct

sockaddr that contains information about your address, namely, port and IP address. addrlen can

be set to sizeof *my_addr or sizeof(struct sockaddr).

Whew. That's a bit to absorb in one chunk. Let's have an example:

#include <string.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#define MYPORT 3490

int main(void)

{

int sockfd;

struct sockaddr_in my_addr;

sockfd = socket(PF_INET, SOCK_STREAM, 0); // do some error checking!

my_addr.sin_family = AF_INET; // host byte order

my_addr.sin_port = htons(MYPORT); // short, network byte order

my_addr.sin_addr.s_addr = inet_addr("10.12.110.57");

memset(my_addr.sin_zero, '\0', sizeof my_addr.sin_zero);

// don't forget your error checking for bind():

bind(sockfd, (struct sockaddr *)&my_addr, sizeof my_addr);

There are a few things to notice here: my_addr.sin_port is in Network Byte Order. So is

my_addr.sin_addr.s_addr. Another thing to watch out for is that the header files might differ

from system to system. To be sure, you should check your local man pages.

Lastly, on the topic of bind(), I should mention that some of the process of getting your own

IP address and/or port can be automated:

my_addr.sin_port = 0; // choose an unused port at random

my_addr.sin_addr.s_addr = INADDR_ANY; // use my IP address

See, by setting my_addr.sin_port to zero, you are telling bind() to choose the port for

you. Likewise, by setting my_addr.sin_addr.s_addr to INADDR_ANY, you are telling it to

automatically fill in the IP address of the machine the process is running on.

If you are into noticing little things, you might have seen that I didn't put INADDR_ANY into

Network Byte Order! Naughty me. However, I have inside info: INADDR_ANY is really zero! Zero

still has zero on bits even if you rearrange the bytes. However, purists will point out that there could

be a parallel dimension where INADDR_ANY is, say, 12 and that my code won't work there. That's

okay with me:

Beej's Guide to Network Programming 14

my_addr.sin_port = htons(0); // choose an unused port at random

my_addr.sin_addr.s_addr = htonl(INADDR_ANY); // use my IP address

Now we're so portable you probably wouldn't believe it. I just wanted to point that out, since

most of the code you come across won't bother running INADDR_ANY through htonl().

bind() also returns -1 on error and sets errno to the error's value.

Another thing to watch out for when calling bind(): don't go underboard with your port

numbers. All ports below 1024 are RESERVED (unless you're the superuser)! You can have any

port number above that, right up to 65535 (provided they aren't already being used by another

program.)

Sometimes, you might notice, you try to rerun a server and bind() fails, claiming “Address

already in use.” What does that mean? Well, a little bit of a socket that was connected is still

hanging around in the kernel, and it's hogging the port. You can either wait for it to clear (a minute

or so), or add code to your program allowing it to reuse the port, like this:

int yes=1;

//char yes='1'; // Solaris people use this

// lose the pesky "Address already in use" error message

if (setsockopt(listener,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) {

perror("setsockopt");

exit(1);

}

One small extra final note about bind(): there are times when you won't absolutely have to

call it. If you are connect()ing to a remote machine and you don't care what your local port is (as

is the case with telnet where you only care about the remote port), you can simply call connect(),

it'll check to see if the socket is unbound, and will bind() it to an unused local port if necessary.

4.3. connect()—Hey, you!

Let's just pretend for a few minutes that you're a telnet application. Your user commands you

(just like in the movie TRON) to get a socket file descriptor. You comply and call socket(). Next,

the user tells you to connect to “10.12.110.57” on port “23” (the standard telnet port.) Yow!

What do you do now?

Lucky for you, program, you're now perusing the section on connect()—how to connect to a

remote host. So read furiously onward! No time to lose!

The connect() call is as follows:

#include <sys/types.h>

#include <sys/socket.h>

int connect(int sockfd, struct sockaddr *serv_addr, int addrlen);

sockfd is our friendly neighborhood socket file descriptor, as returned by the socket() call,

serv_addr is a struct sockaddr containing the destination port and IP address, and addrlen

can be set to sizeof *serv_addr or sizeof(struct sockaddr).

Isn't this starting to make more sense? Let's have an example:

#include <string.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#define DEST_IP "10.12.110.57"

#define DEST_PORT 23

Beej's Guide to Network Programming 15

int main(void)

{

int sockfd;

struct sockaddr_in dest_addr; // will hold the destination addr

sockfd = socket(PF_INET, SOCK_STREAM, 0); // do some error checking!

dest_addr.sin_family = AF_INET; // host byte order

dest_addr.sin_port = htons(DEST_PORT); // short, network byte order

dest_addr.sin_addr.s_addr = inet_addr(DEST_IP);

memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);

// don't forget to error check the connect()!

connect(sockfd, (struct sockaddr *)&dest_addr, sizeof dest_addr);

Again, be sure to check the return value from connect()—it'll return -1 on error and set the

variable errno.

Also, notice that we didn't call bind(). Basically, we don't care about our local port number;

we only care where we're going (the remote port). The kernel will choose a local port for us, and the

site we connect to will automatically get this information from us. No worries.

4.4. listen()—Will somebody please call me?

Ok, time for a change of pace. What if you don't want to connect to a remote host. Say, just for

kicks, that you want to wait for incoming connections and handle them in some way. The process is

two step: first you listen(), then you accept() (see below.)

The listen call is fairly simple, but requires a bit of explanation:

int listen(int sockfd, int backlog);

sockfd is the usual socket file descriptor from the socket() system call. backlog is the

number of connections allowed on the incoming queue. What does that mean? Well, incoming

connections are going to wait in this queue until you accept() them (see below) and this is the

limit on how many can queue up. Most systems silently limit this number to about 20; you can

probably get away with setting it to 5 or 10.

Again, as per usual, listen() returns -1 and sets errno on error.

Well, as you can probably imagine, we need to call bind() before we call listen() or

the kernel will have us listening on a random port. Bleah! So if you're going to be listening for

incoming connections, the sequence of system calls you'll make is:

socket();

bind();

listen();

/* accept() goes here */

I'll just leave that in the place of sample code, since it's fairly self-explanatory. (The code in the

accept() section, below, is more complete.) The really tricky part of this whole sha-bang is the

call to accept().

4.5. accept()—“Thank you for calling port 3490.”

Get ready—the accept() call is kinda weird! What's going to happen is this: someone far

far away will try to connect() to your machine on a port that you are listen()ing on. Their

Beej's Guide to Network Programming 16

connection will be queued up waiting to be accept()ed. You call accept() and you tell it to get

the pending connection. It'll return to you a brand new socket file descriptor to use for this single

connection! That's right, suddenly you have two socket file descriptors for the price of one! The

original one is still listening on your port and the newly created one is finally ready to send() and

recv(). We're there!

The call is as follows:

#include <sys/types.h>

#include <sys/socket.h>

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

sockfd is the listen()ing socket descriptor. Easy enough. addr will usually be a pointer to

a local struct sockaddr_in. This is where the information about the incoming connection will

go (and with it you can determine which host is calling you from which port). addrlen is a local

integer variable that should be set to sizeof *addr or sizeof(struct sockaddr_in) before

its address is passed to accept(). Accept will not put more than that many bytes into addr. If it

puts fewer in, it'll change the value of addrlen to reflect that.

Guess what? accept() returns -1 and sets errno if an error occurs. Betcha didn't figure that.

Like before, this is a bunch to absorb in one chunk, so here's a sample code fragment for your

perusal:

#include <string.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#define MYPORT 3490 // the port users will be connecting to

#define BACKLOG 10 // how many pending connections queue will hold

int main(void)

{

int sockfd, new_fd; // listen on sock_fd, new connection on new_fd

struct sockaddr_in my_addr; // my address information

struct sockaddr_in their_addr; // connector's address information

int sin_size;

sockfd = socket(PF_INET, SOCK_STREAM, 0); // do some error checking!

my_addr.sin_family = AF_INET; // host byte order

my_addr.sin_port = htons(MYPORT); // short, network byte order

my_addr.sin_addr.s_addr = INADDR_ANY; // auto-fill with my IP

memset(my_addr.sin_zero, '\0', sizeof my_addr.sin_zero);

// don't forget your error checking for these calls:

bind(sockfd, (struct sockaddr *)&my_addr, sizeof my_addr);

listen(sockfd, BACKLOG);

sin_size = sizeof their_addr;

new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);

剩余91页未读，继续阅读

林夕林海

粉丝: 0
资源: 1

C语言套接字编程详解：Beej's Guide权威教程

beej-s-guide-to-network-programming-Chinese-zh.pdf

Beej's Guide to Network Programming

Beej Guide to Network Programming简体中文完整版

Beej's Guide to Network Programming.pdf

Beej's Guide to Network Programming网络编程

Beej's Guide to Network Programming Using Internet Sockets

网络编程书籍Beej’s Guide to Network Programming

Beej’s Guide to Network Programming Using Internet Sockets

Beej's Guide to Network Programming详解

Beej's Guide to Network Programming - Unix Socket Edition

最新资源