【转】 Openssl之BIO系列

电玩女神 2022-07-17 04:16 600阅读 0赞

## 1.BIO-抽象的IO接口 ##

## 其实包含了很多种接口，用通用的函数接口，主要控制在BIO\_METHOD中的不同实现函数控制，我初步估计了一下，大概有14种，包括4种filter型和10种source/sink型。  BIO是在底层覆盖了许多类型I/O接口细节的一种应用接口，如果你在程序中使用BIO，那么就可以和SSL、非加密的网络以及文件IO进行透明的连接。有两种不通的BIO接口，一种是source/sink型，一种是fileter型。  顾名思义，source/sink类型的BIO是数据源或输入数据源（我不知道sink该怎么翻译），例如，sokect BIO和文件BIO。而filter BIO就是把数据从一个BIO转换到另外一个BIO或应用接口，在转换过程中，这些数据可以不修改（如信息摘要BIO），也可以进行转换。例如在加密BIO中，如果写操作，数据就会被加密，如果是读操作，数据就会被解密。  BIO可以连接在一起成为一个BIO链（单个的BIO就是一个环节的BIO链的特例），如下是BIO的结构定义，可以看到它有上下环节的：  struct bio\_st  \{   BIO\_METHOD \*method;  /\* bio, mode, argp, argi, argl, ret \*/  long (\*callback)(struct bio\_st \*,int,const char \*,int, long,long);  char \*cb\_arg; /\* first argument for the callback \*/     int init;  int shutdown;  int flags; /\* extra storage \*/  int retry\_reason;  int num;  void \*ptr;  struct bio\_st \*next\_bio; /\* used by filter BIOs \*/BIO下联  struct bio\_st \*prev\_bio; /\* used by filter BIOs \*/BIO上联  int references;  unsigned long num\_read;  unsigned long num\_write;     CRYPTO\_EX\_DATA ex\_data;  \};  一个BIO链通常包括一个source BIO和一个或多个filter BIO，数据从第一个BIO读出或写入，然后经过一系列BIO变化到输出（通常是一个source/sink BIO）。 ##

## 2.BIO结构介绍 ##

## BIO的结构定义和相关项解析如下：（包含在bio.h文件中，其主文件为bio\_lib.c）  typedef struct bio\_st BIO;     struct bio\_st  \{   BIO\_METHOD \*method;  /\*BIO方法结构，是决定BIO类型和行为的重要参数，各种BIO的不同之处主要也正在于此项。\*/  /\* bio, mode, argp, argi, argl, ret \*/  long (\*callback)(struct bio\_st \*,int,const char \*,int, long,long); //BIO回调函数  char \*cb\_arg; /\* first argument for the callback \*/ //回调函数的第一个参量     int init; //初始化标志，初始化了为1，否则为0  int shutdown; //BIO开关标志，如果为1，则处于关闭状态，如果为0，则处于打开的状态。  int flags; /\* extra storage \*/  int retry\_reason;  int num;  void \*ptr;  struct bio\_st \*next\_bio; /\* used by filter BIOs \*/BIO下联  struct bio\_st \*prev\_bio; /\* used by filter BIOs \*/BIO上联  int references;  unsigned long num\_read;//读出的数据长度  unsigned long num\_write;//写入的数据长度     CRYPTO\_EX\_DATA ex\_data;  \};  在BIO的所用成员中，method可以说是最关键的一个成员，它决定了BIO的类型，可以看到，在声明一个新的BIO结构时，总是使用下面的声明：  BIO\* BIO\_new(BIO\_METHOD \*type);  在源代码可以看出，BIO\_new函数除了给一些初始变量赋值外，主要就是把type中的各个变量赋值给BIO结构中的method成员。一般来说，上述type参数是以一个类型生成函数的形式提供的，如生成一个mem型的BIO结构，就使用下面的语句：  BIO \*mem = BIO\_new(BIO\_s\_mem());  这样的函数有以下一些： ##

### 2.1 source/sink型 ###

## 1.       BIO\_s\_accept()：是一个封装了类似TCP/IP socket Accept规则的接口，并且使TCP/IP操作对于BIO接口是透明的。  2.       BIO\_s\_bio()：封装了一个BIO对，数据从其中一个BIO写入，从另外一个BIO读出  3.       BIO\_s\_connect()：是一个封装了类似TCP/IP socket Connect规则的接口，并且使TCP/IP操作对于BIO接口是透明的  4.       BIO\_s\_fd()：是一个封装了文件描述符的BIO接口，提供类似文件读写操作的功能  5.       BIO\_s\_file()：封装了标准的文件接口的BIO，包括标志的输入输出设备如stdin等  6.       BIO\_s\_mem()：封装了内存操作的BIO接口，包括了对内存的读写操作  7.       BIO\_s\_null()：返回空的sink型BIO接口，写入这种接口的所有数据读被丢弃，读的时候总是返回EOF  8.       BIO\_s\_socket()：封装了socket接口的BIO类型 ##

### 2.2 filter型 ###

## 1.       BIO\_f\_base64()：封装了base64编码方法的BIO,写的时候进行编码，读的时候解码  2.       BIO\_f\_buffer()：封装了缓冲区操作的BIO，写入该接口的数据一般是准备传入下一个BIO接口的，从该接口读出的数据一般也是从另一个BIO传过来的。  3.       BIO\_f\_cipher()：封装了加解密方法的BIO，写的时候加密，读的时候解密  4.       BIO\_f\_md()：封装了信息摘要方法的BIO，通过该接口读写的数据都是已经经过摘要的。  5.       BIO\_f\_null()：一个不作任何事情的BIO，对它的操作都简单传到下一个BIO去了，相当于不存在。  6.       BIO\_f\_ssl()：封装了openssl 的SSL协议的BIO类型，也就是为SSL协议增加了一些BIO操作方法。  上述各种类型的函数正是构成BIO强大功能的基本单元，所以，要了解BIO的各种结构和功能，也就应该了解这些函数类型相关的操作函数。所有这些源文件，都基本上包含于/crypto/bio/目录下的同名.c文件（大部分是同名的）中。  在BIO\_METHOD里面，定义了一组行为函数，上述不同类型的BIO\_METHOD行为函数的定义是不同的，其结构如下（以非16位系统为例）：  typedef struct bio\_method\_st  \{   int type;  const char \*name;  int (\*bwrite)(BIO \*, const char \*, int);  int (\*bread)(BIO \*, char \*, int);  int (\*bputs)(BIO \*, const char \*);  int (\*bgets)(BIO \*, char \*, int);  long (\*ctrl)(BIO \*, int, long, void \*);  int (\*create)(BIO \*);  int (\*destroy)(BIO \*);  long (\*callback\_ctrl)(BIO \*, int, bio\_info\_cb \*);  \} BIO\_METHOD;  在BIO的成员中，callback也是比较重要的，它能够用于程序调试用或者自定义改变BIO的行为。详细会在以后相关的部分介绍。BIO的很多操作，都是BIO\_ctrl系列函数根据不同参数组成的宏定义来完成的。所以要了解BIO的行为，了解BIO\_ctrl系列函数以及其各个参数的意义也是很重要的。 ##

### 2.3 BIO目录文件的简要说明 ###

## 1.       bio.h：主定义的头文件，包括了很多通用的宏的定义。  2.       bio\_lib.c主要的BIO操作定义文件，是比较上层的函数了。  3.       bss\_\*系列：是soruce/sink型BIO具体的操作实现文件  4.       bf\_\*系列：是filter型BIO具体的操作实现文件  5.       bio\_err.c:是错误信息处理文件  6.       bio\_cb.c：是callback函数的相关文件  7.       b\_print.c:是信息输出的处理函数文件  8.       b\_socket.c:是Socket连接的一些相关信息处理文件  9.       b\_dump.c:是对内存内容的存储操作处理 ##

## 3.BIO的声明和释放等基本操作 ##

## 在BIO的基本操作系列函数中，他们用来BIO分配和释放操作，其声明形式如下（openssl/bio.h）：  BIO \* BIO\_new(BIO\_METHOD \*type);  int BIO\_set(BIO \*a,BIO\_METHOD \*type);  int BIO\_free(BIO \*a);  void BIO\_vfree(BIO \*a);  void BIO\_free\_all(BIO \*a);  下面分别对这些函数进行解释： ##

### 3.1 BIO\_new ###

## 这个函数创建并返回一个相应的新的BIO，并根据给定的BIO\_METHOD类型调用下述的BIO\_set()函数给BIO结构的method成员赋值，如果创建或给method赋值失败，则返回NULL。创建一个Memory类型的BIO例子如下：  BIO\* mem=BIO\_new(BIO\_s\_mem());  有些类型的BIO使用BIO\_new()函数之后就可以直接使用了，如memory类型的BIO；而有些BIO创建之后还需要一些初始化工作，如文件BIO。一般来说，也提供了这样的一些函数来创建和初始化这种类型的BIO。  这是什么意思呢，举个简单的例子大家就明白了。比如创建一个文件BIO，使用下面的代码：  BIO\* in=NULL;  in=BIO\_new(BIO\_s\_file());  BIO\_read\_filename(in,"rsa512.pem");  这样，BIO in才能使用，而如果是创建一个memory类型的BIO，则只需要如下一句代码：  BIO\* mem=BIO\_new(BIO\_s\_mem());  然后就可以对该BIO mem进行操作了。  另外，需要补充的是（这个大家从前面两篇文章可能已经认识到了），对于source/sink类型的BIO，其类型创建函数一般为BIO\_s\_\*的形式，对于filter型的函数，其类型创建函数一般为BIO\_f\_\*的形式。 ##

### 3.2 BIO\_set ###

## 该函数功能比较简单，就是对一个已经存在的BIO设置新的BIO\_METHOD类型。其实就是简单的对BIO的各个成员进行初始化，并将参数type赋值给该BIO。其实，BIO\_new函数在使用OPENSSL\_malloc给BIO分配了内存之后，就简单调用了BIO\_set函数进行初始化工作。所以一般来说，除非你要重新设置你已经存在的BIO，否则是不需要直接调用这个函数的。成功操作返回1，否则返回0。 ##

### 3.3 BIO\_free ###

## 该函数释放单个BIO的内存和资源，成功操作返回1，失败返回0。BIO的操作不仅仅是释放BIO结构所占用的资源，也会释放其下层的I/O资源，比如关闭释放相关的文件符等，这对不同类型的BIO是不一样的，详细的请参看各种类型BIO本身的说明文件和源文件。需要注意的是，BIO\_free只释放当前的一个BIO，如果用来释放一个BIO链，就可能会导致内存泄漏，这种情况应该使用下述的BIO\_free\_all函数。 ##

### 3.4 BIO\_vfree ###

## 该函数功能与BIO\_free完全相同，只是没有返回值。事实上，它简单调用了BIO\_free函数，但不返回该函数的返回值，所以它的函数实现代码只有一个语句。 ##

### 3.5 BIO\_free\_all ###

## 该函数释放这个BIO链，并且即使在这个过程中，如果释放其中一个BIO出错，释放过程也不会停止，会继续释放下面的BIO，这保证了尽量避免内存泄漏的出现。如果你非要调用这个函数释放单个的BIO，那么效果跟BIO\_free是一样的。事实上，该函数只是简单的遍历整个BIO链，并调用BIO\_free释放各个环节的BIO。 ##

## 4.BIO控制函数介绍 ##

## BIO控制函数有许多，并且不同的BIO类型还有不同的控制函数，这里只简单介绍一些通用的BIO控制函数，至于某种类型BIO的特定控制函数，则参考后续的文件。  BIO的通用控制函数有以下几种，其声明如下（openssl/bio.h）：  long BIO\_ctrl(BIO \*bp,int cmd,long larg,void \*parg);  long BIO\_callback\_ctrl(BIO \*b, int cmd, void (\*fp)(struct bio\_st \*, int, const char \*, int, long, long));  char \* BIO\_ptr\_ctrl(BIO \*bp,int cmd,long larg);  long BIO\_int\_ctrl(BIO \*bp,int cmd,long larg,int iarg);     int BIO\_reset(BIO \*b);  int BIO\_seek(BIO \*b, int ofs);  int BIO\_tell(BIO \*b);  int BIO\_flush(BIO \*b);  int BIO\_eof(BIO \*b);  int BIO\_set\_close(BIO \*b,long flag);  int BIO\_get\_close(BIO \*b);  int BIO\_pending(BIO \*b);  int BIO\_wpending(BIO \*b);  size\_t BIO\_ctrl\_pending(BIO \*b);  size\_t BIO\_ctrl\_wpending(BIO \*b);  其实，在这些函数中，除了BIO\_ctrl、BIO\_callback\_ctrl、BIO\_ptr\_ctrl,BIO\_int\_ctrl、BIO\_ctrl\_pending、BIO\_ctrl\_wpending是真正的函数外，其它都是宏定义，而且，在这些函数中，除了BIO\_ctrl、BIO\_callback\_ctrl，其它基本上都是简单的BIO\_ctrl输入不同的参数的调用。下面就一个一个介绍这些函数。 ##

### 4.1 BIO\_ctrl ###

## 从上面的叙述可以知道，BIO\_ctrl是整个控制函数中最基本的函数，它支持不同的命令输入，从而产生不同的功能，由此，它也就衍生了许多其它函数，作为一个比较地层的控制函数，一般来说用户并不需要直接调用它，因为在它之上已经使用宏定义和函数调用的形式建造了许多直接面向用户的函数。  filter型的BIO没有定义BIO\_ctrl功能，如果对他们调用这个函数，他们就简单的把命令传到BIO链中的下一个BIO。也就是说，通常可以不用直接调用一个BIO的BIO\_ctrl函数，只需要在它所在的BIO链上调用该函数，那么BIO链就会自动将该调用函数传到相应的BIO上去。这样可能就会导致一些意想不到的结果，比如，在目前的filter型BIO中没有实现BIO\_seek()函数（大家待会就会明白BIO\_seek就是BIO\_ctrl的简单宏定义），但如果在这个BIO链上的末尾是一个文件或文件描述符型BIO，那么这个调用也会返回成功的结果。  对于source/sink型BIO来说，如果他们不认得BIO\_ctrl所定义的操作，那么就返回0。 ##

### 4.2 BIO\_callback\_ctrl ###

## 这个函数是这组控制函数中唯一一个不是通过调用BIO\_ctrl建立起来的，它有自己的实现函数，而且跟BIO\_ctrl毫不相干。跟BIO\_ctrl一样，它也是比较底层的控制函数，在它上面也定义了一些直接面向用户的控制函数，一般来说，用户不需要直接调用该函数。  需要说明的是，该函数和BIO\_ctrl函数为了实现不同类型BIO具有不同的BIO\_ctrl控制功能，他们的操作基本上都是由各个BIO的callback函数来定义的。这是不同的BIO能灵活实现不同功能的根本所在。 ##

