<![CDATA[冷枫叶]]> http://hi.baidu.com http://hi.baidu.com http://img.baidu.com/img/logo-hi.gif http://hi.baidu.com/rwen2012 zh-cn www.baidu.com 5 <![CDATA[io模拟i2c程序(zt)]]>

本程序是在周立功网上的程序的基础上修改的，原例里的ACK时序有点问题

/*******************************************************************************************************************
此程序是I2C操作平台（主方式的软件平台）的底层的C子程序,如发送数据
及接收数据,应答位发送,并提供了几个直接面对器件的操作函数，它很方便的与用
户程序连接并扩展。
注意:函数是采用软件延时的方法产生SCL脉冲,对高晶振频率要作一定的修改
(本例是3us机器周期,如果系统对时间要求不是很重要的话,最好在每个单元读写结束时加个延时，
测试有子地址器件函数，未测试无地址的器件，适合器件地址和子地址小于256的器件，
大于256的单元的器件可以自己改写)。
*********************************************************************************************************************/
#include <reg52.h>         /*头文件的包含*/
#include <intrins.h>
#define uchar unsigned char /*宏定义*/
#define uint unsigned int

/*端口位定义*/
sbit BELL_OUT=P3^5;                                               
sbit SCL="P1"^3;/*模拟I2C数据传送位*/
sbit SDA="P1"^4;/*模拟I2C时钟控制位*/          

bit ack;                 /*应答标志位*/

/**************************************************************************************************************************
起动总线函数              
函数原型: void Start_I2c();
功能:启动I2C总线,即发送I2C起始条件
**************************************************************************************************************************/
void Start_I2c()
{
SDA="1";   /*发送起始条件的数据信号*/
_nop_();
SCL="1";   /*起始条件建立时间大于4.7us,延时*/
_nop_();    
SDA="0";   /*发送起始信号*/
_nop_(); /* 起始条件锁定时间大于4μs*/    
SCL="0";   /*钳住I2C总线，准备发送或接收数据 */
_nop_();
}

/************************************************************************************************************************
结束总线函数              
函数原型: void Stop_I2c();
功能:结束I2C总线,即发送I2C结束条件
************************************************************************************************************************/
void Stop_I2c()
{

SDA="0"; /*发送结束条件的数据信号*/
_nop_(); /*发送结束条件的时钟信号*/
SCL="1"; /*结束条件建立时间大于4μs*/
_nop_();
SDA="1"; /*发送I2C总线结束信号*/
_nop_();
}

/*************************************************************************************************************************
字节数据传送函数              
函数原型: void SendByte(uchar c);
功能:将数据c发送出去,可以是地址,也可以是数据,发完后等待应答,并对此状
态位进行操作(不应答或非应答都使ack=0 假) 。发送数据正常，ack=1;
ack=0表示被控器无应答或损坏。
**************************************************************************************************************************/
void SendByte(uchar c)
{
uchar BitCnt;

for(BitCnt=0;BitCnt<8;BitCnt++) /*要传送的数据长度为8位*/
{
SCL="0";
if((c<<BitCnt)&0x80) SDA="1";   /*判断发送位*/
else SDA="0";               
SCL="1";       /*置时钟线为高，通知被控器开始接收数据位*/
_nop_();     /*保证时钟高电平周期大于4μs*/       
}

//从机应答,可以用应答和非应答信号代替
_nop_();
SCL="0";
_nop_();
SDA="1";        //
_nop_();
SCL="1";
_nop_();

if(SDA==1){ack=0;} /*判断是否接收到应答信号*/   
else ack="1";

SCL="0";
_nop_();

}

/**************************************************************************************************************************
字节数据传送函数              
函数原型: uchar RcvByte();
功能:用来接收从器件传来的数据,并判断总线错误(不发应答信号)，
发完后请用应答函数。
***************************************************************************************************************************/
uchar RcvByte()
{
uchar retc;
uchar BitCnt;

retc="0";

for(BitCnt=0;BitCnt<8;BitCnt++)
{         
SCL="1";       /*置时钟线为高使数据线上数据有效*/
_nop_();
retc="retc"<<1;
if(SDA==1) retc="retc"+1; /*读数据位,接收的数据位放入retc中 */
SCL="0";
}
return(retc);
}

/***************************************************************************************************************************
应答子函数
原型: void Ack_I2c();
功能:主控器进行应答信号
***************************************************************************************************************************/
void Ack_I2c()
{
SDA="0";     /*在此发出应答信号 */
_nop_();
SCL="0";
_nop_();     
SCL="1";
_nop_();
SCL="0";     /*清时钟线，钳住I2C总线以便继续接收*/
_nop_();
SDA="1";
_nop_();
}

/*************************************************************************************************************************
非应答子函数
原型: void NoAck_I2c();
功能:主控器进行非应答信号
**************************************************************************************************************************/
void NoAck_I2c()
{
SDA="1"; /*在此发出非应答信号 */
_nop_();     
SCL="1";
_nop_();
SCL="0"; /*清时钟线，钳住I2C总线以便继续接收*/
}

/**************************************************************************************************************************
向无子地址器件发送字节数据函数              
函数原型: bit ISendByte(uchar sla,ucahr c);
功能:从启动总线到发送地址，数据，结束总线的全过程,从器件地址sla。如果
返回1表示操作成功，否则操作有误。
**************************************************************************************************************************/
bit ISendByte(uchar sla,uchar c)
{
Start_I2c();               /*启动总线*/
SendByte(sla);            /*发送器件地址*/
if(ack==0)return(0);

SendByte(c);               /*发送数据*/
if(ack==0)return(0);

Stop_I2c();                 /*结束总线*/
return(1);
}

/**************************************************************************************************************************
向有子地址器件发送多字节数据函数              
函数原型: bit ISendStr(uchar sla,uchar suba,ucahr *s,uchar no);
功能:从启动总线到发送地址，子地址,数据，结束总线的全过程,从器件地址sla，
子地址suba，发送内容是s指向的内容，发送no个字节。如果返回1表示
操作成功，否则操作有误。
***************************************************************************************************************************/
bit ISendStr(uchar sla,uchar suba,uchar *s,uchar no)
{
uchar i;

Start_I2c();               /*启动总线*/
SendByte(sla);           /*发送器件地址*/
if(ack==0)return(0);

SendByte(suba);            /*发送器件子地址*/
if(ack==0)return(0);

for(i=0;i<no;i++)
{  
SendByte(*s);               /*发送数据*/
if(ack==0)return(0);
s++;
}
Stop_I2c();   /*结束总线*/
//delayMs(1);      //         
return(1);
}

/*************************************************************************************************************************
向无子地址器件读字节数据函数              
函数原型: bit IRcvByte(uchar sla,ucahr *c);
功能:从启动总线到发送地址，读数据，结束总线的全过程,从器件地址sla，返
回值在c。如果返回1表示操作成功，否则操作有误。
*************************************************************************************************************************/
bit IRcvByte(uchar sla,uchar *c)
{
Start_I2c();                /*启动总线*/
SendByte(sla+1);           /*发送器件地址*/
if(ack==0)return(0);

*c=RcvByte();               /*读取数据*/
NoAck_I2c();               /*发送非就答位*/
Stop_I2c();                  /*结束总线*/
return(1);
}

/**************************************************************************************************************************
向有子地址器件读取多字节数据函数              
函数原型: bit ISendStr(uchar sla,uchar suba,ucahr *s,uchar no);
功能:从启动总线到发送地址，子地址,读数据，结束总线的全过程,从器件地址sla，
子地址suba，读出的内容放入s指向的存储区，读no个字节。如果返回1
表示操作成功，否则操作有误。
**************************************************************************************************************************/
bit IRcvStr(uchar sla,uchar suba,uchar *s,uchar no)
{
Start_I2c();               /*启动总线*/
SendByte(sla);            /*发送器件地址*/
if(ack==0)return(0);

SendByte(suba);            /*发送器件子地址*/
if(ack==0)return(0);

Start_I2c();
SendByte(sla+1);
if(ack==0)return(0);

while(no!=1)
{
*s=RcvByte();/*发送数据*/
Ack_I2c();   /*发送就答位*/  
s++;
no--;
}
*s=RcvByte();
NoAck_I2c();              /*发送非应位*/
Stop_I2c();             /*结束总线*/
return(1);
}

