c 语言socket接口介绍,新手socket编程入门详解指南

开发环境

运行平台：Ubantu 14.04 LTS

疑问引导

问题1：头文件的疑问：

#include 与#include 有何区别？

解答：

1. 使用diff查看：adc分别表示添加、删除、修改

2. 其实是路径的不同导致有不同的socke.h文件

3.  是 Internet Protocol family，也就是tcpip协议的应用层接口

4. 目前暂时未弄懂，但不是接口函数，估计是系统函数。它应该是被操作系统使用，猜测该文件在tcpip的传输层

问题2：大小端字节序问题：

1.c语言检测：利用指针取值和取址的交叉应用，为了增强网络移植性

2. 而socket提供了字节序转换函数：h：host；n：network；l：long32位；s：short16位

3. htonl：将主机的32位主机字节序(ip地址)，转换为网络字节序(一列数据)。

问题3：就一个服务器、一个客户端来说，有如下的对应角色说法：

对象first

对象second

服务器

客户端

监听者

广播者

提供服务

请求服务

解析socket编程整体过程：

建立与删除

服务器和客户端通过同一的socket信道通信，而创建一个socket信道，提供socket连接。

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

domain(域)：各个域以AF_XXX命令，意指地址族。决定使用何种的地址类型，确定通信特性：包括地址格式

type：确定套字节的类型，(还)可以自由增加类型。

常用：SOCK_STREAM (即：TCP)和 SOCK_DGRAM(即：UDP)

protocol：指定socket使用的传输协议编号，一般直接设置为0即可，以此表示为给定的域和套接字类型选择默认的传输协议。

返回值：正确返回套接字处理代码(我称之为套接字文件描述符)，错误返回-1。该数值将存储使用。

服务器和客户端通都可以，关闭socket通信IO

int shutdown(int s,int how);

s：代表socket_fd，需要关闭的套接字文件描述符

how：为一种方式

shutdown是使socket信道处于不活动状态。可以让该信道关闭写端，而继续接收该套接字读端以此确定数据何时结束，然后再使用close来关闭这个信道。

连接关系

创建和销毁或关闭IO之后，需要知道如何标识一个目标通信进程。

原因：网络有多个计算机，某台计算机上运行着多个程序(进程)。下面是两层关系：

1)目标计算机的网络地址

2)目标计算机上的目标进程的所代表的端口号

所以，目前你需要了解到的有下面几点：

1. 字节序：直接看上面的问题2即可，简单的转换关系。

2. 地址格式：根据不同的因特网地址，在定义不同的结构体，部分socket函数参数调用。如下

3. 定义地址结构体，根据实际装入数值作为socket API实参

4. 地址进制转换：对地址进行二进制与文本字符串格式之间的转换。inet_ntop或inet_pton

绑定接着，对于服务端来说，需要绑定(关联)地址和套接字。为给定的sockfd关联一个sockaddr结构数据。只有服务端将套接字绑定在(域)地址上，客户端才能够连接(connect)成功。

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

sockfd：套接字文件描述符，是socket返回的值

my_addr：(服务器)网络地址信息

返回值：判断是否正确绑定地址和套接字

连接在此之前，我们创建了套接字(socket)、建立连接基础(bind)。那么，就这就是为了在通信之前，将socket信道连接起来。

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

sockfd：套接字文件描述符，是socket返回的值

serv_addr ：网络地址信息

返回值：判断是否正确连接，客户端程序必须要能够处理connect返回的错误。

到目前，你或许已经发现了，connect函数的参数类型与个数都跟bind是一样的(他们的值并不一样，我所说的是形式)，结合一起去理解，会更好。

毕竟，根据TCPIP协议，需要连接的信息：IP地址，端口号，就已经足够了。至于其余的MAC地址等等，在socket里面，我们不需要理会。

监听需要注意的是，这种连接，服务器还需要确定是哪个客户端请求连接。所以，服务器首先进入运行请求客户端(任意一个)连接的状态，进入listen(监听)状态。使用函数：

int listen(int s,int backlog);

s：服务器套接字描述符，是socket返回的值

backlog：指定同时能够处理的最大连接要求

函数返回值：是否正确进入监听状态

连接这时候，服务器已经进入了listen状态，然后紧接着调用：

int accept(int s,struct sockaddr * addr,int * addrlen);

s：服务器套接字描述符，是socket返回的值

addr：某一被连接的客户端的套接字数据

addrlen：某一被连接的客户端的套接字数据长度

返回：某一被连接的客户端的文件描述符

读取与发送数据

到目前为止，服务器和客户端都已经做好了双向通信的基础准备。

send与recv暂时不提及，读者自己去查API

int recv(int s,void *buf,int len,unsigned int flags);

int send(int s,const void * msg,int len,unsigned int falgs);

以下直接与代码相关：

//常用包含头文件 and socket编程的作用

#include //

#include //

#include //errno错误信息变量

#include //

#include //

#include //提供socket API

#include //

#include //socket API参数的类型定义文件

#include //地址转换函数

#include //字节序函数(宏)、域地址类型定义

客户端代码：

#include

#include

#include

#include

#include

#include "wrap.h"

#define MAXLINE 80

#define SERV_PORT 8000

int main(int argc, char *argv[])

{

struct sockaddr_in servaddr;

char buf[MAXLINE];

int sockfd, n;

sockfd = Socket(AF_INET, SOCK_STREAM, 0);

bzero(&servaddr, sizeof(servaddr));

servaddr.sin_family = AF_INET;

inet_pton(AF_INET, "192.168.191.6", &servaddr.sin_addr);

servaddr.sin_port = htons(SERV_PORT);

Connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr));