### 4.3 BIO\_ptr\_ctrl和BIO\_int\_ctrl ###

## 这两个函数都是简单的调用了BIO\_ctrl函数，不同的是，后者是输入了四个参数并传入到BIO\_ctrl函数中，简单返回了调用BIO\_ctrl返回的返回值；而前者只输入了三个参数，最后一个BIO\_ctrl参数是作为输出参数并作为返回值的。 ##

### 4.4 BIO\_reset ###

## 该函数是BIO\_ctrl的宏定义函数，为了大家对BIO\_ctrl的宏定义函数有一个感性的认识，我把这个宏定义写出来，如下：  \#define BIO\_reset(b) (int)BIO\_ctrl(b,BIO\_CTRL\_RESET,0,NULL)  这就是BIO\_ctrl的典型宏定义方式，它通过这种方式产生了大量的控制函数。顾名思义，BIO\_reset函数只是简单的将BIO的状态设回到初始化的时候的状态，比如文件BIO，调用该函数就是将文件指针指向文件开始位置。一般来说，调用成功的时候该函数返回1，失败的时候返回0或－1；但是文件BIO是一个例外，成功调用的时候返回0，失败的时候返回－1。 ##

### 4.5 BIO\_seek ###

## 该函数也是BIO\_ctrl的宏定义函数，其定义如下：  \#define BIO\_seek(b,ofs) (int)BIO\_ctrl(b,BIO\_C\_FILE\_SEEK,ofs,NULL)  该函数将文件相关的BIO（文件和文件描述符类型）的文件指针知道距离开始位置ofs(输入参数)字节的位置上。调用成功的时候，返回文件的位置指针，否则返回－1；但是文件BIO例外，成功的时候返回0，失败的时候返回－1。 ##

### 4.6 BIO\_tell ###

## 该函数也是BIO\_ctrl的宏定义函数，其定义如下：  \#define BIO\_tell(b) (int)BIO\_ctrl(b,BIO\_C\_FILE\_TELL,0,NULL)  该函数返回了文件相关BIO的当前文件指针位置。跟BIO\_seek一样，调用成功的时候，返回文件的位置指针，否则返回－1；但是文件BIO例外，成功的时候返回0，失败的时候返回－1。 ##

### 4.7 BIO\_flush ###

## 该函数也是BIO\_ctrl的宏定义函数，其定义如下：  \#define BIO\_flush(b) (int)BIO\_ctrl(b,BIO\_CTRL\_FLUSH,0,NULL)  该函数用来将BIO内部缓冲区的数据都写出去，有些时候，也用于为了根据EOF查看是否还有数据可以写。调用成功的时候该函数返回1，失败的时候返回0或－1。之所以失败的时候返回0或者－1，是为了标志该操作是否需要稍后以跟BIO\_write()相同的方式重试。这时候，应该调用BIO\_should\_retry()函数，当然，正常的情况下该函数的调用应该是失败的。 ##

### 4.8 BIO\_eof ###

## 该函数也是BIO\_ctrl的宏定义函数，其定义如下  \#define BIO\_eof(b) (int)BIO\_ctrl(b,BIO\_CTRL\_EOF,0,NULL)  如果BIO读到EOF，该函数返回1，至于EOF的具体定义，根据BIO的类型各不相同。如果没有读到EOF，该函数返回0。 ##

### 4.9 BIO\_set\_close ###

## 该函数也是BIO\_ctrl的宏定义函数，其定义如下：  \#define BIO\_set\_close(b,c) (int)BIO\_ctrl(b,BIO\_CTRL\_SET\_CLOSE,(c),NULL)  该函数设置BIO的关闭标志，该标志可以为BIO\_CLOSE或BIO\_NOCLOSE。一般来说，该标志是为了指示在source/sink型BIO释放该BIO的时候是否关闭其下层的I/O流。该函数总是返回1。 ##

### 4.10 BIO\_get\_close ###

## 该函数也是BIO\_ctrl的宏定义函数，其定义如下：  \#define BIO\_get\_close(b) (int)BIO\_ctrl(b,BIO\_CTRL\_GET\_CLOSE,0,NULL)  该函数读取BIO的关闭标志，返回BIO\_CLOSE或BIO\_NOCLOSE。 ##

### 4.11 BIO\_pending、BIO\_wpending、BIO\_ctrl\_pending、BIO\_ctrl\_wpending ###

## 这些函数都是用来得到BIO中读缓存或写缓存中字符的数目的，返回相应缓存中字符的数目。前面两个函数也是BIO\_ctrl的宏定义函数，其定义如下：  \#define BIO\_pending(b) (int)BIO\_ctrl(b,BIO\_CTRL\_PENDING,0,NULL)  \#define BIO\_wpending(b) (int)BIO\_ctrl(b,BIO\_CTRL\_WPENDING,0,NULL)  后两个函数功能跟他们是一样的，只不过他们是通过调用BIO\_ctrl函数实现的，而不是宏定义。此外，前面两个函数返回的是int型，而后面两个函数返回的是size\_t型。  需要注意的是，BIO\_pending和 BIO\_wpending并不是在所有情况下都能很可靠地得到缓存数据的数量，比如在文件BIO中，有些数据可能在文件内部结构的缓存中是有效的，但是不可能简单的在BIO中得到这些数据的数量。而在有些类型BIO中，这两个函数可能还不支持。基于此，Openssl作者本身也建议一般不要使用这两个函数，而是使用后面两个，除非你对你所做的操作非常清楚和了解。 ##

## 5.CallBack函数及其控制 ##

## 通过前面的介绍大家已经知道，BIO的callback函数是非常重要的，是实现BIO多态性的一个关键因素之一，BIO提供的callback控制系列函数有五个，其实都是一些宏定义，下面是它的声明和定义（openssl/bio.h）：  \#define BIO\_set\_callback(b,cb) ((b)->callback=(cb))  \#define BIO\_get\_callback(b) ((b)->callback)  \#define BIO\_set\_callback\_arg(b,arg) ((b)->cb\_arg=(char \*)(arg))  \#define BIO\_get\_callback\_arg(b) ((b)->cb\_arg)  其中，callback函数本身的声明如下：  typedef long callback(BIO \*b, int oper, const char \*argp, int argi, long argl, long retvalue);  此外，还有一个用于调试目的的函数，其实声明如下：  long BIO\_debug\_callback(BIO \*bio,int cmd,const char \*argp,int argi,long argl,long ret);  如果要看具体的例子，那么在文件crypto/bio/bio\_cb.c的函数BIO\_debug\_callback()本身就是一个非常好的例子。  下面，我们从callback函数本身开始分别简单介绍这些函数的作用。 ##

### 5.1 callback ###

## callback函数在BIO中非常重要，许多控制功能都是要通过callbank函数协助完成的，比如BIO要执行释放的操作BIO\_free，那么其实它是先调用callback函数设置下面的操作将是释放操作（控制码:BIO\_CB\_FREE），然后才调用别的相关函数执行真正的操作，在后面我们会列出这些控制功能函数，并简单说明callback函数是怎么在这些功能的实现中使用的。现在，我先简单介绍callback函数的各个参数：（参数名字参看说明的函数的声明）  1.       参数\-b：这是callback函数的输入参数，也就是callback函数对应的BIO  2.       参数\-oper：设置BIO将要执行的操作，有些操作，callback函数将被调用两次，一次实在实际操作之前，一次实在实际操作之后，在后面的调用的时候，一般是将oper和BIO\_CB\_RETURN相或操作后作为参数的。也就是说，后一次调用的时候oper参数应该使用oper|BIO\_CB\_RETURN。  3.       参数\-argp、argi、argl：这些参数根据oper定义的操作的不同而不一样，是在相应操作中要用到的参数。  4.       参数\-retvalue：这是默认的callback函数返回值，也就是说，如果没有提供BIO没有提供相应的callback函数，那么就会返回这个值。真正的返回值是callback函数本身提供的。如果在实际的操作之前调用callback函数，并且这时候retvalue参数设置为1，如果callback的函数返回值无效，那么对callback函数的调用就会导致程序立刻返回，BIO的操作就不会执行。  一般情况下，callback函数在执行完后都应该返回retvalue的值，除非该操作有特别的目的要修改这个返回值。下面简单列出我们比较熟悉的一些跟callback函数相关的BIO函数使用callback函数的情况：  1.       BIO\_free(b)：在执行该操作之前，调用了callback(b, BIO\_CB\_FREE, NULL, 0L, 0L, 1L)  2.       BIO\_read(b,out,outl)：在执行该操作之前，调用了callback(b, BIO\_CB\_READ, out, outl, 0L, 1L)，之后调用了callback(b, BIO\_CB\_READ|BIO\_CB\_RETURN, out, outl, 0L,retvalue)，大家可以看到，这就是我们上面说明过的情况，即两次调用callback的操作，后面一次oper的参数需要或上BIO\_CB\_RETURN。  3.       BIO\_write(b,in,inl)：在执行该操作之前，调用了callback(b, BIO\_CB\_WRITE, in, inl, 0L, 1L)，之后调用了callback(b, BIO\_CB\_WRITE|BIO\_CB\_RETURN, in, inl, 0L, retvalue)  4.       BIO\_gets(b,out,outl)：在执行该操作之前，调用了callback(b, BIO\_CB\_GETS, out, outl, 0L, 1L)，之后调用了callback(b, BIO\_CB\_GETS|BIO\_CB\_RETURN, out, outl, 0L, retvalue)  5.       BIO\_puts(b, in)：在执行该操作之前，调用了callback(b, BIO\_CB\_WRITE, in, 0, 0L, 1L)，之后调用了callback(b, BIO\_CB\_WRITE|BIO\_CB\_RETURN, in, 0, 0L,retvalue)  6.       BIO\_ctrl(BIO \*b, int cmd, long larg, void \*parg)：在执行该操作之前，调用了callback(b,BIO\_CB\_CTRL,parg,cmd,larg,1L),之后调用了callback(b,BIO\_CB\_CTRL|BIO\_CB\_RETURN,parg,cmd, larg,ret) ##

### 5.2 BIO\_set\_callback和BIO\_get\_callback ###

## 这两个函数用于设置和返回BIO中的callback函数，它们都是宏定义，根据前面的叙述我们已经知道，callback函数在许多高层的操作中都使用了，因为它能用于调试跟踪的目的或更改BIO的操作，具有很大的灵活性，所以这两个函数也就有用武之地了。 ##

### 5.3 BIO\_set\_callback\_arg和IO\_get\_callback\_arg ###

## 顾名思义，这两个函数用了设置和得到callback函数中的参数。 ##

### 5.4 BIO\_debug\_callback ###

## 这是一个标准的调试信息输出函数，它把相关BIO执行的所有操作信息都打印输出到制定的地方。如果callback参数没有指定输出这些信息的BIO口，那么就会默认使用stderr作为信息输出端口。 ##

## 6.BIO的IO操作函数 ##

## 这些函数是BIO的基本读写操作函数，包括四个，他们的定义如下（openssl/bio.h）：  int BIO\_read(BIO \*b, void \*buf, int len);  int BIO\_gets(BIO \*b,char \*buf, int size);  int BIO\_write(BIO \*b, const void \*buf, int len);  int BIO\_puts(BIO \*b,const char \*buf); ##

### 6.1 BIO\_read ###

## 从BIO接口中读出指定数量字节len的数据并存储到buf中。成功就返回真正读出的数据的长度，失败返回0或－1，如果该BIO没有实现本函数则返回－2。 ##

### 6.2 BIO\_gets ###

## 该函数从BIO中读取一行长度最大为size的数据。通常情况下，该函数会以最大长度限制读取一行数据，但是也有例外，比如digest型的BIO，该函数会计算并返回整个digest信息。此外，有些BIO可能不支持这个函数。成功就返回真正读出的数据的长度，失败返回0或－1，如果该BIO没有实现本函数则返回－2。需要注意的时，如果相应的BIO不支持这个函数，那么对该函数的调用可能导致BIO链自动增加一个buffer型的BIO。 ##

### 6.3 BIO\_write ###

## 往BIO中写入长度为len的数据。成功就返回真正写入的数据的长度，失败返回0或－1，如果该BIO没有实现本函数则返回－2。 ##

### 6.4 BIO\_puts ###

## 往BIO中写入一个以NULL为结束符的字符串，成功就返回真正写入的数据的长度，失败返回0或－1，如果该BIO没有实现本函数则返回－2。  需要注意的是，返回指为0或－1的时候并不一定就是发生了错误。在非阻塞型的source/sink型或其它一些特定类型的BIO中，这仅仅代表目前没有数据可以读取，需要稍后再进行该操作。  有时候，你可能会使用了阻塞类型的sokect使用的一些系统调用技术（如select、poll、equivalent）来决定BIO中是否有有效的数据被read函数读取，但建议不要在阻塞型的接口中使用这些技术，因为这样的情况下如果调用BIO\_read就会导致在底层的IO中多次调用read函数，从而导致端口阻塞。建议select（或equivalent）应该和非阻塞型的IO一起使用，可以在失败之后能够重新读取该IO，而不是阻塞住了。  关于BIO的IO操作为什么会失败以及怎么处理这些情况请参加BIO\_should\_retry()函数的说明文档。 ##

## 7.BIO链的操作 ##

## BIO结构其实是一个链式结构，单个BIO是只有一个环节的BIO链的特例，那么我们怎么构造或在一个BIO链中增加一个BIO，怎么从一个BIO链中删除一个BIO呢，本节就是专门讲述这个问题的。  在Openssl中，针对BIO链的操作还是很简单的，仅仅包括两个函数（openssl/bio.h）：  BIO \* BIO\_push(BIO \*b,BIO \*append);  BIO \* BIO\_pop(BIO \*b); ##

### 7.1 BIO\_push ###