阅读全文
类别：嵌入式实践 查看评论]]> 2009-11-02 10:08 http://hi.baidu.com/rwen2012/blog/item/1da3bfdcab2c30abcd1166b1.html <![CDATA[CodingStyle/Linux内核代码风格]]> 这是一个简短的文档，描述了linux内核的首选代码风格。代码风格是因人而异的，而且我
不愿意把我的观点强加给任何人，不过这里所讲述的是我必须要维护的代码所遵守的风格，
并且我也希望绝大多数其他代码也能遵守这个风格。请在写代码时至少考虑一下本文所述的
风格。

首先，我建议你打印一份GNU代码规范，然后不要读它。烧了它，这是一个具有重大象征性
意义的动作。

不管怎样，现在我们开始：


第一章：缩进

制表符是8个字符，所以缩进也是8个字符。有些异端运动试图将缩进变为4（乃至2）个字符
深，这几乎相当于尝试将圆周率的值定义为3。

理由：缩进的全部意义就在于清楚的定义一个控制块起止于何处。尤其是当你盯着你的屏幕
连续看了20小时之后，你将会发现大一点的缩进会使你更容易分辨缩进。

现在，有些人会抱怨8个字符的缩进会使代码向右边移动的太远，在80个字符的终端屏幕上
就很难读这样的代码。这个问题的答案是，如果你需要3级以上的缩进，不管用何种方式你
的代码已经有问题了，应该修正你的程序。

简而言之，8个字符的缩进可以让代码更容易阅读，还有一个好处是当你的函数嵌套太深的
时候可以给你警告。留心这个警告。

在switch语句中消除多级缩进的首选的方式是让“switch”和从属于它的“case”标签对齐于同
一列，而不要“两次缩进”“case”标签。比如：

switch (suffix) {
case 'G':
case 'g':
mem <<= 30;
break;
case 'M':
case 'm':
mem <<= 20;
break;
case 'K':
case 'k':
mem <<= 10;
/* fall through */
default:
break;
}


不要把多个语句放在一行里，除非你有什么东西要隐藏：

if (condition) do_this;
do_something_everytime;

也不要在一行里放多个赋值语句。内核代码风格超级简单。就是避免可能导致别人误读的表
达式。

除了注释、文档和Kconfig之外，不要使用空格来缩进，前面的例子是例外，是有意为之。

选用一个好的编辑器，不要在行尾留空格。


第二章：把长的行和字符串打散

代码风格的意义就在于使用平常使用的工具来维持代码的可读性和可维护性。

每一行的长度的限制是80列，我们强烈建议您遵守这个惯例。

长于80列的语句要打散成有意义的片段。每个片段要明显短于原来的语句，而且放置的位置
也明显的靠右。同样的规则也适用于有很长参数列表的函数头。长字符串也要打散成较短的
字符串。唯一的例外是超过80列可以大幅度提高可读性并且不会隐藏信息的情况。

void fun(int a, int b, int c)
{
if (condition)
printk(KERN_WARNING "Warning this is a long printk with "
"3 parameters a: %u b: %u "
"c: %u \n", a, b, c);
else
next_statement;
}

第三章：大括号和空格的放置

C语言风格中另外一个常见问题是大括号的放置。和缩进大小不同，选择或弃用某种放置策
略并没有多少技术上的原因，不过首选的方式，就像Kernighan和Ritchie展示给我们的，是
把起始大括号放在行尾，而把结束大括号放在行首，所以：

if (x is true) {
we do y
}

这适用于所有的非函数语句块（if、switch、for、while、do）。比如：

switch (action) {
case KOBJ_ADD:
return "add";
case KOBJ_REMOVE:
return "remove";
case KOBJ_CHANGE:
return "change";
default:
return NULL;
}

不过，有一个例外，那就是函数：函数的起始大括号放置于下一行的开头，所以：

int function(int x)
{
body of function
}

全世界的异端可能会抱怨这个不一致性是……呃……不一致的，不过所有思维健全的人都知道（
a）K&R是_正确的_，并且（b）K&R是正确的。此外，不管怎样函数都是特殊的（在C语言中
，函数是不能嵌套的）。

注意结束大括号独自占据一行，除非它后面跟着同一个语句的剩余部分，也就是do语句中的
“while”或者if语句中的“else”，像这样：

do {
body of do-loop
} while (condition);

和

if (x == y) {
..
} else if (x > y) {
...
} else {
....
}

理由：K&R。

也请注意这种大括号的放置方式也能使空（或者差不多空的）行的数量最小化，同时不失可
读性。因此，由于你的屏幕上的新行是不可再生资源（想想25行的终端屏幕），你将会有更
多的空行来放置注释。

当只有一个单独的语句的时候，不用加不必要的大括号。

if (condition)
action();

这点不适用于本身为某个条件语句的一个分支的单独语句。这时需要在两个分支里都使用大
括号。

if (condition) {
do_this();
do_that();
} else {
otherwise();
}

3.1：空格

Linux内核的空格使用方式（主要）取决于它是用于函数还是关键字。（大多数）关键字后
要加一个空格。值得注意的例外是sizeof、typeof、alignof和__attribute__，这些关键字
某些程度上看起来更像函数（它们在Linux里也常常伴随小括号而使用，尽管在C语言里这样
的小括号不是必需的，就像“struct fileinfo info”声明过后的“sizeof info”）。

所以在这些关键字之后放一个空格：
if, switch, case, for, do, while
但是不要在sizeof、typeof、alignof或者__attribute__这些关键字之后放空格。例如，
s = sizeof(struct file);

不要在小括号里的表达式两侧加空格。这是一个反例：

s = sizeof( struct file );

当声明指针类型或者返回指针类型的函数时，“*”的首选使用方式是使之靠近变量名或者函
数名，而不是靠近类型名。例子：

char *linux_banner;
unsigned long long memparse(char *ptr, char **retptr);
char *match_strdup(substring_t *s);

在大多数二元和三元操作符两侧使用一个空格，例如下面所有这些操作符：

=  +  -  <  >  *  /  %  |  &  ^  <=  >=  ==  !=  ?  :

但是一元操作符后不要加空格：
&  *  +  -  ~  !  sizeof  typeof  alignof  __attribute__  defined

后缀自加和自减一元操作符前不加空格：
++  --

前缀自加和自减一元操作符后不加空格：
++  --

“.”和“->”结构体成员操作符前后不加空格。

不要在行尾留空白。有些可以自动缩进的编辑器会在新行的行首加入适量的空白，然后你
就可以直接在那一行输入代码。不过假如你最后没有在那一行输入代码，有些编辑器就不
会移除已经加入的空白，就像你故意留下一个只有空白的行。包含行尾空白的行就这样产
生了。

当git发现补丁包含了行尾空白的时候会警告你，并且可以应你的要求去掉行尾空白；不过
如果你是正在打一系列补丁，这样做会导致后面的补丁失败，因为你改变了补丁的上下文。


第四章：命名

C是一个简朴的语言，你的命名也应该这样。和Modula-2和Pascal程序员不同，C程序员不使
用类似ThisVariableIsATemporaryCounter这样华丽的名字。C程序员会称那个变量为“tmp”
，这样写起来会更容易，而且至少不会令其难于理解。

不过，虽然混用大小写的名字是不提倡使用的，但是全局变量还是需要一个具描述性的名字
。称一个全局函数为“foo”是一个难以饶恕的错误。

全局变量（只有当你真正需要它们的时候再用它）需要有一个具描述性的名字，就像全局函
数。如果你有一个可以计算活动用户数量的函数，你应该叫它“count_active_users()”或者
类似的名字，你不应该叫它“cntuser()”。

在函数名中包含函数类型（所谓的匈牙利命名法）是脑子出了问题——编译器知道那些类型而
且能够检查那些类型，这样做只能把程序员弄糊涂了。难怪微软总是制造出有问题的程序。