while (fgets(buf, MAXLINE, stdin) != NULL) {

Write(sockfd, buf, strlen(buf));

n = Read(sockfd, buf, MAXLINE);

if (n == 0)

printf("the other side has been closed.\n");

else

Write(STDOUT_FILENO, buf, n);

}

Close(sockfd);

return 0;

}

服务器代码：

#include

#include

#include

#include "wrap.h"

#define MAXLINE 80

#define SERV_PORT 8000

int main(void)

{

struct sockaddr_in servaddr, cliaddr;

socklen_t cliaddr_len;

int listenfd, connfd;

char buf[MAXLINE];

char str[INET_ADDRSTRLEN];

int i, n;

listenfd = Socket(AF_INET, SOCK_STREAM, 0);

bzero(&servaddr, sizeof(servaddr));

servaddr.sin_family = AF_INET;

servaddr.sin_addr.s_addr = inet_addr("192.168.191.6");

servaddr.sin_port = htons(SERV_PORT);

Bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));

Listen(listenfd, 20);

printf("Accepting connections ...\n");

while (1) {

cliaddr_len = sizeof(cliaddr);

connfd = Accept(listenfd,

(struct sockaddr *) &cliaddr,

&cliaddr_len);

while (1) {

n = Read(connfd, buf, MAXLINE);

if (n == 0) {

printf("the other side has been closed.\n");

break;

}

printf("received from %s at PORT %d\n",

(char *)inet_ntop(AF_INET,

&cliaddr.sin_addr, str,

sizeof(str)),

(int)ntohs(cliaddr.sin_port));

for (i = 0; i < n; i++)

buf[i] = toupper(buf[i]);

Write(connfd, buf, n);

}

Close(connfd);

}

}

运行结果：

hhc@my:~/sharefile/socket/tcp$ ./server &

[1] 15371

hhc@my:~/sharefile/socket/tcp$ Accepting connections ...

hhc@my:~/sharefile/socket/tcp$ ./client

this is a test!

received from 192.168.191.6 at PORT 53685

THIS IS A TEST!

个人封装的socket接口函数：

#include "wrap.h"

void perr_exit(const char *s)

{

perror(s);

exit(1);

}

int Accept(int fd, struct sockaddr *sa, socklen_t * salenptr)

{

int n;

again:

if ((n = accept(fd, sa, salenptr)) < 0) {

if ((errno == ECONNABORTED) || (errno == EINTR))

goto again;

else

perr_exit("accept error");

}

return n;

}

void Bind(int fd, const struct sockaddr *sa, socklen_t salen)

{

if (bind(fd, sa, salen) < 0)

perr_exit("bind error");

}

void Connect(int fd, const struct sockaddr *sa, socklen_t salen)

{

if (connect(fd, sa, salen) < 0)

perr_exit("connect error");

}

void Listen(int fd, int backlog)

{

if (listen(fd, backlog) < 0)

perr_exit("listen error");

}

int Socket(int family, int type, int protocol)

{

int n;

if ((n = socket(family, type, protocol)) < 0)

perr_exit("socket error");

return n;

}

ssize_t Read(int fd, void *ptr, size_t nbytes)

{

ssize_t n;

again:

if ((n = read(fd, ptr, nbytes)) == -1) {

if (errno == EINTR)

goto again;

else

return -1;

}

return n;

}

ssize_t Write(int fd, const void *ptr, size_t nbytes)

{

ssize_t n;

again:

if ((n = write(fd, ptr, nbytes)) == -1) {

if (errno == EINTR)

goto again;

else

return -1;

}

return n;

}

void Close(int fd)

{

if (close(fd) == -1)

perr_exit("close error");

}

ssize_t Readn(int fd, void *vptr, size_t n)

{

size_t nleft;

ssize_t nread;

char *ptr;

ptr = vptr;

nleft = n;

while (nleft > 0) {

if ((nread = read(fd, ptr, nleft)) < 0) {

if (errno == EINTR)

nread = 0;

else

return -1;

} else if (nread == 0)

break;

nleft -= nread;

ptr += nread;

}

return n - nleft;

}

ssize_t Writen(int fd, const void *vptr, size_t n)

{

size_t nleft;

ssize_t nwritten;

const char *ptr;

ptr = vptr;

nleft = n;

while (nleft > 0) {

if ((nwritten = write(fd, ptr, nleft)) <= 0) {

if (nwritten < 0 && errno == EINTR)

nwritten = 0;

else

return -1;

}

nleft -= nwritten;

ptr += nwritten;

}

return n;

}

ssize_t my_read(int fd, char *ptr)

{

static int read_cnt;

static char *read_ptr;

static char read_buf[100];

if (read_cnt <= 0) {

again:

if ((read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {

if (errno == EINTR)

goto again;

return -1;

} else if (read_cnt == 0)

return 0;

read_ptr = read_buf;

}

read_cnt--;

*ptr = *read_ptr++;

return 1;

}

ssize_t Readline(int fd, void *vptr, size_t maxlen)

{

ssize_t n, rc;

char c, *ptr;

ptr = vptr;

for (n = (ssize_t)1; n < (ssize_t)maxlen; n++) {

if ((rc = my_read(fd, &c)) == 1) {

*ptr++ = c;

if (c == '\n')

break;

} else if (rc == 0) {

*ptr = 0;

return n - 1;

} else

return -1;

}

*ptr = 0;

return n;

}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。