## 该函数把参数中名为append的BIO附加到名为b的BIO上，并返回b。其实，openssl作者本身也认识到，BIO\_push的函数名字可能会导致误会，因为BIO\_push函数其实只是将两个BIO连接起来，而不是Push的功能，应该是join才对。  我们举几个简单的例子说明BIO\_push的作用，假设md1、md2是digest类型的BIO，b64是Base64类型的BIO，而f是file类型的BIO，那么如果执行操作  BIO\_push(b64, f);  那么就会形成一个b64-f的链。然后再执行下面的操作：  BIO\_push(md2, b64);  BIO\_push(md1, md2);  那么就会形成md1-md2-b64-f的BIO链，大家可以看到，在构造完一个BIO后，头一个BIO就代表了整个BIO链，这根链表的概念几乎是一样的。这时候，任何写往md1的数据都会经过md1、md2的摘要，然后经过base64编码，最后写入文件f。可以看到，构造一条好的BIO链后，操作是非常方便的，你不用再关心具体的事情了，整个BIO链会自动将数据进行指定操作的系列处理。  需要注意的是，如果是读操作，那么数据会从相反的方向传递和处理，对于上面的BIO链，数据会从f文件读出，然后经过base64解码，然后经过md1、md2编码，最后读出。 ##

### 7.2 BIO\_pop ###

## 该函数把名为b的BIO从一个BIO链中移除并返回下一个BIO，如果没有下一个BIO，那么就返回NULL。被移除的BIO就成为一个单个的BIO，跟原来的BIO链就没有关系了，这样你可以把它释放或连接到另一个BIO上去。可以看到，如果是单个BIO的时候，该操作是没有任何意义的。如果你执行操作  BIO\_pop(md2);  那么返回值将为b64，而md2从上述的链中移除，形成一个新的md1-b64-f的BIO链，对于数据操作来说，还是往md1读写，没有什么变化，但是底层处理过程已经发生变化了，这就是封装与透明的概念。可以看到，虽然BIO\_pop参数只是一个BIO，但该操作直接的后果会对该BIO所在的链产生影响，所以，当BIO所在的链不一样的时候，其结果是不一样的。  此外：BIO\_push和BIO\_pop操作还可能导致其它一些附加的结果，一些相关的BIO可能会调用一些控制操作，这些具体的细节因为各个类型的BIO不一样，在他们各自的说明中会有说明。 ##

## 8.读写出错控制 ##

## 当BIO\_read或BIO\_write函数调用出错的时候，BIO本身提供了一组出错原因的诊断函数，他们定义如下（openssl/bio.h）：  \#define BIO\_should\_read(a) ((a)->flags & BIO\_FLAGS\_READ)  \#define BIO\_should\_write(a) ((a)->flags & BIO\_FLAGS\_WRITE)  \#define BIO\_should\_io\_special(a) ((a)->flags & BIO\_FLAGS\_IO\_SPECIAL)  \#define BIO\_retry\_type(a) ((a)->flags & BIO\_FLAGS\_RWS)  \#define BIO\_should\_retry(a) ((a)->flags & BIO\_FLAGS\_SHOULD\_RETRY)     \#define BIO\_FLAGS\_READ 0x01  \#define BIO\_FLAGS\_WRITE 0x02  \#define BIO\_FLAGS\_IO\_SPECIAL 0x04  \#define BIO\_FLAGS\_RWS (BIO\_FLAGS\_READ | BIO\_FLAGS\_WRITE | BIO\_FLAGS\_IO\_SPECIAL)  \#define BIO\_FLAGS\_SHOULD\_RETRY 0x08     BIO \* BIO\_get\_retry\_BIO(BIO \*bio, int \*reason);  int BIO\_get\_retry\_reason(BIO \*bio);  因为这些函数是用于决定为什么BIO在读写数据的时候不能读出或写入数据，所以他们一般也是在执行BIO\_read或BIO\_write操作之后被调用的。 ##

### 8.1 BIO\_should\_retry ###

## 如果读写出错的情况是要求程序稍后重试，那么该函数返回true.如果该函数返回false，这时候判定错误情况就要根据BIO的类型和BIO操作的返回值来确定了。比如，如果对socket类型的BIO调用BIO\_read操作并且返回值为0，此时BIO\_should\_retry返回false就说明socket连接已经关闭了。而如果是file类型的BIO出现这样的情况，那说明就是读到文件eof了。有些类型BIO还会提供更多的出错信息，具体情况参见各自的说明。  如果BIO下层I/O结构是阻塞模式的，那么几乎所有（SSL类型BIO例外）BIO类型都不会返回重试的情况（就是说调用BIO\_should\_retry不会返回true），因为这时候对下层I/O的调用根本不会进行。所以建议如果你的应用程序能够判定该类型BIO在执行IO操作后不会出现重试的情况时，就不要调用BIO\_should\_retry函数。file类型BIO就是这样的一个典型例子。  SSL类型的BIO是上述规则的唯一例外，也就是说，既便在阻塞型的I/O结构中，如果在调用BIO\_read的时候发生了握手的过程，它也能会返回重试要求（调用BIO\_should\_retry返回true）。在这种情况下，应用程序可以立刻重新执行失败的I/O操作，或者在底层的I/O结构中设置为SSL\_MODE\_AUTO\_RETRY，那么就可以避免出现这种失败的情况。  如果应用程序在非阻塞型BIO中调用IO操作失败后立刻重试，那么可能导致效率很低，因为在数据允许读取或有效之前，调用会重复返回失败结果。所以，正常的应用应该是等到需要的条件满足之后，程序才执行相关的调用，至于具体怎么做，就跟底层的IO结构有关了。例如，如果一个底层IO是一个soket，并且BIO\_should\_retry返回true，那么可以调用select()来等待数据有效之后再重试IO操作。在一个线程中，可以使用一个select()来处理多个非阻塞型的BIO，不过，这时候执行效率可能出现非常低的情况，比如如果其中一个延时很长的SSL类型BIO在握手的时候就会导致这种情况。  在阻塞型的IO结构中，对数据的读取操作可能会导致无限期的阻塞，其情况跟系统的IO结构函数有关。我们当然不期望出现这种情况，解决的办法之一是尽量使用非阻塞型的IO结构和使用select函数（或equivalent）来设置等待时间。 ##

### 8.2 BIO\_should\_read ###

## 该函数返回true如果导致IO操作失败的原因是BIO此时要读数据。 ##

### 8.3 BIO\_should\_write ###

## 该函数返回true如果导致IO操作失败的原因是BIO此时要写数据。 ##

### 8.4 BIO\_should\_io\_special ###

## 该函数返回true如果导致IO操作失败的原因是特殊的（也就是读写之外的原因） ##

### 8.5 BIO\_get\_retry\_reason ###

## 返回失败的原因，其代码包括BIO\_FLAGS\_READ、BIO\_FLAGS\_WRITE和BIO\_FLAGS\_IO\_SPECIAL。目前的BIO类型只返回其中之一。如果输入的BIO是产生特殊出错情况的BIO，那么该函数返回错误的原因代码，就跟BIO\_get\_retry\_BIO()返回的reason一样。 ##

### 8.6 BIO\_get\_retry\_BIO ###

## 该函数给出特殊情况错误的简短原因，它返回出错的BIO，如果reason不是设置为NULL，它会包含错误代码，错误码的含义以及下一步应该采取的处理措施应该根据发生这种情况下各种BIO的类型而定。 ##

## 9.BIO对的创建和应用 ##

## BIO对是BIO中专门创建的一对缓存BIO，要创建BIO对，调用下面定义的函数（openssl\\bio.h）：  int BIO\_new\_bio\_pair(BIO \*\*bio1, size\_t writebuf1, BIO \*\*bio2, size\_t writebuf2);  这个函数调用成功后返回1，这时候bio1和bio2都是有效的了；否则就返回0，而bio1和bio2就会设为NULL，这是后可以检测出错堆栈以得到更多错误信息。  这个BIO对创建之后，它的两端都能作为数据缓冲的输入和输出。典型的应用是它一端和SSL的IO连接，而另一端则被应用控制，这样，应用程序就不需要直接和网络连接打交道了。  这两个BIO对的功能是完全对称的，它们的缓冲区的大小由参数writebuf1和writebuf2决定，如果给定的大小是0，那么该函数就会使用缺省的缓存大小。BIO\_new\_bio\_pair不会检查bio1和bio2是否真的指向其它BIO，bio1和bio2的值都被重写，但是在此之前不会调用BIO\_free()函数。所以，在使用bio1和bio2之前，必须自己保证这两个变量是空的BIO，否则可能造成内存泄漏。  值得注意的是，虽然这两个BIO是一对的和一起创建的，但是却必须分别释放。之所以这样做，是有其重要原因的，因为有些SSL函数，如SSL\_set\_bio或BIO\_free会隐含调用BIO\_free函数，所以这时候另一端的BIO就只能单独释放了。  下面举一个简单的例子说明问题。  BIO对能给提供应用程序中对网络处理的完全控制能力，程序可以对根据需要调用soket的select()函数，同时却可以避免直接处理SSL接口。下面是使用BIO\_new\_bio\_pair的简单代码模型：  BIO \*internal\_bio, \*network\_bio;  ……  BIO\_new\_bio\_pair(internal\_bio, 0, network\_bio, 0);  SSL\_set\_bio(ssl, internal\_bio);  SSL\_operations();  ……  application | TLS-engine  | |  \+----------> SSL\_operations()  | /\\ ||  | || \\/  | BIO-pair (internal\_bio)  \+----------< BIO-pair (network\_bio)  | |  socket |  ……  SSL\_free(ssl); /\* 隐式释放 internal\_bio \*/  BIO\_free(network\_bio); /\* 显式释放 network\_bio\*/  ……  因为BIO对只会简单的缓存数据，而不会直接涉及到连接，所以它看起来就象非阻塞型的接口，如果写缓存满了或读缓存空的时候，调用IO函数就会立刻返回。也就是说，应用程序必须自己对写缓存执行flush操作或对读缓存执行fill操作。可以使用前面介绍过的BIO\_ctrl\_pending函数看看是否有数据在缓存里面并需要传输到网络上去；为了下面的SSL\_operation能够正确执行，可以调用BIO\_ctrl\_get\_read\_request函数，以决定需要在写缓存写入多少数据。上面两个函数可以保证正确的SSL操作的进行。  需要注意的是，SSL\_operation的调用可能会出现返回ERROR\_SSL\_WANT\_READ值，但这时候写缓存却还有数据的情况，所以应用程序不能简单的根据这个错误代码进行判断，而必须保证写缓存以及执行过flush操作了，否则就会造成死锁现象，因为另一端可能知道等到有数据了才会继续进行下面的操作。 ##

## 10.BIO链的定位操作 ##

## 这里讲的是在一个BIO链中，怎么查找一个特定的BIO，怎么遍历BIO链中的每一个BIO，这组函数定义如下（openssl/bio.h）：  BIO \* BIO\_find\_type(BIO \*b,int bio\_type);  BIO \* BIO\_next(BIO \*b);     \#define BIO\_method\_type(b) ((b)->method->type)  可以看到，这组函数中有两个是真正的函数，另一个则是宏定义，其中，bio\_type的值定义如下：  \#define BIO\_TYPE\_NONE 0  \#define BIO\_TYPE\_MEM (1|0x0400)  \#define BIO\_TYPE\_FILE (2|0x0400)     \#define BIO\_TYPE\_FD (4|0x0400|0x0100)  \#define BIO\_TYPE\_SOCKET (5|0x0400|0x0100)  \#define BIO\_TYPE\_NULL (6|0x0400)  \#define BIO\_TYPE\_SSL (7|0x0200)  \#define BIO\_TYPE\_MD (8|0x0200)  \#define BIO\_TYPE\_BUFFER (9|0x0200)  \#define BIO\_TYPE\_CIPHER (10|0x0200)  \#define BIO\_TYPE\_BASE64 (11|0x0200)  \#define BIO\_TYPE\_CONNECT (12|0x0400|0x0100)  \#define BIO\_TYPE\_ACCEPT (13|0x0400|0x0100)  \#define BIO\_TYPE\_PROXY\_CLIENT (14|0x0200)  \#define BIO\_TYPE\_PROXY\_SERVER (15|0x0200)  \#define BIO\_TYPE\_NBIO\_TEST (16|0x0200)  \#define BIO\_TYPE\_NULL\_FILTER (17|0x0200)  \#define BIO\_TYPE\_BER (18|0x0200)  \#define BIO\_TYPE\_BIO (19|0x0400)     \#define BIO\_TYPE\_DESCRIPTOR 0x0100  \#define BIO\_TYPE\_FILTER 0x0200  \#define BIO\_TYPE\_SOURCE\_SINK 0x0400  可以看到，这些定义大部分都是根据各种BIO类型来命名的，但并不是跟现有的BIO类型是一一对应的，在以后的文章里，我会对这些BIO类型一一进行介绍，现在大家只要有一个概念就可以了。 ##

### 10.1 BIO\_find\_type ###

## 该函数在给定的BIO链中根据特定的BIO类型bio\_type进行搜索，搜索的起始位置就是b。如果给定的类型是一个特定的实现类型，那么就会搜索一个给类型的BIO；如果只是一个总体的类型定义，如BIO\_TYPE\_SOURCE\_SINK（就是sourc/sink类型的BIO），那么属于这种类型的最先找到的BIO就是符合条件的。在找到符合的BIO后，BIO\_find\_type返回该BIO，否则返回NULL。需要注意的是，如果你使用的0.9.5a以前版本，如果给输入参数b赋值为NULL，可能引起异常错误！ ##

### 10.2 BIO\_next ###

## 该函数顾名思义，是返回当前BIO所在的BIO链中的下一个BIO，所以，它可以用来遍历整个BIO链，并且可以跟BIO\_find\_type函数结合起来，在整个BIO链中找出所有特定类型的BIO。这个函数是在0.9.6版本新加的，以前的版本要使用这个功能，只能使用bio->next\_bio来定位了。 ##

### 10.3 BIO\_method\_type ###

## 该函数返回给定的BIO的类型。  下面给出一个在一个BIO链中找出所有digest类型BIO的例子：  BIO \*btmp;  btmp = in\_bio; /\* in\_bio 是被搜索的BIO链 \*/     do \{   btmp = BIO\_find\_type(btmp, BIO\_TYPE\_MD);  if(btmp == NULL) break; /\* 如果没有找到\*/  /\* btmp 是一个digest类型的BIO，做些你需要做的处理 ...\*/  ……  btmp = BIO\_next(btmp);  \} while(btmp);  到此为止，就已经基本写完了BIO的基础知识方面的东西，下面的文章将开始对每一个具体的BIO类型进行介绍。 ##

## 11.文件(file)类型BIO ##

## 文件(file)类型BIO的相关函数和定义如下（openssl\\bio.h）：  BIO\_METHOD \* BIO\_s\_file(void);  BIO \*BIO\_new\_file(const char \*filename, const char \*mode);  BIO \*BIO\_new\_fp(FILE \*stream, int flags);     BIO\_set\_fp(BIO \*b,FILE \*fp, int flags);  BIO\_get\_fp(BIO \*b,FILE \*\*fpp);     int BIO\_read\_filename(BIO \*b, char \*name)  int BIO\_write\_filename(BIO \*b, char \*name)  int BIO\_append\_filename(BIO \*b, char \*name)  int BIO\_rw\_filename(BIO \*b, char \*name)  下面逐一介绍它们的作用和用法。 ##