本地变量名应该简短，而且能够表达相关的含义。如果你有一些随机的整数型的循环计数器
，它应该被称为“i”。叫它“loop_counter”并无益处，如果它没有被误解的可能的话。类似
的，“tmp”可以用来称呼任意类型的临时变量。

如果你怕混淆了你的本地变量名，你就遇到另一个问题了，叫做函数增长荷尔蒙失衡综合症
。请看第六章（函数）。


第五章：Typedef

不要使用类似“vps_t”之类的东西。

对结构体和指针使用typedef是一个错误。当你在代码里看到：

vps_t a;

这代表什么意思呢？

相反，如果是这样

struct virtual_container *a;

你就知道“a”是什么了。

很多人认为typedef“能提高可读性”。实际不是这样的。它们只在下列情况下有用：

(a) 完全不透明的对象（这种情况下要主动使用typedef来隐藏这个对象实际上是什么）。

例如：“pte_t”等不透明对象，你只能用合适的访问函数来访问它们。

注意！不透明性和“访问函数”本身是不好的。我们使用pte_t等类型的原因在于真的是
完全没有任何共用的可访问信息。

(b) 清楚的整数类型，如此，这层抽象就可以帮助消除到底是“int”还是“long”的混淆。

u8/u16/u32是完全没有问题的typedef，不过它们更符合类别(d)而不是这里。

再次注意！要这样做，必须事出有因。如果某个变量是“unsigned long“，那么没有必要

typedef unsigned long myflags_t;

不过如果有一个明确的原因，比如它在某种情况下可能会是一个“unsigned int”而在
其他情况下可能为“unsigned long”，那么就不要犹豫，请务必使用typedef。

(c) 当你使用sparse按字面的创建一个新类型来做类型检查的时候。

(d) 和标准C99类型相同的类型，在某些例外的情况下。

虽然让眼睛和脑筋来适应新的标准类型比如“uint32_t”不需要花很多时间，可是有些
人仍然拒绝使用它们。

因此，Linux特有的等同于标准类型的“u8/u16/u32/u64”类型和它们的有符号类型是被
允许的——尽管在你自己的新代码中，它们不是强制要求要使用的。

当编辑已经使用了某个类型集的已有代码时，你应该遵循那些代码中已经做出的选择。

(e) 可以在用户空间安全使用的类型。

在某些用户空间可见的结构体里，我们不能要求C99类型而且不能用上面提到的“u32”
类型。因此，我们在与用户空间共享的所有结构体中使用__u32和类似的类型。

可能还有其他的情况，不过基本的规则是永远不要使用typedef，除非你可以明确的应用上
述某个规则中的一个。

总的来说，如果一个指针或者一个结构体里的元素可以合理的被直接访问到，那么它们就不
应该是一个typedef。


第六章：函数

函数应该简短而漂亮，并且只完成一件事情。函数应该可以一屏或者两屏显示完（我们都知
道ISO/ANSI屏幕大小是80x24），只做一件事情，而且把它做好。

一个函数的最大长度是和该函数的复杂度和缩进级数成反比的。所以，如果你有一个理论上
很简单的只有一个很长（但是简单）的case语句的函数，而且你需要在每个case里做很多很
小的事情，这样的函数尽管很长，但也是可以的。

不过，如果你有一个复杂的函数，而且你怀疑一个天分不是很高的高中一年级学生可能甚至
搞不清楚这个函数的目的，你应该严格的遵守前面提到的长度限制。使用辅助函数，并为之
取个具描述性的名字（如果你觉得它们的性能很重要的话，可以让编译器内联它们，这样的
效果往往会比你写一个复杂函数的效果要好。）

函数的另外一个衡量标准是本地变量的数量。此数量不应超过5－10个，否则你的函数就有
问题了。重新考虑一下你的函数，把它分拆成更小的函数。人的大脑一般可以轻松的同时跟
踪7个不同的事物，如果再增多的话，就会糊涂了。即便你聪颖过人，你也可能会记不清你2
个星期前做过的事情。

在源文件里，使用空行隔开不同的函数。如果该函数需要被导出，它的EXPORT*宏应该紧贴
在它的结束大括号之下。比如：

int system_is_up(void)
{
return system_state == SYSTEM_RUNNING;
}
EXPORT_SYMBOL(system_is_up);

在函数原型中，包含函数名和它们的数据类型。虽然C语言里没有这样的要求，在Linux里这
是提倡的做法，因为这样可以很简单的给读者提供更多的有价值的信息。


第七章：集中的函数退出途径

虽然被某些人声称已经过时，但是goto语句的等价物还是经常被编译器所使用，具体形式是
无条件跳转指令。

当一个函数从多个位置退出并且需要做一些通用的清理工作的时候，goto的好处就显现出来
了。

理由是：

- 无条件语句容易理解和跟踪
- 嵌套程度减小
- 可以避免由于修改时忘记更新某个单独的退出点而导致的错误
- 减轻了编译器的工作，无需删除冗余代码;)

int fun(int a)
{
int result = 0;
char *buffer = kmalloc(SIZE);

if (buffer == NULL)
return -ENOMEM;

if (condition1) {
while (loop1) {
...
}
result = 1;
goto out;
}
...
out:
kfree(buffer);
return result;
}

第八章：注释

注释是好的，不过有过度注释的危险。永远不要在注释里解释你的代码是如何运作的：更好
的做法是让别人一看你的代码就可以明白，解释写的很差的代码是浪费时间。

一般的，你想要你的注释告诉别人你的代码做了什么，而不是怎么做的。也请你不要把注释
放在一个函数体内部：如果函数复杂到你需要独立的注释其中的一部分，你很可能需要回到
第六章看一看。你可以做一些小注释来注明或警告某些很聪明（或者槽糕）的做法，但不要
加太多。你应该做的，是把注释放在函数的头部，告诉人们它做了什么，也可以加上它做这
些事情的原因。

当注释内核API函数时，请使用kernel-doc格式。请看
Documentation/kernel-doc-nano-HOWTO.txt和scripts/kernel-doc以获得详细信息。

Linux的注释风格是C89“/* ... */”风格。不要使用C99风格“// ...”注释。

长（多行）的首选注释风格是：

/*
* This is the preferred style for multi-line
* comments in the Linux kernel source code.
* Please use it consistently.
*
* Description:  A column of asterisks on the left side,
* with beginning and ending almost-blank lines.
*/

注释数据也是很重要的，不管是基本类型还是衍生类型。为了方便实现这一点，每一行应只
声明一个数据（不要使用逗号来一次声明多个数据）。这样你就有空间来为每个数据写一段
小注释来解释它们的用途了。


第九章：你已经把事情弄糟了

这没什么，我们都是这样。可能你的使用了很长时间Unix的朋友已经告诉你“GNU emacs”能
自动帮你格式化C源代码，而且你也注意到了，确实是这样，不过它所使用的默认值和我们
想要的相去甚远（实际上，甚至比随机打的还要差——无数个猴子在GNU emacs里打字永远不
会创造出一个好程序）（译注：请参考Infinite Monkey Theorem）

所以你要么放弃GNU emacs，要么改变它让它使用更合理的设定。要采用后一个方案，你可
以把下面这段粘贴到你的.emacs文件里。

(defun linux-c-mode ()
"C mode with adjusted defaults for use with the Linux kernel."
(interactive)
(c-mode)
(c-set-style "K&R")
(setq tab-width 8)
(setq indent-tabs-mode t)
(setq c-basic-offset 8))

这样就定义了M-x linux-c-mode命令。当你hack一个模块的时候，如果你把字符串
-*- linux-c -*-放在头两行的某个位置，这个模式将会被自动调用。如果你希望在你修改
/usr/src/linux里的文件时魔术般自动打开linux-c-mode的话，你也可能需要添加

(setq auto-mode-alist (cons '("/usr/src/linux.*/.*\\.[ch]$" . linux-c-mode)
auto-mode-alist))

到你的.emacs文件里。

不过就算你尝试让emacs正确的格式化代码失败了，也并不意味着你失去了一切：还可以用“
indent”。

不过，GNU indent也有和GNU emacs一样有问题的设定，所以你需要给它一些命令选项。不
过，这还不算太糟糕，因为就算是GNU indent的作者也认同K&R的权威性（GNU的人并不是坏
人，他们只是在这个问题上被严重的误导了），所以你只要给indent指定选项“-kr -i8”
（代表“K&R，8个字符缩进”），或者使用“scripts/Lindent”，这样就可以以最时髦的方式
缩进源代码。

“indent”有很多选项，特别是重新格式化注释的时候，你可能需要看一下它的手册页。不过
记住：“indent”不能修正坏的编程习惯。


第十章：Kconfig配置文件

对于遍布源码树的所有Kconfig*配置文件来说，它们缩进方式与C代码相比有所不同。紧挨
在“config”定义下面的行缩进一个制表符，帮助信息则再多缩进2个空格。比如：

config AUDIT
bool "Auditing support"
depends on NET
help
Enable auditing infrastructure that can be used with another
kernel subsystem, such as SELinux (which requires this for
logging of avc messages output).  Does not do system-call
auditing without CONFIG_AUDITSYSCALL.

仍然被认为不够稳定的功能应该被定义为依赖于“EXPERIMENTAL”：

config SLUB
depends on EXPERIMENTAL && !ARCH_USES_SLAB_PAGE_STRUCT
bool "SLUB (Unqueued Allocator)"
...

而那些危险的功能（比如某些文件系统的写支持）应该在它们的提示字符串里显著的声明这
一点：

config ADFS_FS_RW
bool "ADFS write support (DANGEROUS)"
depends on ADFS_FS
...

要查看配置文件的完整文档，请看Documentation/kbuild/kconfig-language.txt。


第十一章：数据结构

如果一个数据结构，在创建和销毁它的单线执行环境之外可见，那么它必须要有一个引用计
数器。内核里没有垃圾收集（并且内核之外的垃圾收集慢且效率低下），这意味着你绝对需
要记录你对这种数据结构的使用情况。

引用计数意味着你能够避免上锁，并且允许多个用户并行访问这个数据结构——而不需要担心
这个数据结构仅仅因为暂时不被使用就消失了，那些用户可能不过是沉睡了一阵或者做了一
些其他事情而已。

注意上锁不能取代引用计数。上锁是为了保持数据结构的一致性，而引用计数是一个内存管
理技巧。通常二者都需要，不要把两个搞混了。

很多数据结构实际上有2级引用计数，它们通常有不同“类”的用户。子类计数器统计子类用
户的数量，每当子类计数器减至零时，全局计数器减一。

这种“多级引用计数”的例子可以在内存管理（“struct mm_struct”：mm_users和mm_count）
和文件系统（“struct super_block”：s_count和s_active）中找到。

记住：如果另一个执行线索可以找到你的数据结构，但是这个数据结构没有引用计数器，这
里几乎肯定是一个bug。


第十二章：宏，枚举和RTL

用于定义常量的宏的名字及枚举里的标签需要大写。

#define CONSTANT 0x12345

在定义几个相关的常量时，最好用枚举。

宏的名字请用大写字母，不过形如函数的宏的名字可以用小写字母。

一般的，如果能写成内联函数就不要写成像函数的宏。

含有多个语句的宏应该被包含在一个do-while代码块里：

#define macrofun(a, b, c)             \
do {                    \
if (a == 5)            \
do_this(b, c);        \
} while (0)

使用宏的时候应避免的事情：

1) 影响控制流程的宏：

#define FOO(x)                    \
do {                    \
if (blah(x) < 0)        \
return -EBUGGERED;    \
} while(0)

非常不好。它看起来像一个函数，不过却能导致“调用”它的函数退出；不要打乱读者大脑里
的语法分析器。

2) 依赖于一个固定名字的本地变量的宏：

#define FOO(val) bar(index, val)

可能看起来像是个不错的东西，不过它非常容易把读代码的人搞糊涂，而且容易导致看起来
不相关的改动带来错误。

3) 作为左值的带参数的宏： FOO(x) = y；如果有人把FOO变成一个内联函数的话，这种用
法就会出错了。

4) 忘记了优先级：使用表达式定义常量的宏必须将表达式置于一对小括号之内。带参数的
宏也要注意此类问题。

#define CONSTANT 0x4000
#define CONSTEXP (CONSTANT | 3)

cpp手册对宏的讲解很详细。Gcc internals手册也详细讲解了RTL（译注：register
transfer language），内核里的汇编语言经常用到它。


第十三章：打印内核消息

内核开发者应该是受过良好教育的。请一定注意内核信息的拼写，以给人以好的印象。不要
用不规范的单词比如“dont”，而要用“do not”或者“don't”。保证这些信息简单、明了、无
歧义。

内核信息不必以句号（译注：英文句号，即点）结束。

在小括号里打印数字(%d)没有任何价值，应该避免这样做。

<linux/device.h>里有一些驱动模型诊断宏，你应该使用它们，以确保信息对应于正确的
设备和驱动，并且被标记了正确的消息级别。这些宏有：dev_err(), dev_warn(),
dev_info()等等。对于那些不和某个特定设备相关连的信息，<linux/kernel.h>定义了
pr_debug()和pr_info()。

写出好的调试信息可以是一个很大的挑战；当你写出来之后，这些信息在远程除错的时候
就会成为极大的帮助。当DEBUG符号没有被定义的时候，这些信息不应该被编译进内核里
（也就是说，默认地，它们不应该被包含在内）。如果你使用dev_dbg()或者pr_debug()，
就能自动达到这个效果。很多子系统拥有Kconfig选项来启用-DDEBUG。还有一个相关的惯例
是使用VERBOSE_DEBUG来添加dev_vdbg()消息到那些已经由DEBUG启用的消息之上。


第十四章：分配内存

内核提供了下面的一般用途的内存分配函数：kmalloc()，kzalloc()，kcalloc()和
vmalloc()。请参考API文档以获取有关它们的详细信息。

传递结构体大小的首选形式是这样的：

p = kmalloc(sizeof(*p), ...);

另外一种传递方式中，sizeof的操作数是结构体的名字，这样会降低可读性，并且可能会引
入bug。有可能指针变量类型被改变时，而对应的传递给内存分配函数的sizeof的结果不变。

强制转换一个void指针返回值是多余的。C语言本身保证了从void指针到其他任何指针类型
的转换是没有问题的。


第十五章：内联弊病

有一个常见的误解是内联函数是gcc提供的可以让代码运行更快的一个选项。虽然使用内联
函数有时候是恰当的（比如作为一种替代宏的方式，请看第十二章），不过很多情况下不是
这样。inline关键字的过度使用会使内核变大，从而使整个系统运行速度变慢。因为大内核
会占用更多的指令高速缓存（译注：一级缓存通常是指令缓存和数据缓存分开的）而且会导
致pagecache的可用内存减少。想象一下，一次pagecache未命中就会导致一次磁盘寻址，将
耗时5毫秒。5毫秒的时间内CPU能执行很多很多指令。

一个基本的原则是如果一个函数有3行以上，就不要把它变成内联函数。这个原则的一个例
外是，如果你知道某个参数是一个编译时常量，而且因为这个常量你确定编译器在编译时能
优化掉你的函数的大部分代码，那仍然可以给它加上inline关键字。kmalloc()内联函数就
是一个很好的例子。

人们经常主张给static的而且只用了一次的函数加上inline，如此不会有任何损失，因为没
有什么好权衡的。虽然从技术上说这是正确的，但是实际上这种情况下即使不加inline gcc
也可以自动使其内联。而且其他用户可能会要求移除inline，由此而来的争论会抵消inline
自身的潜在价值，得不偿失。


第十六章：函数返回值及命名

函数可以返回很多种不同类型的值，最常见的一种是表明函数执行成功或者失败的值。这样
的一个值可以表示为一个错误代码整数（-Exxx＝失败，0＝成功）或者一个“成功”布尔值（
0＝失败，非0＝成功）。