### 11.1 BIO\_s\_file ###

## 经过前面的介绍，大家应该对这种类型的函数结构很熟悉了，他们就是生成BIO类型的基本构造函数，BIO\_s\_file返回file类型的BIO，file类型的BIO封装了一个标准的文件结构，它是一种source/sink型BIO。file类型的BIO\_METHOD结构定义如下：  static BIO\_METHOD methods\_filep=  \{   BIO\_TYPE\_FILE,  "FILE pointer",  file\_write,  file\_read,  file\_puts,  file\_gets,  file\_ctrl,  file\_new,  file\_free,  NULL,  \};  可以看到，file类型的BIO定义了7个函数，这些函数的实现都在Crypto\\bio\\bss\_file.c里面，大家如果要了解该类型BIO的函数实现，可以参考该文件。事实上，BIO\_s\_file只是简单返回一个file类型的BIO\_METHOD的结构的指针，其函数实现如下：  BIO\_METHOD \*BIO\_s\_file(void)  \{   return(&methods\_filep);  \}  其实，从这个结构可以略见BIO的实现的一斑，即BIO的所有动作都是根据它的BIO\_METHOD的类型（第一个参数）来决定它的动作和行为的，从而实现BIO对各种类型的多态实现。  在file类型中，使用前面介绍过的BIO\_read和BIO\_write对底层的file数据流进行读写操作，file类型BIO是支持BIO\_gets和BIO\_puts函数的。  BIO\_flush函数在file类型BIO中只是简单调用了API函数fflush。  BIO\_reset函数则将文件指针重新指向文件的开始位置，它调用fseek(stream,0,0)函数实现该功能。  BIO\_seek函数将文件指针位置至于所定义的位置ofs上（从文件开头开始计算的偏移ofs），它调用了文件的操作函数fseek(stream,ofs,0)，是一个宏定义形式的函数，需要注意的是，因为该函数调用了fseek函数，所以成功的时候返回0，失败的时候返回－1，这是跟标准BIO\_seek函数定义不一样的，因为标准的定义是成功返回1，失败返回非正值。  BIO\_eof调用了feof函数。  如果在BIO结构中设置了BIO\_CLOSE的标志，则在BIO释放的时候会自动调用fclose函数。 ##

### 11.2 BIO\_new\_file ###

## 该函数根据给定的mode类型创建了一个文件BIO，mode参数的函数跟fopen函数中mode参数的含义是一样的。返回的BIO设置了BIO\_CLOSE标志。调用成功返回一个BIO，否则返回NULL。事实上，该函数先调用了fopen函数打开一个文件，然后调用BIO\_new函数创建一个file类型BIO，最后调用函数BIO\_set\_fp函数给BIO结构跟相关的file帮定。 ##

### 11.3 BIO\_new\_fp ###

## 用文件描述符创建一个file类型BIO，参数Flags可以为BIO\_CLOSE,BIO\_NOCLOSE（关闭标志）以及BIO\_FP\_TEXT（将文件设置为文本模式，默认的是二进制模式，该选项只对Win32平台有效）。事实上，该函数调用BIO\_new函数创建一个file类型BIO，然后调用函数BIO\_set\_fp函数给BIO结构跟相关的file绑定。需要注意的是，如果下层封装的是stdout,stdin和stderr，他们因为跟一般的是不关闭的，所以应该设置BIO\_NOCLOSE标志。调用成功返回一个BIO，否则返回NULL。 ##

### 11.4 BIO\_set\_fp ###

## 该函数将BIO跟文件描述符fp帮定在一起，其参数flags的含义跟BIO\_new\_fp是一样的。该函数是一个宏定义函数。调用成功返回1，否则返回0，不过目前的实现是从来不会出现失败情况的。 ##

### 11.5 BIO\_get\_fp ###

## 该函数返回file类型BIO中文件描述符，也是一个宏定义。调用成功返回1，否则返回0，不过目前的实现是从来不会出现失败情况的。 ##

### 11.6 BIO\_tell ###

## 返回位置指针的值。是一个宏定义函数。 ##

### 11.7 BIO\_read\_filename、BIO\_write\_filename、BIO\_append\_filename、BIO\_rw\_filename ###

## 这四个函数分别设置BIO的读文件名，写文件名，附加文件名以及读写的文件名。他们都是一些宏定义函数。调用成功返回1，否则返回0。  从上面各函数的介绍可以看出，因为BIO调用了底层的各种操作函数，所以，如果底层函数的调用有任何异常，都会反映在BIO的调用上。  下面举几个BIO文件类型操作的简单例子：  1.最简单的实例程序  BIO \*bio\_out;  bio\_out = BIO\_new\_fp(stdout, BIO\_NOCLOSE);  BIO\_printf(bio\_out, "Hello World\\n");  2.上述例子的另一种实现方法  BIO \*bio\_out;  bio\_out = BIO\_new(BIO\_s\_file());  if(bio\_out == NULL) /\* 出错\*/  if(!BIO\_set\_fp(bio\_out, stdout, BIO\_NOCLOSE)) /\* 出错则将文件流定向到标准输出\*/  BIO\_printf(bio\_out, "Hello World\\n");  3.写文件操作  BIO \*out;  out = BIO\_new\_file("filename.txt", "w");  if(!out) /\*出错 \*/  BIO\_printf(out, "Hello World\\n");  BIO\_free(out);  4.上述例子的另一种实现方法  BIO \*out;  out = BIO\_new(BIO\_s\_file());  if(out == NULL) /\* Error ... \*/  if(!BIO\_write\_filename(out, "filename.txt")) /\* Error ... \*/  BIO\_printf(out, "Hello World\\n");  BIO\_free(out); ##

## 12.文件描述符(fd)类型BIO ##

## 文件描述符类型BIO也是一个source/sink型的BIO,它定义了以下一些类型的函数（openssl\\bio.h）：  BIO\_METHOD \* BIO\_s\_fd(void);  \#define BIO\_set\_fd(b,fd,c) BIO\_int\_ctrl(b,BIO\_C\_SET\_FD,c,fd)  \#define BIO\_get\_fd(b,c) BIO\_ctrl(b,BIO\_C\_GET\_FD,0,(char \*)c)  BIO \*BIO\_new\_fd(int fd, int close\_flag);  有一点需要说明的是，虽然存在bss\_fd.c文件，但是关于fd类型的BIO的实现函数，并非真正在bss\_fd.c里面，而是在bss\_sock.c里面，bss\_fd.c这是简单包含了bss\_sock.c文件，所以大家要找实现函数，应该到bss\_sock.c里面找。 ##

### 12.1 BIO\_s\_fd ###

## 该函数返回一个文件描述符类型的BIO\_METHOD结构，它封装了文件描述符类型的一些规则，如read()和write()函数等。fd类型的BIO\_METHOD结构如下：  static BIO\_METHOD methods\_fdp=  \{   BIO\_TYPE\_FD,"file descriptor",  fd\_write,  fd\_read,  fd\_puts,  NULL, /\* fd\_gets, \*/  fd\_ctrl,  fd\_new,  fd\_free,  NULL,  \};  可见，跟file类型BIO相比，它没有实现gets的方法。下面对一些同样的BIO操作函数作些简单说明：  BIO\_read和BIO\_write对底层的文件描述符结构进行读写操作。这两个函数的一些行为取决于他们所在的平台的文件描述符的读写函数的行为，如果底层的文件描述符是非阻塞型的，那么他们基本上是跟我们前面介绍过得BIO的IO操作函数一样的。请参看前面的文章和资料。socket是一类特殊的描述符，不应该使用文件描述符类型的BIO来封装它，而应该使用专门的socke类型BIO，在以后我们会进行介绍。  BIO\_puts是支持的，但是BIO\_gets在本类型描述符中是不支持的。如果设置了关闭标志，那么当BIO被释放的时候底层的文件描述符就会被关闭。  BIO\_reset调用lseek(fd,0,0)函数，使文件指针指向开始的位置。调用成功返回0，失败返回－1。  BIO\_seek调用了lseek(fd,ofs,0)函数，设置文件指针的位置到从文件头偏移ofs的位置，成功返回文件指针的位置，失败返回－1。  BIO\_tell返回目前文件指针的位置，它其实调用了lseek(fd,0,1)函数，失败返回－1。 ##

### 12.2 BIO\_set\_fd ###

## 该函数将BIO的底层文件描述符设置为fd，关闭标志也同时做了设置，其含义与文件类型BIO相应的含义一样。返回1。 ##

### 12.3 BIO\_get\_fd ###

## 返回相应BIO的底层文件描述符，存于参数c，不过，同时也作为返回值返回。c应该为int \*类型的指针。如果BIO没有初始化，调用该函数将失败，返回－1。 ##

### 12.4 BIO\_new\_fd ###

## 创建并返回一个底层描述符为fd，关闭标志为close\_flag的文件描述符类型的BIO。其实，该函数依次调用了BIO\_s\_fd、BIO\_new和BIO\_set\_fd完成了该功能。该函数如果调用失败返回NULL。  下面是一个简单的例子：  BIO \*out;  out = BIO\_new\_fd(fileno(stdout), BIO\_NOCLOSE);  BIO\_printf(out, "Hello World\\n");  BIO\_free(out); ##

## 13.Socket类型BIO ##

## Socket类型的BIO也是一种source/sink型BIO，封装了Socket的IO操作，它相关的一些函数定义如下（openssl\\bio.h）：  BIO\_METHOD \* BIO\_s\_socket(void);  \#define BIO\_set\_fd(b,fd,c) BIO\_int\_ctrl(b,BIO\_C\_SET\_FD,c,fd)  \#define BIO\_get\_fd(b,c) BIO\_ctrl(b,BIO\_C\_GET\_FD,0,(char \*)c)  BIO \*BIO\_new\_socket(int sock, int close\_flag);  前面我们在介绍fd类型BIO的时候曾经说过，它的函数的实现文件跟Soket类型的BIO其实是放在一起的，都在文件bss\_socket.c里面，从这些定义我们就可以知道，之所以这样做，是因为这两种类型的BIO实现的函数基本是相同的，并且具有很多的共性。 ##

### 13.1 BIO\_s\_socket ###

## 该函数返回一个Socket类型的BIO\_METHOD结构，BIO\_METHOD结构的定义如下：  static BIO\_METHOD methods\_sockp=  \{   BIO\_TYPE\_SOCKET,  "socket",  sock\_write,  sock\_read,  sock\_puts,  NULL, /\* sock\_gets, \*/  sock\_ctrl,  sock\_new,  sock\_free,  NULL,  \};  可以看到，它跟fd类型BIO在实现的动作上基本上是一样的。只不过是前缀名和类型字段的名称不一样。其实在象Linux这样的系统里，Socket类型跟fd类型是一样，他们是可以通用的，但是，为什么要分开来实现呢，那是因为有些系统如windows系统，socket跟文件描述符是不一样的，所以，为了平台的兼容性，openssl就将这两类分开来了。  BIO\_read和BIO\_write对底层的Socket结构进行读写操作。  BIO\_puts是支持的，但是BIO\_gets在Socket类型BIO中是不支持的，大家如果看源代码就可以知道，虽然BIO\_gets在Socket类型是不支持的，但是如果调用该函数，不会出现异常，只会返回\-1的出错信息。  如果设置了关闭标志，那么当BIO被释放的时候底层的Socket连接就会被关闭。 ##

### 13.2 BIO\_set\_fd ###

## 该函数将Socket描述符fd设置为BIO的底层IO结构，同时可以设置关闭标志c。该函数返回1。 ##

### 13.3 BIO\_get\_fd ###

## 该函数返回指定BIO的Socket描述符，如果c参数不是NULL，那么就将该描述符存在参数c里面，当然，Socket描述符同时也作为返回值，如果BIO没有初始化则调用失败，返回－1。 ##

### 13.4 BIO\_new\_socket ###

## 该函数根据给定的参数返回一个socket类型的BIO，成功返回该BIO指针，失败返回NULL。其实，该函数依次调用了BIO\_s\_socket，BIO\_new和BIO\_set\_fd实现它的功能。 ##

## 14.source/sink型BIO ##

## 这是一个空的source/sink型BIO，写到这个BIO的数据都被丢掉了，从这里执行读操作也总是返回EOF。该BIO非常简单，其相关函数的定义如下(openssl\\bio.h)：  BIO\_METHOD \* BIO\_s\_null(void);  其相关的源文件实现函数在bss\_null.c里面。 ##

### 14.1 BIO\_s\_null ###

## 该函数返回一个NULL型的BIO\_METHOD结构，该结构定义如下：  static BIO\_METHOD null\_method=  \{   BIO\_TYPE\_NULL,  "NULL",  null\_write,  null\_read,  null\_puts,  null\_gets,  null\_ctrl,  null\_new,  null\_free,  NULL,  \};  从结构上看，这个类型的BIO实现了不少的函数，但是，仔细看看源文件，就会发现所有这些函数都只是简单返回0、1或者输入数据的长度，而不作任何事情。熟悉Linux系统的技术人员可能知道，这跟Linux系统的/dev/null设备的行为是一样的。  一般来说，在openssl里面，这种类型的BIO是置放在BIO链的末尾的，比如在应用程序中，如果你要将一些数据通过filter型的BIO digest进行摘要算法，但不需要把它送往任何地方，又因为一个BIO链要求以source/sink型BIO开始或结束，所以这时候就可以在BIO链的末尾添加一个source/sink型的NUll类型BIO来实现这个功能。 ##

## 15.mem类型BIO ##