混合使用这两种表达方式是难于发现的bug的来源。如果C语言本身严格区分整形和布尔型变
量，那么编译器就能够帮我们发现这些错误……不过C语言不区分。为了避免产生这种bug，请
遵循下面的惯例：

如果函数的名字是一个动作或者强制性的命令，那么这个函数应该返回错误代码整
数。如果是一个判断，那么函数应该返回一个“成功”布尔值。

比如，“add work”是一个命令，所以add_work()函数在成功时返回0，在失败时返回-EBUSY。
类似的，因为“PCI device present”是一个判断，所以pci_dev_present()函数在成功找到
一个匹配的设备时应该返回1，如果找不到时应该返回0。

所有导出（译注：EXPORT）的函数都必须遵守这个惯例，所有的公共函数也都应该如此。私
有（static）函数不需要如此，但是我们也推荐这样做。

返回值是实际计算结果而不是计算是否成功的标志的函数不受此惯例的限制。一般的，他们
通过返回一些正常值范围之外的结果来表示出错。典型的例子是返回指针的函数，他们使用
NULL或者ERR_PTR机制来报告错误。


第十七章：不要重新发明内核宏

头文件include/linux/kernel.h包含了一些宏，你应该使用它们，而不要自己写一些它们的
变种。比如，如果你需要计算一个数组的长度，使用这个宏

#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))

类似的，如果你要计算某结构体成员的大小，使用

#define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))

还有可以做严格的类型检查的min()和max()宏，如果你需要可以使用它们。你可以自己看看
那个头文件里还定义了什么你可以拿来用的东西，如果有定义的话，你就不应在你的代码里
自己重新定义。


第十八章：编辑器模式行和其他需要罗嗦的事情

有一些编辑器可以解释嵌入在源文件里的由一些特殊标记标明的配置信息。比如，emacs
能够解释被标记成这样的行：

-*- mode: c -*-

或者这样的：

/*
Local Variables:
compile-command: "gcc -DMAGIC_DEBUG_FLAG foo.c"
End:
*/

Vim能够解释这样的标记：

/* vim:set sw=8 noet */

不要在源代码中包含任何这样的内容。每个人都有他自己的编辑器配置，你的源文件不应
该覆盖别人的配置。这包括有关缩进和模式配置的标记。人们可以使用他们自己定制的模
式，或者使用其他可以产生正确的缩进的巧妙方法。 阅读全文
类别：c语言实践 查看评论]]> 2009-10-23 11:04 http://hi.baidu.com/rwen2012/blog/item/308fd413897ca48a6538dbcf.html <![CDATA[Many Ways to Use Remote Desktop (X11VNC)]]> Many Ways to Use Remote Desktop (X11VNC)
Thursday, 22 October 2009 06:21 Aaron

There are many ways to get into a computer by using remote desktop. Some examples include: ssh, VNC, RDP, XDMCP, ICA, X11VNC, etc.

Remote desktop can be used for lots of different reasons, such as if you promised your son to get him a game in your house and you have to go to work, VNC can come to the rescue!. Or, if you need help with configuring something on your system and know a trusted person that can assist you remotely, X11VNC is the tool to help.

Today, I'm going to talk about X11VNC. X11VNC is the most commonly used remote desktop tool for X systems. To start X11VNC, you need to first install it. To get X11VNC, type this command in a terminal of a Debian- or Ubuntu-based:

sudo apt-get install x11vnc
  1. To start it up, just for a test, type 
    x11vnc
    and you might see something that catches your attention. You're using X11VNC without a password. Press Ctrl + C.
  2. Time to setup a password. Type 
    x11vnc -storepasswd
  3. Enter a password.
  4. X11VNC will ask you to save your password into a place like /home/<YOUR LOGIN NAME>/.vnc/passwd. It will ask you to confirm. Press y.
  5. To start X11VNC with a password, get ready to type 32 letters or more if your name is large. Type 
    x11vnc -rfbauth /home/<YOUR LOGIN NAME>/.vnc/passwd
    and there you have it!

Note your host and port. Since the server setup is complete, let's move on to client. You should have two accounts for this step.

  1. Login to the other account without closing the terminal or logging off that account.
  2. Open a terminal and type 
    vncviewer <THE HOST NAME>:<THE PORT>.
You're done, remote desktop is set up.


http://www.linux.com/learn/tutorials/102976-many-ways-to-use-remote-desktop-x11vnc 阅读全文
类别：Tools 查看评论]]> 2009-10-23 08:51 http://hi.baidu.com/rwen2012/blog/item/49713109029ec1a52fddd435.html <![CDATA[ffs/fls]]>
#include <asm-generic/bitops/ffz.h>
#include <asm-generic/bitops/__fls.h>
#include <asm-generic/bitops/__ffs.h>
#include <asm-generic/bitops/fls.h>
#include <asm-generic/bitops/ffs.h>

#else

static inline int constant_fls(int x)
{
int r = 32;

if (!x)
return 0;
if (!(x & 0xffff0000u)) {
x <<= 16;
r -= 16;
}
if (!(x & 0xff000000u)) {
x <<= 8;
r -= 8;
}
if (!(x & 0xf0000000u)) {
x <<= 4;
r -= 4;
}
if (!(x & 0xc0000000u)) {
x <<= 2;
r -= 2;
}
if (!(x & 0x80000000u)) {
x <<= 1;
r -= 1;
}
return r;
}

/*
* On ARMv5 and above those functions can be implemented around
* the clz instruction for much better code efficiency.
*/

static inline int fls(int x)
{
int ret;

if (__builtin_constant_p(x))
return constant_fls(x);

asm("clz\t%0, %1" : "=r" (ret) : "r" (x) : "cc");
ret = 32 - ret;
return ret;
}

#define __fls(x) (fls(x) - 1)
#define ffs(x) ({ unsigned long __t = (x); fls(__t & -__t); })
#define __ffs(x) (ffs(x) - 1)
#define ffz(x) __ffs( ~(x) )

#endif


#ifndef _ASM_GENERIC_BITOPS_FFS_H_
#define _ASM_GENERIC_BITOPS_FFS_H_

/**
* ffs - find first bit set
* @x: the word to search
*
* This is defined the same way as
* the libc and compiler builtin ffs routines, therefore
* differs in spirit from the above ffz (man ffs).
*/

static inline int ffs(int x)
{
int r = 1;

if (!x)
return 0;
if (!(x & 0xffff)) {
x >>= 16;
r += 16;
}
if (!(x & 0xff)) {
x >>= 8;
r += 8;
}
if (!(x & 0xf)) {
x >>= 4;
r += 4;
}
if (!(x & 3)) {
x >>= 2;
r += 2;
}
if (!(x & 1)) {
x >>= 1;
r += 1;
}
return r;
}

#endif /* _ASM_GENERIC_BITOPS_FFS_H_ */

阅读全文
类别：c语言实践 查看评论]]> 2009-10-19 15:36 http://hi.baidu.com/rwen2012/blog/item/35db04a95e25abf61e17a2c9.html <![CDATA[srand()/rand()]]> #include <stdlib.h>
#include <time.h>
#include <sys/types.h>

void rand_init(void){
srand(time(0));
}

u_int8_t  get_rand8(void){
return(rand() % 256);
}
u_int16_t get_rand16(void){
return(rand() % 65536);
}
u_int32_t get_rand32(void){
return(rand());
}
u_int32_t get_n(u_int32_t n){
return(rand() % n);
}
类别：c语言实践 查看评论]]> 2009-10-12 09:41 http://hi.baidu.com/rwen2012/blog/item/3ea0f63593ffd281a61e12ca.html <![CDATA[type.h]]> #define _TYPES_H_

#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))

typedef unsigned char        u8;
typedef unsigned short        u16;
typedef unsigned int        u32;
typedef unsigned long long    u64;
typedef signed char        s8;
typedef short            s16;
typedef int            s32;
typedef long long        s64;

#define min(x,y) ({ \
typeof(x) _x = (x);    \
typeof(y) _y = (y);    \
(void) (&_x == &_y);    \
_x < _y ? _x : _y; })

#define max(x,y) ({ \
typeof(x) _x = (x);    \
typeof(y) _y = (y);    \
(void) (&_x == &_y);    \
_x > _y ? _x : _y; })

#endif /* _TYPES_H_ */ 阅读全文
类别：c语言实践 查看评论]]> 2009-09-30 10:36 http://hi.baidu.com/rwen2012/blog/item/4163bb034fb6e782d53f7cf8.html <![CDATA[tmpfile]]> ngx_open_tempfile(u_char *name, ngx_uint_t persistent, ngx_uint_t access)
{
ngx_fd_t  fd;

fd = open((const char *) name, O_CREAT|O_EXCL|O_RDWR,
access ? access : 0600);

if (fd != -1 && !persistent) {
unlink((const char *) name);
}

return fd;
}

类别：c语言实践 查看评论]]> 2009-09-18 09:54 http://hi.baidu.com/rwen2012/blog/item/f9554d46801dad036b63e5cf.html <![CDATA[base64 decode/encode from nginx]]> void
ngx_encode_base64(ngx_str_t *dst, ngx_str_t *src)
{
u_char         *d, *s;
size_t          len;
static u_char   basis64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

len = src->len;
s = src->data;
d = dst->data;

while (len > 2) {
*d++ = basis64[(s[0] >> 2) & 0x3f];
*d++ = basis64[((s[0] & 3) << 4) | (s[1] >> 4)];
*d++ = basis64[((s[1] & 0x0f) << 2) | (s[2] >> 6)];
*d++ = basis64[s[2] & 0x3f];

s += 3;
len -= 3;
}

if (len) {
*d++ = basis64[(s[0] >> 2) & 0x3f];

if (len == 1) {
*d++ = basis64[(s[0] & 3) << 4];
*d++ = '=';

} else {
*d++ = basis64[((s[0] & 3) << 4) | (s[1] >> 4)];
*d++ = basis64[(s[1] & 0x0f) << 2];
}

*d++ = '=';
}

dst->len = d - dst->data;
}


ngx_int_t
ngx_decode_base64(ngx_str_t *dst, ngx_str_t *src)
{
size_t          len;
u_char         *d, *s;
static u_char   basis64[] = {
77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 62, 77, 77, 77, 63,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 77, 77, 77, 77, 77, 77,
77,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 77, 77, 77, 77, 77,
77, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 77, 77, 77, 77, 77,

77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77
};

for (len = 0; len < src->len; len++) {
if (src->data[len] == '=') {
break;
}

if (basis64[src->data[len]] == 77) {
return NGX_ERROR;
}
}

if (len % 4 == 1) {
return NGX_ERROR;
}

s = src->data;
d = dst->data;

while (len > 3) {
*d++ = (u_char) (basis64[s[0]] << 2 | basis64[s[1]] >> 4);
*d++ = (u_char) (basis64[s[1]] << 4 | basis64[s[2]] >> 2);
*d++ = (u_char) (basis64[s[2]] << 6 | basis64[s[3]]);

s += 4;
len -= 4;
}

if (len > 1) {
*d++ = (u_char) (basis64[s[0]] << 2 | basis64[s[1]] >> 4);
}

if (len > 2) {
*d++ = (u_char) (basis64[s[1]] << 4 | basis64[s[2]] >> 2);
}

dst->len = d - dst->data;

return NGX_OK;
}

阅读全文
类别：c语言实践 查看评论]]> 2009-09-18 09:46 http://hi.baidu.com/rwen2012/blog/item/7a429600495ddf1b738b65c1.html <![CDATA[纪念Richard Stevens逝世10周年]]> 阅读全文
类别：随笔 查看评论]]> 2009-09-05 10:06 http://hi.baidu.com/rwen2012/blog/item/8eadc0447062eb45500ffe27.html <![CDATA[读配置文件]]>
/* read file like this: (net-eth0.txt)

MODE  =  static
IPADDR=192.168.9.159
NETMASK=255.255.255.0
GATEWAY=192.168.9.1

*/

#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>


int readline(int fd, char *buf)
{
char c;
int n;

for (;;) {
n = read(fd, &c, 1);
if (n == 1) {
if (c != '\n' && c !=' ') *buf++ = c;
else if (c == ' ') continue;
else break; /* '\n' */
} else
return 0;
}

*buf = '\0';           
return 1;
}


typedef int (*fn_t)(char *name, char *value, void *arg);
int parse(char *buf, fn_t fn, void *arg)
{
char *s;
char *name, *value;   

name = buf;
s = strchr(buf, '=');
if (!s) return -1;
value = s;

*s = '\0';
value++;

fn(name, value, arg);

return 0;
}


typedef struct ipconf {
char mode[64];
char ipaddr[64];   
char netmask[64];
char gateway[64];
} ipconf_t;

int getipconf(char *name, char *value, void *arg)
{
//    char *name, *value;
int ret;

ipconf_t *ipc = (ipconf_t *)arg;

if (!strcmp("MODE", name)) {
strcpy(ipc->mode, value);
} else if (!strcmp("IPADDR", name)) {
strcpy(ipc->ipaddr, value);
} else if (!strcmp("NETMASK", name)){
strcpy(ipc->netmask, value);
} else if (!strcmp("GATEWAY", name)) {
strcpy(ipc->gateway, value);
} else
printf("not reconigse: name = %s, value = %s\n", name, value);

return 0;
}


int main(void)
{
int fd;
char buf[512];
ipconf_t ipc;
int ret;

fd = open("net-eth0.txt", O_RDONLY);

for (;;) {
ret = readline(fd, buf);
if (ret <= 0)
break;

parse(buf, getipconf, &ipc);
}

printf("ipc->mode: %s\n", ipc.mode);
printf("ipc->ipaddr: %s\n", ipc.ipaddr);
printf("ipc->netmask: %s\n", ipc.netmask);
printf("ipc->gateway: %s\n", ipc.gateway);

return 0;
}



阅读全文
类别：c语言实践 查看评论]]> 2009-09-03 17:20 http://hi.baidu.com/rwen2012/blog/item/74ba2c6091676a4debf8f899.html <![CDATA[UDP编程中的connect(zt)]]> 方法一：
socket----->sendto()或recvfrom()
方法二：
socket----->connect()----->send()或recv()

首先从这里看出udp中也是可以使用connect的，但是这两种方法到底有什么区别呢？首先把这四个发送函数的定义列出来：
int send(int s, const void *msg, size_t len, int flags);
int sendto(int s, const void *msg, size_t len, int flags,
const struct sockaddr *to, socklen_t tolen);

int recv(int s, void *buf, size_t len, int flags);
int  recvfrom(int  s, void *buf, size_t len, int flags,
struct sockaddr *from,  socklen_t *fromlen);
从他们的定义可以看出，sendto和recvfrom在收发时指定地址，而send和recv则没有，那么他们的地址是在那里指定的呢，答案就在于connect.
int  connect(int  sockfd,  const  struct sockaddr *serv_addr, socklen_t
addrlen);
在udp编程中，如果你只往一个地址发送，那么你可以使用send和recv，在使用它们之前用connect把它们的目的地址指定一下就可以了。connect函数在udp中就是这个作用，用它来检测udp端口的是否开放是没有用的。下面是ntpclient中的代码
struct sockaddr_in sa_dest;
bzero((char *) sa_dest, sizeof(*sa_dest));
sa_dest->sin_family=AF_INET;
if(StuffNetAddr(&(sa_dest->sin_addr),host))
return 1;

sa_dest->sin_port=htons(port);

if (connect(usd,(struct sockaddr *)&sa_dest,sizeof(sa_dest))==-1)
{perror("connect");return 1;}

return 0;



=================================

除非套接口已连接，否则异步错误是不会返回到UDP套接口的，我们确实可以给UDP套接口调用connect，然而这样做的结果却与TCP连接大相径庭：没有三路握手过程。

相反内核只是检查是否存在立即可知的错误(例如一个显然不可达的目的地)，记录对端的IP地址和端口号（取自传递给connect的套接口地址结构），然后立即返回到调用进程。