## 内存（mem）类型BIO所定义的相关系列函数如下（openssl\\bio.h）：  BIO\_METHOD \* BIO\_s\_mem(void);  BIO\_set\_mem\_eof\_return(BIO \*b,int v)  long BIO\_get\_mem\_data(BIO \*b, char \*\*pp)  BIO\_set\_mem\_buf(BIO \*b,BUF\_MEM \*bm,int c)  BIO\_get\_mem\_ptr(BIO \*b,BUF\_MEM \*\*pp)  BIO \*BIO\_new\_mem\_buf(void \*buf, int len);  内存型BIO是source/sink型BIO，它使用内存作为它的I/O。写进该类型BIO的数据被存储在BUF\_MEM结构中，该结构被定义为适合存储数据的一种结构，其结构定义如下：  typedef struct buf\_mem\_st  \{   int length； /\* current number of bytes \*/  char \*data;  int max; /\* size of buffer \*/  \} BUF\_MEM;  可见，该结构定义了内存数据长度，数据存储空间以及最大长度三个变量来表述一段内存存储数据。但值得注意的是，内存型BIO的内存是可以无限扩大的，也就是说，不过你往里面写多少数据，都能成功执行。  一般来说，任何写入内存型BIO的数据都能被读出，除非该内存型BIO是只读类型的，那么，这时候如果对只读的内存型BIO执行读操作，那么相关数据就会从该BIO删除掉（其实没有删掉，只是指针往后面移动，访问不了了，如果调用BIO\_reset就可以再访问）。 ##

### 15.1 BIO\_s\_mem ###

## 该函数返回一个内存型的BIO\_METHOD结构，期定义如下：  static BIO\_METHOD mem\_method=  \{   BIO\_TYPE\_MEM,  "memory buffer",  mem\_write,  mem\_read,  mem\_puts,  mem\_gets,  mem\_ctrl,  mem\_new,  mem\_free,  NULL,  \};  BIO\_write和BIO\_read函数是支持的。对内存型BIO执行写操作总是成功的，因为内存型BIO的内存能够无限扩大。任何一个对可读写的内存型BIO的读操作都会在使用内部拷贝操作从BIO里面删除该段数据，这样一来，如果BIO里面有大量的数据，而读的却只是很小的一些片断，那么会导致操作非常慢。使用只读的内存型BIO避免了这个问题。在使用的时候，如果内存型BIO必须使用可读写的，那么可以加一个Buffer型BIO到BIO链中，这可以使操作速度更快。在以后的版本（该文档所述版本为0.9.6a）,可能会优化速度操作的问题。  BIO\_gets和BIO\_puts操作在该类型BIO是支持的。  如果设置了BIO\_CLOSE标志，那么内存型BIO被释放的时候其底层的BUF\_MEM型BIO也同时被释放。  BIO\_reset函数被调用时，如果该BIO是可读写的，那么该BIO所有数据都会被清空；如果该BIO是只读的，那么该操作只会简单将指针指向原始位置，里面的数据可以再读。该文档所述版本的（0.9.6a）的内存型BIO对读写模式的BIO没有提供一个可以将指针重置但不破坏原有数据的方法，在以后的版本可能会增加的。  BIO\_eof返回true，表明只时候BIO里面没有可读数据。  BIO\_ctrl\_pending返回目前BIO里面存储的数据的字节(byte)数。 ##

### 15.2 BIO\_set\_mem\_eof\_return ###

## 该函数设置一个没有数据的内存型BIO的执行读动作的行为。如果参数v是0，那么该空的内存型BIO就会返回EOF，也就是说，这时候返回为0，如果调用BIO\_should\_retry就会返回false。如果参数v为非零，那么就会返回v，并且同时会设置重试标志，也就是说此时调用BIO\_read\_retry会返回true。为了跟正常的返回正值避免混淆，v应该设置为负值，典型来说是－1。 ##

### 15.3 BIO\_get\_mem\_data ###

## 该函数是一个宏定义函数，它将参数pp的指针指向内存型BIO的数据开始处，返回所有有效的数据。 ##

### 15.4 BIO\_set\_mem\_buf ###

## 该函数将参数bm所代表的BUF\_MEM结构作为该BIO的底层结构，并把关闭标志设置为参数c，c可以是BIO\_CLOSE或BIO\_NOCLOSE，该函数也是一个宏定义。 ##

### 15.5 BIO\_get\_mem\_ptr ###

## 该函数也是一个宏定义函数，它将底层的BUF\_MEM结构放在指针pp中。 ##

### 15.6 BIO\_new\_mem\_buf ###

## 该函数创建一个内存型BIO，其数据为buf里面长度为len的数据（单位为byte），如果参数len是－1，那么就默认buf是以null结束的，使用strlen解决长度。这时候BIO被设置为只读的，不能执行写操作。它用于数据需要存储在一块静态内存中并以BIO形式存在的时候。所需要的数据是直接从内存中读取的，而不是先要执行拷贝操作（读写方式的内存BIO就是要先拷贝），这也就要求这块内存是只读的，不能改变，一直维持到BIO被释放。  例子  1.创建一个内存型BIO并写入数据  BIO \*mem = BIO\_new(BIO\_s\_mem());  BIO\_puts(mem, "Hello World\\n");  2.创建一个只读的内存型BIO  char data\[\] = "Hello World";  BIO \*mem;  mem = BIO\_new\_mem\_buf(data, -1);  3.把一个BUF\_MEM结构从一个BIO中取出并释放该BIO  BUF\_MEM \*bptr;  BIO\_get\_mem\_ptr(mem, &bptr);  BIO\_set\_close(mem, BIO\_NOCLOSE); /\* BIO\_free() 不释放BUF\_MEM结构 \*/  BIO\_free(mem); ##

## 16.BIO对(pair)类型BIO ##

## BIO对也是作为一种source/sink类型的BIO来处理的，也就是说，BIO里面还提供了一种专门的BIO\_METHO方法来处理BIO对的各种操作。BIO对的各种相关的函数定义如下(openssl\\bio.h)：  BIO\_METHOD \*BIO\_s\_bio(void);     \#define BIO\_make\_bio\_pair(b1,b2) (int)BIO\_ctrl(b1,BIO\_C\_MAKE\_BIO\_PAIR,0,b2)  \#define BIO\_destroy\_bio\_pair(b) (int)BIO\_ctrl(b,BIO\_C\_DESTROY\_BIO\_PAIR,0,NULL)     \#define BIO\_shutdown\_wr(b) (int)BIO\_ctrl(b, BIO\_C\_SHUTDOWN\_WR, 0, NULL)     \#define BIO\_set\_write\_buf\_size(b,size) (int)BIO\_ctrl(b,BIO\_C\_SET\_WRITE\_BUF\_SIZE,size,NULL)  \#define BIO\_get\_write\_buf\_size(b,size) (size\_t)BIO\_ctrl(b,BIO\_C\_GET\_WRITE\_BUF\_SIZE,size,NULL)     int BIO\_new\_bio\_pair(BIO \*\*bio1, size\_t writebuf1, BIO \*\*bio2, size\_t writebuf2);     \#define BIO\_get\_write\_guarantee(b) (int)BIO\_ctrl(b,BIO\_C\_GET\_WRITE\_GUARANTEE,0,NULL)  size\_t BIO\_ctrl\_get\_write\_guarantee(BIO \*b);     \#define BIO\_get\_read\_request(b) (int)BIO\_ctrl(b,BIO\_C\_GET\_READ\_REQUEST,0,NULL)  size\_t BIO\_ctrl\_get\_read\_request(BIO \*b);     int BIO\_ctrl\_reset\_read\_request(BIO \*b);  可以看到，这些函数中大多数是宏定义函数并且都是基于BIO\_ctrl函数的。  BIO对类型的BIO是一对source/sink型的BIO，数据通常是从一个BIO缓冲写入，从另一个BIO读出。其实，从源代码（bss\_bio.c）可以看出，所谓的BIO对只是将两个BIO的终端输出（BIO结构中参数peer的ptr成员）相互设置为对方，从而形成一种对称的结构，如下：  bio1->peer->ptr=bio2  bio2->peer->ptr=bio1     数据流向1(写bio1,读bio2)：\--->bio1--->bio2--->  数据流行2(写bio2,读bio1)：\--->bio2--->bio1--->  因为没有提供内部数据结构的内存锁结构(lock)，所以，一般来说这个BIO对的两个BIO都必须在一个线程下使用。因为BIO链通常是以一个source/sink BIO结束的，所以就可以实现应用程序通过控制BIO对的一个BIO从而控制整个BIO链的数据处理。其实，也就相当于BIO对给应用程序提供了一个处理整个BIO链的入口。上次我们说BIO对的时候就说过，BIO对的一个典型应用就是在应用程序里面控制TLS/SSL的I/O接口，一般来说，在应用程序想在TLS/SSL中使用非标准的传输方法或者不适合使用标准的socket方法的时候就可以采用这样的方法来实现。  前面提过，BIO对释放的时候，需要分别释放两个BIO，如果在使用BIO\_free或者BIO\_free\_all释放了其中一个BIO的时候，另一个BIO就也必须要释放。  当BIO对使用在双向应用程序的时候，如TLS/SSL，一定要对写缓冲区里面的数据执行flush操作。当然，也可以通过在BIO对中的另一个BIO调用BIO\_pending函数，如果有数据在缓冲区中，那么就将它们读出并发送到底层的传输通道中区。为了使请求或BIO\_should\_read函数调用成功（为true），在执行任何正常的操作（如select）之前，都必须这样做才行。  下面举一个例子说明执行flush操作的重要性：  考虑在TLS/SSL握手过程中，采用了BIO\_write函数发送了数据，相应的操作应该使BIO\_read。BIO\_write操作成功执行并将数据写入到写缓冲区中。BIO\_read调用开始会失败，BIO\_should\_retry返回true。如果此时对写缓冲区不执行flush操作，那么BIO\_read调用永远不会成功，因为底层传输通道会一直等待直到数据有效（但数据却在写缓冲区里，没有传到底层通道）。 ##

### 16.1 BIO\_s\_bio ###

## 该函数返回一个BIO对类型的BIO\_METHOD，其定义如下：  static BIO\_METHOD methods\_biop =  \{   BIO\_TYPE\_BIO,  "BIO pair",  bio\_write,  bio\_read,  bio\_puts,  NULL /\* 没有定义 bio\_gets \*/,  bio\_ctrl,  bio\_new,  bio\_free,  NULL /\* 没有定义 bio\_callback\_ctrl \*/  \};  从定义中可以看到，该类型的BIO不支持BIO\_gets的功能。  BIO\_read函数从缓冲BIO中读取数据，如果没有数据，则发出一个重试请求。  BIO\_write函数往缓冲BIO中写入数据，如果缓冲区已满，则发出一个重试请求。  BIO\_ctrl\_pending和BIO\_ctrl\_wpending函数可以用来查看在读或写缓冲区里面有效的数据的数量。  BIO\_reset函数将写缓冲区里面的数据清除。 ##

### 16.2 BIO\_make\_bio\_pair ###

## 该函数将两个单独的BIO连接起来成为一个BIO对。 ##

### 16.3 BIO\_destroy\_pair ###

## 该函数跟上面的函数相反，它将两个连接起来的BIO对拆开；如果一个BIO对中的任何一个BIO被释放，该操作会自动执行。 ##

### 16.4 BIO\_shutdown\_wr ###

## 该函数关闭BIO对的其中一个BIO，一个BIO被关闭后，针对该BIO的任何写操作都会返回错误。从另一个BIO读数据的时候要么返回剩余的有效数据，要么返回EOF。 ##

### 16.5 BIO\_set\_write\_buf\_size ###

## 该函数设置BIO的缓冲区大小。如果该BIO的缓存区大小没有初始化，那么就会使用默认的值，大小为17k，这对于一个TLS记录来说是足够大的了。 ##

### 16.6 BIO\_get\_write\_buf\_size ###

## 该函数返回写缓冲区的大小。 ##

### 16.7 BIO\_new\_bio\_pair ###

## 该函数我们在前面的《BIO系列之9---BIO对的创建和应用》中已经做了详细的介绍，其实，它是调用了BIO\_new,BIO\_make\_bio\_pair和BIO\_set\_write\_buf\_size函数来创建一对BIO对的。如果两个缓冲区长度的参数都为零，那么就会使用默认的缓冲区长度。 ##

### 16.8 BIO\_get\_write\_guarantee和BIO\_ctrl\_get\_write\_guarantee ###

## 这两个函数返回当前能够写入BIO的数据的最大长度。如果往BIO写入的数据长度比该函数返回的数据长度大，那么BIO\_write返回的写入数据长度会小于要求写入的数据，如果缓冲区已经满了，则会发出一个重试的请求。这两个函数的唯一不同之处是一个使用函数实现的，一个是使用宏定义实现的。 ##

### 16.9 BIO\_get\_read\_request和BIO\_ctrl\_get\_read\_request ###

## 这两个函数返回要求发送的数据的长度，这通常是在对该BIO对的另一个BIO执行读操作时因为缓冲区数据为空导致失败时发出的请求。所以，这通常用来表明现在应该写入多少数据才能使接下来的读操作能够成功执行，这在TLS/SSL应用程序中是非常有用的，因为对于这个协议来说，读取的数据长度比缓冲区的数据长度通常要有意义的多。如果在读操作成功之后调用这两个函数会返回0，如果在调用该函数之前有新的数据写入（不管是部分还是全部满足需要读取的数据的要求），那么调用该函数也会返回0。理所当然，该函数返回的数据长度肯定不会大于BIO\_get\_write\_guarantee函数返回的数据长度。 ##

### 16.10 BIO\_ctrl\_reset\_read\_request ###

## 该函数就是把BIO\_get\_read\_request要返回值设置为0。 ##

## 17.连接(connect)类型BIO ##

## 该类型的BIO封装了socket的Connect方法，它使得编程的时候可以使用统一的BIO规则进行socket的connect连接的操作和数据的发送接受，而不用关心具体平台的Socket的connect方法的区别。其相关定义的一些函数如下(openssl\\bio.h)：  BIO\_METHOD \* BIO\_s\_connect(void);  \#define BIO\_set\_conn\_hostname(b, name) BIO\_ctrl(b, BIO\_C\_SET\_CONNECT, 0, (char \*) name)  \#define BIO\_set\_conn\_port(b,port) BIO\_ctrl(b,BIO\_C\_SET\_CONNECT,1,(char \*)port)  \#define BIO\_set\_conn\_ip(b,ip) BIO\_ctrl(b,BIO\_C\_SET\_CONNECT,2,(char \*)ip)  \#define BIO\_set\_conn\_int\_port(b,port) BIO\_ctrl(b,BIO\_C\_SET\_CONNECT,3,(char \*)port)  \#define BIO\_get\_conn\_hostname(b) BIO\_ptr\_ctrl(b,BIO\_C\_GET\_CONNECT,0)  \#define BIO\_get\_conn\_port(b) BIO\_ptr\_ctrl(b,BIO\_C\_GET\_CONNECT,1)  \#define BIO\_get\_conn\_ip(b,ip) BIO\_ptr\_ctrl(b,BIO\_C\_SET\_CONNECT,2)  \#define BIO\_get\_conn\_int\_port(b,port) BIO\_int\_ctrl(b,BIO\_C\_SET\_CONNECT,3,port)  \#define BIO\_set\_nbio(b,n) BIO\_ctrl(b,BIO\_C\_SET\_NBIO,(n),NULL)  \#define BIO\_do\_connect(b) BIO\_do\_handshake(b)  BIO \*BIO\_new\_connect(char \*str) ##

### 17.1 BIO\_s\_connect ###

## 该函数返回一个connect类型的BIO\_METHOD结构，该结构定义如下：  static BIO\_METHOD methods\_connectp=  \{   BIO\_TYPE\_CONNECT,  "socket connect",  conn\_write,  conn\_read,  conn\_puts,  NULL, /\* connect\_gets, \*/  conn\_ctrl,  conn\_new,  conn\_free,  conn\_callback\_ctrl,  \};  事实上，为了维护一个Socket结构，openssl里面还定义了一个BIO\_CONNECT结构来维护底层socket的地址信息以及状态信息，不过，通过封装，我们一般是不用直接接触该结构的，在此也就不再多做介绍，感兴趣可以参看文件bss\_conn.c里面的定义和函数。  BIO\_read和BIO\_write的操作调用底层的连接的IO操作来完成。如果在服务器地址和端口设置正确，但连接没有建立的时候调用读写操作函数，那么会先进行连接的建立操作，然后再进行读写操作。  BIO\_puts操作是支持的，但是BIO\_gets操作不支持，这在该类型BIO的BIO\_METHOD结构定义中就可以看出来。  如果关闭标志设置了，那么在BIO被释放的时候，任何活动的连接和socket都会被关闭。  BIO\_reset方法被调用的时候，连接（connect）类型的BIO的任何活动连接都会被关闭，从而回到可以重新跟同样的主机建立连接的状态。  BIO\_get\_fd函数返回连接类型的BIO的底层socket，当参数c不是NULL的时候，就将该socket赋值给c，当然，socket也作为返回值。c参数应该为int\*类型。如果BIO没有初始化，则返回－1。 ##

### 17.2 BIO\_set\_conn\_hostname ###

## 该函数使用字符串设置主机名，该主机名也可以为IP地址的形式，还可以包括端口号，如hostname:port，hostname/any/other/path和hostname:port/any/other/path也是可以的。返回1。 ##

### 17.3 BIO\_set\_conn\_port ###

## 该函数设置主机的端口号。该端口号的形式可以为数字的形式，也可以为字符串类似"http"的形式。如果使用字符串形式，首先会使用getservbyname函数搜索其相关的端口，如果没有搜索到，那么就会使用一张缺省的名字端口解释表，目前该表列出的字符串有：http, telnet, socks, https, ssl, ftp, gopher 和 wais.返回1。  需要注意的是：如果端口名已经作为主机名的一部分设置了，那么它就会覆盖BIO\_set\_conn\_port函数设置的端口值。有的时候（如有些应用可能不希望用固定的端口连接）可能不方便，这时候可以通过检测输入主机名的字符串中的":"字符，报错或截取字符串来避免这种情况。 ##

### 17.4 BIO\_set\_conn\_ip ###

## 该函数使用二进制的模式设置IP地址。返回1。 ##

### 17.5 BIO\_set\_conn\_int\_port ###

## 该函数以整数形式设置主机端口号，参数应该为int\*的形式。返回1。 ##

### 17.6 BIO\_get\_conn\_hostname ###

## 该函数返回连接类型BIO的主机名，如果BIO以及初始化，但是没有设置主机名，那么返回NULL。返回值因为是一个内部指针，所有不能更改它的值。 ##

### 17.7 BIO\_get\_conn\_port ###

## 该函数返回字符串类型的端口信息。如果没有设置，就返回NULL。 ##

### 17.8 BIO\_get\_conn\_ip ###

## 该函数返回二进制形式的IP地址。如果没有设置，返回为全0。 ##

### 17.9 BIO\_get\_conn\_int\_port ###

## 该函数返回整数形式的端口号，如果没有设置，则返回0。  上述四个函数的返回值在连接操作完成之后会被更新。而在此之前，返回值都是应用程序自己设置的。 ##

### 17.10 BIO\_set\_nbio ###

## 设置I/O的非阻塞标志。如果参数n为0，则I/O设置为阻塞模式；如果n为1，则I/O设置为非阻塞模式。缺省的模式是阻塞模式。应该在连接建立之前调用本函数，因为非阻塞模式的I/O是在连接过程中设置的。返回值恒为1。  注意：如果是阻塞模式的I/O，执行IO操作时（如读写），如果返回负值，说明就产生了错误的情况，如果返回值是0，一般来说表明连接已经关闭。如果设置为非阻塞模式，那么发出重试的请求就是很正常的事情了。 ##

### 17.11 BIO\_do\_connect ###

## 该函数进行给定BIO的连接操作，如果连接成功，返回1，否则返回0或负值。在非阻塞模式的时候，如果调用失败了，可以调用BIO\_should\_retry函数以决定是否需要重试。  一般来说，应用程序不需要调用本函数，只有在希望将连接过程跟其它IO处理过程独立开来的时候，才需要调用本函数。  在初始化连接的过程的时候，如果返回值失败的原因为BIO\_RR\_CONNECT，调用BIO\_should\_io\_special返回值可能也为true。如果出现这种情况，说明连接过程被阻塞住了，应用程序应该使用正常的方法进行处理，直到底层的socket连接上了再重试。 ##

### 17.12 BIO\_new\_connect ###

## 该函数创建并返回一个连接类型的BIO，其实，它调用了BIO\_s\_connect、BIO\_new已经BIO\_set\_conn\_hostname函数完成了整个操作。成功则返回一个BIO，否则返回NULL。  例子：这是一个连接到本地Web服务器的例子，返回一页的信息并把该信息复制到标准输出设备。  BIO \*cbio, \*out;  int len;  char tmpbuf\[1024\];  ERR\_load\_crypto\_strings();  cbio = BIO\_new\_connect("localhost:http");  out = BIO\_new\_fp(stdout, BIO\_NOCLOSE);  if(BIO\_do\_connect(cbio) <= 0)  \{   fprintf(stderr, "Error connecting to server\\n");  ERR\_print\_errors\_fp(stderr);  /\* whatever ... \*/  \}  BIO\_puts(cbio, "GET / HTTP/1.0\\n\\n");  for(;;)  \{   len = BIO\_read(cbio, tmpbuf, 1024);  if(len <= 0) break;  BIO\_write(out, tmpbuf, len);  \}  BIO\_free(cbio);  BIO\_free(out); ##

## 18.接受(accept)类型BIO ##

## 接受（accept）类型的BIO跟连接（connect）类型BIO是相对应的，它封装了Socket的accept方法及其相关的一些操作，使得能够对不同的平台使用同一的函数进行操作。其定义的相关函数如下(openssl\\bio.h)：  BIO\_METHOD \* BIO\_s\_accept(void);  \#define BIO\_set\_accept\_port(b,name) BIO\_ctrl(b,BIO\_C\_SET\_ACCEPT,0,(char \*)name)  \#define BIO\_get\_accept\_port(b) BIO\_ptr\_ctrl(b,BIO\_C\_GET\_ACCEPT,0)  BIO \*BIO\_new\_accept(char \*host\_port);  \#define BIO\_set\_nbio\_accept(b,n) BIO\_ctrl(b,BIO\_C\_SET\_ACCEPT,1,(n)?"a":NULL)  \#define BIO\_set\_accept\_bios(b,bio) BIO\_ctrl(b,BIO\_C\_SET\_ACCEPT,2,(char \*)bio)  \#define BIO\_set\_bind\_mode(b,mode) BIO\_ctrl(b,BIO\_C\_SET\_BIND\_MODE,mode,NULL)  \#define BIO\_get\_bind\_mode(b,mode) BIO\_ctrl(b,BIO\_C\_GET\_BIND\_MODE,0,NULL)  \#define BIO\_BIND\_NORMAL 0  \#define BIO\_BIND\_REUSEADDR\_IF\_UNUSED 1  \#define BIO\_BIND\_REUSEADDR 2  \#define BIO\_do\_accept(b) BIO\_do\_handshake(b) ##

### 18.1 BIO\_s\_accept ###

## 该函数返回一个接受（Accept）类型的BIO\_METHOD结构，其定义如下：  static BIO\_METHOD methods\_acceptp=  \{   BIO\_TYPE\_ACCEPT,  "socket accept",  acpt\_write,  acpt\_read,  acpt\_puts,  NULL, /\* connect\_gets, \*/  acpt\_ctrl,  acpt\_new,  acpt\_free,  NULL,  \};  通过该结构我们可以一目了然的知道该方法支持什么I/O操作，在本类型中，BIO\_gets的操作是不支持的。跟连接（connect）类型BIO一样，openssl也定义了一个维护接受Socket信息的结构，在此我也不再详细介绍该结构，大家参考bss\_acpt.c文件。  本类型的BIO对各种平台的TCP/IP的accept做了封装，所以在使用的时候就可以同一的使用BIO的规则进行操作，而不用担心因为不同的平台带来程序改写或增加移植的工作量，这也是BIO很重要的一个目的。  BIO\_read和BIO\_write函数操作调用了底层平台连接的I/O相关操作，如果这时候没有连接建立，端口设置正确，那么该BIO就会等待连接的建立。事实上，当一个连接建立的时候，一个新的socket类型BIO就会被创建并附加到BIO链中，形成accept->socket的BIO结构，所以这时候对初始化了的接受socket进行IO操作就会导致它处于等待连接建立的状态。当一个接受类型的BIO在BIO链的末尾的时候，在处理I/O调用之前它会先等待一个连接的建立；如果不是在末尾，那么它简单的把I/O调用传到下一个BIO。  如果接受（accept）类型BIO的关闭标志设置了，那么当BIO被释放的时候，该BIO链上任何活动的连接和socket都会被关闭。  BIO\_get\_fd和BIO\_set\_fd可以用来取得和设置该连接的socket描述符，详细情况参看“12.描述符(fd) 类型BIO”。 ##

### 18.2 BIO\_set\_accept\_port ###

## 该函数使用字串名来设置接受端口。其形式为“host:port”，“host”是要使用的接口，“port”是端口。这两部分都可以为“\*”，这时候表示可以使用任意接口和端口。这里的端口的字符串含义跟连接（connect）类型BIO里面定义的一样，可以为数字形式的，可以使用getservbyname函数去匹配得到，还可以使用字符串的表，请参看连接型BIO说明的相关部分。 ##

### 18.3 BIO\_new\_accept ###

## 该函数将BIO\_new和BIO\_set\_accept\_port函数放在一个函数里面调用，创建一个新的接受（accept）类型的BIO。 ##

### 18.4 BIO\_set\_nbio\_accept ###

## 该函数设置接受socket是否为阻塞模式（缺省），如果参数n为0，为阻塞模式，n为1则为非阻塞模式。 ##

### 18.5 BIO\_set\_accept\_bios ###

## 该函数用来设置一个BIO链，当接受到一个连接的时候，这个设置好的BIO链就会被复制或附加到整个BIO链上来。有的时候这中处理方法是非常好的，比如，如果每个连接都需要一个缓冲区或SSL类型的BIO，这时候使用本函数就省了很多麻烦了。需要注意的是，在调用本函数后，这个设置的链上的BIO不能自己释放，在接受（accept）BIO被释放后，它们会自动释放。  当该函数调用的时候，其设置的BIO链位于接受BIO和socket类型的BIO之间，即形成：accept->otherbios->socket的新的BIO链。 ##

### 18.6 BIO\_set\_bind\_mode和BIO\_get\_bind\_mode ###

## 这两个函数用来设置和取得目前的绑定模式。如果设置为BIO\_BIND\_NORMAL（缺省），那么另外一个socket就不能绑定到同一个端口。如果设置为BIO\_BIND\_REUSEADDR，那么另外的socket可以绑定到同一个端口。如果设置为BIO\_BIND\_REUSEADDR\_IF\_UNUSED，那么首先会尝试以BIO\_BIND\_NORMAL的模式绑定到端口，如果失败了而且端口没有使用，那么就会使用BIO\_BIND\_REUSEADDR模式绑定到端口。 ##

### 18.7 BIO\_do\_accept ###

## 该函数有两个功能，当它在接受（accept）BIO设置好之后第一被调用的时候，它会创建一个接受socket并把它跟地址绑定；第二次被调用的时候，它会等待连接的到来。  注意：如果服务器端希望可以处理多个连接的情况（通常都是这样的），那么接受BIO必须能够用来处理以后的连接，这时候可以这样做：等待到一个连接后，调用  connection=BIO\_pop(accept)  这样，connection会包含一个最近建立的连接的BIO，accept就再次成为一个独立的BIO，可以用来处理其它连接了。如果没有其它连接建立，那么就可以使用BIO\_free释放该BIO。  当然，如果只有一个连接需要处理，也可以使用连接BIO本身来进行I/O操作。但是一般来说不推荐这样做，因为这时候该接受BIO依然处于接受其它连接建立的状态。这可以使用上述的方法解决。  例子：这个例子在4444端口接受了两个连接，发送信息到每个连接上然后释放他们。  BIO \*abio, \*cbio, \*cbio2;  ERR\_load\_crypto\_strings();  abio = BIO\_new\_accept("4444");  /\* 首先调用BIO\_accept启动接受BIO \*/  if(BIO\_do\_accept(abio) <= 0)  \{   fprintf(stderr, "Error setting up accept\\n");  ERR\_print\_errors\_fp(stderr);  exit(0);  \}  /\* 等待连接建立\*/  if(BIO\_do\_accept(abio) <= 0)  \{   fprintf(stderr, "Error accepting connection\\n");  ERR\_print\_errors\_fp(stderr);  exit(0);  \}  fprintf(stderr, "Connection 1 established\\n");  /\* 返回连接的BIO\*/  cbio = BIO\_pop(abio);  BIO\_puts(cbio, "Connection 1: Sending out Data on initial connection\\n");  fprintf(stderr, "Sent out data on connection 1\\n");  /\* 等待另一个连接的建立 \*/  if(BIO\_do\_accept(abio) <= 0)  \{   fprintf(stderr, "Error accepting connection\\n");  ERR\_print\_errors\_fp(stderr);  exit(0);  \}  fprintf(stderr, "Connection 2 established\\n");  /\* 关闭连接BIO，不再接受连接的建立 \*/  cbio2 = BIO\_pop(abio);  BIO\_free(abio);  BIO\_puts(cbio2, "Connection 2: Sending out Data on second\\n");  fprintf(stderr, "Sent out data on connection 2\\n");  BIO\_puts(cbio, "Connection 1: Second connection established\\n");  /\* 关闭这两个连接 \*/  BIO\_free(cbio);  BIO\_free(cbio2); ##