对于已连接UDP套接口，与缺省的未连接套接口相比，发生了三个变化：
1 我们再也不能给输出操作指定宿IP和端口号，也就是说我们不使用sendto，而改用write或send，写到已连接UDP套接口上的任何内容都自动发送到由connect指定的协议地址（例如IP地址和端口号）
2 我们不必使用recvfrom以获悉数据报的发送者，而改用read，recv或recvmsg，在一个已连接UDP套接口上由内核为输入操作返回的数据 报仅仅是那些来自connect所指定协议地址的数据报。目的地为这个已连接UDP套接口的本地协议地址，发源地却不是该套接口早先connect到的协 议地址的数据报，不会投递到该套接口。这样就限制了一个已连接UDP套接口而且仅能与一个对端交换数据报。
3 由已连接的UDP套接口引发的异步错误返回给他们所在的进程。

相反我们说过未连接UDP套接口不接收任何异步错误给一个UDP套接口多次调用connect拥有一个已连接UDP套接口的进程可以为下列2个目的之一：
a.指定新的IP地址和端口号；
b.断开套接口

第一个目的（即给一个已连接UDP套接口指定新的对端）不同于TCP套接口中connect的使用:对于TCP套接口，connect只能调用一次。

为了断开一个已connect的UDP套接口连接，我们再次调用connect时把套接口地址结构的地址簇成员（sin_family）设置为AF_UNSPEC。
这么做可能返回一个EAFNOSUPPORT错误，不过没有关系。
使得套接口断开连接的是在已连接UDP套接口上调用connect的进程。



=================================

有如下的一些好处：
1）选定了对端，内核只会将帮定对象的对端发来的数据报传给套接口，因此在一定环境下可以提升安全性；
2)会返回异步错误，如果对端没启动，默认情况下发送的包对应的ICMP回射包不会给调用进程，如果用了connect，嘿嘿
3）发送两个包间不要先断开再连接，提升了效率。


做个实验测试下吧

先弄个UDP回射服务器，把所有收到的数据报回射回去：
a@a-desktop:~/d/lab$ cat rollbackserver.cpp
#include<iostream>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
using namespace std;
int main()
{
int sockListener,nMsgLen;
char szBuf[1024];
struct sockaddr_in addrListener;
socklen_t addrLen;
addrLen=sizeof(struct sockaddr_in);
bzero(&addrListener,sizeof(addrListener));
addrListener.sin_family=AF_INET;
addrListener.sin_port=htons(8000);

if((sockListener=socket(AF_INET,SOCK_DGRAM,0))==-1)
{
perror("error in getting a socket");
exit(1);
}

if(bind(sockListener,(struct sockaddr*)&addrListener,sizeof(addrListener))==-1)
{
perror("bind a listener for a socket");
exit(2);
}

struct sockaddr_in addrClient;
cout<<"callback server begin to listen"<<endl;
while(true)
{
nMsgLen=recvfrom(sockListener,szBuf,1024,0,(struct sockaddr*)&addrClient,&addrLen);
if(nMsgLen>0)
{
szBuf[nMsgLen]='\0';
cout<<"send back:"<<szBuf<<endl;
sendto(sockListener,szBuf,nMsgLen,0,(struct sockaddr*)&addrClient,addrLen);
}
}

}


再写个客户端，绑定个端口，再连接服务器端。随时接受键盘输入并发送到服务器端，随时接受端口到来的数据并打印。如果没有连接 ，发送到此端口的数据会被接受，但是调用connect后会怎样呢？
a-desktop:~/d/lab$ cat udpclient.cpp
#include<iostream>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/select.h>
using namespace std;
int main()
{
int sockClient,nMsgLen,nReady;
char szRecv[1024],szSend[1024],szMsg[1024];
struct sockaddr_in addrServer,addrClient,addrLocal;
socklen_t addrLen;
fd_set setHold,setTest;

sockClient=socket(AF_INET,SOCK_DGRAM,0);
addrLen=sizeof(struct sockaddr_in);
bzero(&addrServer,sizeof(addrServer));
addrServer.sin_family=AF_INET;
addrServer.sin_addr.s_addr=inet_addr("127.0.0.1");
addrServer.sin_port=htons(8000);

addrLocal.sin_family=AF_INET;//bind to a local port
addrLocal.sin_addr.s_addr=htonl(INADDR_ANY);
addrLocal.sin_port=htons(9000);
if(bind(sockClient,(struct sockaddr*)&addrLocal,sizeof(addrLocal))==-1)
{
perror("error in binding");
exit(2);
}

if(connect(sockClient,(struct sockaddr*)&addrServer,sizeof(addrServer))==-1)
{
perror("error in connecting");
exit(1);
}

FD_ZERO(&setHold);
FD_SET(STDIN_FILENO,&setHold);
FD_SET(sockClient,&setHold);
cout<<"you can type in sentences any time"<<endl;
while(true)
{
setTest=setHold;
nReady=select(sockClient+1,&setTest,NULL,NULL,NULL);
if(FD_ISSET(0,&setTest))
{
nMsgLen=read(0,szMsg,1024);
write(sockClient,szMsg,nMsgLen);
}
if(FD_ISSET(sockClient,&setTest))
{
nMsgLen=read(sockClient,szRecv,1024);
szRecv[nMsgLen]='\0';
cout<<"read:"<<szRecv<<endl;
}

}

}
最后来个“第三者”，向第二个的端口发数据报。看她会不会成为忠贞的感情守护人:
a@a-desktop:~/d/lab$ cat clienta.cpp
#include<string.h>
#include<iostream>
#include<stdlib.h>
#include<unistd.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
using namespace std;
int main()
{
socklen_t addrLen=sizeof(struct sockaddr_in);
struct sockaddr_in addrServer;
char szMsg[1024];
int sockClient;

addrServer.sin_family=AF_INET;
addrServer.sin_addr.s_addr=inet_addr("127.0.0.1");
addrServer.sin_port=htons(9000);

sockClient=socket(AF_INET,SOCK_DGRAM,0);
while(true)
{
static int id=0;
snprintf(szMsg,sizeof(szMsg),"this is %d",id++);
sendto(sockClient,szMsg,strlen(szMsg),0,(struct sockaddr*)&addrServer,sizeof(addrServer));
sleep(1);
}
}



实验结果：
现运行第一个程序，再运行第三个程序，然后运行第二个程序。
服务器端：

a@a-desktop:~/d/lab$ ./rollback
callback server begin to listen
send back:xinheblue likes playing

send back:and listenning to music


第二个程序：
a@a-desktop:~/d/lab$ ./udpclient
you can type in sentences any time
xinheblue likes playing
read:xinheblue likes playing

and listenning to music
read:and listenning to music


实现结果证明，第二个程序调用connect后，不甩第三个程序发来的数据包。对于感情，希望将来我的她也能这样。。。 阅读全文
类别：Networking 查看评论]]> 2009-09-03 12:35 http://hi.baidu.com/rwen2012/blog/item/523c4bf4f63327e67709d723.html <![CDATA[iptoint && inttoip]]> #include <stdio.h>
#include <stdlib.h>
#include <strings.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>


static char const rcsid[] = "$Id: rv_iptoint.c,v 1.2 2004/03/10 18:04:33 wilhelm Exp $";

unsigned int rv_iptoint (char * ipstring) {
/* ==============

 Converts an IP number (e.g. 1.2.3.4) into an 32 unsigned int ("0x01020304").

 Input : char * ipstring String containing the ip number
 Output: unsigned int IP number as a 32 bit unsigned int.

 Non-numbers in the input string will be converted to FF.


 $Author: wilhelm $
 $Date: 2004/03/10 18:04:33 $
 $Revision: 1.2 $

*/

 unsigned int temp;
 char buffer[10];
 char *point= &buffer[0];
 int i;

 point = strtok ( ipstring, "." );
 if (point == NULL) { return 0; }

 if (strcmp(point, "??") == 0) {
 temp = 0xFF;
 }
 else {
 temp = (int) strtol (point, (char**)NULL, 10);
 }

 for (i=0 ; i<3 ; i++) {
 point = strtok ( NULL, "." );
 if ( (point == NULL) ) {
 return 0;
 }
 else if ((strcmp(point, "??") == 0) ) {
 temp = temp*0x100 + 0xFF;
 }
 else {
 temp = temp*0x100 + (int) strtol (point, (char**)NULL, 10);
 }
 }

 return temp;
}