## 19.Fileter类型的NULL型BIO ##

## 前面我们已经介绍完source/sink型的BIO了，以后的BIO系列文章将开始介绍过滤(filter)类型的BIO。那么首先介绍的是一个非常简单的BIO类型——NULL型filter BIO，其定义如下（openssl\\bio.h）：  BIO\_METHOD \* BIO\_f\_null(void);  在本类型中，只有这个函数是定义了的，该函数返回一个NULL型的过滤BIO\_METHOD结构，NULL过滤型BIO是一个不作任何事情的BIO。针对该类型BIO的任何调用都会被简单传递中BIO链中的下一个BIO中去，也就相当于该BIO是不存在的一样。所以，一般来说，该类型的BIO用处不大。 ##

## 20.缓冲（buffer）类型BIO ##

## 缓冲（buffer）类型BIO是一种过滤（filter）型的BIO，其相关的一些函数定义如下（openssl\\bio.h）：  BIO\_METHOD \* BIO\_f\_buffer(void);  \#define BIO\_get\_buffer\_num\_lines(b) BIO\_ctrl(b,BIO\_C\_GET\_BUFF\_NUM\_LINES,0,NULL)  \#define BIO\_set\_read\_buffer\_size(b,size) BIO\_int\_ctrl(b,BIO\_C\_SET\_BUFF\_SIZE,size,0)  \#define BIO\_set\_write\_buffer\_size(b,size) BIO\_int\_ctrl(b,BIO\_C\_SET\_BUFF\_SIZE,size,1)  \#define BIO\_set\_buffer\_size(b,size) BIO\_ctrl(b,BIO\_C\_SET\_BUFF\_SIZE,size,NULL)  \#define BIO\_set\_buffer\_read\_data(b,buf,num) BIO\_ctrl(b,BIO\_C\_SET\_BUFF\_READ\_DATA,num,buf) ##

### 20.1 BIO\_f\_buffer ###

## 该函数返回一个Buffer类型的BIO\_METHOD结构，该结构定义如下（bf\_buff.c）：  static BIO\_METHOD methods\_buffer=  \{   BIO\_TYPE\_BUFFER,  "buffer",  buffer\_write,  buffer\_read,  buffer\_puts,  buffer\_gets,  buffer\_ctrl,  buffer\_new,  buffer\_free,  buffer\_callback\_ctrl,  \};  由结构定义可见，该类型BIO支持所有BIO的I/O函数。写入缓冲(buffer)BIO的数据存储在缓冲区里面，定期写入到BIO链的下一个BIO中，事实上，只有缓冲区已满或者调用了BIO\_flush函数时，数据才会写入下面的BIO，所以，当任何存储在缓冲区的数据需要写入的时候（如在使用BIO\_pop函数从BIO链中删除一个buffer类型BIO之前），必须使用BIO\_flush函数，如果BIO链的末尾是一个非阻塞型的BIO，有时候调用BIO\_flush可能出现失败，需要重试的情况。从该类型BIO读取数据时，数据从下一个BIO填充到该BIO的内部缓冲区中，然后再读出来。该类型BIO支持BIO\_gets和BIO\_puts方法，事实上，BIO\_gets函数是通过在下一个BIO的BIO\_read函数来实现的，所以，如果一个BIO不支持BIO\_gets方法（如SSL类型的BIO），可以通过预先附加一个buffer类型BIO来实现BIO\_gets的功能。  BIO\_reset被调用的时候，该类型BIO里面的所有数据都会被清空。 ##

### 20.2 BIO\_get\_buffer\_num\_lines ###

## 返回缓冲区中目前数据的的行数。 ##

### 20.3 BIO\_set\_read\_buffer\_size、BIO\_set\_write\_buffer\_size和BIO\_set\_buffer\_size ###

## 这三个函数分别设置缓冲类型BIO的读、写或者读写缓冲区的大小。初始的缓冲区大小由宏定义DEFAULT\_BUFFER\_SIZE决定，默认的是1024。如果设置的缓冲区大小小于DEFAULT\_BUFFER\_SIZE，那么就会被忽略，也就是说缓冲区大小会保持为DEFAULT\_BUFFER\_SIZE所定义的大小。当重新设置缓冲区大小时，里面的数据会全部被清空。成功执行返回1，否则返回0。 ##

### 20.4 BIO\_set\_buffer\_read\_data ###

## 该函数清空缓冲区原有的数据，并使用num个buf中的数据填充该缓冲区，如果num的大小大于目前的缓冲区设定大小，那么缓冲区就会自动扩大。成功设置返回1，否则返回0。 ##

## 21.Base64类型BIO ##

## 该类型为过滤（filter）类型BIO，其定义如下（openssl\\bio.h,openssl\\evp.h）：  BIO\_METHOD \* BIO\_f\_base64(void); ##

### 21.1 BIO\_f\_base64 ###

## 该函数返回一个Base64类型的BIO\_METHOD结构，该结构定义如下（evp\\bio\_b64.c）：  static BIO\_METHOD methods\_b64=  \{   BIO\_TYPE\_BASE64,  "base64 encoding",  b64\_write,  b64\_read,  NULL, /\* b64\_puts, \*/  NULL, /\* b64\_gets, \*/  b64\_ctrl,  b64\_new,  b64\_free,  b64\_callback\_ctrl,  \};  应该注意的是，该类型的BIO其定义并不在bio目录下，而是在evp目录下。  当往该BIO写入数据时，数据被Base64编码，当从该BIO读数据时，数据被Base64解码。该BIO不支持BIO\_gets和BIO\_puts的功能。  BIO\_flush在该类型BIO被调用的时候，表示需要写入的数据已经写完，用来把最后的一段数据写入到BIO里面去。 ##

### 21.2 BIO\_set\_flags ###

## 该函数可以用来设置标记BIO\_FLAGS\_BASE64\_NO\_NL，该标记设置后，将把所有数据编码成为一行或者说期望所有数据都在一行上。需要注意的是，由于base64编码本身格式的原因，不能准确可靠的决定编码后的数据块的结束位置，大家使用的时候自己需要注意数据的长度问题。  例子：  1、下面的程序将字符串"Hello World\\n"进行base64编码并写入到标准输出设备。  BIO \*bio, \*b64;  char message\[\] = "Hello World \\n";     b64 = BIO\_new(BIO\_f\_base64());  bio = BIO\_new\_fp(stdout, BIO\_NOCLOSE);  bio = BIO\_push(b64, bio);  BIO\_write(bio, message, strlen(message));  BIO\_flush(bio);     BIO\_free\_all(bio);  2、下面的程序将base64编码的数据从标准输入设备读出并将解码数据输出到标准输出设备：  BIO \*bio, \*b64, bio\_out;  char inbuf\[512\];  int inlen;  char message\[\] = "Hello World \\n";     b64 = BIO\_new(BIO\_f\_base64());  bio = BIO\_new\_fp(stdin, BIO\_NOCLOSE);  bio\_out = BIO\_new\_fp(stdout, BIO\_NOCLOSE);  bio = BIO\_push(b64, bio);  while((inlen = BIO\_read(bio, inbuf, strlen(message))) > 0)  BIO\_write(bio\_out, inbuf, inlen);  BIO\_free\_all(bio); ##

## 22.Cipher类型BIO ##

## 该类型为过滤（filter）类型BIO，其定义如下（openssl\\bio.h,openssl\\evp.h）：  BIO\_METHOD \* BIO\_f\_cipher(void);  void BIO\_set\_cipher(BIO \*b,const EVP\_CIPHER \*cipher,unsigned char \*key, unsigned char \*iv, int enc);  int BIO\_get\_cipher\_status(BIO \*b)  int BIO\_get\_cipher\_ctx(BIO \*b, EVP\_CIPHER\_CTX \*\*pctx) ##

### 22.1 BIO\_f\_cipher ###

## 该函数返回cipher类型的BIO\_METHOD结构，其结构定义如下（evp\\bio\_enc.c）：  static BIO\_METHOD methods\_enc=  \{   BIO\_TYPE\_CIPHER,"cipher",  enc\_write,  enc\_read,  NULL, /\* enc\_puts, \*/  NULL, /\* enc\_gets, \*/  enc\_ctrl,  enc\_new,  enc\_free,  enc\_callback\_ctrl,  \};  该类型的BIO将写入该BIO的数据加密，从该BIO读数据时数据被解密，它事实上封装了EVP\_CipherInit、EVP\_CipherUpdate、EVP\_CipherFinal三种方法。它不支持BIO\_puts和BIO\_gets的方法，如果要使用这两个方法，可以通过在前面附加一个buffer类型的BIO来实现，这在前面我们介绍过。  跟base64型BIO相似，当调用BIO\_flush函数时，表明所有数据都已经通过该类型BIO加密了，用来将最后的一段数据通过该BIO进行加密。在进行加密的时候，必须调用BIO\_flush函数来把最后的数据通过BIO进行加密，否则最后的数据会在解密的时候出现失败的情况。当从一个加密类型的BIO读取数据时，当读到最后一段数据时，会通过检测EOF自动检测到数据结束标志并自动将这段数据解密。 ##

### 22.2 BIO\_set\_cipher ###

## 该函数设置该BIO的加密算法，数据使用参数key为加密密钥，参数iv作为加密的IV（初始化向量）。如果enc设置为1，则为加密，enc设置为0，则为解密。该函数不返回值。 ##

### 22.3 BIO\_get\_cipher\_status ###

## 该函数是一个BIO\_ctrl的宏，用来检测解密是否成功执行。因为在解密的时候（执行读操作的时候），如果最后一段数据发生错误，会返回0，而遇到EOF成功完成操作后也会返回0，所以必须调用本函数确定解密操作是否成功执行了。解密成功返回1，否则返回0。 ##

### 22.4 BIO\_get\_cipher\_ctx ###

## 该函数也是BIO\_ctrl的一个宏定义函数，它返回BIO的内部加密体制。返回的加密体制可以使用标准的加密规则进行设置。这在BIO\_set\_cipher函数的灵活性不能适应应用程序的需要的时候是很有用的。该函数总是返回1。 ##

## 23.MD类型BIO ##

## 该类型为过滤（filter）类型BIO，其定义如下（openssl\\bio.h,openssl\\evp.h）：  BIO\_METHOD \* BIO\_f\_md(void);  int BIO\_set\_md(BIO \*b,EVP\_MD \*md);  int BIO\_get\_md(BIO \*b,EVP\_MD \*\*mdp);  int BIO\_get\_md\_ctx(BIO \*b,EVP\_MD\_CTX \*\*mdcp);  跟Cipher类型一样，该类型的一些定义和实现文件是在evp\\bio\_md.c里面，而不是在bio目录下。大家要看源文件，请参看这个文件。 ##

### 23.1 BIO\_f\_md ###

## 该函数返回一个MD类型的BIO\_METHOD结构，其定义如下：  static BIO\_METHOD methods\_md=  \{   BIO\_TYPE\_MD,"message digest",  md\_write,  md\_read,  NULL, /\* md\_puts, \*/  md\_gets,  md\_ctrl,  md\_new,  md\_free,  md\_callback\_ctrl,  \};  MD类型BIO对通过它的任何数据都进行摘要操作（digest），事实上，该类型BIO封装了EVP\_DigestInit、EVP\_DigestUpdate和EVP\_DigestFinal三个函数的功能和行为。该类型BIO是完全对称的，也就是说，不管是读数据（BIO\_read）还是写数据（BIO\_write），都进行相同的摘要操作。  BIO\_gets函数执行的时候，如果给定的size参数足够大，可以完成摘要（digest）计算，那么就会返回摘要值。BIO\_puts函数是不支持的，如果需要支持该函数，可以在前面附加一个buffer类型的BIO。  BIO\_reset函数重新初始化一个摘要类型的BIO，事实上，它是简单重新调用了EVP\_DigestInit函数进行初始化。  注意，在从一个摘要BIO里面读取完摘要信息之后，在重新使用该BIO之前，必须调用BIO\_reset或BIO\_set\_md重新初始化该BIO才行。 ##

### 23.2 BIO\_set\_md ###

## 该函数是一个BIO\_ctrl函数的宏定义函数，它使用参数md设置给定BIO的摘要算法。该函数必须在执行读写操作之前调用，用来初始化一个摘要类型的BIO。调用成功返回1，否则返回0。 ##

### 23.3 BIO\_get\_md ###

## 该函数也是BIO\_ctrl函数一个宏定义。它返回BIO摘要方法的指针到mdp参数里面。调用成功返回1，否则返回0。 ##

### 23.4 BIO\_get\_md\_ctx ###

## 该函数返回摘要BIO的方法结构到mdcp参数里面。该结构可以作为参数使用在EVP\_DigestFinal、EVP\_SignFinal和EVP\_VerifyFinal函数里，这增加了灵活性。因为该函数返回的结构是一个BIO内部的结构，所以对该结构的任何改变操作都会影响到相应的BIO，并且如果该BIO释放了，该结构指针也就无效了。调用成功返回1，否则返回0。  例子  1、下列的例子创建一个包含SHA1和MD5类型摘要BIO的BIO链，并将数据"Hello World"通过它们进行摘要操作。  BIO \*bio, \*mdtmp;  char message\[\] = "Hello World";  bio = BIO\_new(BIO\_s\_null());  mdtmp = BIO\_new(BIO\_f\_md());  BIO\_set\_md(mdtmp, EVP\_sha1());     // 使用BIO\_push在BIO链前面增加一个sink类型的BIO，作为BIO链开始的标志  bio = BIO\_push(mdtmp, bio);  mdtmp = BIO\_new(BIO\_f\_md());  BIO\_set\_md(mdtmp, EVP\_md5());  bio = BIO\_push(mdtmp, bio);  /\* 注意，现在mdtmp变量已经没有用了\*/  BIO\_write(bio, message, strlen(message));//因为最后一个BIO是null型的BIO，所以数据实际上已经自动被丢弃了。  2、下面的例子演示了从摘要类型BIO读数据的过程：  BIO \*bio, \*mdtmp;  char buf\[1024\];  int rdlen;  bio = BIO\_new\_file(file, "rb");  mdtmp = BIO\_new(BIO\_f\_md());  BIO\_set\_md(mdtmp, EVP\_sha1());  bio = BIO\_push(mdtmp, bio);  mdtmp = BIO\_new(BIO\_f\_md());  BIO\_set\_md(mdtmp, EVP\_md5());  bio = BIO\_push(mdtmp, bio);  do  \{   rdlen = BIO\_read(bio, buf, sizeof(buf));  /\* 可以在这里面加入处理数据的代码 \*/  \} while(rdlen > 0);  3、下面的例子从一个BIO链中读取摘要数据并输出。可以跟上面的例子一起使用。  BIO \*mdtmp;  unsigned char mdbuf\[EVP\_MAX\_MD\_SIZE\];  int mdlen;  int i;  mdtmp = bio; /\* 这里假设BIO已经设置好了\*/  do  \{   EVP\_MD \*md;  mdtmp = BIO\_find\_type(mdtmp, BIO\_TYPE\_MD);  if(!mdtmp) break;  BIO\_get\_md(mdtmp, &md);  printf("%s digest", OBJ\_nid2sn(EVP\_MD\_type(md)));  mdlen = BIO\_gets(mdtmp, mdbuf, EVP\_MAX\_MD\_SIZE);  for(i = 0; i < mdlen; i++) printf(":%02X", mdbuf\[i\]);  printf("\\n");  mdtmp = BIO\_next(mdtmp);  \} while(mdtmp);  BIO\_free\_all(bio); ##

## 24.SSL类型的BIO ##

## 从名字就可以看出，这是一个非常重要的BIO类型，它封装了openssl里面的ssl规则和函数，相当于提供了一个使用SSL很好的有效工具，一个很好的助手。其定义（openssl\\bio.h,openssl\\ssl.h）如下：  BIO\_METHOD \*BIO\_f\_ssl(void);  \#define BIO\_set\_ssl(b,ssl,c) BIO\_ctrl(b,BIO\_C\_SET\_SSL,c,(char \*)ssl)  \#define BIO\_get\_ssl(b,sslp) BIO\_ctrl(b,BIO\_C\_GET\_SSL,0,(char \*)sslp)  \#define BIO\_set\_ssl\_mode(b,client) BIO\_ctrl(b,BIO\_C\_SSL\_MODE,client,NULL)  \#define BIO\_set\_ssl\_renegotiate\_bytes(b,num) BIO\_ctrl(b,BIO\_C\_SET\_SSL\_RENEGOTIATE\_BYTES,num,NULL);  \#define BIO\_set\_ssl\_renegotiate\_timeout(b,seconds) BIO\_ctrl(b,BIO\_C\_SET\_SSL\_RENEGOTIATE\_TIMEOUT,seconds,NULL);  \#define BIO\_get\_num\_renegotiates(b) BIO\_ctrl(b,BIO\_C\_SET\_SSL\_NUM\_RENEGOTIATES,0,NULL);  BIO \*BIO\_new\_ssl(SSL\_CTX \*ctx,int client);  BIO \*BIO\_new\_ssl\_connect(SSL\_CTX \*ctx);  BIO \*BIO\_new\_buffer\_ssl\_connect(SSL\_CTX \*ctx);  int BIO\_ssl\_copy\_session\_id(BIO \*to,BIO \*from);  void BIO\_ssl\_shutdown(BIO \*bio);  \#define BIO\_do\_handshake(b) BIO\_ctrl(b,BIO\_C\_DO\_STATE\_MACHINE,0,NULL)  该类型BIO的实现文件在ssl\\bio\_ssl.c里面，大家可以参看这个文件得到详细的函数实现信息。 ##

### 24.1 BIO\_f\_ssl ###

## 该函数返回一个SSL类型的BIO\_METHOD结构，其定义如下：  static BIO\_METHOD methods\_sslp=  \{   BIO\_TYPE\_SSL,"ssl",  ssl\_write,  ssl\_read,  ssl\_puts,  NULL, /\* ssl\_gets, \*/  ssl\_ctrl,  ssl\_new,  ssl\_free,  ssl\_callback\_ctrl,  \};  可见，SSL类型BIO不支持BIO\_gets的功能。  BIO\_read和BIO\_write函数调用的时候，SSL类型的BIO会使用SSL协议进行底层的I/O操作。如果此时SSL连接并没有建立，那么就会在调用第一个IO函数的时候先进行连接的建立。  如果使用BIO\_push将一个BIO附加到一个SSL类型的BIO上，那么SSL类型的BIO读写数据的时候，它会被自动调用。  BIO\_reset调用的时候，会调用SSL\_shutdown函数关闭目前所有处于连接状态的SSL，然后再对下一个BIO调用BIO\_reset，这功能一般就是将底层的传输连接断开。调用完成之后，SSL类型的BIO就处于初始的接受或连接状态。  如果设置了BIO关闭标志，那么SSL类型BIO释放的时候，内部的SSL结构也会被SSL\_free函数释放。 ##

### 24.2 BIO\_set\_ssl ###

## 该函数设置SSL类型BIO的内部ssl指针指向ssl，同时使用参数c设置了关闭标志。 ##

### 24.3 BIO\_get\_ssl ###

## 该函数返回SSL类型BIO的内部的SSL结构指针，得到该指针后，可以使用标志的SSL函数对它进行操作。 ##

### 24.4 BIO\_set\_ssl\_mode ###

## 该函数设置SSL的工作模式，如果参数client是1，那么SSL工作模式为客户端模式，如果client为0，那么SSL工作模式为服务器模式。 ##

### 24.5 BIO\_set\_ssl\_renegotiate\_bytes ###

## 该函数设置需要重新进行session协商的读写数据的长度为num。当设置完成后，在没读写的数据一共到达num字节后，SSL连接就会自动重新进行session协商，这可以加强SSL连接的安全性。参数num最少为512字节。 ##

### 24.6 BIO\_set\_ssl\_renegotiate\_timeout ###

## 该函数跟上述函数一样都是为了加强SSL连接的安全性的。不同的是，该函数采用的参数是时间。该函数设置重新进行session协商的时间，其单位是秒。当SSL session连接建立的时间到达其设置的时间时，连接就会自动重新进行session协商。 ##

### 24.7 BIO\_get\_num\_renegotiates ###

## 该函数返回SSL连接在因为字节限制或时间限制导致session重新协商之前总共读写的数据长度。 ##

### 24.8 BIO\_new\_ssl ###

## 该函数使用ctx参数所代表的SSL\_CTX结构创建一个SSL类型的BIO，如果参数client为非零值，就使用客户端模式。 ##

### 24.9 BIO\_new\_ssl\_connect ###

## 该函数创建一个包含SSL类型BIO的新BIO链，并在后面附加了一个连接类型的BIO。方便而且有趣的是，因为在filter类型的BIO里，如果是该BIO不知道（没有实现）BIO\_ctrl操作，它会自动把该操作传到下一个BIO进行调用，所以我们可以在调用本函数得到BIO上直接调用BIO\_set\_host函数来设置服务器名字和端口，而不需要先找到连接BIO。 ##

### 24.10 BIO\_new\_buffer\_ssl\_connect ###

## 创建一个包含buffer型的BIO，一个SSL类型的BIO以及一个连接类型的BIO。 ##

### 24.11 BIO\_ssl\_copy\_session\_id ###

## 该函数将BIO链from的SSL Session ID拷贝到BIO链to中。事实上，它是通过查找到两个BIO链中的SSL类型BIO，然后调用SSL\_copy\_session\_id来完成操作的。 ##

### 24.12 BIO\_ssl\_shutdown ###

## 该函数关闭一个BIO链中的SSL连接。事实上，该函数通过查找到该BIO链中的SSL类型BIO，然后调用SSL\_shutdown函数关闭其内部的SSL指针。 ##

### 24.13 BIO\_do\_handshake ###

## 该函数在相关的BIO上启动SSL握手过程并建立SSL连接。连接成功建立返回1，否则返回0或负值，如果连接BIO是非阻塞型的BIO，此时可以调用BIO\_should\_retry函数以决定释放需要重试。如果调用该函数的时候SSL连接已经建立了，那么该函数不会做任何事情。一般情况下，应用程序不需要直接调用本函数，除非你希望将握手过程跟其它IO操作分离开来。  需要注意的是，如果底层是阻塞型（openssl帮助文档写的是非阻塞型,non blocking,但是根据上下文意思已经BIO的其它性质，我个人认为是阻塞型，blocking才是正确的）的BIO，在一些意外的情况SSL类型BIO下也会发出意外的重试请求，如在执行BIO\_read操作的时候如果启动了session重新协商的过程就会发生这种情况。在0.9.6和以后的版本，可以通过SSL的标志SSL\_AUTO\_RETRY将该类行为禁止，这样设置之后，使用阻塞型传输的SSL类型BIO就永远不会发出重试的请求。  例子  1.一个SSL/TLS客户端的例子，完成从一个SSL/TLS服务器返回一个页面的功能。其中IO操作的方法跟连接类型BIO里面的例子是相同的。  BIO \*sbio, \*out;  int len;  char tmpbuf\[1024\];  SSL\_CTX \*ctx;  SSL \*ssl;  ERR\_load\_crypto\_strings();  ERR\_load\_SSL\_strings();  OpenSSL\_add\_all\_algorithms();  //如果系统平台不支持自动进行随机数种子的设置，这里应该进行设置(seed PRNG)  ctx = SSL\_CTX\_new(SSLv23\_client\_method());  //通常应该在这里设置一些验证路径和模式等，因为这里没有设置，所以该例子可以跟使用任意CA签发证书的任意服务器建立连接  sbio = BIO\_new\_ssl\_connect(ctx);  BIO\_get\_ssl(sbio, &ssl);  if(!ssl)  \{fprintf(stderr, "Can't locate SSL pointer\\n");\}  /\* 不需要任何重试请求\*/  SSL\_set\_mode(ssl, SSL\_MODE\_AUTO\_RETRY);  //这里你可以添加对SSL的其它一些设置  BIO\_set\_conn\_hostname(sbio, "localhost:https");  out = BIO\_new\_fp(stdout, BIO\_NOCLOSE);  if(BIO\_do\_connect(sbio) <= 0)  \{   fprintf(stderr, "Error connecting to server\\n");  ERR\_print\_errors\_fp(stderr);  \}  if(BIO\_do\_handshake(sbio) <= 0)  \{   fprintf(stderr, "Error establishing SSL connection\\n");  ERR\_print\_errors\_fp(stderr);  \}  /\* 这里可以添加检测SSL连接的代码，得到一些连接信息\*/  BIO\_puts(sbio, "GET / HTTP/1.0\\n\\n");  for(;;)  \{   len = BIO\_read(sbio, tmpbuf, 1024);  if(len <= 0) break;  BIO\_write(out, tmpbuf, len);  \}  BIO\_free\_all(sbio);  BIO\_free(out);  2.一个简单的服务器的例子。它使用了buffer类型的BIO，从而可以使用BIO\_gets从一个SSL类型的BIO读取数据。它创建了一个包含客户端请求的随机web页，并把请求信息输出到标准输出设备。  BIO \*sbio, \*bbio, \*acpt, \*out;  int len;  char tmpbuf\[1024\];  SSL\_CTX \*ctx;  SSL \*ssl;  ERR\_load\_crypto\_strings();  ERR\_load\_SSL\_strings();  OpenSSL\_add\_all\_algorithms();  //可能需要进行随机数的种子处理（seed PRNG）  ctx = SSL\_CTX\_new(SSLv23\_server\_method());  if ( !SSL\_CTX\_use\_certificate\_file ( ctx, "server.pem", SSL\_FILETYPE\_PEM ) || !SSL\_CTX\_use\_PrivateKey\_file ( ctx, "server.pem", SSL\_FILETYPE\_PEM ) || !SSL\_CTX\_check\_private\_key(ctx))  \{   fprintf(stderr, "Error setting up SSL\_CTX\\n");  ERR\_print\_errors\_fp(stderr);  return 0;  \}  //可以在这里设置验证路径，DH和DSA算法的临时密钥回调函数等等  /\* 创建一个新的服务器模式的SSL类型BIO\*/  sbio=BIO\_new\_ssl(ctx,0);  BIO\_get\_ssl(sbio, &ssl);  if(!ssl)  \{fprintf(stderr, "Can't locate SSL pointer\\n");\}  /\* 不需要任何重试请求 \*/  SSL\_set\_mode(ssl, SSL\_MODE\_AUTO\_RETRY);  /\* 创建一个Buffer类型BIO \*/  bbio = BIO\_new(BIO\_f\_buffer());  /\* 加到BIO链上\*/  sbio = BIO\_push(bbio, sbio);  acpt=BIO\_new\_accept("4433");  /\*当一个新连接建立的时候，我们可以将sbio链自动插入到连接所在的BIO链中去。这时候，这个BIO链(sbio)就被accept类型BIO吞并了，并且当accept类型BIO释放的时候，它会自动被释放。\*/  BIO\_set\_accept\_bios(acpt,sbio);  out = BIO\_new\_fp(stdout, BIO\_NOCLOSE);  /\* 设置 accept BIO \*/  if(BIO\_do\_accept(acpt) <= 0)  \{   fprintf(stderr, "Error setting up accept BIO\\n");  ERR\_print\_errors\_fp(stderr);  return 0;  \}  /\* 等待连接的建立 \*/  if(BIO\_do\_accept(acpt) <= 0)  \{   fprintf(stderr, "Error in connection\\n");  ERR\_print\_errors\_fp(stderr);  return 0;  \}  /\*因为我们只想处理一个连接，所以可以删除和释放 accept BIO了\*/  sbio = BIO\_pop(acpt);  BIO\_free\_all(acpt);  if(BIO\_do\_handshake(sbio) <= 0)  \{   fprintf(stderr, "Error in SSL handshake\\n");  ERR\_print\_errors\_fp(stderr);  return 0;  \}  BIO\_puts(sbio, "HTTP/1.0 200 OK\\r\\nContent-type: text/html\\r\\n\\r\\n");  BIO\_puts(sbio, "<pre>\\r\\nConnection Established\\r\\nRequest headers:\\r\\n");  BIO\_puts(sbio, "--------------------------------------------------\\r\\n");  for(;;)  \{   len = BIO\_gets(sbio, tmpbuf, 1024);  if(len <= 0) break;  BIO\_write(sbio, tmpbuf, len);  BIO\_write(out, tmpbuf, len);  /\* 查找请求头的结束标准空白行\*/  if((tmpbuf\[0\] == '\\r') || (tmpbuf\[0\] == '\\n')) break;  \}  BIO\_puts(sbio, "--------------------------------------------------\\r\\n");  BIO\_puts(sbio, "</pre>\\r\\n");  /\* 因为使用了buffer类型的BIO，我们最好调用BIO\_flush函数 \*/  BIO\_flush(sbio);  BIO\_free\_all(sbio); ##