#include <stdio.h>
#include <strings.h>

static char const rcsid[] = "$Id: rv_inttoip.c,v 1.1 2002/08/15 23:15:48 ttraffic Exp $";

char* rv_inttoip (unsigned int ipno, char* point) {
/* ============

 Converts an unsigned int ("0x01020304") into a standard IP number (1.2.3.4);
 Space for the string must have been alloced in the calling routine.

 $Author: ttraffic $
 $Date: 2002/08/15 23:15:48 $
 $Revision: 1.1 $

*/
 int byte[4], i;

 for (i=0 ; i<4 ; i++) {
 byte[i] = ipno & 0xFF;
 ipno = ipno / 0x100;
 }

 sprintf (point, "%d.%d.%d.%d", byte[3], byte[2], byte[1], byte[0]);

 return point;
}
 阅读全文
类别：c语言实践 查看评论]]> 2009-09-02 18:00 http://hi.baidu.com/rwen2012/blog/item/a781d2cac1304d8fc81768c4.html <![CDATA[xor encryption and decryption]]> /* Encryption and decryption are symmetric */
#define stream_decrypt stream_encrypt
static void stream_encrypt(stream_state *self, unsigned char *block,
 int len)
{
 int i, j = self->last_pos;
 for(i=0; i<len; i++, j=(j+1) % self->keylen)
 {
 block[i] ^= self->key[j];
 }
 self->last_pos = j;
}
 阅读全文
类别：c语言实践 查看评论]]> 2009-08-13 12:50 http://hi.baidu.com/rwen2012/blog/item/4c85da16ddf51f58f3de32d3.html <![CDATA[xor encryption]]> /**************************************************************
* Basic xor encryption program by spade89 :) *
* this code is for everyhuman no copyrights *
* feel free to modify or duplicate as much as you want. *
* *
***************************************************************
*/
#include<iostream.h>
#include<conio.h>
#include<stdio.h>
#include<string.h>
int encrypt(char *,char *);
int decrypt(char *,char *);
long filesize(FILE *);
int main(){
 begining:
 unsigned char key[128],filename[64];
 textcolor(LIGHTGREEN);
 //startup:
 cprintf("BASIC XOR ENCRYPTION BY SPADE %c") ;cout<<endl;
 for(int i=0;i<80;i++)cprintf("%c",6);
 cout<<endl;
// synchronize i/o
 cin.tie(&cout);
 cout<<"Enter filename:\n";
 //get filename
 cin>>filename;
 cout<<"Enter key:\n";
 //get encryption decryption key
 cin>>key;

 char op;
 cout<<"Enter option<Encrypt/Decrypt>:\n";
 //see what the user wants us to do
 op=getch();

 switch(op){

 case 'd':
 case 'D':
 decrypt(filename,key);
 break;
 case 'e':
 case 'E':
 encrypt(filename,key);
 default:
 break;
 }
 op=getch();
 //see of tje user still wants to continue, 0x1b is escape key
 if(op==0x1b)goto end;
 goto begining;
 end:
 return 0;
}
/*
function filesize
arguments FILE *stream
a file stream object
returns size of the file as long
*/
long filesize(FILE *stream)
{
 long curpos, length;

 curpos = ftell(stream);
 fseek(stream, 0L, SEEK_END);
 length = ftell(stream);
 fseek(stream, curpos, SEEK_SET);
 return length;

}
/*
function encrypt:
arguments char *fname,char *key
 fname is filename to be encrypted,key is the encryption key
returns -1 if file fails to open, 0 if all goes well


*/
int encrypt(char *fname,char *key){

FILE *out;
 unsigned char *buf;
 //open file and check if it exists
 if((out=fopen(fname,"rb+"))==NULL){textcolor(LIGHTRED);
 cprintf("error opening file!!! :(");cout<<endl; return -1;}
// find the size of our file and convert the result to int
 int size=(int) filesize(out);
 //make sure we are at begining of file
 fseek(out, 0L, SEEK_SET);
 //make a buffer for file data
 buf=new char[size];
 //read all the data of the file into buf
 for(int i=0;i<size;i++){
 buf[i]=fgetc(out);



}
//close our file stream
fclose(out);
 //remove our file from the system
remove(fname);
 //make a new file using our oringinal file name
 if((out=fopen(fname,"ab+"))==NULL){textcolor(LIGHTRED);
 cprintf("error opening file!!! :(");cout<<endl; return -1;}

 for(int i=0,j=0;i<size;i++,j++){
 //when j equals length of the key make j=0
 if(j==strlen(key)-1)j=0;
 //xor each value of buf with each value of key
 buf[i]=buf[i]^key[j];
 //write the encrypted char's
 fputc(buf[i],out);
 }
 textcolor(YELLOW);
 cprintf("File encrypted :)");cout<<endl;
 return 1;
}
/*
function decrypt:
arguments char *fname,char *key
 fname is filename to be decrypted,key is the decryption key
returns -1 if file fails to open, 0 if all goes well
 this function is basically a duplicate of encrypt

*/
int decrypt(char *fname,char *key){
FILE *out;
 unsigned char *buf;
 //open file and check if it exists
 if((out=fopen(fname,"rb+"))==NULL){textcolor(LIGHTRED);cprintf("error opening file!!! :(");cout<<endl; return -1;}
 // find the size of our file and convert the result to int
 int size=(int) filesize(out);
 //make sure we are at begining of file
 fseek(out, 0L, SEEK_SET);
 //make a buffer for file data
 buf=new char[size];
 //read all the data of the file into buf
 for(int i=0;i<size;i++){
 buf[i]=fgetc(out);



}
//close our file stream
fclose(out);
//remove our file from the system
remove(fname);
 //make a new file using our oringinal file name
 if((out=fopen(fname,"ab+"))==NULL){textcolor(LIGHTRED);
 cprintf("error opening file!!! :(");
 cout<<endl;
 return -1;}

 for(int i=0,j=0;i<size;i++,j++){
 //when j equals length of the key make j=0
 if(j==strlen(key)-1)j=0;
 //xor each value of buf with each value of key
 buf[i]=buf[i]^key[j];
 //write the decrypted char's
 fputc(buf[i],out);
 }
 textcolor(YELLOW);
 cprintf("File decrypted :)",0x38); cout<<endl;
return 1;
}

 阅读全文
类别：c语言实践 查看评论]]> 2009-08-13 12:48 http://hi.baidu.com/rwen2012/blog/item/094af41c230c118287d6b6d2.html <![CDATA[测试循环展开的优化（ARM）]]> /* 循环展开可以避免小循环中，由于循环开销所占的比例过大造成的性能下降*/

#include <stdio.h>
#include <time.h>

int checksum(int num)
{
int i;
int sum1=0, sum2=0;

time_t t1, t2;

t1 = time(NULL);
for (i=num; i>0; i--)
sum1 += i;

t2 = time(NULL);
t1 = t2 - t1;
{
for (i=num/4; i>0; i--) {
sum2 += i;
sum2 += i+1;       
sum2 += i+2;
sum2 += i+3;
}

for (i=num&3; i>0; i--)
sum2 += i;
}

t2 = time(NULL) - t2;

printf("sum1 = %d, time1 = %d, sum2 = %d, time2 = %d\n", \
sum1, sum2, t1, t2);

return (sum1 + sum2);
}


int main(void)
{

checksum(100000000);   /* or use 10, 000, 000 */

return 0;

} 阅读全文
类别：c语言实践 查看评论]]> 2009-08-09 10:49 http://hi.baidu.com/rwen2012/blog/item/2dcfb4de84e72f5d95ee3774.html