Linux系统下.ko文件是什么文件？.so文件是什么文件... 5
我有一个文件abc.txt，我想用bunzip2压缩工具进行压缩！... 5
insmod(installmodule)5
记mount NFS遇到的一个问题(-o nolock)6
关于C语言结构体赋值(LINUX内核风格). 6
sprintf格式... 8
sprintf格式... 8
标识符... 9
宽度... 10
精度... 11
指示符... 11
指定参数... 14
注释问题... 15
解决 multiple definitionof15
Fopen函数简介... 16
strtok. 17
编辑本段原型... 17
编辑本段功能... 17
编辑本段说明... 18
编辑本段返回值... 18
编辑本段使用... 18
strncmp用法... 18
fwrite. 18
编辑本段函数名... 18
编辑本段功能... 18
编辑本段用法... 19
编辑本段程序示例... 19
#pragma pack. 21
编辑本段对齐方式... 21
gcc 错误搜集1. 22
如何解决warning:no newline at end of file?. 22
结构体初始化赋值={0}，GCC打开-Wall选项编译会警告，大家探讨一下... 22
windows 如何查看端口占用情况?. 23
memmove、memcpy和memccpy简介... 24
流控制... 25
字符串操作函数... 26
使用pthread_mutex_t锁的例子... 27
linux下select 和 poll的用法... 29
ioctl. 30
套接口操作：... 33
文件操作：... 33
编辑本段定义... 33
编辑本段必要性... 34
编辑本段实现操作... 34
编辑本段其他信息... 35
Mkdir函数... 35
信号量sem_wait sem_post36
Linux下开启/关闭防火墙命令... 39
Linux下配置ip、子网掩码、网关，并把他们保存在指定的文件中，每次启动后不用重新设置。 40
Linux的关机与重启命令... 40
安装RPM包或者安装源码包... 41
Linux rpm 命令参数使用详解［介绍和应用］... 53
GCC警告选项例解... 62
Csocket基本原理... 74
从问题看本质：socket到底是什么？... 78
半双工通信... 83
MFC打开/保存文件对话框:CFileDialog. 83
setsockopt的各种使用... 84
使用CFile类对文件进行读写... 86
MFC同步类... 90
同步对象的适用场合... 90
等待类CSingleLock. 90
TTS. 92
-qws命令... 92
ultraedit 自动缩进修改... 94
typedef 函数指针的用法... 95
【转】（转）MFC中TRACE的用法... 99
linux c语言定时器... 100
Linux下查看文件和文件夹大小的df和du命令... 105
linux 查看文件属性命令... 107
pthread_attr_init线程属性... 107
1．线程属性... 107
2、线程的分离状态... 108
3、线程的继承性... 110
4、线程的调度策略... 110
5、线程的调度参数... 111
vsnprintf112
目 录... 112
1函数简介... 113
2用法实例... 113
SOCKADDR_IN.. 114
目 录... 114
1基本结构... 115
2参数说明... 115
AF_INET和PF_INET的细微不同... 117
popen. 117
pthread_cond_signal和pthread_cond_wait简介... 119
linux 下route命令... 125
UNIX环境高级编程读书笔记（十一）—终端IO （3）... 128
select()函数以及FD_ZERO、FD_SET、FD_CLR、FD_ISSET. 132
ioctl 函数... 136
（C语言）共用体union的用法举例... 140
Linux下getsockopt/setsockopt 函数说明... 143
SVN多版本库配置问题... 146
windows 下本机配置svn以及多版本库的创建... 147
【C/C++】Linux下使用system()函数一定要谨慎... 151
fork()函数 UNIX.. 154
头文件：... 154
函数原型：... 154
函数说明：... 155
为什么fork会返回两次？... 155
Linux下/proc目录简介... 156
shell的条件分支语句：... 162
shell判断文件file存在：... 163
在 /dev 中创建设备... 163
6.8.1. 创建初始设备节点... 163
6.8.2. 挂载ramfs 并填充/dev 目录... 163
linux 目录树... 164
虚拟内存盘... 173
CramFS 文件系统的制作... 174
【摘】编程质量--内存移动函数... 176
vim与复制，删除，粘贴，块操作以及快速替换功能... 180
先谈一下基于块的复制，删除，粘贴操作... 181
使用块选的好处... 181
批量替换列块... 181
与移动相关... 182
与复制相关... 183
复原以及重做操作... 183
替换模式... 183
移动光标... 183
在一行内移动光标... 184
插入文本... 184
删除和移动文本... 185
修改文本... 185
复制文本... 186
如何画程序流程图... 186
10个比viso好的流程图制作软件... 193
Linuxpthread_mutex_init()函数... 194
条件变量、pthread_cond_init195
1.初始化条件变量pthread_cond_init195
2.阻塞在条件变量上pthread_cond_wait196
3.解除在条件变量上的阻塞pthread_cond_signal196
4.阻塞直到指定时间pthread_cond_timedwait197
5.释放阻塞的所有线程pthread_cond_broadcast197
6.释放条件变量pthread_cond_destroy. 197
7.唤醒丢失问题... 198
#ifdef __cplusplus 有什么作用... 198
Linux系统中的poll函数... 207
ubuntu下配置vim.. 210
VIM查找替换归纳总结zz. 211
Linux下转换字符集(UTF8转换)（转）... 212
pthread_attr_setdetachstate. 216
pthread_attr_init线程属性... 217
Linux信号量线程控制... 223
C语言中printf格式化输出函数... 226
例解GNUC之typeof232
预编译语句中#与##的作用... 234
Linux系统下.ko文件是什么文件？.so文件是什么文件？
A：.ko（kernel object），内核模块，可以在linux内核起来之后动态的加载和卸载
.so（shared object）用户层的动态库与（.a对应），使用同一个.so的程序在运行只需要该.so的一份拷贝
我有一个文件abc.txt，我想用bunzip2压缩工具进行压缩！
我有一个文件abc.txt，我想用bunzip2压缩工具进行压缩
#bzip2 abc.txt
注释：压缩后会得到一个压缩文件abc.txt.bz2，同时原abc.txt会被删除。（这点很重要哦，linux考试会问到这一点）
如果有一个文件abc.txt.bz2，想解压缩：
#bunzip2 abc.txt.bz2
注释：解压后会得到abc.txt，而原abc.txt.bz2会被删除。
insmod(install module)
功能说明：载入模块 install loadable kernel module
语法：insmod [-fkmpsvxX][-o<模块名称>][模块文件][符号名称= 符号值]
参数：
-f 不检查目前kernel版本与模块编译时的kernel版本是否一致，强制将模块载入。
-k 将模块设置为自动卸除。
-m 输出模块的载入信息。
-o <模块名称> 指定模块的名称，可使用模块文件的文件名。
-p 测试模块是否能正确地载入kernel。
-s 将所有信息记录在系统记录文件中。
-v 执行时显示详细的信息。
-x 不要汇出模块的外部符号。
-X 汇出模块所有的外部符号，此为预设置。
使用说明：Linux有许多功能是通过模块的方式，在需要时才载入kernel。如此可使kernel较为精简，进而提高效率，以及保有较大的弹性。这类可载入的模块，通常是设备驱动程序。
insmod命令主要用于在Linux 2.4内核之前加载Linux内核模块命令。对于通过此命令加载的Linux内核模块，系统不仅不会自动解决内核模块之间的依赖关系，而且还要求将模块路径写详细。所以在Linux 2.6内核出现时，此命令已渐渐被遗忘。
加载RAID1阵列级别模块，如下所示：
[root@rhel5 boot]# insmod /lib/modules/2.6.
18-8.el5/kernel/drivers/md/raid1.ko
[root@rhel5 boot]# lsmod |grep raid1
raid1 25153 0
从以上显示结果可知，RAID1模块已加载成功。只是在使用insmod命令加载模块时，需要使用绝对路径方能加载，且加载时无法自动解决依赖关系。
记mountNFS遇到的一个问题(-onolock)
前两天测试过程中，测试机始终mount不上我们的nfs。
比如我使用命令：mount vt-nfs:/share /mnt/share
开始是mount命令一直hang在那里（卡住了）；另一种情况是，有类似如下的错误输出：
portmap: server localhost not responding, timed out
RPC: failed to contact portmap (errno -5).
lockd_up: makesock failed, error=-5
经过找了很久才发现了解决方案：
nfs mount 默认选项包括文件锁，依赖于portmap提供的动态端口分配功能；
简单的解决方法：kill 文件锁（lockd）或者mount -o nolock
nolock这个选项是针对NFS所特有的：Disable NFS locking. Do not start lockd. This hasto be used with some old NFS servers that don't support locking.
命令改为：mount -o nolock my-nfs:/share /mnt/share
这样就可以正常工作了。
BTW：
mount iso文件常用命令 mount -o loop disk1.iso /mnt/disk
mount一个本地的目录 mount --bind ./dir1 ./dir2
参考：
http://blog.chinaunix.net/space.php?uid=24499&do=blog&cuid=480784
http://linux.die.net/man/8/mount
http://linux.die.net/man/5/nfs
关于C语言结构体赋值(LINUX内核风格)
http://helloxchen.itpub.net/post/42725/508908
作者helloxchen 16:53 | 静态链接网址 | 最新回复(0) | 引用(1) | Linux_C
1 对成员赋值.
例如结构体struct st1 {
int a;
int b;
int c;
}
1.1 用{}形式.
struct st1 st1 = {1,2,3);
1.2 linux kernel风格.
struct st1 st1 = {
.a = 1;
.b = 2;
};
//注此风格（即在成员变量之前加点“.”）,可以不按成员变量的顺序进行赋值。如可以为
struct st1 st1 = {
.c = 3;
.a = 1;
.b = 2;
};
2 对整体赋值.
struct st1 a,b;
b = a;
3 结构体作为函数返回值对另一个结构体赋值.
struct st1 func1();
struct st1 a= func1();
举例:
[ctest]# vi t.c
#include
struct st1 {
int e1;
int e2;
};
struct st1 func1()
{
struct st1 h = { 77, 88};
return h;
}
int main()
{
struct st1 a= { 33, 44};
struct st1 b = {
.e1 = 55,
};
struct st1 c;
struct st1 d;
c = a;
d = func1();
printf("e1 e2 is %d %dn", a.e1, a.e2);
printf("e1 e2 is %d %dn", b.e1, b.e2);
printf("e1 e2 is %d %dn", c.e1, c.e2);
printf("e1 e2 is %d %dn", d.e1, d.e2);
return 0;
}
"t.c" 29L, 420Cwritten
[ctest]# gcc -o a t.c
[ctest]# ./a
e1 e2 is 33 44
e1 e2 is 55 0
e1 e2 is 33 44
e1 e2 is 77 88
http://blog.163.com/a3563@126/blog/static/54675706200710134410126/
sprintf格式
sprintf格式
Ruby的sprintf格式与C语言的sprintf(3)基本相同。但还是有些差别: 它没有针对C特有类型的修饰符,如short或long等; 它包含2进制数的指示符(%b); 它不支持sprintf的方言式的语法。
下面就对ruby的sprintf格式进行详细的说明。
sprintf格式的规格如下所示。[]中的部分是可选的。
%[指定参数$][标识符][宽度][.精度]指示符
若想输出`%'本身时, 请这样`%%'处理。
下面就分别介绍一下各元素的用法。
标识符
标识符包括`#', `+', ` '(空格), `-'和`0'这5个。
#
使用2进制、8进制、16进制的指示符(`b', `o', `x', `X')时, 会分别添加"0b","0", "0x", "0X"前缀。
p sprintf("%#b", 10) # => "0b1010"
p sprintf("%#o", 10) # => "012"
p sprintf("%#x", 10) # => "0xa"
p sprintf("%#X", 10) # => "0XA"
对于浮点数 (`f', `e', `E', `g', `G'), 则必定在输出中添加"."。
p sprintf("%.0f", 10) # => "10"
p sprintf("%#.0f", 10) # => "10."
p sprintf("%.0e", 10) # => "1e+01"
p sprintf("%#.0e", 10) # => "1.e+01"
`g',`G'除了具有上述特性外, 还会在末尾添加多余的0。
p sprintf("%.05g", 10) # => "10"
p sprintf("%#.05g", 10) # => "10.000"
+
使输出字符串带上符号。如果是正数的话, 就会添加`+'。它只对数值指示符(`d', `i', `b', `o', `x', `X', `u', `f', `e', `E', `g', `G')起作用。另外, 如果是`b', `o', `x', `X', `u'的话, 则会为负数添加`-'。
p sprintf("%d", 1) # => "1"
p sprintf("%+d", 1) # => "+1"
p sprintf("%x", -1) # => "..f" # ".." 表示f无限延续
p sprintf("%+x", -1) # => "-1"
' '(空格)
与`+'相同, 用空格来代替正号`+'。它只对数值指示符(`d', `i', `b', `o', `x',`X', `u', `f', `e', `E', `g', `G')起作用。
p sprintf("%d", 1) # => "1"
p sprintf("%+d", 1) # => "+1"
p sprintf("% d", 1) # => " 1"
p sprintf("%x", -1) # => "..f"
p sprintf("% x", 1) # => " 1"
p sprintf("% x", -1) # => "-1"
-
使输出内容靠左. 若尚未指定宽度的话,则不起作用。
0
当输出内容靠右时, 使用`0'而并非空格来填充多余部分。
它只对数值指示符(`d', `i', `b', `o', `x', `X', `u', `f', `g', `G')起作用(对`e', `E'无效)
p sprintf("%010d", 10)
# => "0000000010"
与`#'一起使用时, 输出情况如下。
p sprintf("%#010x", 10) # => "0x0000000a"
p sprintf("%#010o", 10) # => "0000000012"
p sprintf("%#010b", 10) # => "0b00001010"
它等同于下例。
p sprintf("%#10.8x", 10) # => "0x0000000a"
p sprintf("%#10.9o", 10) # => "0000000012"
p sprintf("%#10.8b", 10) # => "0b00001010"
通常情况下, 会输出如下内容。
p sprintf("%#10x", 10) # => " 0xa"
p sprintf("%#10o", 10) # => " 012"
p sprintf("%#10b", 10) # => " 0b1010"
宽度
以非0数字开头的数串负责指定宽度。宽度是指生成字符串的宽度, 它不受后文中的精度的限制。
确定宽度时, 也会考虑标识符中附加的" ","+","-", "0b", "0", "0x","0X"的长度。
p sprintf("%#05x", 10) # => "0x00a"
宽度是指"必要的最小宽度". 若结果字符串的宽度超过指定宽度时, 指定宽度就会失效。
若将宽度指定为`*'时, 将从参数中取得宽度值。
p sprintf("%10s", "foo") # => " foo"
p sprintf("%*s", 10, "foo") # => " foo"
精度
紧跟在"."后面的数串表示精度(若只有"."的话，则为".0")。若遇到整数的指示符(`d', `i', `b', `o', `x',`X', `u')的话，精度表示数值部分的长度。
p sprintf("%10.5d", 1) # => " 00001"
p sprintf("%#10.5x", 1) # => " 0x00001"
p sprintf("%+10.5x", 1) # => " +00001"
若遇到浮点数的指示符(`f')的话，它表示小数部分的位数。
p sprintf("%10.5f", 1) # => " 1.00000"
p sprintf("%10.5f", 10) # => " 10.00000"
若遇到浮点数的指示符(`e', `E', `g', `G')的话，它表示有效位数。
p sprintf("%10.5e", 1) # => "1.00000e+00"
p sprintf("%10.5e", 10) # => "1.00000e+01"
p sprintf("%10.5g", 10) # => " 10"
p sprintf("%#10.5G", 10) # => " 10.000"
如果是字符串指示符(`s', `p')的话，将会按照精度的规定来检查参数中的字符串长度，并切除多余部分。若将宽度和精度设为同值的话，则只输出参数字符串中的符合精度规定的部分。
p sprintf("%10.2s", "foo") # => " fo"
p sprintf("%5.5s", "foo") # => # => " foo"
p sprintf("%5.5s", "foobar") # => # => "fooba"
若将精度设为`*'的话，将从参数中提取精度的值。
p sprintf("%.5s", "foobar") # => "fooba"
p sprintf("%.*s", 5, "foobar") # => "fooba"
指示符
指示符指出参数的类型，且是必选的。大体说来它包括：
· 表示字符串的指示符: `c', `s', `p'
· 表示整数的指示符: `d', `i', `u', `b', `o', `x', `X',
· 表示浮点数的指示符: `f', `g', `e', `E', `G'
这几类。
c
将参数的数值(0×255)看作是字符代码，并输出对应的字符。若参数并非数值、String、 nil,true或false的话，将尝试用to_int方法进行变换。
此时，只有标识符`-'和"宽度"的设定是有效的。
s
输出字符串。
若参数并非String对象的话，将使用to_s方法对其进行变换。
p
ruby 1.8 特性: 输出Object#inspect的结果。
p sprintf("%s", [1, 2, 3]) # => "123"
p sprintf("%p", [1, 2, 3]) # => "[1, 2, 3]"
d
i
以10进制整数的形式输出参数中的数值。
若参数并非整数，则使用与Integer函数相同的规则将其变为整数。
u
将参数的数值看作是无符号整数，并以10进制整数的形式输出它。
p sprintf("%u", -1) # => "..4294967295"
上面的代码会输出 p ".." + 0xffff_ffff.to_s。
ruby 1.7 特性: 在version 1.7中，不会附加".."。若是'%u'的话，则将参数看作是定长整数。此时，对于负整数n来说
printf("%u", n)
与
printf("%d", n & ~(-1 << n.size*8))
是一个意思。
b
o
x
X
分别以2进制、8进制、16进制、16进制(大写字母)字符串的形式输出整数。
若使用了`#' 标识符的话，则分别在前面添加"0b", "0", "0x", "0X"。
若没有使用`+', ` ' 标识符时，将在负数的前面(若有`#' 标识符，则在"0x"等的后面)添加".."。这表示最高位字符无限延伸，它采用了2的补数形式来表现负数。
p sprintf("%#b", 10) # => "0b1010"
p sprintf("%#o", 10) # => "012"
p sprintf("%#x", 10) # => "0xa"
# 对负数添加".."
p sprintf("%#b", -1) # => "0b..1"
p sprintf("%#o", -1) # => "0..7"
p sprintf("%#x", -1) # => "0x..f"
p sprintf("%10x", -1) # => " ..f"
p sprintf("%-10x", -1) # => "..f "
# 若指定了"精度"的话，则不会添加".."
p sprintf("%.10x", -1) # => "ffffffffff"
f
e
E
g
G
`f' 以小数点形式(xxx.xxx)输出数值。
`e' 以指数形式(x.xxxe+xx)输出数值。
`g' 的情况比较特殊。当指数小于-4或者超出精度范围时，它采用`e'方式进行输出。除此之外，它采用`f'方式进行输出。另外，它会删除小数部分尾部的0。
大写字母指示符(`E', `G')会将输出中的字母变为大写形式。
p sprintf("%f", 1.0) # => "1.000000"
p sprintf("%e", 1.0) # => "1.000000e+00"
p sprintf("%g", 1.0) # => "1"
p sprintf("%f", 10.1) # => "10.100000"
p sprintf("%e", 10.1) # => "1.010000e+01"
p sprintf("%g", 10.1) # => "10.1"
p sprintf("%g", 10 ** 6) # => "1e+06"
p sprintf("%g", 10 ** -5) # => "1e-05"
精度的缺省值为6。
若遇到无限大值或NaN(Not a Number)时，输出情况如下。
p sprintf("%f", 1.0/0) # => "inf"
p sprintf("%f", -1.0/0) # => "-inf"
p sprintf("%f", 0.0/0) # => "nan"
p sprintf("%E", 1.0/0) # => "INF"
p sprintf("%E", -1.0/0) # => "-INF"
p sprintf("%E", 0.0/0) # => "NAN"
指定参数
这部分的利用频率最低，所以放在最后。
nth$
表示将使用第nth个参数进行格式化操作。
p sprintf("%1$d, %1$x, %1$o", 10)
=> "10, a, 12"
p sprintf("%3$d, %2$x, %1$o", 1, 2, 3)
=> "3, 2, 1"
若您不想改变参数的顺序而只想改变格式的话，也可以使用它。
case ENV['LC_TIME']
when /^ja_JP/
fmt = "%1$d年%2$d月%3$d日"
else
fmt = "%2$02d/%03$2d/%1$02d"
end
p sprintf(fmt, 1, 4, 22)
=> "04/22/01"
您也可以先插入"*"，然后借用参数来设定"宽度"和"精度"的值。
p sprintf("%5.2f", 1); # => " 1.00"
p sprintf("%*.*f", 5, 2, 1); # => " 1.00"
p sprintf("%1$*2$.*3$f", 1, 5, 2); # => " 1.00
注释问题
2009-06-24 10:27 157人阅读 评论(0) 收藏 举报
====================================================================
// Some comment
// /
// Some more comment
int main(int, char **) { return 0; }
====================================================================
compiling with g++ will yield the following warning:
x.cc:2:2:warning: multi-line comment
What isthe point of this warning? Shouldn't the preprocessor
> > > just ignore everything between the // and the end-of-line?
> >
> > No, backslash-newline conversion happens before comments
> > are discarded. You really do have a multi-line comment;
> > one that would be dangerous if your next line weren't a
> > comment as well.
在//注释行的最后不能加 \ ,加 \ 表示下一行看成是注释，如果下一行不是注释的话会出错
解决 multipledefinition of
总结了解决multipledefinition of的方法：
问题原因：
当多个文件包含同一个头文件时，并且你的.H里面没有加上条件编译
#ifndef TEST_H
#define TEST_H
#endif
就会独立的解释,然后生成每个文件生成独立的标示符。在编译器连接时，就会将工程中所有的符号整合在一起，由于，文件中有重名变量，于是就出现了重复定义的错误。
方法1：
给每一个头文件加上条件编译，避免该文件被多次引用时被多次解释，这是个应该是习惯。这个方法会解决大部分低级问题。
方法2：
当方法1无效时，可以把所有的全局变量放入一个头文件 global.h (名字随意起，但要加条件编译)中，每一个变量前面加extern，声明一下这些变量将在其它文件中定义。 然后建立一个和头文件名字对应的.cor .cpp文件 如global.c。在里面声明所有的全局变量。例如：void(*Handl_Display)();
然后，让涉及到全局变量的文件include ”global.h“。这样编译时，会先对global.c编译生成一个global.o ，然后再和其它文件的.o链接生成可执行文件。
方法3：
懒人方法，在所有的全局变量前加上static ，声明成静止变量。也能解决问题。
所有的方法都是网来的，O(∩_∩)O哈哈~
谢谢所有的提供方法的哥们~
函数fopen
Fopen函数简介
函数功能：打开一个文件
函数原型：FILE* fopen(const char * path,const char * mode);
相关函数：open，fclose，fopen_s[1]，_wfopen
所需库：<stdio.h>
返回值：文件顺利打开后，指向该流的文件指针就会被返回。如果文件打开失败则返回NULL，并把错误代码存在errno 中。
一般而言，打开文件后会作一些文件读取或写入的动作，若打开文件失败，接下来的读写动作也无法顺利进行，所以一般在fopen()后作错误判断及处理。
参数说明：
参数path字符串包含欲打开的文件路径及文件名，参数mode字符串则代表着流形态。
mode有下列几种形态字符串:
r 以只读方式打开文件，该文件必须存在。
r+ 以可读写方式打开文件，该文件必须存在。
rb+ 读写打开一个二进制文件，允许读写数据。
rw+ 读写打开一个文本文件，允许读和写。
w 打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。
w+ 打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。
a 以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。（EOF符保留）
a+ 以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。 （原来的EOF符不保留）
wb 只写打开或新建一个二进制文件；只允许写数据。
wb+ 读写打开或建立一个二进制文件，允许读和写。
ab+ 读写打开一个二进制文件，允许读或在文件末追加数据。
at+ 打开一个叫string的文件，a表示append,就是说写入处理的时候是接着原来文件已有内容写入，不是从头写入覆盖掉，t表示打开文件的类型是文本文件，+号表示对文件既可以读也可以写。
上述的形态字符串都可以再加一个b字符，如rb、w+b或ab+等组合，加入b 字符用来告诉函数库以二进制模式打开文件。如果不加b，表示默认加了t，即rt,wt,其中t表示以文本模式打开文件。由fopen()所建立的新文件会具有S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH(0666)权限，此文件权限也会参考umask值。
有些C编译系统可能不完全提供所有这些功能，有的C版本不用"r+","w+","a+",而用"rw","wr","ar"等，读者注意所用系统的规定。
二进制和文本模式的区别
1.在windows系统中，文本模式下，文件以""代表换行。若以文本模式打开文件，并用fputs等函数写入换行符"\n"时，函数会自动在"\n"前面加上"\r"。即实际写入文件的是""。
2.在类Unix/Linux系统中文本模式下，文件以"\n"代表换行。所以Linux系统中在文本模式和二进制模式下并无区别。
strtok
原型
功能
说明
返回值
使用
其他相关信息
展开
原型
功能
说明
返回值
使用
其他相关信息
展开
编辑本段原型
char *strtok(char s[], const char *delim);
编辑本段功能
分解字符串为一组字符串。s为要分解的字符串，delim为分隔符字符串。
例如：strtok("abc,def,ghi",",")，最后可以分割成为abc defghi.尤其在点分十进制的IP中提取应用较多。
编辑本段说明
strtok()用来将字符串分割成一个个片段。参数s指向欲分割的字符串，参数delim则为分割字符串中包含的所有字符。当strtok()在参数s的字符串中发现参数delim中包涵的分割字符时,则会将该字符改为\0 字符。在第一次调用时，strtok()必需给予参数s字符串，往后的调用则将参数s设置成NULL。每次调用成功则返回指向被分割出片段的指针。
编辑本段返回值
从s开头开始的一个个被分割的串。当没有被分割的串时则返回NULL。
所有delim中包含的字符都会被滤掉，并将被滤掉的地方设为一处分割的节点。
编辑本段使用
strtok函数会破坏被分解字符串的完整，调用前和调用后的s已经不一样了。如果
要保持原字符串的完整，可以使用strchr和sscanf的组合等。
strncmp用法
函数名:strncmp
功 能: 串比较
用 法: intstrncmp(char *str1, char *str2, int maxlen);
说明:此函数功能即比较字符串str1和str2的前maxlen个字符。如果前maxlen字节完全相等，返回值就=0；在前maxlen字节比较过程中，如果出现str1[n]与str2[n]不等，则返回（str1[n]-str2[n]）。
fwrite
函数名
功能
用法
程序示例
编辑本段函数名
fwrite
编辑本段功能
C语言函数，向文件写入一个数据块
编辑本段用法
size_t fwrite(const void* buffer, size_t size, size_t count, FILE*stream);
注意：这个函数以二进制形式对文件进行操作，不局限于文本文件
返回值：返回实际写入的数据块数目
（1）buffer：是一个指针，对fwrite来说，是要输出数据的地址；
（2）size：要写入内容的单字节数；
（3）count:要进行写入size字节的数据项的个数；
（4）stream:目标文件指针；
（5）返回实际写入的数据项个数count。
说明：写入到文件的哪里？ 这个与文件的打开模式有关，如果是w+，则是从filepointer指向的地址开始写，替换掉之后的内容，文件的长度可以不变，stream的位置移动count个数；如果是a+，则从文件的末尾开始添加，文件长度加大。
fseek对此函数有作用，但是fwrite[1]函数写到用户空间缓冲区，并未同步到文件中，所以修改后要将内存与文件同步可以用fflush（FILE *fp）函数同步。
编辑本段程序示例
示例一：
#include
struct mystruct
{
int i;
char ch;
};
int main(void)
{
FILE *stream;
struct mystruct s;
if ((stream = fopen("TEST.$$$", "wb")) ==NULL) /* open file TEST.$$$ */
{
fprintf(stderr, "Cannot open output file.\n");
return 1;
}
s.i = 0;
s.ch = 'A';
fwrite(&s, sizeof(s), 1, stream); /* 写的struct文件*/
fclose(stream); /*关闭文件*/
return 0;
}
示例二：
#include
#define SIZE 1
typedef struct
{
char name[10];
int num;
int age;
char addr[15];
}student;
student stu[SIZE];
void save()
{
FILE *fp;
int i;
if((fp=fopen("dat.txt","w"))==NULL)
{
printf("无法打开此文件!\n");
return;
}
for(i=0;i
if(fwrite(&stu[i], sizeof(student), 1, fp) != 1)
printf("文件写入错误。!\n");
fclose(fp);
}
void main()
{
int i;
for(i=0;i
scanf("%s%d%d%s",&stu[i].name,&stu[i].num,&stu[i].age,&stu[i].addr);
save();
}
示例三：
/* fwrite example : write buffer */
#include
int main ()
{
FILE * pFile;
char buffer[] = { 'x' , 'y' , 'z' };
pFile = fopen ( "myfile.bin" , "wb" );
fwrite (buffer , sizeof(buffer), 1 , pFile );
fclose (pFile);
return 0;
}
//称为myfile.bin的一个文件被创建并存储到它的缓冲区的内容。为了简单起见，该缓冲区包含Char元素，但它可以包含任何其他类型。.
sizeof(buffer)字节数组的长度(在这种情况下，它是三个，因为数组有三个元素，每次一个字节)。
示例四：
//程序示例fwrite fread fseek
FILE *fp;
char msg[] = "file content";
char buf[20];
fp = fopen("d:\\a\\a.txt","w+");
if (NULL == fp)
{
printf("The file doesn't exist!\n");
return -1;
}
fwrite(msg,strlen(msg),1,fp);//把字符串内容写入到文件
fseek(fp,0,SEEK_SET);//定位文件指针到文件开始位置
fread(buf,strlen(msg),1,fp);//把文件内容读入到缓存
buf[strlen(msg)] = '\0';//删除缓存内多余的空间
printf("buf = %s\n",buf);
printf("strlen(buf) = %d\n",strlen(buf));
#pragma pack
对齐方式
对齐用法详解
编辑本段对齐方式
程序编译器对结构的存储的特殊处理确实提高CPU存储变量的速度，但是有时候也带来了一些麻烦，我们也屏蔽掉变量默认的对齐方式，自己可以设定变量的对齐方式。
编译器中提供了#pragma pack(n)来设定变量以n字节对齐方式。n字节对齐就是说变量存放的起始地址的偏移量有两种情况：第一、如果n大于等于该变量所占用的字节数，那么偏移量必须满足默认的对齐方式，第二、如果n小于该变量的类型所占用的字节数，那么偏移量为n的倍数，不用满足默认的对齐方式。结构的总大小也有个约束条件，分下面两种情况：如果n大于所有成员变量类型所占用的字节数，那么结构的总大小必须为占用空间最大的变量占用的空间数的倍数；否则必须为n的倍数。
下面举例说明其用法。
#pragma pack(push) //保存对齐状态
#pragma pack(4)//设定为4字节对齐
struct test
{
char m1;
double m4;
int m3;
};
#pragma pack(pop)//恢复对齐状态
以上结构体的大小为16，下面分析其存储情况，首先为m1分配空间，其偏移量为0，满足我们自己设定的对齐方式（4字节对齐），m1大小为1个字节。接着开始为m4分配空间，这时其偏移量为4，需要补足3个字节，这样使偏移量满足为n=4的倍数（因为sizeof(double)大于4）,m4占用8个字节。接着为m3分配空间，这时其偏移量为12，满足为4的倍数，m3占用4个字节。这时已经为所有成员变量分配了空间，共分配了16个字节，满足为n的倍数。如果把上面的#pragma pack(4)改为#pragma pack(8)，那么我们可以得到结构的大小为24。
gcc 错误搜集1
以下错误，都是在别的编译编译正确，而在GCC的错误。dev c++
错误提示：48 D:\××.c [Warning] malformed'#pragma pack(push[, id], )' - ignored
#pragma pack(push)
#pragma pack(1)
struct tagPhysStruct
{
*****
#pragma pack(pop)
修改开头两行合并为一行。#pragmapack(push，1)
如何解决warning: no newline at end of file?
今天写了一段代码, 是在Windows下编辑的, 保存后放在linux系统下编译.
gcc和cc都产生以下的警告:
a.h:1:2: warning: no newline at end of file
后来发现解决这个问题产生的原因是源文件的最后一行没有回车符造成的; 解决的办法很简单, 在最后一行敲一个回车, 然后保存, 重新编译.
结构体初始化赋值={0}，GCC打开-Wall选项编译会警告，大家探讨一下
比如结构体的第一个成员变量是数组或者嵌套的小结构体，linux下编译时gcc打开-Wall选项时会报告警类似如下：
警告：‘char [100]’的初始值设定周围缺少花括号
警告：‘struct_a_s’的初始值设定周围缺少花括号
因为本来数组或者结构体就得使用{}赋值，但是被嵌套了以后应该使用={{第一个成员变量的指定初始化值}，第二个成员变量的指定初始化值}来初始化。故而报警了。
基于此，我分析有两种情况：
一、指定初始化只是第一个成员变量的第一个值，比如数组的第一个值，或者嵌套的小结构体的第一个成员变量的值被指定初始化为0，其他未指定的值根据gcc的编译器来初始化，但是在gcc下gdb走读代码发现并不符合“静态区初始化为0，动态区随机”规则，而是未指定的都初始化为0；
二、指定初始化只是第一个成员变量的值。
windows 如何查看端口占用情况?
开始--运行--cmd进入命令提示符 输入netstat-ano 即可看到所有连接的PID 之后在任务管理器中找到这个PID所对应的程序如果任务管理器中没有PID这一项,可以在任务管理器中选"查看"-"选择列"
经常，我们在启动应用的时候发现系统需要的端口被别的程序占用，如何知道谁占有了我们需要的端口，很多人都比较头疼，下面就介绍一种非常简单的方法，希望对大家有用
假如我们需要确定谁占用了我们的9050端口
1、Windows平台
在windows命令行窗口下执行：
1.查看所有的端口占用情况
C:\>netstat -ano
协议 本地地址 外部地址 状态 PID
TCP 127.0.0.1:1434 0.0.0.0:0 LISTENING 3236
TCP 127.0.0.1:5679 0.0.0.0:0 LISTENING 4168
TCP 127.0.0.1:7438 0.0.0.0:0 LISTENING 4168
TCP 127.0.0.1:8015 0.0.0.0:0 LISTENING 1456
TCP 192.168.3.230:139 0.0.0.0:0 LISTENING 4
TCP 192.168.3.230:1957 220.181.31.225:443 ESTABLISHED 3068
TCP 192.168.3.230:2020 183.62.96.189:1522 ESTABLISHED 1456
TCP 192.168.3.230:2927 117.79.91.18:80 ESTABLISHED 4732
TCP 192.168.3.230:2929 117.79.91.18:80 ESTABLISHED 4732
TCP 192.168.3.230:2930 117.79.91.18:80 ESTABLISHED 4732
TCP 192.168.3.230:2931 117.79.91.18:80 ESTABLISHED 4732
2.查看指定端口的占用情况
C:\>netstat -aon|findstr "9050"
协议 本地地址 外部地址 状态 PID
TCP 127.0.0.1:9050 0.0.0.0:0 LISTENING 2016
P: 看到了吗，端口被进程号为2016的进程占用，继续执行下面命令： （也可以去任务管理器中查看pid对应的进程）
3.查看PID对应的进程
C:\>tasklist|findstr "2016"
映像名称 PID 会话名 会话# 内存使用
========================= ======== ================
tor.exe 2016Console 0 16,064 K
P:很清楚吧，tor占用了你的端口。
4.结束该进程
C:\>taskkill /f /t /im tor.exe
memmove、memcpy和memccpy简介
memmove、memcpy和memccpy三个函数都是内存的拷贝，从一个缓冲区拷贝到另一个缓冲区。
memmove(void *dest,void*src,int count)
memcpy(void *dest,void *src,int count)
memccpy(void*dest,void*src,int ch,int count)
表头文件: #include
定义函数: void *memcpy(void *dest, const void *src, size_t n)
函数说明: memcpy()用来拷贝src所指的内存内容前n个字节到dest所指的内存地址上。与strcpy()不同的是,memcpy()会完整的复制n个字节,不会因为遇到字符串结束'\0'而结束
返回值: 返回指向dest的指针
表头文件: #include
定义函数: void *memccpy(void *dest, const void *src, int c, size_tn);
函数说明: memccpy()用来拷贝src所指的内存内容前n个字节到dest所指的地址上。与memcpy()不同的是,memccpy()如果在src中遇到某个特定值(int c)立即停止复制。
返回值: 返回指向dest中值为c的下一个字节指针。返回值为0表示在src所指内存前n个字节中没有值为c的字节。
表头文件: #include
定义函数: void *memmove(void *dest, const void *src, size_t n);
函数说明:memmove()是从一个缓冲区移动到另一个缓冲区中。
返回值: 返回指向dest指针。
当dest <= src-count 或dest>= src+count时，以上三个函数均不会产生覆盖问题，即源数据不会被更改。
若不在以上范围内，则源数据会被更改。
如:
char a[]={'a','b'};
char b[]={'c','d','e','f','g','h'};
memmove(a,b,sizeof(b));
或是直接char *p=b+2;memmove(p,b,sizeof(b));
输出数据会发现b中数据输出已被更改。
发现即使a数组指向的空间不够存储数据，也能够移动成功。
原因|dest - src |
如果在使用这些函数时，分配给足够的空间，然后再使用就不会出现覆盖问题。也就是说如果外部分配给的空间不足以存储要拷贝的数据时，就有可能出现源数据被覆盖更改的问题。
#include
#include
#include
void main(void)
{
int i=0;
chara[9]={'a','b','c','d','e','f','g','h','\0'};
char p[2]={'q','w'};//或char *p=a+2;
memmove(p,a,sizeof(a));
puts(a);
printf("_____________________________________________\n");
puts(p);
printf("_____________________________________________\n");
for(i =0;i<10;i++)
printf("%c %d\n",*(a+i),a+i);
printf("_____________________________________________\n");
for(i =0;i<8;i++)
printf("%c %d\n",*(p+i),p+i);
}
观察输出结果。
把memmove(p,a,sizeof(a));改为memcpy(p,a,sizeof(a));或memccpy(p,a,'e',sizeof(a));再观察输出结果。
可以看出在目的存储空间不足时，便会出现源数据被覆盖改变的问题。
如果目的存储空间分配足够的空间，则便不会出现覆盖问题。
流控制
串口的流控是指数据流。数据在两个串口之间传输时，常常会出现丢失数据的现象，或者两台计算机的处理速度不同，如台式机与单片机之间的通信，接收端数据缓冲区已满，则此时继续发送来的数据就会丢失。当接收端数据处理不过来时，就发出"不再接收"的信号，发送端就停止发送，直到收到“可以继续发送”的信号再发送数据。PC机中常用的两种流控制分别是硬件流控制（包括RTS/CTS、DTR/DSR等）和软件流控制XON/XOFF。
基于OSI七层模型的流控制的类型包括：Buffering（缓存）、Window（基于窗口）、Congestionavoidance（冲突避免）。
2.硬件流控制
硬件流控制常用的有RTS/CTS流控制和DTR/DSR（数据终端就绪/数据设置就绪）流控制。
硬件流控制必须将相应的电缆线连上，用RTS/CTS（请求发送/清除发送）流控制时，应将通讯两端的RTS、CTS线对应相连，数据终端设备（如计算机）使用RTS来起始调制解调器或其它数据通讯设备的数据流，而数据通讯设备（如调制解调器）则用CTS来起动和暂停来自计算机的数据流。这种硬件握手方式的过程为：我们在编程时根据接收端缓冲区大小设置一个高位标志（可为缓冲区大小的75%）和一个低位标志（可为缓冲区大小的25%），当缓冲区内数据量达到高位时，我们在接收端将CTS线置低电平（送逻辑0），当发送端的程序检测到CTS为低后，就停止发送数据，直到接收端缓冲区的数据量低于低位而将CTS置高电平。RTS则用来标明接收设备有没有准备好接收数据。
常用的流控制还有还有DTR/DSR（数据终端就绪/数据设置就绪）。我们在此不再详述。
3.软件流控制
由于电缆线的限制，我们在普通的控制通讯中一般不用硬件流控制，而用软件流控制。一般通过XON/XOFF来实现软件流控制。常用方法是：当接收端的输入缓冲区内数据量超过设定的高位时，就向数据发送端发出XOFF字符（十进制的19或Control-S，设备编程说明书应该有详细阐述），发送端收到XOFF字符后就立即停止发送数据；当接收端的输入缓冲区内数据量低于设定的低位时，就向数据发送端发出XON字符（十进制的17或Control-Q），发送端收到XON字符后就立即开始发送数据。一般可以从设备配套源程序中找到发送的是什么字符。
应该注意，若传输的是二进制数据，标志字符也有可能在数据流中出现而引起误操作，这是软件流控制的缺陷，而硬件流控制不会有这个问题。
字符串操作函数
| strtok() |
字符串分割函数 |
| strstr() |
字符串查找函数 |
| strspn() |
字符查找函数 |
| strrchr() |
定位字符串中最后出现的指定字符 |
| strpbrk() |
定位字符串中第一个出现的指定字符 |
| strncpy() |
复制字符串 |
| strncat() |
字符串连接函数 |
| strncasecmp() |
字符串比较函数(忽略大小写) |
| strlen() |
字符串长度计算函数 |
| strdup() |
复制字符串 |
| strcspn() |
查找字符串 |
| strcpy() |
复制字符串 |
| strcoll() |
字符串比较函数(按字符排列次序) |
| strcmp() |
字符串比较函数(比较字符串) |
| strchr() |
字符串查找函数(返回首次出现字符的位置) |
| strcat() |
连接字符串 |
| strcasecmp() |
字符串比较函数(忽略大小写比较字符串) |
| rindex() |
字符串查找函数(返回最后一次出现的位置) |
| index() |
字符串查找函数(返回首次出现的位置) |
| toupper() |
字符串转换函数(小写转大写) |
| tolower() |
字符串转换函数(大写转小写) |
| toascii() |
将整数转换成合法的ASCII码字符 |
| strtoul() |
将字符串转换成无符号长整型数 |
| strtol() |
将字符串转换成长整型数 |
| strtod() |
将字符串转换成浮点数 |
| gcvt() |
将浮点型数转换为字符串(四舍五入) |
| atol() |
将字符串转换成长整型数 |
| atoi() |
将字符串转换成整型数 |
| atof() |
将字符串转换成浮点型数 |
| |
使用pthread_mutex_t锁的例子
linux下为了多线程同步，通常用到锁的概念。
posix下抽象了一个锁类型的结构：ptread_mutex_t。通过对该结构的操作，来判断资源是否可以访问。顾名思义，加锁(lock)后，别人就无法打开，只有当锁没有关闭(unlock)的时候才能访问资源。
它主要用如下5个函数进行操作。
1：pthread_mutex_init(pthread_mutex_t * mutex,constpthread_mutexattr_t *attr);
初始化锁变量mutex。attr为锁属性，NULL值为默认属性。
2：pthread_mutex_lock(pthread_mutex_t *mutex);加锁
3：pthread_mutex_tylock(pthread_mutex_t *mutex);加锁，但是与2不一样的是当锁已经在使用的时候，返回为EBUSY，而不是挂起等待。
4：pthread_mutex_unlock(pthread_mutex_t *mutex);释放锁
5：pthread_mutex_destroy(pthread_mutex_t *mutex);使用完后释放
下面经典例子为创建两个线程对sum从1加到100。前面第一个线程从1－49，后面从50－100。主线程读取最后的加值。为了防止资源竞争，用了pthread_mutex_t 锁操作。
#include
#include
#include
#include
typedef struct ct_sum
{ int sum;
pthread_mutex_t lock;
}ct_sum;
void * add1(void * cnt)
{
pthread_mutex_lock(&(((ct_sum*)cnt)->lock));
int i;
for( i=0;i<50;i++)
{(*(ct_sum*)cnt).sum+=i;
}
pthread_mutex_unlock(&(((ct_sum*)cnt)->lock));
pthread_exit(NULL);
return 0;
}
void * add2(void *cnt)
{
int i;
cnt= (ct_sum*)cnt;
pthread_mutex_lock(&(((ct_sum*)cnt)->lock));
for( i=50;i<101;i++)
{ (*(ct_sum*)cnt).sum+=i;
}
pthread_mutex_unlock(&(((ct_sum*)cnt)->lock));
pthread_exit(NULL);
return 0;
}
int main(void)
{ int i;
pthread_t ptid1,ptid2;
int sum=0;
ct_sum cnt;
pthread_mutex_init(&(cnt.lock),NULL);
cnt.sum=0;
pthread_create(&ptid1,NULL,add1,&cnt);
pthread_create(&ptid2,NULL,add2,&cnt);
pthread_mutex_lock(&(cnt.lock));
printf("sum %d\n",cnt.sum);
pthread_mutex_unlock(&(cnt.lock));
pthread_join(ptid1,NULL);
pthread_join(ptid2,NULL);
pthread_mutex_destroy(&(cnt.lock));
return 0;
}
linux下select 和 poll的用法
select()函数的作用
系统调用select和poll的后端实现，用这两个系统调用来查询设备是否可读写，或是否处于某种状态。如果poll为空，则驱动设备会被认为即可读又可写，返回值是一个状态掩码 如何使用select()函数?
select()函数的接口主要是建立在一种叫'fd_set'类型的基础上。它('fd_set') 是一组文件描述符(fd)的集合。由于fd_set类型的长度在不同平台上不同，因此应该用一组标准的宏定义来处理此类变量：
fd_set set;
FD_ZERO(&set); /* 将set清零 */ FD_SET(fd, &set); /* 将fd加入set */ FD_CLR(fd, &set); /* 将fd从set中清除 */ FD_ISSET(fd, &set); /* 如果fd在set中则真 */
在过去，一个fd_set通常只能包含少于等于32个文件描述符，因为fd_set其实只用了一个int的比特矢量来实现，在大多数情况下，检查 fd_set能包括任意值的文件描述符是系统的责任，但确定你的fd_set到底能放多少有时你应该检查/修改宏FD_SETSIZE的值。*这个值是系统相关的*，同时检查你的系统中的select() 的man手册。有一些系统对多于1024个文件描述符的支持有问题。[译者注： Linux就是这样的系统！你会发现sizeof(fd_set)的结果是128(*8 = FD_SETSIZE=1024) 尽管很少你会遇到这种情况。]
select的基本接口十分简单：
int select(int nfds, fd_set *readset, fd_set *writeset, fd_set *exceptset, struct timeval *timeout); 其中： nfds
需要检查的文件描述符个数，数值应该比是三组fd_set中最大数 更大，而不是实际文件描述符的总数。 readset
用来检查可读性的一组文件描述符。 writeset
用来检查可写性的一组文件描述符。 exceptset
用来检查意外状态的文件描述符。(注：错误并不是意外状态) timeout
NULL指针代表无限等待，否则是指向timeval结构的指针，代表最 长等待时间。(如果其中tv_sec和tv_usec都等于0, 则文件描述符 的状态不被影响，但函数并不挂起)
Linux快速入门Linux快速入门（...Linux快速入门（...
函数将返回响应操作的对应操作文件描述符的总数，且三组数据均在恰当位置被修改，只有响应操作的那一些没有修改。接着应该用FD_ISSET宏来查找返回的文件描述符组。
这里是一个简单的测试单个文件描述符可读性的例子：
int isready(int fd) { int rc; fd_set fds; struct timeval tv;
FD_ZERO(&fds); FD_SET(fd,&fds);
// tv.tv_sec = tv.tv_usec = 0;
//rc = select(fd+1, &fds, NULL, NULL, &tv); rc = select(fd+1, &fds, NULL, NULL, NULL); if (rc < 0) return -1;
return FD_ISSET(fd,&fds) ? 1 : 0; }
当然如果我们把NULL指针作为fd_set传入的话，这就表示我们对这种操作的发生不感兴趣，但select() 还是会等待直到其发生或者超过等待时间。
[译者注：在Linux中，timeout指的是程序在非sleep状态中度过的时间，而不是实际上过去的时间，这就会引起和非Linux平台移植上的时间不等问题。移植问题还包括在System V风格中select()在函数退出前会把timeout设为未定义的 NULL状态，而在BSD中则不是这样， Linux在这点上遵从System V，因此在重复利用timeout指针问题上也应该注意。] Linux下select调用的过程:
1.用户层应用程序调用select(),底层调用poll()) 2.核心层调用sys_select() ------> do_select()
最终调用文件描述符fd对应的struct file类型变量的struct file_operations *f_op的poll函数。 poll指向的函数返回当前可否读写的信息。 1)如果当前可读写，返回读写信息。
2)如果当前不可读写，则阻塞进程，并等待驱动程序唤醒，重新调用poll函数，或超时返回。 3.驱动需要实现poll函数。
当驱动发现有数据可以读写时，通知核心层，核心层重新调用poll指向的函数查询信息。 poll_wait(filp,&wait_q,wait) // 此处将当前进程加入到等待队列中，但并不阻塞 在中断中使用wake_up_interruptible(&wait_q)唤醒等待队列
ioctl
函数名:ioctl
头文件：#include
功 能: 控制I/O设备 ，提供了一种获得设备信息和向设备发送控制参数的手段。用于向设备发控制和配置命令 ，有些命令需要控制参数，这些数据是不能用read/ write 读写的,称为Out-of-band数据。也就是说,read /write 读写的数据是in-band数据,是I/O操作的主体，而ioctl 命令传送的是控制信息,其中的数据是辅助的数据。
用 法: intioctl(int handle, int cmd,[int *argdx, int argcx]);
返回值：成功为0，出错为-1
usr/include/asm-generic/ioctl.h中定义的宏的注释：
#define _IOC_NRBITS 8 //序数（number）字段的字位宽度，8bits
#define _IOC_TYPEBITS 8 //幻数（type）字段的字位宽度，8bits
#define _IOC_SIZEBITS 14 //大小（size）字段的字位宽度，14bits
#define _IOC_DIRBITS 2 //方向（direction）字段的字位宽度，2bits
#define _IOC_NRMASK ((1 << _IOC_NRBITS)-1) //序数字段的掩码，0x000000FF
#define _IOC_TYPEMASK ((1 << _IOC_TYPEBITS)-1) //幻数字段的掩码，0x000000FF
#define _IOC_SIZEMASK ((1 << _IOC_SIZEBITS)-1) //大小字段的掩码，0x00003FFF
#define _IOC_DIRMASK ((1 << _IOC_DIRBITS)-1) //方向字段的掩码，0x00000003
#define _IOC_NRSHIFT 0 //序数字段在整个字段中的位移，0
#define _IOC_TYPESHIFT (_IOC_NRSHIFT+_IOC_NRBITS) //幻数字段的位移，8
#define _IOC_SIZESHIFT (_IOC_TYPESHIFT+_IOC_TYPEBITS) //大小字段的位移，16
#define _IOC_DIRSHIFT (_IOC_SIZESHIFT+_IOC_SIZEBITS) //方向字段的位移，30
/*
* Direction bits.
*/
#define _IOC_NONE 0U //没有数据传输
#define _IOC_WRITE 1U //向设备写入数据，驱动程序必须从用户空间读入数据
#define _IOC_READ 2U //从设备中读取数据，驱动程序必须向用户空间写入数据
#define _IOC(dir,type,nr,size) \
(((dir) << _IOC_DIRSHIFT) | \
((type) << _IOC_TYPESHIFT) | \
((nr) << _IOC_NRSHIFT) | \
((size) << _IOC_SIZESHIFT))
/*
* used to create numbers
*/
//构造无参数的命令编号
#define _IO(type,nr) _IOC(_IOC_NONE,(type),(nr),0)
//构造从驱动程序中读取数据的命令编号
#define _IOR(type,nr,size)_IOC(_IOC_READ,(type),(nr),sizeof(size))
//用于向驱动程序写入数据命令
#define _IOW(type,nr,size) _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
//用于双向传输
#define _IOWR(type,nr,size)_IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
/*
*used to decode ioctl numbers..
*/
//从命令参数中解析出数据方向，即写进还是读出
#define _IOC_DIR(nr) (((nr) >> _IOC_DIRSHIFT) &_IOC_DIRMASK)
//从命令参数中解析出幻数type
#define _IOC_TYPE(nr) (((nr) >> _IOC_TYPESHIFT) &_IOC_TYPEMASK)
//从命令参数中解析出序数number
#define _IOC_NR(nr) (((nr) >> _IOC_NRSHIFT) &_IOC_NRMASK)
//从命令参数中解析出用户数据大小
#define _IOC_SIZE(nr) (((nr) >> _IOC_SIZESHIFT) &_IOC_SIZEMASK)
/* ...and for the drivers/sound files... */
#define IOC_IN (_IOC_WRITE << _IOC_DIRSHIFT)
#define IOC_OUT (_IOC_READ << _IOC_DIRSHIFT)
#define IOC_INOUT ((_IOC_WRITE|_IOC_READ) << _IOC_DIRSHIFT)
#define IOCSIZE_MASK (_IOC_SIZEMASK << _IOC_SIZESHIFT)
#define IOCSIZE_SHIFT (_IOC_SIZESHIFT)
程序例:
#include
#include
#include
int main(void) {
..int stat;
/* use func 8 to determine if the default drive is removable */
..stat = ioctl(0, 8, 0, 0);
..if (!stat)
....printf("Drive %c is removable.\n", getdisk() + 'A');
..else
....printf("Drive %c is not removable.\n", getdisk() +'A');
..return 0;
}
int ioctl( int fd, int request, .../* void *arg */ ) 详解
第三个参数总是一个指针，但指针的类型依赖于request参数。我们可以把和网络相关的请求划分为6类：
套接口操作
文件操作
接口操作
ARP 高速缓存操作
路由表操作
流系统
下表列出了网络相关ioctl请求的request 参数以及arg 地址必须指向的数据类型：
| 类别 |
Request |
说明 |
数据类型 |
| 套 接 口 |
SIOCATMARK SIOCSPGRP SIOCGPGRP |
是否位于带外标记 设置套接口的进程ID 或进程组ID 获取套接口的进程ID 或进程组ID |
int int int |
| 文 件 |
FIONBIO FIOASYNC FIONREAD FIOSETOWN FIOGETOWN |
设置/ 清除非阻塞I/O 标志 设置/ 清除信号驱动异步I/O 标志 获取接收缓存区中的字节数 设置文件的进程ID 或进程组ID 获取文件的进程ID 或进程组ID |
int int int int int |
| 接 口 |
SIOCGIFCONF SIOCSIFADDR SIOCGIFADDR SIOCSIFFLAGS SIOCGIFFLAGS SIOCSIFDSTADDR SIOCGIFDSTADDR SIOCGIFBRDADDR SIOCSIFBRDADDR SIOCGIFNETMASK SIOCSIFNETMASK SIOCGIFMETRIC SIOCSIFMETRIC SIOCGIFMTU SIOCxxx |
获取所有接口的清单 设置接口地址 获取接口地址 设置接口标志 获取接口标志 设置点到点地址 获取点到点地址 获取广播地址 设置广播地址 获取子网掩码 设置子网掩码 获取接口的测度 设置接口的测度 获取接口MTU （还有很多取决于系统的实现） |
struct ifconf struct ifreq struct ifreq struct ifreq struct ifreq struct ifreq struct ifreq struct ifreq struct ifreq struct ifreq struct ifreq struct ifreq struct ifreq struct ifreq |
| ARP |
SIOCSARP SIOCGARP SIOCDARP |
创建/ 修改ARP 表项 获取ARP 表项 删除ARP 表项 |
struct arpreq struct arpreq struct arpreq |
| 路 由 |
SIOCADDRT SIOCDELRT |
增加路径 删除路径 |
struct rtentry struct rtentry |
| 流 |
I_xxx |
|
|
套接口操作：
明确用于套接口操作的ioctl请求有三个, 它们都要求ioctl的第三个参数是指向某个整数的一个指针。
SIOCATMARK: 如果本套接口的的度指针当前位于带外标记，那就通过由第三个参数指向的整数返回一个非0值；否则返回一个0值。POSIX以函数sockatmark替换本请求。
SIOCGPGRP ： 通过第三个参数指向的整数返回本套接口的进程ID或进程组ID，该ID指定针对本套接口的SIGIO或SIGURG信号的接收进程。本请求和fcntl的F_GETOWN命令等效，POSIX标准化的是fcntl函数。
SIOCSPGRP ： 把本套接口的进程ID或者进程组ID设置成第三个参数指向的整数，该ID指定针对本套接口的SIGIO或SIGURG信号的接收进程，本请求和fcntl的F_SETOWN命令等效，POSIX标准化的是fcntl操作。
文件操作：
以下5个请求都要求ioctl的第三个参数指向一个整数。
FIONBIO ： 根据ioctl的第三个参数指向一个0或非0值分别清除或设置本套接口的非阻塞标志。本请求和O_NONBLOCK文件状态标志等效，而该标志通过fcntl的F_SETFL命令清除或设置。
FIOASYNC ： 根据ioctl的第三个参数指向一个0值或非0值分别清除或设置针对本套接口的信号驱动异步I/O标志，它决定是否收取针对本套接口的异步I/O信号（SIGIO）。本请求和O_ASYNC文件状态标志等效，而该标志可以通过fcntl的F_SETFL命令清除或设置。
FIONREAD ： 通过由ioctl的第三个参数指向的整数返回当前在本套接口接收缓冲区中的字节数。本特性同样适用于文件，管道和终端。
FIOSETOWN ： 对于套接口和SIOCSPGRP等效。
FIOGETOWN ： 对于套接口和SIOCGPGRP等效。
编辑本段定义
ioctl是设备驱动程序中对设备的I/O通道进行管理的函数。所谓对I/O通道进行管理，就
是对设备的一些特性进行控制，例如串口的传输波特率、马达的转速等等。它的调用个数
如下：
int ioctl(int fd, int cmd, …)；
其中fd就是用户程序打开设备时使用open函数返回的文件标示符，cmd就是用户程序对设
备的控制命令，至于后面的省略号，那是一些补充参数，一般最多一个，有或没有是和
cmd的意义相关的。
ioctl函数是文件结构中的一个属性分量，就是说如果你的驱动程序提供了对ioctl的支
持，用户就能在用户程序中使用ioctl函数控制设备的I/O通道。
编辑本段必要性
如果不用IOCTL的话，也能实现对设备I/O通道的控制，但那就是蛮拧了。例如，我们可
以在驱动程式中实现WRITE的时候检查一下是否有特别约定的数据流通过，如果有的话，
那么后面就跟着控制命令（一般在SOCKET编程中常常这样做）。不过如果这样做的话，会
导致代码分工不明，程式结构混乱，程式员自己也会头昏眼花的。
所以，我们就使用IOCTL来实现控制的功能。要记住，用户程式所作的只是通过命令码告
诉驱动程式他想做什么，至于怎么解释这些命令和怎么实现这些命令，这都是驱动程式要
做的事情。
编辑本段实现操作
读者只要把write换成ioctl，就知道用户程式的ioctl是怎么和驱动程式中的ioctl实现联系在一起的了。
我这里说一个大概思路，因为我觉得《Linux设备驱动程式》这本书已说的非常清晰
了，不过得花一些时间来看。
在驱动程式中实现的ioctl函数体内，实际上是有一个switch{case}结构，每一个case对
应一个命令码，做出一些相应的操作。怎么实现这些操作，这是每一个程式员自己的事
情，因为设备都是特定的，这里也没法说。关键在于怎么样组织命令码，因为在ioctl中
命令码是唯一联系用户程式命令和驱动程式支持的途径。
命令码的组织是有一些讲究的，因为我们一定要做到命令和设备是一一对应的，这样才不
会将正确的命令发给错误的设备，或是把错误的命令发给正确的设备，或是把错误的
命令发给错误的设备。这些错误都会导致不可预料的事情发生，而当程式员发现了这些奇
怪的事情的时候，再来调试程式查找错误，那将是非常困难的事情。
所以在Linux核心中是这样定义一个命令码的：
____________________________________
| 设备类型| 序列号| 方向|数据尺寸|
|----------|--------|------|--------|
| 8 bit | 8 bit |2 bit |8~14 bit|
|----------|--------|------|--------|
这样一来，一个命令就变成了一个整数形式的命令码。不过命令码非常的不直观，所以
Linux Kernel中提供了一些宏，这些宏可根据便于理解的字符串生成命令码，或是从
命令码得到一些用户能理解的字符串以标明这个命令对应的设备类型、设备序列号、数
据传送方向和数据传输尺寸。
这些宏我就不在这里解释了，具体的形式请读者察看Linux核心原始码中的和，文件里给
除了这些宏完整的定义。这里我只多说一个地方，那就是"幻数"。
幻数是个字母，数据长度也是8，所以就用一个特定的字母来标明设备类型，这和用一
个数字是相同的，只是更加利于记忆和理解。就是这样，再没有更复杂的了。
更多的说了也没有，读者还是看一看原始码吧，推荐各位阅读《Linux设备驱动程式》所
带原始码中的short一例，因为他比较短小，功能比较简单，能看明白ioctl的功能和细
节。
编辑本段其他信息
cmd参数怎么得出
这里确实要说一说，cmd参数在用户程式端由一些宏根据设备类型、序列号、传送方向、
数据尺寸等生成，这个整数通过系统调用传递到内核中的驱动程式，再由驱动程式使用解
码宏从这个整数中得到设备的类型、序列号、传送方向、数据尺寸等信息，然后通过
switch{case}结构进行相应的操作。
要透彻理解，只能是通过阅读原始码，我这篇文章实际上只是个引子。Cmd参数的组织
还是比较复杂的，我认为要搞熟他还是得花不少时间的，不过这是值得的，驱动程式中最
难的是对中断的理解。
五、 小结
ioctl其实没有什么非常难的东西需要理解，关键是理解cmd命令码是怎么在用户程式里生成
并在驱动程式里解析的，程式员最主要的工作量在switch{case}结构中，因为对设备的
I/O控制都是通过这一部分的代码实现的。
Mkdir函数
原型：int mkdir (const char *filename, mode_t mode)
返回0表示成功，返回-1表述出错。使用该函数需要包含头文件sys/stat.h
mode 表示新目录的权限，可以取以下值：
S_IRUSR
S_IREAD
Read permission bit for the owner of the file. On many systems this bit is 0400. S_IREAD is an obsolete synonym provided for BSD compatibility.
S_IWUSR
S_IWRITE
Write permission bit for the owner of the file. Usually 0200. S_IWRITE is an obsolete synonym provided for BSD compatibility.
S_IXUSR
S_IEXEC
Execute (for ordinary files) or search (for directories) permission bit for the owner of the file. Usually 0100. S_IEXEC is an obsolete synonym provided for BSD compatibility.
S_IRWXU
This is equivalent to (S_IRUSR | S_IWUSR | S_IXUSR).
S_IRGRP
Read permission bit for the group owner of the file. Usually 040.
S_IWGRP
Write permission bit for the group owner of the file. Usually 020.
S_IXGRP
Execute or search permission bit for the group owner of the file. Usually 010.
S_IRWXG
This is equivalent to (S_IRGRP | S_IWGRP | S_IXGRP).
S_IROTH
Read permission bit for other users. Usually 04.
S_IWOTH
Write permission bit for other users. Usually 02.
S_IXOTH
Execute or search permission bit for other users. Usually 01.
S_IRWXO
This is equivalent to (S_IROTH | S_IWOTH | S_IXOTH).
S_ISUID
This is the set-user-ID on execute bit, usually 04000. See How Change Persona.
S_ISGID
This is the set-group-ID on execute bit, usually 02000. See How Change Persona.
S_ISVTX
This is the sticky bit, usually 01000.
信号量 sem_wait sem_post
信号量的数据类型为结构sem_t，它本质上是一个长整型的数。函数sem_init（）用来初始化一个信号量。它的原型为：
extern int sem_init __P((sem_t *__sem, int __pshared, unsigned int __value));
sem为指向信号量结构的一个指针；pshared不为０时此信号量在进程间共享，否则只能为当前进程的所有线程共享；value给出了信号量的初始值。
函数sem_post( sem_t *sem )用来增加信号量的值。当有线程阻塞在这个信号量上时，调用这个函数会使其中的一个线程不在阻塞，选择机制同样是由线程的调度策略决定的。
函数sem_wait( sem_t *sem )被用来阻塞当前线程直到信号量sem的值大于0，解除阻塞后将sem的值减一，表明公共资源经使用后减少。函数sem_trywait( sem_t *sem )是函数sem_wait（）的非阻塞版本，它直接将信号量sem的值减一。
函数sem_destroy(sem_t *sem)用来释放信号量sem。
信号量用sem_init函数创建的，下面是它的说明：
#include
int sem_init (sem_t *sem, int pshared, unsigned int value);
这个函数的作用是对由sem指定的信号量进行初始化，设置好它的共享选项，并指定一个整数类型的初始值。pshared参数控制着信号量的类型。如果pshared的值是０，就表示它是当前里程的局部信号量；否则，其它进程就能够共享这个信号量。我们现在只对不让进程共享的信号量感兴趣。 （这个参数受版本影响）， pshared传递一个非零将会使函数调用失败。
这两个函数控制着信号量的值，它们的定义如下所示：
#include
int sem_wait(sem_t * sem);
int sem_post(sem_t * sem);
这两个函数都要用一个由sem_init调用初始化的信号量对象的指针做参数。
sem_post函数的作用是给信号量的值加上一个“1”，它是一个“原子操作”－－－即同时对同一个信号量做加“1”操作的两个线程是不会冲突的；而同时对同一个文件进行读、加和写操作的两个程序就有可能会引起冲突。信号量的值永远会正确地加一个“2”－－因为有两个线程试图改变它。
sem_wait函数也是一个原子操作，它的作用是从信号量的值减去一个“1”，但它永远会先等待该信号量为一个非零值才开始做减法。也就是说，如果你对一个值为2的信号量调用sem_wait(),线程将会继续执行，介信号量的值将减到1。如果对一个值为0的信号量调用sem_wait()，这个函数就会地等待直到有其它线程增加了这个值使它不再是0为止。如果有两个线程都在sem_wait()中等待同一个信号量变成非零值，那么当它被第三个线程增加一个“1”时，等待线程中只有一个能够对信号量做减法并继续执行，另一个还将处于等待状态。
信号量这种“只用一个函数就能原子化地测试和设置”的能力下正是它的价值所在。还有另外一个信号量函数sem_trywait，它是sem_wait的非阻塞搭档。
最后一个信号量函数是sem_destroy。这个函数的作用是在我们用完信号量对它进行清理。下面的定义：
#include
int sem_destroy (sem_t *sem);
这个函数也使用一个信号量指针做参数，归还自己战胜的一切资源。在清理信号量的时候如果还有线程在等待它，用户就会收到一个错误。
与其它的函数一样，这些函数在成功时都返回“0”。
#include
#include
#include
#include
#include
#include
sem_t bin_sem;
void *thread_function1(void *arg)
{
printf("thread_function1--------------sem_wait\n");
sem_wait(&bin_sem);
printf("sem_wait\n");
while (1)
{
}
}
void*thread_function2(void *arg)
{
printf("thread_function2--------------sem_post\n");
sem_post(&bin_sem);
printf("sem_post\n");
while (1)
{
}
}
int main()
{
int res;
pthread_t a_thread;
void *thread_result;
res = sem_init(&bin_sem, 0, 0);
if (res != 0)
{
perror("Semaphore initialization failed");
}
printf("sem_init\n");
res = pthread_create(&a_thread, NULL, thread_function1, NULL);
if (res != 0)
{
perror("Thread creation failure");
}
printf("thread_function1\n");
sleep (5);
printf("sleep\n");
res = pthread_create(&a_thread, NULL, thread_function2, NULL);
if (res != 0)
{
perror("Thread creation failure");
}
while (1)
{
}
}
sem_init
thread_function1
thread_function1--------------sem_wait
sleep
thread_function2--------------sem_post
sem_wait
sem_post
Linux下开启/关闭防火墙命令
1) 永久性生效，重启后不会复原
开启： chkconfig iptables on
关闭： chkconfig iptables off
2) 即时生效，重启后复原
开启： service iptables start
关闭： service iptables stop
需要说明的是对于Linux下的其它服务都可以用以上命令执行开启和关闭操作。
在当开启了防火墙时，做如下设置，开启相关端口，
修改/etc/sysconfig/iptables 文件，添加以下内容：
-A RH-Firewall-1-INPUT -m state --state NEW -m tcp -p tcp --dport 80 -j ACCEPT
-A RH-Firewall-1-INPUT -m state --state NEW -m tcp -p tcp --dport 22 -j ACCEPT
二.UBuntu关闭防火墙
iptables -A INPUT -i ! PPP0 -j ACCEPT
三.CentOS Linux防火墙配置及关闭
执行”setup”命令启动文字模式配置实用程序,在”选择一种工具”中选择”防火墙配置”,然后选择”运行工具”按钮,出现防火墙配置界面,将”安全级别”设为”禁用”,然后选择”确定”即可.
或者用命令:
#/sbin/iptables -I INPUT -p tcp –dport 80 -j ACCEPT
#/sbin/iptables -I INPUT -p tcp –dport 22 -j ACCEPT
#/etc/rc.d/init.d/iptables save
这样重启计算机后,防火墙默认已经开放了80和22端口
这里应该也可以不重启计算机：
#/etc/init.d/iptables restart
防火墙的关闭，关闭其服务即可：
查看防火墙信息：
#/etc/init.d/iptables status
关闭防火墙服务：
#/etc/init.d/iptables stop
永久关闭？不知道怎么个永久法：
#chkconfig –level 35 iptables off
Linux下配置ip、子网掩码、网关，并把他们保存在指定的文件中，每次启动后不用重新设置。
1、 可以把它放在/etc/rc.d/init.d/rc.local文件中
ifconfig eth0 192.168.10.50 netmask 255.255.0.0
route add default gw 192.168.1.1
2、配置网卡的配置文件
创建或修改此文件/etc/sysconfig/network-scripts/ifcfg-eth0#ifcfg-eth0
DEVICE=eth0
BOOTPROTO=static
BROADCAST=192.168.10.255
IPADDR=192.168.10.50
NETMASK=255.255.255.0
NETWORK=192.168.10.0
ONBOOT=yes
TYPE=Ethernet
USERCTL=no
PEERDNS=no
GATEWAY=
##Add to tail of /etc/sysconfig/static-routes
eth0 192.168.1.1
Linux的关机与重启命令
作者: Aillo, 发布于2009-05-10, 在系统分类下, 1条留言。
重启命令：
1、reboot
2、shutdown -r now 立刻重启(root用户使用)
3、shutdown -r 10 过10分钟自动重启(root用户使用)
4、shutdown -r 20:35 在时间为20:35时候重启(root用户使用)
如果是通过shutdown命令设置重启的话，可以用shutdown -c命令取消重启
关机命令：
1、halt 立刻关机
2、poweroff 立刻关机
3、shutdown -h now 立刻关机(root用户使用)
4、shutdown -h 10 10分钟后自动关机
如果是通过shutdown命令设置关机的话，可以用shutdown -c命令取消重启
安装RPM包或者安装源码包
在windows下安装一个软件很轻松，只要双击.exe的文件，安装提示连续“下一步”即可，然而linux系统下安装一个软件似乎并不那么轻松了，因为我们不是在图形界面下。所以你要学会如何在linux下安装一个软件。
在前面的内容中多次提到的yum，这个yum是Redhat所特有的安装RPM程序包的工具，使用起来相当方便。因为使用RPM安装某一个程序包有可能会因为该程序包依赖另一个程序包而无法安装。而使用yum工具就可以连同依赖的程序包一起安装。当然CentOS同样可以使用yum工具，而且在CentOS中你可以免费使用yum，但Redhat中只有当你付费后才能使用yum，默认是无法使用yum的。在介绍yum之前先说一说RPM相关的东西。
【RPM工具】
RPM是”Redhat Package Manager”的缩写，根据名字也能猜到这是Redhat公司开发出来的。RPM 是以一种数据库记录的方式来将你所需要的套件安装到你的Linux 主机的一套管理程序。也就是说，你的linux系统中存在着一个关于RPM的数据库，它记录了安装的包以及包与包之间依赖相关性。RPM包是预先在linux机器上编译好并打包好的文件，安装起来非常快捷。但是也有一些缺点，比如安装的环境必须与编译时的环境一致或者相当；包与包之间存在着相互依赖的情况；卸载包时需要先把依赖的包卸载掉，如果依赖的包是系统所必须的，那就不能卸载这个包，否则会造成系统崩溃。
如果你的光驱中还有系统安装盘的话，你可以通过”mount /dev/cdrom /mnt”命令把光驱挂载到/mnt目录下，那么你会在/mnt/CentOS目录下看到很多.rpm的文件，这就是RPM包了。
每一个rpm包的名称都由”-“和”.”分成了若干部分。就拿 a2ps-4.13b-57.2.el5.i386.rpm 这个包来解释一下，a2ps 为包名；4.13b则为版本信息；57.2.el5为发布版本号；i386为运行平台。其中运行平台常见的有i386,i586, i686, x86_64 ，需要你注意的是cpu目前是分32位和64位的，i386,i586和i686都为32位平台，x86_64则代表为64位的平台。另外有些rpm包并没有写具体的平台而是noarch，这代表这个rpm包没有硬件平台限制。例如 alacarte-0.10.0-1.fc6.noarch.rpm。下面介绍一下rpm常用的命令。
1）安装一个rpm包
-i ：安装的意思
-v ：可视化
-h ：显示安装进度
另外在安装一个rpm包时常用的附带参数有：
--force 强制安装，即使覆盖属于其他包的文件也要安装
--nodeps 当要安装的rpm包依赖其他包时，即使其他包没有安装，也要安装这个包
2）升级一个rpm包
rpm-Uvh filename -U ：即升级的意思
3）卸载一个rpm包
rpm -efilename 这里的filename是通过rpm的查询功能所查询到的，稍后会作介绍。
卸载时后边跟的filename和安装时的是有区别的。上面命令提到的 “|”在linux系统中用的非常多也非常有用，它是一个管道符，用来把前面运行的结果传递给后面的命令。以后会做详细介绍，而后出现的grep命令则是用来过滤某个关键词的工具，在后续章节中会做详细介绍。
4）查询一个包是否安装
rpm -qrpm包名（这里的包名，是不带有平台信息以及后缀名的）
如果加上了平台信息以及后缀名反而不能查出来。你还可以查询当前系统中所安装的所有rpm包。
因为太多，所以笔者列出前十个。
5）得到一个rpm包的相关信息
rpm -qi 包名 （同样不需要加平台信息与后缀名）
6）列出一个rpm包安装的文件
rpm -ql 包名
通过上面的命令可以看出vim是通过安装vim-enhanced-7.0.109-6.el5这个rpm包得来的。那么反过来如何通过一个文件去查找是由安装哪个rpm包得来的？
7）列出某一个文件属于哪个rpm包
rpm -qf 文件的绝对路径
前面讲过如何查找一个文件（可执行命令）的绝对路径
所以你也可以把这两条命令连起来写
看到了吗，whichvim 这条命令是由两个反引号引起来的，这代表引用反引号里面的命令所产生的结果。关于rpm工具的使用还有很多内容，笔者就不一一列举了，只要你掌握上面这些内容，完全够你平时工作用的了。
【yum工具】
介绍完rpm工具后，还需要你掌握最常用的yum工具，这个工具比rpm工具好用多了，当然前提是你使用的linux系统是支持yum的。yum最大的优势在于可以联网去下载所需要的rpm包，然后自动安装，在这个工程中如果要安装的rpm包有依赖关系，yum会帮你解决掉这些依赖关系依次安装所有rpm包。下面笔者介绍常用的yum 命令。
1） 列出所有可用的rpm包 “yum list “
限于篇幅，笔者只列举出来前7个包信息。从上例中可以看到有”mirrors.163.com”信息出现，这是在告诉用户，它是从mirrors.163.com这里下载到的rpm包资源。如果你使用的是CentOS则你可以从/etc/yum.repos.d/CentOS-Base.repo这个文件下看到相关的配置信息。从上面的例子中你还可以看到最左侧是rpm包名字，中间是版本信息，最右侧是安装信息，如果安装了就显示installed，未安装则显示base或者extras，如果是该rpm包已安装但需要升级则显示updates。
2）搜索一个rpm包 “yum search [相关关键词]”
除了这样搜索外，笔者常用的是利用grep来过滤
相信你也会喜欢用后者吧，这样看起来简明的多。
3）安装一个rpm包 “yum install [-y] [rpm包名]”
如果不加-y选项，则会以与用户交互的方式安装，首先是列出需要安装的rpm包信息，然后会问用户是否需要安装，输入y则安装，输入n则不安装。而笔者嫌这样太麻烦，所以直接加上-y选项，这样就省略掉了问用户是否安装的那一步。
4）卸载一个rpm包 “yum remove [-y] [rpm包名]”
卸载和安装一样，你也可以直接加上-y选项来省略掉和用户交互的步骤。在这里笔者要提醒你一下，卸载某个rpm包一定要看清楚了，不要连其他重要的rpm包一起卸载了，以免影响正常的业务。
4）升级一个rpm包 “yum update [-y] [rpm包]”
以上介绍了如何使用yum搜索、安装、卸载以及升级一个rpm包，如果你掌握了这些那么你就已经可以解决日常工作中遇到的与rpm包相关问题了。当然yum工具还有好多其他好用的命令，笔者不在列举出来，如果你感兴趣就去man一下吧。除此之外，笔者还会教你一些关于yum的小应用。
1 使用本地的光盘来制作一个yum源
有时候你的linux系统不能联网，当然就不能很便捷的使用联网的yum源了，这时候就需要你自己会利用linux系统光盘制作一个yum源。具体步骤如下：
a.挂载光盘
[root@fortest Server]# mount -t iso9660 -o loop /dev/cdrom /mnt
b.删除/etc/yum.repos.d目录所有的repo文件
[root@fortest Server]# rm -rf /etc/yum.repos.d/*
c.创建新文件dvd.repo
[root@fortest Server]# vim /etc/yum.repos.d/dvd.repo
加入以下内容：
[dvd]
name=install dvd
baseurl=file:///mnt
enabled=1
gpgcheck=0
d.刷新repos,生成缓存
[root@fortest Server]#yum makecache
然后就可以使用yum命令安装你所需要的软件包了
2 利用yum工具下载一个rpm包
有时，我们需要下载一个rpm包，只是下载下来，拷贝给其他机器使用，前面也介绍过yum安装rpm包的时候，首先得下载这个rpm包然后再去安装，所以使用yum完全可以做到只下载而不安装。
a. 首选要安装 yum-downloadonly
# yum install -y yum-downloadonly.noarch
b. 下载一个rpm包而不安装
# yum install test.rpm -y --downloadonly //这样虽然下载了，但是并没有保存到我们想要的目录下，那么如何指定目录呢？
c. 下载到指定目录
# yum install test.rpm -y --downloadonly --downloaddir=/usr/local/src
【安装源码包】
其实，在linux下面安装一个源码包是最常用的，笔者在日常的管理工作中，大部分软件都是通过源码安装的。安装一个源码包，是需要我们自己把源代码编译成二进制的可执行文件。如果你读得懂这些源代码，那么你就可以去修改这些源代码自定义功能，然后再去编译成你想要的。使用源码包的好处除了可以自定义修改源代码外还可以定制相关的功能，因为源码包在编译的时候是可以附加额外的选项的。
源码包的编译用到了linux系统里的编译器，常见的源码包一般都是用C语言开发的，这也是因为C语言为linux上最标准的程序语言。Linux上的C语言编译器叫做gcc，利用它就可以把C语言变成可执行的二进制文件。所以如果你的机器上没有安装gcc就没有办法去编译源码。你可以使用 yum install -y gcc 来完成安装。
安装一个源码包，通常需要三个步骤：
1. ./config 在这一步可以定制功能，加上相应的选项即可，具有有什么选项可以通过”./config--help ”命令来查看。在这一步会自动检测你的linux系统与相关的套件是否有编译该源码包时需要的库，因为一旦缺少某个库就不能完成编译。只有检测通过后才会生成一个Makefile文件。
2. make 使用这个命令会根据Makefile文件中预设的参数进行编译，这一步其实就是gcc在工作了。
3. make install 安装步骤，生成相关的软件存放目录和配置文件的过程。
上面介绍的3步并不是所有的源码包软件都一样的，笔者以前也曾经遇到过，安装步骤并不是这样，也就是说源码包的安装并非具有一定的标准安装步骤。这就需要你拿到源码包解压后，然后进入到目录找相关的帮助文档，通常会以INSTALL或者README为文件名。所以，你一定要去看一下。下面笔者会编译安装一个源码包来帮你更深刻的去理解如何安装源码包。
1. 下载一个源码包
这里要提一下，建议以后你把所有下载的源码包放到/usr/local/src/目录下，这个并不是必须的，只是一个约定。方便你和你的同事将来更好的去运维这台服务器。wget即为下载的命令，后边跟源码包的下载地址。该地址为笔者从网上找的一个apache的下载地址。
2. 解压源码包
一般的源码包都是一个压缩包，如何解压一个.tar.gz的包上一章讲过的。
3. 配置相关的选项，并生成Makefile
使用./config--help 可以查看可用的选项。一般常用的有”--prefix=PREFIX“ 这个选项的意思是定义软件包安装到哪里。到这里，笔者再提一个小小的约定，通常源码包都是安装在/usr/local/目录下的。比如，我们把apache安装在/usr/local/apache2下，那么这里就应该这样写” --prefix=/usr/local/apache2”。其他还有好多选项，如果你有耐心你可以挨个去看一看都有什么作用。
笔者在这里只定义了apache的安装目录，其他都是默认。回车后，开始执行check操作。
等check结束后生成了Makefile文件
除了查看有没有生成Makefile文件来判定有没有完成./config 的操作外，还可以通过这个命令”echo $?”来判定，如果是0，则表示上一步操作成功完成，否则就是没有成功。
4. 进行编译
这一步操作，就是把源代码编译成二进制的可执行文件，这一步也是最漫长的一步，编译时间的长短取决于源代码的多少和机器配置。
5. 安装
在安装前，先确认上一步操作是否成功完成。
makeinstall 会创建相应的目录以及文件。当完成安装后，会在/usr/local目录下多了一个apache2目录，这就是apache所安装的目录了。
其实在日常的源码安装工作中，并不是每个都像笔者这样顺利完成安装的，遇到错误不能完成安装的情况是很多的。通常都是因为缺少某一个库文件导致的。这就需要你仔细琢磨报错信息或者查看当前目录下的config.log去得到相关的信息。另外，如果自己不能解决那就去网上google一下吧，通常你会得到你想要的答案。
Linux rpm 命令参数使用详解［介绍和应用］
全屏阅读
2013-03-0823:03:47 作者：王睿宇 所属分类：Linux 阅读：322 评论：0
· · RPM是RedHat Package Manager（RedHat软件包管理工具）类似Windows里面的“添加/删除程序”
rpm 执行安装包
二进制包（Binary）以及源代码包（Source）两种。二进制包可以直接安装在计算机中，而源代码包将会由RPM自动编译、安装。源代码包经常以src.rpm作为后缀名。
常用命令组合：
－ivh：安装显示安装进度--install--verbose--hash
－Uvh：升级软件包--Update；
－qpl：列出RPM软件包内的文件信息[Query Package list]；
－qpi：列出RPM软件包的描述信息[Query Package install package(s)]；
－qf：查找指定文件属于哪个RPM软件包[Query File]；
－Va：校验所有的RPM软件包，查找丢失的文件[View Lost]；
－e：删除包
rpm -q samba //查询程序是否安装rpm -ivh /media/cdrom/RedHat/RPMS/samba-3.0.10-1.4E.i386.rpm //按路径安装并显示进度
rpm -ivh --relocate /=/opt/gaim gaim-1.3.0-1.fc4.i386.rpm //指定安装目录rpm -ivh --test gaim-1.3.0-1.fc4.i386.rpm //用来检查依赖关系；并不是真正的安装；
rpm -Uvh --oldpackage gaim-1.3.0-1.fc4.i386.rpm //新版本降级为旧版本rpm -qa | grep httpd ＃[搜索指定rpm包是否安装]--all搜索*httpd*
rpm -ql httpd ＃[搜索rpm包]--list所有文件安装目录rpm -qpi Linux-1.4-6.i368.rpm ＃[查看rpm包]--query--package--install package信息
rpm -qpf Linux-1.4-6.i368.rpm ＃[查看rpm包]--file
rpm -qpR file.rpm ＃[查看包]依赖关系
rpm2cpio file.rpm |cpio -div ＃[抽出文件]
rpm -ivh file.rpm ＃[安装新的rpm]--install--verbose--hash
rpm -ivh
rpm -Uvh file.rpm ＃[升级一个rpm]--upgrade
rpm -e file.rpm ＃[删除一个rpm包]--erase
常用参数：
Install/Upgrade/Erase options:
-i, --install install package(s)
-v, --verbose provide more detailed output
-h, --hash print hash marks as package installs (good with -v)
-e, --erase erase (uninstall) package
-U, --upgrade=+ upgrade package(s)
－-replacepkge 无论软件包是否已被安装，都强行安装软件包
--test 安装测试，并不实际安装
--nodeps 忽略软件包的依赖关系强行安装
--force 忽略软件包及文件的冲突Query options (with -q or --query):
-a, --all query/verify all packages
-p, --package query/verify a package file
-l, --list list files in package
-d, --docfiles list all documentation files
-f, --file query/verify package(s) owning file
RPM源代码包装安装
.src.rpm结尾的文件，这些文件是由软件的源代码包装而成的，用户要安装这类RPM软件包，必须使用命令：
rpm--recompilevim-4.6-4.src.rpm ＃这个命令会把源代码解包并编译、安装它，如果用户使用命令：rpm--rebuildvim-4.6-4.src.rpm ＃在安装完成后，还会把编译生成的可执行文件重新包装成i386.rpm的RPM软件包。
偶不喜欢写比较复杂的东东，麻烦的话`不过做为参考`偶还素转了一位哒人的`写的真很全面`
作者：北南南北
来自：LinuxSir.Org
提要：RPM 是 Red Hat PackageManager 的缩写，原意是Red Hat 软件包管理；本文介绍RPM，并结合实例来解说RPM手工安装、查询等应用；
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
正文：
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
RPM 是 Red Hat Package Manager 的缩写，本意是Red Hat 软件包管理，顾名思义是RedHat 贡献出来的软件包管理；在Fedora 、Redhat、Mandriva、SuSE、YellowDog等主流发行版本，以及在这些版本基础上二次开发出来的发行版采用；
RPM包里面都包含什么？里面包含可执行的二进制程序，这个程序和Windows的软件包中的.exe文件类似是可执行的；RPM包中还包括程序运行时所需要的文件，这也和Windows的软件包类似，Windows的程序的运行，除了.exe文件以外，也有其它的文件；
一个RPM 包中的应用程序，有时除了自身所带的附加文件保证其正常以外，还需要其它特定版本文件，这就是软件包的依赖关系；依赖关系并不是Linux特有的， Windows操作系统中也是同样存在的；比如我们在Windows系统中运行3D游戏，在安装的时候，他可能会提示，要安装Direct 9 ；Linux和Windows原理是差不多的；
软件安装流程图：
本文使用范围：
1、本文是对RPM管理的软件的说明，对通过file.tar.gz 或file.tar.bz2源码包用 make ;make install 安装的软件无效；
2、安装软件时，最好用各自发行版所提供的系统软件包管理工具，对于Fedora/Redhat 您可以参考如下文章；
1）Fedora 系统管理软件包工具 system-config-packages，方便的添加和移除系统安装盘提供的软件包，详情请看《Fedora 软件包管理器system-config-packages》
2）Redhat 系统管理软件包工具,新一点的系统应该是 redhat-config-packages ，用法和《Fedora 软件包管理器system-config-packages》一样；
3）apt + synaptic 软件包在线安装、移除、升级工具；用法：《用apt+synaptic 在线安装或升级Fedoracore 4.0 软件包》
4）yum 软件包在线安装、升级、移除工具；用法：《Fedora/Redhat 在线安装更新软件包，yum 篇》
5）所有的yum和apt 教程《apt and yum》
目前 apt和yum 已经极为成熟了，建议我们安装软件时，采用apt或者yum ；如果安装系统盘提供的软件包，可以用 system-config-packages 或redhat-config-packages ；
一、RPM包管理的用途；
1、可以安装、删除、升级和管理软件；当然也支持在线安装和升级软件；
2、通过RPM包管理能知道软件包包含哪些文件，也能知道系统中的某个文件属于哪个软件包；
3、可以在查询系统中的软件包是否安装以及其版本；
4、作为开发者可以把自己的程序打包为RPM 包发布；
5、软件包签名GPG和MD5的导入、验证和签名发布
6、依赖性的检查，查看是否有软件包由于不兼容而扰乱了系统；
二、RPM的使用权限；
RPM软件的安装、删除、更新只有root权限才能使用；对于查询功能任何用户都可以操作；如果普通用户拥有安装目录的权限，也可以进行安装；
三、rpm的一点简单用法；
我们除了软件包管理器以外，还能通过rpm 命令来安装；是不是所有的软件包都能通过rpm 命令来安装呢？不是的，文件以.rpm 后缀结尾的才行；有时我们在一些网站上找到file.rpm ，都要用 rpm 来安装；
一）初始化rpm数据库；
通过rpm 命令查询一个rpm 包是否安装了，也是要通过rpm 数据库来完成的；所以我们要经常用下面的两个命令来初始化rpm 数据库；
[root@localhostbeinan]# rpm --initdb
[root@localhost beinan]# rpm --rebuilddb 注：这个要花好长时间；
注：这两个参数是极为有用，有时rpm系统出了问题，不能安装和查询，大多是这里出了问题；
二）RPM软件包管理的查询功能：
命令格式
rpm {-q|--query}[select-options] [query-options]
RPM的查询功能是极为强大，是极为重要的功能之一；举几个常用的例子，更为详细的具体的，请参考#man rpm
1、对系统中已安装软件的查询；
1）查询系统已安装的软件；
语法：rpm-q 软件名
举例：
[root@localhostbeinan]# rpm -q gaim
gaim-1.3.0-1.fc4
-q就是 --query ，中文意思是“问”，此命令表示的是，是不是系统安装了gaim ；如果已安装会有信息输出；如果没有安装，会输出gaim 没有安装的信息；
查看系统中所有已经安装的包，要加 -a参数；
[root@localhostRPMS]# rpm -qa
如果分页查看，再加一个管道 |和more命令；
[root@localhostRPMS]# rpm -qa |more
在所有已经安装的软件包中查找某个软件，比如说gaim ；可以用 grep 抽取出来；
[root@localhostRPMS]# rpm -qa |grep gaim
上面这条的功能和rpm -q gaim 输出的结果是一样的；
2）查询一个已经安装的文件属于哪个软件包；
语法rpm -qf 文件名
注：文件名所在的绝对路径要指出
举例：
[root@localhostRPMS]# rpm -qf /usr/lib/libacl.la
libacl-devel-2.2.23-8
3）查询已安装软件包都安装到何处；
语法：rpm-ql 软件名或 rpm rpmquery -ql 软件名
举例：
[root@localhostRPMS]# rpm -ql lynx
[root@localhost RPMS]# rpmquery -ql lynx
4）查询一个已安装软件包的信息
语法格式：rpm -qi 软件名
举例：
[root@localhostRPMS]# rpm -qi lynx
5）查看一下已安装软件的配置文件；
语法格式：rpm-qc 软件名
举例：
[root@localhostRPMS]# rpm -qc lynx
6）查看一个已经安装软件的文档安装位置：
语法格式：rpm -qd 软件名
举例：
[root@localhostRPMS]# rpm -qd lynx
7）查看一下已安装软件所依赖的软件包及文件；
语法格式：rpm -qR 软件名
举例：
[root@localhostbeinan]# rpm -qR rpm-python
查询已安装软件的总结：对于一个软件包已经安装，我们可以把一系列的参数组合起来用；比如 rpm -qil ；比如：
[root@localhostRPMS]# rpm -qil lynx
2、对于未安装的软件包的查看：
查看的前提是您有一个.rpm 的文件，也就是说对既有软件file.rpm的查看等；
1）查看一个软件包的用途、版本等信息；
语法：rpm -qpi file.rpm
举例：
[root@localhostRPMS]# rpm -qpi lynx-2.8.5-23.i386.rpm
2）查看一件软件包所包含的文件；
语法：rpm -qpl file.rpm
举例：
[root@localhostRPMS]# rpm -qpl lynx-2.8.5-23.i386.rpm
3）查看软件包的文档所在的位置；
语法：rpm -qpd file.rpm
举例：
[root@localhostRPMS]# rpm -qpd lynx-2.8.5-23.i386.rpm
5）查看一个软件包的配置文件；
语法：rpm -qpc file.rpm
举例：
[root@localhostRPMS]# rpm -qpc lynx-2.8.5-23.i386.rpm
4）查看一个软件包的依赖关系
语法：rpm -qpR file.rpm
举例：
[root@localhostarchives]# rpm -qpR yumex_0.42-3.0.fc4_noarch.rpm
/bin/bash
/usr/bin/python
config(yumex) = 0.42-3.0.fc4
pygtk2
pygtk2-libglade
rpmlib(CompressedFileNames) <= 3.0.4-1
rpmlib(PayloadFilesHavePrefix) <= 4.0-1
usermode
yum >= 2.3.2
三）软件包的安装、升级、删除等；
1、安装和升级一个rpm 包；
[root@localhostbeinan]#rpm -vih file.rpm 注：这个是用来安装一个新的rpm包；
[root@localhost beinan]#rpm -Uvh file.rpm 注：这是用来升级一个rpm 包；
如果有依赖关系的，请解决依赖关系，其实软件包管理器能很好的解决依赖关系，请看前面的软件包管理器的介绍；如果您在软件包管理器中也找不到依赖关系的包；那只能通过编译他所依赖的包来解决依赖关系，或者强制安装；
语法结构：
[root@localhostbeinan]# rpm -ivh file.rpm --nodeps --force
[root@localhost beinan]# rpm -Uvh file.rpm --nodeps --force
更多的参数，请查看man rpm
举例应用：
[root@localhostRPMS]# rpm -ivh lynx-2.8.5-23.i386.rpm
Preparing... ########################################### [100%]
1:lynx########################################### [100%]
[root@localhost RPMS]# rpm -ivh --replacepkgslynx-2.8.5-23.i386.rpm
Preparing... ########################################### [100%]
1:lynx########################################### [100%]
注： --replacepkgs 参数是以已安装的软件再安装一次；有时没有太大的必要；
测试安装参数--test ，用来检查依赖关系；并不是真正的安装；
[root@localhostRPMS]# rpm -ivh --test gaim-1.3.0-1.fc4.i386.rpm
Preparing... ########################################### [100%]
由新版本降级为旧版本，要加--oldpackage 参数；
[root@localhostRPMS]# rpm -qa gaim
gaim-1.5.0-1.fc4
[root@localhost RPMS]# rpm -Uvh --oldpackagegaim-1.3.0-1.fc4.i386.rpm
Preparing... ########################################### [100%]
1:gaim########################################### [100%]
[root@localhost RPMS]# rpm -qa gaim
gaim-1.3.0-1.fc4
为软件包指定安装目录：要加-relocate 参数；下面的举例是把gaim-1.3.0-1.fc4.i386.rpm指定安装在 /opt/gaim 目录中；
[root@localhostRPMS]# rpm -ivh --relocate /=/opt/gaim gaim-1.3.0-1.fc4.i386.rpm
Preparing... ########################################### [100%]
1:gaim########################################### [100%]
[root@localhost RPMS]# ls /opt/
gaim
为软件包指定安装目录：要加-relocate 参数；下面的举例是把lynx-2.8.5-23.i386.rpm 指定安装在 /opt/lynx 目录中；
[root@localhost RPMS]# rpm -ivh --relocate /=/opt/lynx --badreloclynx-2.8.5-23.i386.rpm
Preparing... ########################################### [100%]
1:lynx ########################################### [100%]
我们安装在指定目录中的程序如何调用呢？一般执行程序，都放在安装目录的bin或者sbin目录中；看下面的例子；如果有错误输出，就做相应的链接，用 ln -s ；
[root@localhostRPMS]# /opt/lynx/usr/bin/lynx
Configuration file /etc/lynx.cfg is not available.
[root@localhost RPMS]# ln -s /opt/lynx/etc/lynx.cfg/etc/lynx.cfg
[root@localhost RPMS]# /opt/lynx/usr/bin/lynx www.linuxsir.org
2、删除一个rpm 包；
首先您要学会查询rpm包；请看前面的说明；
[root@localhost beinan]#rpm -e 软件包名
举例：我想移除lynx包，完整的操作应该是：
[root@localhostRPMS]# rpm -e lynx
如果有依赖关系，您也可以用--nodeps忽略依赖的检查来删除。但尽可能不要这么做，最好用软件包管理器 systerm-config-packages 来删除或者添加软件；
[root@localhostbeinan]# rpm -e lynx --nodeps
四、导入签名：
[root@localhost RPMS]# rpm --import 签名文件
举例：
[root@localhostfc40]# rpm --import RPM-GPG-KEY
[root@localhost fc40]# rpm --import RPM-GPG-KEY-fedora
关于RPM的签名功能，详情请参见man rpm
五、RPM管理包管理器支持网络安装和查询；
比如我们想通过 Fedora Core 4.0 的一个镜像查询、安装软件包；
地址：
http://mirrors.kernel.org/fedora/core/4/i386/os/Fedora/RPMS/
举例：
命令格式：
rpm 参数 rpm包文件的http或者ftp的地址
# rpm -qpi http://mirrors.kernel.org/fedora/core/4/i386/os/ Fedora/RPMS/gaim-1.3.0-1.fc4.i386.rpm
# rpm -ivh http://mirrors.kernel.org/fedora/core/4/i386/os/ Fedora/RPMS/gaim-1.3.0-1.fc4.i386.rpm
举一反三吧；
六、对已安装软件包查询的一点补充；
[root@localhostRPMS]# updatedb
[root@localhost RPMS]# locate 软件名或文件名
通过updatedb，我们可以用locate 来查询一些软件安装到哪里了；系统初次安装时要执行updatedb ，每隔一段时间也要执行一次；以保持已安装软件库最新；updatedb 是slocate软件包所有；如果您没有这个命令，就得安装slocate ；
举例：
[root@localhostRPMS]# locate gaim
七、从rpm软件包抽取文件；
命令格式：rpm2cpio file.rpm |cpio -div
举例：
[root@localhostRPMS]# rpm2cpio gaim-1.3.0-1.fc4.i386.rpm |cpio -div
抽取出来的文件就在当用操作目录中的usr 和etc中；
其实这样抽到文件不如指定安装目录来安装软件来的方便；也一样可以抽出文件；
为软件包指定安装目录：要加-relocate 参数；下面的举例是把gaim-1.3.0-1.fc4.i386.rpm指定安装在 /opt/gaim 目录中；
[root@localhostRPMS]# rpm -ivh --relocate /=/opt/gaim gaim-1.3.0-1.fc4.i386.rpm
Preparing... ########################################### [100%]
1:gaim########################################### [100%]
[root@localhost RPMS]# ls /opt/
gaim
这样也能一目了然；gaim的所有文件都是安装在/opt/gaim 中，我们只是把gaim 目录备份一下，然后卸掉gaim；这样其实也算提取文件的一点用法；
八、RPM的配置文件；
RPM包管理，的配置文件是 rpmrc ，我们可以在自己的系统中找到；比如Fedora Core 4.0中的rpmrc 文件位于；
[root@localhostRPMS]# locate rpmrc
/usr/lib/rpm/rpmrc
/usr/lib/rpm/redhat/rpmrc
我们可以通过rpm --showrc 查看；具体的还得我们自己来学习。呵。。。不要问我，我也不懂；只要您看了这篇文章，认为对您有用，您的水平就和我差不多；咱们水平是一样的，所以我不能帮助您了；请理解；
九、src.rpm的用法：
《file.src.rpm 使用方法的简介》
后记：Fedora/Redhat 入门教程中的软件包管理篇，我已经写了很多了；目前还缺少通过源码包安装软件我方法以及一篇总结性的文档；我想在最近两天补齐，这两篇我以前写过；重新整理一下贴出来就行了；
以我的水平来看，写Fedora入门教程是极为费力气的，只能一点一点的完善和补充；我所写的教程是面对的是对Linux一无所知新手；教程中实例应用占大部份；我发现没有实例的情况下，新手不如看man ；能看man了，当然也不是什么新手；
经常在论坛上看一些弟兄的提问，虽然一问话解说过去也能应付；但想让大家更方便一点，不如写系统入门教程；虽然所花的时间要长一点；
GCC警告选项例解
发布时间：2007-01-0117:26:00 来源： ChinaUnix博客 作者： ChinaUnix博客 点击：358
程序员是追求完美的一族，即使是一般的程序员大多也都不想看到自己的程序中有甚至那么一点点的瑕疵。遇到任意一条编译器警告都坚决不放过。有人会说：我们可以使用比编译器更加严格的静态代码检查工具，如
splint
。 这个建议也很不错。不过lint工具使用起来较繁琐，有时候还需要记住一些特定符号并插入到你自己的代码中才行，门槛较高，这也让很多人止步于此。那么我 们就从此放弃么？不，如今的编译器做得都很好，它可以帮助我们的找到绝大多数可能出现问题的代码，前提是你要学会控制编译器去找到这些问题代码，而熟悉编 译器的警告选项恰恰是体现控制力的好方法。当你可以自如控制编译器警告输出的时候，你就算是’入道’了，同时你对语言的理解也更进一步了。
有人说：我就是用一个-Wall选项就可以了，一般选手可以这么做，而且他可以不知道-Wall会跟踪哪些类型的问题；但是高级选手是不会只使用-Wall的，他会把每条警告都研究的很透彻，会在Makefile中列出他想让编译器输出哪些类型的警告以替代-Wall，他会屏蔽掉那些对他的代码’毫 无用处’的警告(很可能他使用了编译器对语言的扩展功能)，他会有个和编译器交流的过程。
俗话说：’工欲善其事，必先利其器’，一直在工作中使用
GNU C
编译器(以下简称GCC)，这里对GCC的一些警告选项细致的分析，并列举几个简单的例子[注1]供分析参考。
1. -Wall集合警告选项
我们平时可能大多数情况只使用-Wall编译警告选项，实际上-Wall选项是一系列警告编译选项的集合。下面逐一分析这一集合中的各个选项：
[-Wchar-subscripts]
如果数组使用char类型变量做为下标值的话，则发出警告。因为在某些平台上char可能默认为signedchar，一旦溢出，就可能导致某些意外的结果。
e.g.
/* test_signed_char.c */
＃include
int main () {
char c = 255; // 我们以为char是无符号的，其范围应该是[0,255]
int i = 0;
int a[256];
for (i = 0; i type `char’
其输出结果：
-1
-41Array7476
1
从输出结果来看SolarisArray/gcc 3.2上char默认实现类型为signedchar；在WindowsXP/gcc-3.4.2上也是一样。
Windows上的输出结果：
-1
16 (随机值)
1
[-Wcomment]
当’/*’出现在 ’/* ...*/’注释中，或者’＼’出现在’// ...’注释结尾处时，使用-Wcomment会给出警告。不要小觑这些马虎代码，它很可能会影响程序的运行结果。如下面的例子：
e.g.
/*
* test_comment.c
* gcc -Wcomment test_comment.c
*/
＃include
int main() {
int a = 1;
int b = 2;
int c = 0; // ok just test＼
c = a + b;
/*
* 这里我们期待c = 3
* /* 但实际上输出c = 0
*/
printf("the c is %d＼n",c);
return 0;
}
gcc -Wcomment test_comment.c
test_comment.c:10:30: warning: multi-line comment
test_comment.c:15:12: warning: "/*" within comment
输出：
the c is 0
[-Wformat]
检查printf和scanf等格式化输入输出函数的格式字符串与参数类型的匹配情况，如果发现不匹配则发出警告。某些时候格式字符串与参数类型的不匹配会导致程序运行错误，所以这是个很有用的警告选项。
e.g.
/*
* test_format.c
*/
＃include
int main() {
long l = 1;
double d = 55.67;
printf("%d＼n",l);
printf("%d＼n",d);
return 0;
}
gcc -Wformat test_format.c
test_format.c: In function `main’:
test_format.c:10: warning: int format, long int arg (arg 2)
test_format.c:11: warning: int format, double arg (arg 2)
输出：
1
1078711746
[-Wimplicit]
该警告选项实际上是-Wimplicit-int和-Wimplicit-function-declaration两个警告选项的集合。前者在声明函数却未指明函数返回类型时给出警告，后者则是在函数声明前调用该函数时给出警告。
e.g.
/*
* test_implicit.c
*/
＃include
add(int a, int b) { //函数没有声明返回类型
return a + b;
}
int test() {
int a = 0;
int b = 0;
int c = 0;
int d = 0;
c = add(a, b);
d = sub(a, b); //未声明sub的函数原型
return 0;
}
gcc -Wimplicit -c test_implicit.c
test_implicit.c:7: warning: return type defaults to `int’
test_implicit.c: In function `test’:
test_implicit.c:18: warning: implicit declaration of function `sub’
[-Wmissing-braces]
当聚合类型或者数组变量的初始化表达式没有’充分’用括号{}括起时，给出警告。文字表述很难理解，举例说明则清晰些。看下面的例子：
e.g.
/*
* test_missing_braces.c
*/
struct point {
int x;
int y;
};
struct line {
struct point start;
struct point end;
};
typedef struct line line;
int main() {
int array1[2][2] = {11, 12, 13, 14};
int array2[2][2] = {{11, 12}, {13, 14}}; // ok
line l1 = {1, 1, 2, 2};
line l2 = {{2, 2}, {3, 3}};// ok
return 0;
}
gcc -Wmissing-braces test_missing_braces.c
test_missing_braces.c: In function `main’:
test_missing_braces.c:1Array: warning: missing braces around initializer
test_missing_braces.c:1Array: warning: (near initialization for `array1[0]’)
test_missing_braces.c:21: warning: missing braces around initializer
test_missing_braces.c:21: warning: (near initialization for `l1.start’)
[-Wparentheses]
这是一个很有用的警告选项，它能帮助你从那些看起来语法正确但却由于操作符优先级或者代码结构’障眼’而导致错误运行的代码中解脱出来。好长的一个长句，还是看例子理解吧！:)
e.g.
/*
* test_parentheses.c
* gcc -Wparentheses test_parentheses.c
*/
＃include
int main() {
int a = 1;
int b = 1;
int c = 1;
int d = 1;
if (a && b || c) { // 人们很难记住逻辑操作符的操作顺序，所以编译器建议加上()
;
}
if (a == 12)
if(b)
d = Array;
else
d= 10; //从代码的缩进上来看，这句仿佛是if(a == 12)的else分支
printf("the d is %d＼n",d); //期待d= 10, 而结果却是1
return 0;
}
gcc -Wparentheses test_parentheses.c
test_parentheses.c: In function `main’:
test_parentheses.c:13: warning: suggest parentheses around && within ||
test_parentheses.c:17: warning: suggest explicit braces to avoid ambiguous`else’
输出：
the d is 1
[-Wsequence-point]
关于顺序点(sequencepoint)，在C标准中有解释，不过很晦涩。我们在平时编码中尽量避免写出与实现相关、受实现影响的代码便是了。而-Wsequence-point选项恰恰可以帮我们这个忙，它可以帮我们查出这样的代码来，并给出其警告。
e.g.
/*
* test_sequence_point.c
* gcc -Wsequence-point test_sequence_point.c
*/
＃include
int main() {
int i = 12;
i = i--;
printf("the i is %d＼n",i);
return 0;
}
gcc -Wsequence-point test_sequence_point.c
test_sequence_point.c: In function `main’:
test_sequence_point.c:10: warning: operation on `i’ may be undefined
在两个平台上给出的编译警告都是一致的，但是输出结果却大相径庭。
Solaris输出：
the i is 11
Windows输出：
the i is 12
类似的像这种与顺序点相关的代码例子有：
i = i++;
a =b[i++]
a[i++] = i
等等...
[-Wswitch]
这个选项的功能浅显易懂，通过文字描述也可以清晰的说明。当以一个枚举类型(enum)作为switch语句的索引时但却没有处理default情况，或者没有处理所有枚举类型定义范围内的情况时，该选项会给处警告。
e.g.
/*
* test_switch1.c
*/
enum week {
SUNDAY,
MONDAY,
TUESDAY /* only an example , we omittedthe others */
};
int test1() {
enum week w = SUNDAY;
switch(w) {
case SUNDAY:
break; // without default or the other casehandlings
};
return 0;
}
int test2() { // Ok, won’t invoke even a warning
enum week w = SUNDAY;
switch(w) {
case SUNDAY:
break;
default:
break;
};
return 0;
}
int test3() { // Ok, won’t invoke even a warning
enum week w = SUNDAY;
switch(w) {
case SUNDAY:
break;
case MONDAY:
break;
case TUESDAY:
break;
};
return 0;
}
gcc -Wswitch -c test_switch.c
test_switch.c: In function `test1’:
test_switch.c:16: warning: enumeration value `MONDAY’ not handled in switch
test_switch.c:16: warning: enumeration value `TUESDAY’ not handled in switch
[-Wunused]
-Wunused是-Wunused-function、-Wunused-label、-Wunused-variable、-Wunused-value选项的集合，-Wunused-parameter需单独使用。
(1) -Wunused-function用来警告存在一个未使用的static函数的定义或者存在一个只声明却未定义的static函数，参见下面例子中的func1和func2；
(2) -Wunused-label用来警告存在一个使用了却未定义或者存在一个定义了却未使用的label，参加下面例子中的func3和func7；
(3) -Wunused-variable用来警告存在一个定义了却未使用的局部变量或者非常量static变量；参见下面例子中func5和var1；
(4) -Wunused-value用来警告一个显式计算表达式的结果未被使用；参见下面例子中func6
(5) -Wunused-parameter用来警告一个函数的参数在函数的实现中并未被用到，参见下面例子中func4。
下面是一个综合的例子
e.g.
/*
* test_unused.c
*/
static void func1(); //to prove function used but never defined
static void func2(); //to prove function defined but not used
static void func3(); //to prove label used but never defined
static void func7(); //to prove label defined but never used
static void func4(int a); //to prove parameter declared but not used
static void func5(); //to prove local variable defined but not used
static void func6(); //to prove value evaluated but not used
static int var1;
void test() {
func1();
func3();
func4(4);
func5();
func6();
}
static void func2() {
; // do nothing
}
static void func3() {
goto over;
}
static void func4(int a) {
; // do nothing
}
static void func5() {
int a = 0;
}
static void func6() {
int a = 0;
int b = 6;
a + b;
}
gcc -Wunused-parameter -c test_unused.c //如果不是用-Wunused-parameter，则func4函数将不被警告。
test_unused.c: In function `func3’:
test_unused.c:30: label `over’ used but not defined
test_unused.c: In function `func7’:
test_unused.c:35: warning: deprecated use of label at end of compound statement
test_unused.c:34: warning: label `over’ defined but not used
test_unused.c: In function `func4’:
test_unused.c:37: warning: unused parameter `a’
test_unused.c: In function `func5’:
test_unused.c:42: warning: unused variable `a’
test_unused.c: In function `func6’:
test_unused.c:48: warning: statement with no effect
test_unused.c: At top level:
test_unused.c:6: warning: `func1’used but never defined
test_unused.c:25: warning: `func2’defined but not used
test_unused.c:14: warning: `var1’defined but not used
[-Wuninitialized]
该警告选项用于检查一个局部自动变量在使用之前是否已经初始化了或者在一个longjmp调用可能修改 一个non-volatileautomatic variable时给出警告。目前编译器还不是那么smart，所以对有些可以正确按照程序员的意思运行的代码还是给出警告。而且该警告选项需要和’-O’选项一起使用，否则你得不到任何uinitialized的警告。
e.g.
/*
* test_uninitialized.c
*/
int test(int y) {
int x;
switch (y) {
case 1:
x = 11;
break;
case 2:
x = 22;
break;
case 3:
x = 33;
break;
}
return x;
}
gcc -Wuninitialized -O -c test_uninitialized.c
test_uninitialized.c: In function `test’:
test_uninitialized.c:6: warning: `x’ might be used uninitialized in thisfunction
2、非-Wall集合警告选项
以下讨论的这些警告选项并不包含在-Wall中，需要程序员显式添加。
[-Wfloat-equal]
该项用来检查浮点值是否出现在相等比较的表达式中。
e.g.
/*
* test_float_equal.c
*/
void test(int i) {
double d = 1.5;
if (d == i) {
;
}
}
gcc -Wfloat-equal -c test_float_equal.c
test_float_equal.c: In function `test’:
test_float_equal.c:8: warning: comparing floating point with == or != is unsafe
[-Wshadow]
当局部变量遮蔽(shadow)了参数、全局变量或者是其他局部变量时，该警告选项会给我们以警告信息。
e.g.
/*
* test_shadow.c
*/
int g;
void test(int i) {
short i;
double g;
}
gcc -Wshadow -c test_shadow.c
test_shadow.c: In function `test’:
test_shadow.c:Array: warning: declaration of `i’ shadows a parameter
test_shadow.c:10: warning: declaration of `g’ shadows a global declaration
test_shadow.c:6: warning: shadowed declaration is here
[-Wbad-function-cast]
当函数(准确地说应该是函数返回类型)被转换为非匹配类型时，均产生警告。
e.g.
/*
* test_bad_func_case.c
*/
int add(int a, int b) {
return a+b;
}
void test() {
char *p = (char*)add(1, 13);
}
gcc -Wbad-function-cast -c test_bad_func_case.c
test_bad_func_case.c: In function `test’:
test_bad_func_case.c:11: warning: cast does not match function type
[-Wcast-qual]
当去掉修饰源Target的限定词(如const)时，给出警告。
e.g.
/*
* test_cast_qual.c
*/
void test() {
char c = 0;
const char *p = &c;
char *q;
q = (char*)p;
}
gcc -Wcast-qual -c test_cast_qual.c
test_cast_qual.c: In function `test’:
test_cast_qual.c:10: warning: cast discards qualifiers from pointer target type
[-Wcast-align]
这是个非常有用的选项，特别是对于在Solaris这样的对内存对齐校验的平台尤其重要。它用于在从对齐系数小的地址(如char*)转换为对齐系数大的地址(如int*)转换时给出警告。
e.g.
/*
* test_cast_align.c
*/
＃include
int main() {
char c = 1;
char *p =&c; //ok
int *q =(int*)p; //bad align-cast
printf("the *q is %d＼n",*q);
return 0;
}
gcc -Wcast-align test_cast_align.c
test_cast_align.c: In function `main’:
test_cast_align.c:Array: warning: cast increases required alignment of targettype
输出：
总线错误(（主存储器）信息转储)//on Solaris Array
[-Wsign-compare]
在有符号数和无符号数进行值比较时，有符号数可能在比较之前被转换为无符号数而导致结果错误。使用该选项会对这样的情况给出警告。
e.g.
/*
* test_sign_compare.c
*/
＃include
int main() {
unsigned int i =128;
signed int j =-1;
if (i j＼n");
}
return 0;
}
gcc -Wsign-compare test_sign_compare.c
test_sign_compare.c: In function `main’:
test_sign_compare.c:10: warning: comparison between signed and unsigned
输出：
i type
test_unreachable.c:Array: warning: will never be executed
[-Wconvertion]
由于原型定义而引起的定点和浮点数之间的隐式转换(强制转换)或者由有符号数和无符号数之间隐式转换转换引起的警告。
e.g.
/*
* test_conversion.c
*/
＃include
void getdouble(double d) {
; // do nothing
}
int main() {
unsigned int k;
int n = 12;
k = -1;
k = (unsigned int)-1; // ok, explicitconversion ,no warning
getdouble(n);
return 0;
}
gcc -Wconversion test_conversion.c
test_conversion.c: In function `main’:
test_conversion.c:15: warning: negative integer implicitly converted tounsigned type
test_conversion.c:18: warning: passing arg 1 of `getdouble’ as floating ratherthan integer due to prototype
3、-Wtraditional和-W
这两个警告选项其实也都是一些组合(大部分都在上面提到过)，前者用来在代码中使用了标准C不同于传统C的特性时，发出警告；后者也是针对一些事件打开一个警告集合。关于它们的说明具体可参见’
Using the GNU Compiler Collection
Csocket基本原理
2009-03-20 20:09 1259人阅读 评论(0) 收藏 举报
socketserver网络socketsthreadstream
我通过几个采用 CSocket 类编写并基于Client/Server （客户端/ 服务端）的网络聊天和传输文件的程式 ，在调试这些程式的过程中，追踪深入至CSocket 类核心源码SockCore.cpp ，对于CSocket 类的运行机制可谓是一览无遗，并且对于阻塞和非阻塞方式下的socket 程式的编写也是稍有体会。
阅读本文请先注意 :
• 这里的阻塞和非阻塞的概念仅适用于Server 端socket 程式。
• socket 意为套接字，他和Socket 不同，请注意首字母的大小写。
说明：客户端和服务端的通信简单来讲：服务端 socket 负责监听，应答，接收和发送消息，而客户端socket 只是连接，应答，接收，发送消息。此外，如果你对于采用CSocket 类编写Client/Server 网络程式的原理不是非常了解，请先查询一下（ 详见：参考书籍和在线帮助 ）。
在此之前，有必要先讲述一下：网络传输服务提供者， ws2_32.dll ， socket 事件和 socket window 。
1. 网络传输服务提供者（网络传输服务进程），Socket 事件， SocketWindow
网络传输服务提供者（ transport service provider ）是以 DLL 的形式存在的，在 windows操作系统启动时由服务进程svchost.exe 加载。当socket 被创建时，调用API 函数 Socket （在 ws2_32.dll中）， Socket 函数会传递三个参数 : 地址族，套接字类型 ( 注 2 )和协议，这三个参数决定了是由哪一个类型的网络传输服务提供者来启动网络传输服务功能。所有的网络通信正是由网络传输服务提供者完成, 这里将网络传输服务提供者称为网络传输服务进程更有助于理解，因为前文已提到网络传输服务提供者是由 svchost.exe 服务进程所加载的。
当 Client 端 socket 和 Server 端 socket 相互通信时，两端均会触发 socket 事件 :
这里仅简要说明两个 socket 事件：
FD_CONNECT:连接事件 , 通常 Client 端 socket 调用 socketAPI 函数 Connect时所触发，这个事件发生在Client 端。
FD_ACCEPT：正在引入的连接事件，通常Server 端socket 正在接收来自Client 端socket 连接时触发，这个事件发生在Server 端。
网络传输服务进程将 socket 事件保存至 socket 的事件队列中。
此外，网络传输服务进程还会向 socketwindow 发送消息WM_SOCKET_NOTIFY , 通知有socket 事件产生，见下文对 socketwindow 的周详说明：
调用 CSocket::Create 函数后， socket 被创建。 socket 创建过程中调用CAsyncSocket::AttachHandle(SOCKET hSocket, CAsyncSocket* pSocket, BOOL bDead) 。该函数的作用是：
a. 将 socket 实例句柄和 socket 指针添加至当前模块状态（ 注 1 ）的一个映射表变量 m_pmapSocketHandle 中。
b. 在AttachHandle 过程中，会new 一个CSocketWnd 实例( 基于 CWnd 派生 ) ，这里将这个实例称之为 socketwindow ，进一步理解为他是存放所有sockets 的消息池（ window 消息），请仔细查看，这里 socket 后多加了一个 s ，表示创建的多个 socket 将共享一个消息池。
c. 当 Client 端 socket 和 Server 端相互通信时 , 此时网络传输服务进程向 socket window 发送消息WM_SOCKET_NOTIFY ，需要说明的是CSocketWnd 窗口句柄保存在当前模块状态的m_hSocketWindow 变量中。
2. 阻塞模式
阻塞模式下 Server 端和 Client 端之间的通信处于同步状态下。
在 Server 端直接实例化 CSocket类，调用 Create 方法创建 socket ，然后调用方法 Listen 开始侦听，最后用一个 while 循环阻塞调用 Accept 函数用于等待来自 Client 端的连接，如果这个 socket 在主线程（主程式）中运行，这将导致主线程的阻塞。因此，需要创建一个新的线程以运行socket 服务。
调试跟踪至 CSocket::Accept 函数源码：
while(!Accept(...))
{
if (GetLastError() == WSAEWOULDBLOCK) // The socket ismarked as nonblocking and no connections are present to be accepted.
PumpMessage(FD_ACCEPT);
else
return FALSE;
}
他不断调用 CAsyncSocket::Accept （ CSocket派生自CAsyncSocket 类）判断Server 端socket 的事件队列中是否存在正在引入的连接事件- FD_ACCEPT （见1 ），换句话说，就是判断是否有来自Client 端socket 的连接请求。
如果当前 Server 端 socket 的事件队列中存在正在引入的连接事件，Accept 返回一个非0 值。否则， Accept 返回 0 ，此时调用GetLastError 将返回错误代码WSAEWOULDBLOCK ，表示队列中无所有连接请求。
注意到在循环体内有一句代码：
PumpMessage(FD_ACCEPT);
PumpMessage作为一个消息泵使得socket window 中的消息能够维持在活动状态。
实际跟踪进入 PumpMessage 中，发现这个消息泵和 Accept 函数的调用并不相关，他只是使非常少的socket window 消息（典型的是WM_PAINT 窗口重绘消息）处于活动状态，而绝大部分的socket window 消息被阻塞，被阻塞的消息中含有WM_SOCKET_NOTIFY 。
非常显然，如果没有来自 Client 端 socket 的连接请求， CSocket就会不断调用 Accept 产生循环阻塞，直到有来自 Client 端 socket 的连接请求而解除阻塞。
阻塞解除后，表示 Server 端 socket 和 Client 端 socket 已成功连接， Server 端和 Client 端彼此相互调用 Send 和 Receive方法开始通信。
3. 非阻塞模式
在非阻塞模式下利用 socket 事件的消息机制， Server 端和 Client 端之间的通信处于异步状态下。
通常需要从 CSocket 类派生一个新类，派生新类的目的是重载socket 事件的消息函数，然后在 socket 事件的消息函数中添入合适的代码以完成 Client 端和 Server 端之间的通信，和阻塞模式相比，非阻塞模式无需创建一个新线程。
这里将讨论当 Server 端 socket 事件－ FD_ACCEPT 被触发后，该事件的处理函数OnAccept 是怎么进一步被触发的。其他事件的处理函数如OnConnect, OnReceive 等的触发方式和此类似。
在 1 中已提到Client/Server 端通信时，Server 端socket 正在接收来自Client 端socket 连接请求，这将会触发FD_ACCEPT 事件，同时Server 端的网络传输服务进程向 Server 端的 socketwindow (CSocketWnd ）发送事件通知消息WM_SOCKET_NOTIFY , 通知有FD_ACCEPT 事件产生, CsocketWnd 在收到事件通知消息后，调用消息处理函数OnSocketNotify:
LRESULT CSocketWnd::OnSocketNotify(WPARAMwParam, LPARAM lParam)
{
CSocket::AuxQueueAdd(WM_SOCKET_NOTIFY, wParam, lParam);
CSocket::ProcessAuxQueue();
return 0L ;
}
消息参数 wParam 是 socket 的句柄， lParam 是 socket 事件。这里稍作解释一下， CSocketWnd 类是作为 CSocket类的友元类，这意味着他能访问 CSocket类中的保护和私有成员函数和变量，AuxQueueAdd 和ProcessAuxQueue 是CSocket 类的静态成员函数，如果你对友元不熟悉，请迅速找本有关C++ 书看一下友元的使用方法吧！
ProcessAuxQueue 是实质处理socket 事件的函数，在该函数中有这样一句代码：
CAsyncSocket* pSocket =CAsyncSocket::LookupHandle((SOCKET)wParam, TRUE);
其实也就是由 socket 句柄得到发送事件通知消息的 socket 指针 pSocket：从m_pmapSocketHandle 中查找（见1 ）！
最后， WSAGETSELECTEVENT(lParam) 会取出事件类型，在一个简单的switch 语句中判断事件类型并调用事件处理函数。
在这里，事件类型是FD_ACCEPT ，当然就调用pSocket->OnAccept ！
本文的结束：
Server 端 socket 处于阻塞调用模式下，他必须在一个新创建的线程中工作，防止主线程被阻塞。
当有多个 Client 端 socket 和 Server 端 socket 连接及通信时， Server 端采用阻塞模式就显得不适合了，应该采用非阻塞模式, 利用 socket 事件的消息机制来接受多个 Client 端 socket 的连接请求并进行通信。
在非阻塞模式下，利用 CSocketWnd 作为所有 sockets的消息池，是实现socket 事件的消息机制的关键技术。
文中存在用词不妥和可能存在的技术问题，请大家原谅，也请批评指正，谢谢！
注：
1. 当前模块状态
用于保存当前线程和模块状态的一个结构，能通过AfxGetThreadModule() 获得。AFX_MODULE_THREAD_STATE 在CSocket 重新定义为_AFX_SOCK_THREAD_STATE 。
2.socket 类型
在 TCP/IP 协议中，Client/Server 网络程式采用TCP 协议：即 socket 类型为 SOCK_STREAM，他是可靠的连接方式。在这里不采用UDP 协议：即 socket 类型为SOCK_DGRAM ，他是不可靠的连接方式。
从问题看本质：socket到底是什么？
分类： 4.网络与云2011-09-2210:32 2151人阅读 评论(1) 收藏 举报
socket数据结构服务器网络serverunix
一、问题的引入——socket的引入是为了解决不同计算机间进程间通信的问题
1.socket与进程的关系
1).socket与进程间的关系:socket 用来让一个进程和其他的进程互通信息(IPC)，而Socket接口是TCP/IP网络的API接口函数。
2).进程间通信（本机内）
进程间通信（不同计算机，要联网）
2、socket与文件的关系——如何理解socket是种特殊的I/O?
1）Socket最先应用于Unix操作系统,如果了解Unix系统的I/O的话，就很容易了解Socket了，因为Socket数据传输其实就是一种特殊的I/O。
2）可对其进行文件操作
3）有文件描述符。而文件描述符的本质是一个非负整数。只是用于区分。类似的还有进程ID。
3.服务器端口与连接个数的关系
1）服务端在8088上监听，然后生成一个新的socket与client通讯。(注意：服务器端监听端口是
不变的，但socket连接可以一直生成，一个线程对应一个socket.)
同一时刻，一个端口只能建立一个连接。
在一个端口监听，但是在监听端口的同时，生成一个等待队列，每一个来自客户端的连接都会送入等待队列中，服务器利用一定的算法进行选择相应的连接请求处理，所以在一个端口可以监听多各请求嘛。如果同时的连接过多，服务器相应每个连接的时间就会相应的变长。就会变慢。
2）QQ的实现方法就是在登陆的时候告诉服务器你已经登陆，发送消息的时候，首先你会发送一个包给服务器，服务器查看你需要发送的对方是否在线，如果在线就返回包告诉你对方在线，然后你就会和对方建立一个连接，然后直接发消息给对方，如果对方不在线，那么就会通过服务器转发你这次的消息
3）网络IO数与你的CPU数目一致将是比较好的选择（考虑到多线程多进程可以提高效率）。
没有必要每个客户分配一个端口。绝对是一种无谓的浪费。
4.有人知道socket监听的一个端口.最多可以有多少个客户连接?
1）listen()中有个参数，应该是确定并行连接客户数？！
2）The maximum length of the queue of pending connections. If this value is SOMAXCONN, then the underlying service provider responsible for socket s will set the backlog to a maximum "reasonable " value. There is no standard provision to find out the actual backlog value.
3）linux2.4下，最多可以有1024个socket连接
4）同时连接请求好像是5个（是连接请求，不是连接），可保持的链接理论上是65535（2字节的SOCKET端口号），
3.Socket是网络上运行的两个程序间双向通讯的一端，它既可以接受请求，也可以发送请求，利用它可以较为方便的编写网络上数据的传递。
5.问：现在server与client想建立socket连接，server仅知道client的IP，端口号不知道，能建立连接吗?怎么建立呢？有没有代码看看？
答：C和S是相对而言的，发起连接的一方就是C，而监听端口接受连接的一方就是S，C如果不知道S监听的端口，怎么发起连接呢，
另外，对于S而言，端口是S上各个服务的区分标志，如果用错误的端口号去连接，是不能获得正确的服务的。
client的端口是不需要指定的，Server绑定端口，然后监听，client使用server的IP和端口建立socket连接
6.精彩问答
问：看到的文章上说“每个网络通信循环地进出主计算机的TCP 应用层。它被两个所连接的号码唯一地识别。这两个号码合起来叫做套接字.组成套接字的这两个号码就是机器的IP 地址和TCP 软件所使用的端口号。”
又说“通过socket（）函数可以创建一个套接字，然后再把它绑定到端口号...”
那么套接字socket的概念究竟到哪里为止呢？是仅限于socket()返回的文件描述符？还是是IP和端口号的组合？如果是，那么socket()调用之后产生的套接字描述符的作用是什么呢？ 套接字描述符，IP地址，端口号三者间的关系是怎样的？
谢谢各位前辈解答。
答：一个socket句柄代表两个地址对 “本地ip:port”--“远程ip:port”
问：那么socket的概念到底到那里为止呢？比如，利用socket()可以产生一个套接字句柄，可是在bind() 或者 connect () 之前它只是一个文件描述符，和linux中其他的文件描述符一样。
如果说socket代表一个两个地址对，那么句柄的作用是不是仅仅是在bind() 或者 connect () 之后的用于区分和标记这样的地址对呢？因为这样他才能和网络的概念联系起来。这样的话，socket的意义应该是说用文件描述符描述的通信双方的IP地址和端口号地址对？（而文件描述符是区分这些地址对的标记？)
答：socket为内核对象，由操作系统内核来维护其缓冲区，引用计数，并且可以在多个进程中使用。
至于称它为“句柄”“文件描述符”都是一样的，它只不过是内核开放给用户进程使用的整数而已
问：谢谢楼上，是我没描述清楚。对于“句柄”和“文件描述符”我没有异议。
我想我的问题是在于句柄和ip、port的关系，不知道我这样说对否：
1. 每一个socket 本质上都是指一个ip地址和端口对
2. 为了操作这样的地址对，使用了文件描述符
3. socket（）函数只创建了一个普通的文件描述符，在进行bind（）或者connect()之前并不能说创建了用于网络通讯的套接字
4. 只有在进行了bind（）或者connect()之后socket才被创立起来
答：socket（）创建了一个socket内核对象。
accept或者connect后，才可以对socket句柄读写。因为只有在 connect或者bind,listen,accept后才会设置好socket内核对象里边的ip和端口
二、socket和端口理解
一个socket句柄代表两个地址对 “本地ip:port”--“远程ip:port”
在windows下叫句柄，在linux下叫文件描述符
socket为内核对象，由操作系统内核来维护其缓冲区，引用计数，并且可以在多个进程中使用。 至于称它为“句柄”“文件描述符”都是一样的
我假定读者已经对于socket连接的建立过程和各种状态转换比较熟悉了，因为这篇文档的目的是澄清概念，而不是介绍概念。
在使用socket编程时，我们都知道在网络通信以前首先要建立连接，而连接的建立是通过对socket的一些操作来完成的。那么，建立连接的过程大致可以分为以下几步：
1）建立socket套接字。
2）给套接字赋予地址，这个地址不是通常的网络地址的概念。
3）建立socket连接。
1．建立socket套接字。
使用socket建立套接字的时候，我们实际上是建立了一个数据结构。这个数据结构最主要
的信息是指定了连接的种类和使用的协议，此外还有一些关于连接队列操作的结构字段
（这里就先不涉及他们了）。
当我们使用socket函数以后，如果成功的话会返回一个int型的描述符，它指向前面那个
被维护在内核里的socket数据结构。我们的任何操作都是通过这个描述符而作用到那个数
据结构上的。这就像是我们在建立一个文件后得到一个文件描述符一样，对文件的操作都
是通过文件描述符来进行的，而不是直接作用到inode数据结构上。我之所以用文件描述
符举例，是因为socket数据结构也是和inode数据结构密切相关，它不是独立存在于内核
中的，而是位于一个VFS inode结构中。所以，有一些比较抽象的特性，我们可以用文件
操作来不恰当的进行类比以加深理解。
如前所述，当建立了这个套接字以后，我们可以获得一个象文件描述符那样的套接字描述
符。就象我们对文件进行操作那样，我们可以通过向套接字里面写数据将数据传送到我们
指定的地方，这个地方可以是远端的主机，也可以是本地的主机。如果你有兴趣的话，还
可以用socket机制来实现IPC，不过效率比较低，试试也就行了（我没有试过）。
2．给套接字赋予地址。
依照建立套接字的目的不同，赋予套接字地址的方式有两种：服务器端使用bind，客户端
使用connetc。
Bind:
我们都知道，只要使用IP, prot就可以区分一个tcp/ip连接（当然这个连接指的是一个
连接通道，如果要区分特定的主机间的连接，还需要第三个属性 hostname）。
我们可以使用bind函数来为一个使用在服务器端例程中的套接字赋予通信的地址和端口。
在这里我们称通信的IP地址和端口合起来构成了一个socket地址，而指定一个socket使
用特定的IP和port组合来进行通行的过程就是赋予这个socket一个地址。
要赋予socket地址，就得使用一个数据结构来指明特定的socket地址，这个数据结构就
是struct sockaddr。对它的使用我就不说了，因为这篇文档的目的是澄清概念而不是说
明使用方法。Bind函数的作用就是将这个特定的标注有socket地址信息的数据结构和
socket套接字联系起来，即赋予这个套接字一个地址。但是在具体实现上，他们两个是怎
么联系在一起的，我还不知道。
一个特定的socket的地址的生命期是bind成功以后到连接断开前。你可以建立一个
socket数据结构和socket地址的数据结构，但是在没有bind以前他们两个是没有关系
的，在bind以后他们两个才有了关系。这种关系一直维持到连接的结束，当一个连接结束
时，socket数据结构和socket地址的数据结构还都存在，但是他们两个已经没有关系
了。如果你要是用这个套接字在socket地址上重新进行连接时，需重新bind他们两个。再
注明一次，我说的这个连接是一个连接通道，而不是特定的主机之间的连接。
Bind指定的IP通常是本地IP（一般不特别指定，而使用INADDR_ANY来声明），而最主要
的作用是指定端口。在服务器端的socket进行了bind以后就是用listen来在这个socket
地址上准备进行连接。
connect:
对于客户端来说，是不会使用bind的（并不是不能用，但没什么意义），他们会通过
connet函数来建立socket和socket地址之间的关系。其中的socket地址是它想要连接的
服务器端的socket地址。在connect建立socket和socket地址两者关系的同时，它也在
尝试着建立远端的连接。
3．建立socket连接。
对于准备建立一个连接，服务器端要两个步骤：bind, listen；客户端一个步骤：
connct。如果服务器端accept一个connect，而客户端得到了这个accept的确认，那么
一个连接就建立了。
三、客户/服务器模式模式的理解
客户/服务器模式采取的是主动请求方式：
首先服务器方要先启动，并根据请求提供相应服务：
1. 打开一通信通道并告知本地主机，它愿意在某一公认地址上（周知口，如FTP为21）接收客户请求；
2. 等待客户请求到达该端口；
3. 接收到重复服务请求，处理该请求并发送应答信号。接收到并发服务请求，要激活一新进程来处理这个客户请求（如UNIX系统中用fork、exec）。新进程处理此客户请求，并不需要对其它请求作出应答。服务完成后，关闭此新进程与客户的通信链路，并终止。
4. 返回第二步，等待另一客户请求。
5. 关闭服务器
客户方：
1. 打开一通信通道，并连接到服务器所在主机的特定端口；
2. 向服务器发服务请求报文，等待并接收应答；继续提出请求......
3. 请求结束后关闭通信通道并终止。
从上面所描述过程可知：
1. 客户与服务器进程的作用是非对称的，因此编码不同。
2. 服务进程一般是先涌纪纪户请求而启动的。只要系统运行，该服务进程一直存在，直到正常或强迫终止。
半双工通信
即Half-duplexCommunication。这种通信方式可以实现双向的通信，但不能在两个方向上同时进行，必须轮流交替地进行。也就是说，通信信道的每一段都可以是发送端，也可以是接收端。但同一时刻里，信息只能有一个传输方向。如日常生活中的例子有步话机通信,对讲机等。
半双工传输的协议是称为线路规程的过程的一部分，它是OSI模型的第二层，数据链路层所包含的一项功能
MFC打开/保存文件对话框:CFileDialog
CFileDialog
文件选择对话框的使用：首先构造一个对象并提供相应的参数，构造函数原型如下：
CFileDialog::CFileDialog( BOOL bOpenFileDialog,
LPCTSTRlpszDefExt = NULL,
LPCTSTRlpszFileName = NULL,
DWORDdwFlags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
LPCTSTRlpszFilter = NULL,
CWnd*pParentWnd = NULL ,
DWORDdwSize = 0
);
参数意义如下：
bOpenFileDialog 为TRUE则显示打开对话框，为FALSE则显示保存对话文件对话框。
lpszDefExt 指定默认的文件扩展名。
lpszFileName 指定默认的文件名。
dwFlags 指明一些特定风格。
lpszFilter 是最重要的一个参数，它指明可供选择的文件类型和相应的扩展名。参数格式如：
"Chart Files (*.xlc)|*.xlc|Worksheet Files(*.xls)|*.xls|Data Files (*.xlc;*.xls)|*.xlc; *.xls|All Files (*.*)|*.*||";文件类型说明和扩展名间用 | 分隔，同种类型文件的扩展名间可以用 ; 分割，每种文件类型间用 | 分隔，末尾用 || 指明。
pParentWnd 为父窗口指针。
dwSize
The size of the OPENFILENAME structure. This value is dependent onthe operating system version, so MFC can determine the appropriate kind ofdialog box to create (for example, new Windows 2000 dialogs as opposed to NT4dialogs). The default size of 0 means that the MFC code will determine theproper dialog box size to use based on the operating system version on whichthe program is run.
创建文件对话框可以使用DoModal()，在返回后可以利用下面的函数得到用户选择：
CString CFileDialog::GetPathName( ) 得到完整的文件名，包括目录名和扩展名如：c: est est1.txt
CString CFileDialog::GetFileName( ) 得到完整的文件名，包括扩展名如：test1.txt
CString CFileDialog::GetExtName( ) 得到完整的文件扩展名，如：txt
CString CFileDialog::GetFileTitle ( ) 得到完整的文件名，不包括目录名和扩展名如：test1
POSITION CFileDialog::GetStartPosition( ) 对于选择了多个文件的情况得到第一个文件位置。
CString CFileDialog::GetNextPathName( POSITION& pos ) 对于选择了多个文件的情况得到下一个文件位置，并同时返回当前文件名。但必须已经调用过POSITION CFileDialog::GetStartPosition( )来得到最初的POSITION变量。
例如
{
CString
FilePathName;
CFileDialog dlg(TRUE);///TRUE为OPEN对话框，FALSE为SAVE AS对话框
//dlg.m_ofn.lpstrInitialDir=_T("d:\\"); //这里就设置了对话框的默认目录d盘
if(dlg.DoModal()==IDOK)
FilePathName=dlg.GetPathName();
}
相关信息：CFileDialog用于取文件名的几个成员函数：
假如选择的文件是C:WINDOWSTEST.EXE
则:
(1)GetPathName();取文件名全称，包括完整路径。取回C:WINDOWSTEST.EXE
(2)GetFileTitle();取文件全名：TEST.EXE
(3)GetFileName();取回TEST
(4)GetFileExt();取扩展名EXE
setsockopt的各种使用
1. 如果在已经处于 ESTABLISHED状态下的socket(一般由端口号和标志符区分）调用
closesocket（一般不会立即关闭而经历TIME_WAIT的过程）后想继续重用该socket：
BOOL bReuseaddr=TRUE;
setsockopt(s,SOL_SOCKET ,SO_REUSEADDR,(const char*)&bReuseaddr,sizeof(BOOL));
2. 如果要已经处于连接状态的soket在调用closesocket后强制关闭，不经历
TIME_WAIT的过程：
BOOL bDontLinger = FALSE;
setsockopt(s,SOL_SOCKET,SO_DONTLINGER,(const char*)&bDontLinger,sizeof(BOOL));
3.在send(),recv()过程中有时由于网络状况等原因，发收不能预期进行,而设置收发时限：
int nNetTimeout=1000;//1秒
//发送时限
setsockopt(socket，SOL_S0CKET,SO_SNDTIMEO，(char *)&nNetTimeout,sizeof(int));
//接收时限
setsockopt(socket，SOL_S0CKET,SO_RCVTIMEO，(char *)&nNetTimeout,sizeof(int));
4.在send()的时候，返回的是实际发送出去的字节(同步)或发送到socket缓冲区的字节
(异步);系统默认的状态发送和接收一次为8688字节(约为8.5K)；在实际的过程中发送数据
和接收数据量比较大，可以设置socket缓冲区，而避免了send(),recv()不断的循环收发：
// 接收缓冲区
int nRecvBuf=32*1024;//设置为32K
setsockopt(s,SOL_SOCKET,SO_RCVBUF,(const char*)&nRecvBuf,sizeof(int));
//发送缓冲区
int nSendBuf=32*1024;//设置为32K
setsockopt(s,SOL_SOCKET,SO_SNDBUF,(const char*)&nSendBuf,sizeof(int));
5. 如果在发送数据的时，希望不经历由系统缓冲区到socket缓冲区的拷贝而影响
程序的性能：
int nZero=0;
setsockopt(socket，SOL_S0CKET,SO_SNDBUF，(char *)&nZero,sizeof(nZero));
6.同上在recv()完成上述功能(默认情况是将socket缓冲区的内容拷贝到系统缓冲区)：
int nZero=0;
setsockopt(socket，SOL_S0CKET,SO_RCVBUF，(char *)&nZero,sizeof(int));
7.一般在发送UDP数据报的时候，希望该socket发送的数据具有广播特性：
BOOL bBroadcast=TRUE;
setsockopt(s,SOL_SOCKET,SO_BROADCAST,(const char*)&bBroadcast,sizeof(BOOL));
8.在client连接服务器过程中，如果处于非阻塞模式下的socket在connect()的过程中可
以设置connect()延时,直到accpet()被呼叫(本函数设置只有在非阻塞的过程中有显著的
作用，在阻塞的函数调用中作用不大)
BOOL bConditionalAccept=TRUE;
setsockopt(s,SOL_SOCKET,SO_CONDITIONAL_ACCEPT,(const char*)&bConditionalAccept,sizeof(BOOL));
9.如果在发送数据的过程中(send()没有完成，还有数据没发送)而调用了closesocket(),以前我们
一般采取的措施是"从容关闭"shutdown(s,SD_BOTH),但是数据是肯定丢失了，如何设置让程序满足具体
应用的要求(即让没发完的数据发送出去后在关闭socket)？
struct linger {
u_short l_onoff;
u_short l_linger;
};
linger m_sLinger;
m_sLinger.l_onoff=1;//(在closesocket()调用,但是还有数据没发送完毕的时候容许逗留)
// 如果m_sLinger.l_onoff=0;则功能和2.)作用相同;
m_sLinger.l_linger=5;//(容许逗留的时间为5秒)
setsockopt(s,SOL_SOCKET,SO_LINGER,(const char*)&m_sLinger,sizeof(linger));
Note:1.在设置了逗留延时，用于一个非阻塞的socket是作用不大的，最好不用;
2.如果想要程序不经历SO_LINGER需要设置SO_DONTLINGER，或者设置l_onoff=0；
10.还一个用的比较少的是在SDI或者是Dialog的程序中，可以记录socket的调试信息：
(前不久做过这个函数的测试，调式信息可以保存，包括socket建立时候的参数,采用的
具体协议，以及出错的代码都可以记录下来）
BOOL bDebug=TRUE;
setsockopt(s,SOL_SOCKET,SO_DEBUG,(const char*)&bDebug,sizeof(BOOL));
11.附加：往往通过setsockopt()设置了缓冲区大小，但还不能满足数据的传输需求，
我的习惯是自己写个处理网络缓冲的类，动态分配内存;下面我将这个类写出，希望对
初学者有所帮助：
使用CFile类对文件进行读写
2011-05-27 09:55 2028人阅读 评论(0) 收藏 举报
mfcfilewindowsc磁盘api
CFile类提供了对文件进行打开，关闭，读，写，删除，重命名以及获取文件信息等文件操作的基本功能，足以处理任意类型的文件操作
一个读写文件的例子：
文件I/O
虽然使用CArchive类内建的序列化功能是保存和加载持久性数据的便捷方式，但有时在程序中需要对文件处理过程拥有更多的控制权，对于这种文件输入输出（I/O）服务的需求，Windows提供了一系列相关的API函数，并由MFC将其封装为CFile类，提供了对文件进行打开，关闭，读，写，删除，重命名以及获取文件信息等文件操作的基本功能，足以处理任意类型的文件操作。CFile类是MFC文件类的基类，支持无缓冲的二进制输入输出，也可以通过与CArchive类的配合使用而支持对MFC对象的带缓冲的序列化。
CFile类包含有一个公有型数据成员m_hFile，该数据成员包含了同CFile类对象相关联的文件句柄。如果没有指定句柄，则该值为CFile::hFileNull。由于该数据成员所包含的意义取决于派生的类，因此一般并不建议使用m_hFile。
通过CFile类来打开文件可以采取两种方式：一种方式是先构造一个CFile类对象然后再调用成员函数Open（）打开文件，另一种方式则直接使用CFile类的构造函数去打开一个文件。下面的语句分别演示了用这两种方法打开磁盘文件“C:/TestFile.txt”的过程：
// 先构造一个实例，然后再打开文件
CFile file;
file.Open(“C://TestFile.txt”, CFile::modeReadWrite);
……
// 直接通过构造函数打开文件
CFile file(“C://TestFile.txt”, CFile::modeReadWrite);
其中参数CFile::modeReadWrite是打开文件的模式标志，CFile类中与之类似的标志还有十几个，现集中列表如下：
文件模式标志说明
CFile::modeCreate 创建方式打开文件，如文件已存在则将其长度设置为0
CFile::modeNoInherit 不允许继承
CFile::modeNoTruncate 创建文件时如文件已存在不对其进行截断
CFile::modeRead 只读方式打开文件
CFile::modeReadWrite 读写方式打开文件
CFile::modeWrite 写入方式打开文件
CFile::shareCompat 在使用过程中允许其他进程同时打开文件
CFile::shareDenyNone 在使用过程中允许其他进程对文件进行读写
CFile::shareDenyRead 在使用过程中不允许其他进程对文件进行读取
CFile::shareDenyWrite 在使用过程中不允许其他进程对文件进行写入
CFile::shareExclusive 取消对其他进程的所有访问
CFile::typeBinary 设置文件为二进制模式
CFile::typeText 设置文件为文本模式
这些标志可以通过“或”运算符而同时使用多个，并以此来满足多种需求。例如，需要以读写方式打开文件，如果文件不存在就创建一个新的，如果文件已经存在则不将其文件长度截断为0。为满足此条件，可用CFile::modeCreate、CFile::modeReadWrite和CFile::modeNoTruncate等几种文件模式标志来打开文件：
CFilefile ("C://TestFile.txt", CFile::modeCreate | CFile::modeReadWrite |CFile::modeNoTruncate);
在打开的文件不再使用时需要将其关闭，即可以用成员函数Close（）关闭也可以通过CFile类的析构函数来完成。当采取后一种方式时，如果文件还没有被关闭，析构函数将负责隐式调用Close（）函数去关闭文件，这也表明创建在堆上的CFile类对象在超出范围后将自动被关闭。由于调用了对象的析构函数，因此在文件被关闭的同时CFile对象也被销毁，而采取Close（）方式关闭文件后，CFile对象仍然存在。所以，在显式调用Close（）函数关闭一个文件后可以继续用同一个CFile对象去打开其他的文件。
文件读写是最常用的文件操作方式，主要由CFile类成员函数Read（）、Write（）来实现。其函数原型分别为：
UINTRead( void* lpBuf, UINT nCount );
void Write( const void* lpBuf, UINT nCount );
参数lpBuf为指向存放数据的缓存的指针，nCount为要读入或写入的字节数，Read（）返回的为实际读取的字节数，该数值小于或等于nCount，如果小于nCount则说明已经读到文件末尾，可以结束文件读取，如继续读取，将返回0。因此通常可以将实际读取字节数是否小于指定读取的字节数或是否为0作为判断文件读取是否到达结尾的依据。下面这段代码演示了对文件进行一次性写入和循环多次读取的处理过程：
// 创建、写入方式打开文件
CFile file;
file.Open("C://TestFile.txt", CFile::modeWrite | CFile::modeCreate);
// 写入文件
memset(WriteBuf, 'a', sizeof(WriteBuf));
file.Write(WriteBuf, sizeof(WriteBuf));
// 关闭文件
file.Close();
// 只读方式打开文件
file.Open("C://TestFile.txt", CFile::modeRead);
while (true)
{
// 读取文件数据
int ret = file.Read(ReadBuf, 100);
……
// 如果到达文件结尾则中止循环
if (ret < 100)
break;
}
// 关闭文件
file.Close();
Write（）和Read（）函数执行完后将自动移动文件指针，因此不必再显示调用Seek（）函数去定位文件指针。包含有文件定位函数的完整代码如下所示：
// 创建、写入方式打开文件
CFile file;
file.Open("C://TestFile.txt", CFile::modeWrite | CFile::modeCreate);
// 写入文件
memset(WriteBuf, 'a', sizeof(WriteBuf));
file.SeekToBegin();
file.Write(WriteBuf, sizeof(WriteBuf));
// 关闭文件
file.Close();
// 只读方式打开文件
file.Open("C://TestFile.txt", CFile::modeRead);
while (true)
{
// 文件指针
static int position = 0;
// 移动文件指针
file.Seek(position, CFile::begin);
// 读取文件数据
int ret = file.Read(ReadBuf, 100);
position += ret;
……
// 如果到达文件结尾则中止循环
if (ret < 100)
break;
}
// 关闭文件
file.Close();
补充：
使用CFile类对文件进行按结构读取,如：
CFilefileRead,fileWrite;
fileRead.Open(_T("E://a.dat"),CFile::modeRead);//这里使用宏_T
fileWrite.Open(_T("E://backup.txt"),CFile::modeCreate |CFile::modeWrite);
VIDEOHEADER *videoheader=new VIDEOHEADER();
fileRead.Read(videoheader,sizeof(VIDEOHEADER));
charbuf[sizeof(VIDEOHEADER)*8];
sprintf(buf,"videoheader.cCommandID:%s ,videoheader->cCommandID);通过sprintf对我们需要写入文件中的数据进行格式化，这样在文件中存储的数据就是以这里定义的格式显示的。
MFC同步类
· CCriticalSection 临界区：在用户模式工作 ( 遇到加锁等待时会进入内核模式 ) ，使用与保护线程间共享资源，一个线程可以多次 Lock 不会错。不支持在多进程之间工作。将一段代码置入临界区，只允许最多一个线程进入执行这段代码。一个临界区仅在创建它的进程中有效。
· CMutex 互斥量：在内核模式工作，除支持临界区的功能外，还可以为互斥量命名，以便在多进程中工作。互斥量比临界区耗资源。一个时刻至多只允许一个线程访问某资源，未被占用时处于有信号状态，可以实现对共享资源的互斥访问。
· CEvent 事件：在内核模式工作，适用于某一线程等待某事件发生才执行的场合。
· CSemaphore 信号量 ( 信号灯 ) ：在内核模式工作，适用于允许特定个数的线程执行某任务。允许一定数目的线程访问某个共享资源，常用来控制访问共享资源的线程数量。
同步对象的适用场合
· 1.如果某个线程必须等待某些事件发生后才能存取相应的资源，则用 CEvent
· 2.如果一个应用程序同时可以有多个线程存取相应资源，则用 CSemaphore
· 3.如果多个应用程序 ( 多个线程 ) 同时存取相应资源，则用 CMutex ，否则用CCriticalSection
等待类CSingleLock
一个 CSingleLock 类对象代表一种访问控制机制，这种机制用于控制在一个多线程程序中对一个资源的访问。为了使用同步类 CSemaphore 、 CMutex 、 CCriticalSection 、CEvent 所创建的同步对象，你必须创建一个 CSingleLock 或者 CMultiLock 对象来等待和释放这个同步对象。当你只需要每次等待一个对象时，则用 CsingleLock ，否则用CMultiLock 。
要使用一个 CSingleLock 对象，在被控制资源的类中的一个成员函数内部调用CSingleLock 的构造函数。然后调用 IsLock 成员函数来确定这个资源是否可用。如果资源是可用的，则继续该成员函数的其余部分。
CSingleLock::CSingleLock( CSyncObject* pObject, BOOL bInitialLock = FALSE );
pObject 指向要被访问的同步对象。不能是NULL
bInitialLock 指示是否要在最初尝试访问所提供的对象
BOOL CSingleLock::IsLocked()
返回值：如果对象被加锁则返回非零值；否则返回0。此成员函数用来确定与CSingleLock对象相关的对象是否没有发信号（不能使用）。
BOOL CSingleLock::Lock( DWORD dwTimeOut = INFINITE );
返回值：如果函数成功则返回非零值；否则返回0。
参数：dwTimeOut 指定等待要被利用的同步对象的时间数量。如果是INFINITE，则Lock等待直到该对象在返回之前可用。
说明：此成员函数用来获取对由同步对象控制的资源的访问，这个访问要提供给CSingleLock构造函数。如果同步对象是可用的，Lock将成功返回，而且线程拥有了该对象。如果此同步对象是不可用的，则Lock将等待此同步对象在dwTimeOut参数指定的时间内变为可用。如果此同步对象在指定的时间内没有变为可用的，则Lock返回失败。
BOOL CSingleLock::Unlock( );
BOOL CSingleLock::Unlock( LONG lCount, LPLONG lPrevCount = NULL );
返回值：如果函数成功则返回非零值；否则返回0。
参数： lCount:要释放的访问数目。必须要大于0。如果指定的数量要导致对象的计数超过它的最大值，则计数不改变，并且函数返回FALSE。
lPrevCount:指向一个用来接收同步对象的先前计数的变量。如果是NULL，则不返回先前的计数。
说明：此成员函数用来释放由CSingleLock拥有的同步对象。由CSingleLock的析构函数类调用这个函数。如果你需要释放一个信号的多于一个的访问计数，可以使用Unlock的第二种形式，并指定要释放的访问数目。
在 MFC 中，具有等待功能的类 CSingleLock 和 CMultiLock 封装了 Win32 中的等待函数WaitForSingleObject() 和 WaitForMultipleObjects()
TTS
TTS的全称为Text To Speech，即“从文本到语音”。它是同时运用语言学和心理学的杰出之作，在内置芯片的支持之下，通过神经网络的设计，把文字智能地转化为自然语音流。
TTS技术对文本文件进行实时转换，转换时间之短可以秒计算。在其特有智能语音控制器作用下，文本输出的语音音律流畅，使得听者在听取信息时感觉自然，毫无机器语音输出的冷漠与生涩感。TTS语音合成技术即将覆盖国标一、二级汉字，具有英文接口，自动识别中、英文，支持中英文混读。所有声音采用真人普通话为标准发音，实现了120-150个汉字/秒的快速语音合成，朗读速度达3-4个汉字/秒，使用户可以听到清晰悦耳的音质和连贯流畅的语调。
-qws命令
运行嵌入式程序
在嵌入式QT版本中，程序需要服务器或自己作为服务器程序。服务器程序构造的方法是构造一个QApplication::GuiServe类型的QApplication对象。或者使用-qws命令选项启动程序。
Using a Single Display
使用-qws选项
接下来的程序可以当做客户端来运行，只要不使用-qws选项。那么客户端程序就会自动连接到服务程序中。
using Mutiple Displays
嵌入式版本中运行多个县市同时运行。两种方式可以实现，要么多次运行服务程序，要么使用read-mae Multi screen driver
当多个服务程序运行时，每个程序必须使用-display选项指定显示驱动，或者使用QWS_DISPLAY环境变量来指定。
服务程序运行时：
./mysecondserverapplication -qws -display"QVFb:2"
客户程序运行时：
./myclientapplication -display"QVFb:2"
若想在不同显示器移动应用程序，则只能通过Muti显示器实现。
./myserverapplication -qws -display"Multi: QVFb:0
QVFb:1:offset=0,0 VNC:offset=640,0 :2"
程序启动命令选项：
-fn 定义程序的字体，例如./myapplication -fn helvetica
-bg 设置程序默认背景颜色例如./myapplication -bg blue，颜色名称必须能被QColor类构造函数识别
-btn 设置默认的按钮颜色，例如./myapplication -btn green 同样颜色必须被认识
-fg 设置foreground颜色，例如./myapplication -fg 'dark blue' 同上需被认识
-name 设置应用程序名字例如./myapplication -nametexteditapplication
-title
设置应用程序标题。./myapplication -title 'Text Edit'</p>
<p> </p>
<p>-geometry<width>x<height>+<Xoffset>+<Yoffset></p>
<p>设置窗口大小， ./myapplication-geometry 300x200+50+50</p>
<p> </p>
<p>-keyboard 启动键盘</p>
<p> </p>
<p>-nokeyboard 关闭键盘</p>
<p> </p>
<p>-mouse 启动鼠标</p>
<p> </p>
<p>-nomouse 关闭鼠标</p>
<p> </p>
<p>-qws 设置为服务程序</p>
<p> </p>
<p>-display 设置显示器驱动</p>
<p> </p>
<p>-decoration<style></p>
<p>设置程序的风格，例如./myapplication-decoration windows，只支持windows default styled</p>
<h2>ultraedit 自动缩进修改 </h2>
<p>2011-04-29 18:31:41| 分类： <span style="color:windowtext">教程技巧</span>|字号 订阅</p>
<p>经常在一行之后回车,或者在if else之后回车,光标不是和上一行对齐,而是向后移动了4个空格(如果是设置是4的话),这样看起来让人很不爽,</p>
<p>自动缩进的修改点,有三个地方,作用不一,自己去体会</p>
<p>1.高级-》配置-》编辑器显示-》格式化</p>
<p>2.找到wordfile.uew 文件进行修改,</p>
<p>一般wordfile.uew 文件的目录是C:\Documents andSettings\***\Application Data\IDMComp\UltraEdit\而不是你的安装目录</p>
<p><br> 找到/IndentStrings = "{" "if" "else"":" </p>
<p>把 if, else, :去掉就可以了 </p>
<p>然后重新启动ultraedit.</p>
<p>3.艺术样式</p>
<p><span style="color:windowtext">http://hi.baidu.com/begin_think/blog/item/a40f4a2eeb9af7341e308976.html</span> </p>
<p> 工作的时候，要经常拿到别人的代码来改，有些人不太注重编程风格，代码看上去很乱，所以不得不用一些自动排格式的软件先来“格式化”一下，以前我总用VC来排，可是用VC始终感觉太麻烦，而且它的排版功能太死板了，跟自己的风格有些差别，所以想到用UE来试试，没想到真的能改出和自己编程的风格类似的代码。下面就说说我是如何设置UE让它能按我的想法来排版的：</p>
<p><br> 首先单击帮助工具栏（根据设置的不同可能在其他工具栏上）上的“艺术样式”按钮，<br> <br> 弹出如下对话框<br> <br> 然后就可以按照自己的习惯设置缩进的方式了，如果对排版没有特别的要求，默认的选择就可以了，在这种设置状态下，switch后的case是不会缩进的，如果要让case缩进，那么需要选中切换或大小写（就是switch和case，翻译的问题），最好不要两个都选，否则case会缩进两个单位，如果要case后的语句也缩进就选切换，如果只缩进case就选大小写，按照我的习惯是选择切换。其他的选择就看程序员自己的习惯了。<br> 样式我选择的是ANSI，除了GUN，到没有感觉和其他样式有什么区别，有时间再来研究下吧。<br> UE默认情况下制表符是占两个空格，习惯四个空格的可以选菜单栏中的高级-配置-编辑器-自动换行/制表符设置，将缩进空格改为4就可以了。</p>
<h2>typedef 函数指针的用法</h2>
<p><span style="color:#3366FF">在网上搜索函数指针，看到一个例子。开始没看懂，想放弃，可是转念一想，这个用法迟早要弄懂的，现在多花点时间看懂它，好过以后碰到了要再花一倍时间来弄懂它。其实很多时候都是这样，如果每次到难一点的内容，总想着下次我再来解决它，那就永远也学不到东西。</span></p>
<p><span style="color:#3366FF">后面那个例子加了注释，是我对这种用法的理解，希望对新手有所帮助。</span></p>
<p>进入正文：</p>
<p> <strong><span style="color:maroon">代码简化</span></strong>, 促进跨平台开发的目的.</p>
<p> typedef 行为有点像 #define 宏，用其实际类型替代同义字。</p>
<p> 不同点：typedef 在<strong><span style="color:maroon">编译时被解释</span></strong>，因此让编译器来应付<strong><span style="color:maroon">超越预处理器能力的文本替换</span></strong>。</p>
<p><strong><span style="color:purple">用法一：</span></strong></p>
<p><strong><span style="color:purple">typedef</span> <span style="color:purple">int</span></strong> (*MYFUN)<strong><span style="color:purple">(int, int)</span></strong>; <br> 这种用法一般用在给<strong><span style="color:maroon">函数定义别名</span></strong>的时候<br> 上面的例子定义<strong><span style="color:#003300">MYFUN</span> </strong>是一个<strong><span style="color:#003300">函数指针</span></strong>, 函数类型是带两个int 参数, 返回一个int <br> <br> 在<strong><span style="color:#003300">分析</span></strong>这种形式的定义的时候可以用下面的方法: <br> <strong>先去掉<span style="color:#003300">typedef </span><span style="color:#003300">和别名</span></strong>, <strong><span style="color:#003300">剩下的就是原变量的类型</span><span style="color:#003300">.</span> <br> <span style="color:#003300">去掉</span><span style="color:#003300">typedef</span><span style="color:#003300">和</span><span style="color:#003300">MYFUN</span><span style="color:#003300">以后就剩</span><span style="color:#003300">:</span></strong> <br> int (*)(int, int)</p>
<p><strong><span style="color:purple">用法二：</span></strong></p>
<p>typedef给变量类型定义一个<strong><span style="color:purple">别名</span></strong>.</p>
<p><strong><span style="color:maroon">typedef</span></strong> struct{ <br> int a; <br> int b; <br> }<strong><span style="color:maroon">MY_TYPE</span></strong>; <br> <br> 这里把一个未命名结构直接取了一个叫MY_TYPE的别名, 这样如果你想定义结构的实例的时候就可以这样: <br> MY_TYPE tmp;</p>
<p><strong>第二种用法<span style="color:#003300">：</span><span style="color:#003300">typedef</span> <span style="color:#3366FF">原变量类型</span> <span style="color:#333300">别名</span></strong></p>
<p>简单的函数指针的用法</p>
<p>//形式1：返回类型（*函数名）（参数表）</p>
<p>char（*pFun)(int);</p>
<p>//<strong><span style="color:maroon">typedef</span> <span style="color:purple">char(*</span></strong>pFun<strong><span style="color:purple">)(int) //</span><span style="color:purple">跟上一行功能等同</span></strong></p>
<p><strong><span style="color:purple">/*typedef</span><span style="color:purple">的功能是</span><span style="color:maroon">定义新的类型</span><span style="color:purple">。第一句就是定义了一种</span><span style="color:purple">PTRFUN</span><span style="color:purple">的类型，并定义这种类型为</span><span style="color:maroon">指向某种函数的指针</span><span style="color:purple">，这种函数以一个</span><span style="color:purple">int</span><span style="color:purple">为参数并返回</span><span style="color:purple">char</span><span style="color:purple">类型。</span><span style="color:purple">*/</span></strong></p>
<p>char glFun(int a){return;}</p>
<p>void main()</p>
<p>{</p>
<p>pFun =glFun;</p>
<p>(*pFun)(2);</p>
<p>}</p>
<p>第一行定义了一个指针变量<strong><span style="color:maroon">pFun</span></strong>.它是一个指向某种函数的指针，这种函数参数是一个int类型，返回值是char类型。<strong>只有第一句我们还无法使用这个指针，因为我们还未对它进行<span style="color:maroon">赋值</span></strong>。</p>
<p>第二行定义了一个函数<strong><span style="color:maroon">glFun().</span></strong>该函数正好是一个以int为参数返回char的函数。我们要从指针的层次上理解函数-<strong><span style="color:maroon">函数的函数名实际上就是一个指针</span></strong>，<strong><span style="color:maroon">函数名</span></strong>指向<strong><span style="color:maroon">该函数的代码在内存中的首地址</span></strong>。</p>
<p>下面是一个例子：</p>
<p style="background:rgb(248,248,248)"><span style="color:silver">C</span><span style="color:silver">代码</span><span style="color:silver"> </span><span style="color:silver"></span></p>
<div style="background:#F8F8F8">
<p><span style="color:#5C5C5C">1. </span><span style="color:#008200">//#include<iostream.h> </span> </p>
<p><span style="color:#5C5C5C">2. </span><span style="color:gray">#include<stdio.h> </span> </p>
<p><span style="color:#5C5C5C">3. </span> </p>
<p><span style="color:#5C5C5C">4. </span><strong><span style="color:#7F0055">typedef</span> <span style="color:seagreen">int</span></strong> (*FP_CALC)(<strong><span style="color:seagreen">int</span></strong>, <strong><span style="color:seagreen">int</span></strong>); </p>
<p><span style="color:#5C5C5C">5. </span><span style="color:#008200">//</span><span style="color:#008200">注意这里不是函数声明而是函数定义，它是一个地址，你可以直接输出</span><span style="color:#008200">add</span><span style="color:#008200">看看</span><span style="color:#008200"> </span> </p>
<p><span style="color:#5C5C5C">6. </span><strong><span style="color:seagreen">int</span></strong> add(<strong><span style="color:seagreen">int</span></strong> a, <strong><span style="color:seagreen">int</span></strong> b) </p>
<p><span style="color:#5C5C5C">7. </span>{ </p>
<p><span style="color:#5C5C5C">8. </span> <strong><span style="color:#7F0055">return</span></strong> a + b; </p>
<p><span style="color:#5C5C5C">9. </span>} </p>
<p><span style="color:#5C5C5C">10. </span><strong><span style="color:seagreen">int</span></strong> sub(<strong><span style="color:seagreen">int</span></strong> a, <strong><span style="color:seagreen">int</span></strong> b) </p>
<p><span style="color:#5C5C5C">11. </span>{ </p>
<p><span style="color:#5C5C5C">12. </span> <strong><span style="color:#7F0055">return</span></strong> a - b; </p>
<p><span style="color:#5C5C5C">13. </span>} </p>
<p><span style="color:#5C5C5C">14. </span><strong><span style="color:seagreen">int</span></strong> mul(<strong><span style="color:seagreen">int</span></strong> a, <strong><span style="color:seagreen">int</span></strong> b) </p>
<p><span style="color:#5C5C5C">15. </span>{ </p>
<p><span style="color:#5C5C5C">16. </span> <strong><span style="color:#7F0055">return</span></strong> a * b; </p>
<p><span style="color:#5C5C5C">17. </span>} </p>
<p><span style="color:#5C5C5C">18. </span><strong><span style="color:seagreen">int</span></strong> div(<strong><span style="color:seagreen">int</span></strong> a, <strong><span style="color:seagreen">int</span></strong> b) </p>
<p><span style="color:#5C5C5C">19. </span>{ </p>
<p><span style="color:#5C5C5C">20. </span> <strong><span style="color:#7F0055">return</span></strong> b? a/b : -1; </p>
<p><span style="color:#5C5C5C">21. </span>} </p>
<p><span style="color:#5C5C5C">22. </span><span style="color:#008200">//</span><span style="color:#008200">定义一个函数，参数为</span><span style="color:#008200">op</span><span style="color:#008200">，返回一个指针。该指针类型为</span><span style="color:#008200">拥有两个</span><span style="color:#008200">int</span><span style="color:#008200">参数、</span><span style="color:#008200"> </span> </p>
<p><span style="color:#5C5C5C">23. </span><span style="color:#008200">//</span><span style="color:#008200">返回类型为</span><span style="color:#008200">int </span><span style="color:#008200">的函数指针。它的作用是根据操作符返回相应函数的地址</span><span style="color:#008200"> </span> </p>
<p><span style="color:#5C5C5C">24. </span>FP_CALC calc_func(<strong><span style="color:seagreen">char</span></strong> op) </p>
<p><span style="color:#5C5C5C">25. </span>{ </p>
<p><span style="color:#5C5C5C">26. </span> <strong><span style="color:#7F0055">switch</span></strong> (op) </p>
<p><span style="color:#5C5C5C">27. </span> { </p>
<p><span style="color:#5C5C5C">28. </span> <strong><span style="color:#7F0055">case</span></strong> <span style="color:blue">'+'</span>: <strong><span style="color:#7F0055">return</span></strong> add;<span style="color:#008200">//</span><span style="color:#008200">返回函数的地址</span><span style="color:#008200"> </span> </p>
<p><span style="color:#5C5C5C">29. </span> <strong><span style="color:#7F0055">case</span></strong> <span style="color:blue">'-'</span>: <strong><span style="color:#7F0055">return</span></strong> sub; </p>
<p><span style="color:#5C5C5C">30. </span> <strong><span style="color:#7F0055">case</span></strong> <span style="color:blue">'*'</span>: <strong><span style="color:#7F0055">return</span></strong> mul; </p>
<p><span style="color:#5C5C5C">31. </span> <strong><span style="color:#7F0055">case</span></strong> <span style="color:blue">'/'</span>: <strong><span style="color:#7F0055">return</span></strong> div; </p>
<p><span style="color:#5C5C5C">32. </span> <strong><span style="color:#7F0055">default</span></strong>: </p>
<p><span style="color:#5C5C5C">33. </span> <strong><span style="color:#7F0055">return</span></strong> NULL; </p>
<p><span style="color:#5C5C5C">34. </span> } </p>
<p><span style="color:#5C5C5C">35. </span> <strong><span style="color:#7F0055">return</span></strong> NULL; </p>
<p><span style="color:#5C5C5C">36. </span>} </p>
<p><span style="color:#5C5C5C">37. </span><span style="color:#008200">//s_calc_func</span><span style="color:#008200">为函数，它的参数是</span><span style="color:#008200"> op</span><span style="color:#008200">，</span><span style="color:#008200"> </span> </p>
<p><span style="color:#5C5C5C">38. </span><span style="color:#008200">//</span><span style="color:#008200">返回值为一个拥有</span><span style="color:#008200">两个</span><span style="color:#008200">int</span><span style="color:#008200">参数、返回类型为</span><span style="color:#008200">int </span><span style="color:#008200">的函数指针</span><span style="color:#008200"> </span> </p>
<p><span style="color:#5C5C5C">39. </span><strong><span style="color:seagreen">int</span></strong> (*s_calc_func(<strong><span style="color:seagreen">char</span></strong> op)) (<strong><span style="color:seagreen">int</span></strong>, <strong><span style="color:seagreen">int</span></strong>) </p>
<p><span style="color:#5C5C5C">40. </span>{ </p>
<p><span style="color:#5C5C5C">41. </span> <strong><span style="color:#7F0055">return</span></strong> calc_func(op); </p>
<p><span style="color:#5C5C5C">42. </span>} </p>
<p><span style="color:#5C5C5C">43. </span><span style="color:#008200">//</span><span style="color:#008200">最终用户直接调用的函数，该函数接收两个</span><span style="color:#008200">int</span><span style="color:#008200">整数，和一个算术运算符，返回两数的运算结果</span><span style="color:#008200"> </span> </p>
<p><span style="color:#5C5C5C">44. </span><strong><span style="color:seagreen">int</span></strong> calc(<strong><span style="color:seagreen">int</span></strong> a, <strong><span style="color:seagreen">int</span></strong> b, <strong><span style="color:seagreen">char</span></strong> op) </p>
<p><span style="color:#5C5C5C">45. </span>{ </p>
<p><span style="color:#5C5C5C">46. </span> FP_CALC fp =calc_func(op); <span style="color:#008200">//</span><span style="color:#008200">根据预算符得到各种运算的函数的地址</span><span style="color:#008200"> </span> </p>
<p><span style="color:#5C5C5C">47. </span> <strong><span style="color:seagreen">int</span></strong> (*s_fp)(<strong><span style="color:seagreen">int</span></strong>, <strong><span style="color:seagreen">int</span></strong>) = s_calc_func(op);<span style="color:#008200">//</span><span style="color:#008200">用于测试</span><span style="color:#008200"> </span> </p>
<p><span style="color:#5C5C5C">48. </span> <span style="color:#008200">// ASSERT(fp ==s_fp); // </span><span style="color:#008200">可以断言这俩是相等的</span><span style="color:#008200"> </span> </p>
<p><span style="color:#5C5C5C">49. </span> <strong><span style="color:#7F0055">if</span></strong> (fp) <strong><span style="color:#7F0055">return</span></strong> fp(a, b);<span style="color:#008200">//</span><span style="color:#008200">根据上一步得到的函数的地址调用相应函数，并返回结果</span><span style="color:#008200"> </span> </p>
<p><span style="color:#5C5C5C">50. </span> <strong><span style="color:#7F0055">else</span> <span style="color:#7F0055">return</span></strong> -1; </p>
<p><span style="color:#5C5C5C">51. </span>} </p>
<p><span style="color:#5C5C5C">52. </span> </p>
<p><span style="color:#5C5C5C">53. </span><strong><span style="color:#7F0055">void</span></strong> main() </p>
<p><span style="color:#5C5C5C">54. </span>{ </p>
<p><span style="color:#5C5C5C">55. </span> <strong><span style="color:seagreen">int</span></strong> a = 100, b = 20; </p>
<p><span style="color:#5C5C5C">56. </span> </p>
<p><span style="color:#5C5C5C">57. </span> printf(<span style="color:blue">"calc(%d, %d, %c)= %d\n"</span>, a, b, <span style="color:blue">'+'</span>, calc(a, b, <span style="color:blue">'+'</span>)); </p>
<p><span style="color:#5C5C5C">58. </span> printf(<span style="color:blue">"calc(%d, %d, %c)= %d\n"</span>, a, b, <span style="color:blue">'-'</span>, calc(a, b, <span style="color:blue">'-'</span>)); </p>
<p><span style="color:#5C5C5C">59. </span> printf(<span style="color:blue">"calc(%d, %d, %c)= %d\n"</span>, a, b, <span style="color:blue">'*'</span>, calc(a, b, <span style="color:blue">'*'</span>)); </p>
<p><span style="color:#5C5C5C">60. </span> printf(<span style="color:blue">"calc(%d, %d, %c)= %d\n"</span>, a, b, <span style="color:blue">'/'</span>, calc(a, b, <span style="color:blue">'/'</span>)); </p>
<p><span style="color:#5C5C5C">61. </span>} </p>
</div>
<p>//#include<iostream.h></p>
<p>#include<stdio.h></p>
<p>typedef int(*FP_CALC)(int, int);</p>
<p>//注意这里不是函数声明而是函数定义，它是一个地址，你可以直接输出add看看</p>
<p>int add(int a, int b)</p>
<p>{</p>
<p>return a + b;</p>
<p>}</p>
<p>int sub(int a, int b)</p>
<p>{</p>
<p>return a - b;</p>
<p>}</p>
<p>int mul(int a, int b)</p>
<p>{</p>
<p>return a * b;</p>
<p>}</p>
<p>int div(int a, int b)</p>
<p>{</p>
<p>return b? a/b : -1;</p>
<p>}</p>
<p>//定义一个函数，参数为op，返回一个指针。该指针类型为 拥有两个int参数、</p>
<p>//返回类型为int 的函数指针。它的作用是根据操作符返回相应函数的地址</p>
<p>FP_CALCcalc_func(char op)</p>
<p>{</p>
<p>switch (op)</p>
<p>{</p>
<p>case '+': returnadd;//返回函数的地址</p>
<p>case '-': return sub;</p>
<p>case '*': return mul;</p>
<p>case '/': return div;</p>
<p>default:</p>
<p>return NULL;</p>
<p>}</p>
<p>return NULL;</p>
<p>}</p>
<p>//s_calc_func为函数，它的参数是 op，</p>
<p>//返回值为一个拥有 两个int参数、返回类型为int 的函数指针</p>
<p>int(*s_calc_func(char op)) (int, int)</p>
<p>{</p>
<p>return calc_func(op);</p>
<p>}</p>
<p>//最终用户直接调用的函数，该函数接收两个int整数，和一个算术运算符，返回两数的运算结果</p>
<p>int calc(int a, intb, char op)</p>
<p>{</p>
<p>FP_CALC fp =calc_func(op); //根据预算符得到各种运算的函数的地址</p>
<p>int (*s_fp)(int, int)= s_calc_func(op);//用于测试</p>
<p>// ASSERT(fp ==s_fp); // 可以断言这俩是相等的</p>
<p>if (fp) return fp(a,b);//根据上一步得到的函数的地址调用相应函数，并返回结果</p>
<p>else return -1;</p>
<p>}</p>
<p>void main()</p>
<p>{</p>
<p>int a = 100, b = 20;</p>
<p>printf("calc(%d,%d, %c) = %d\n", a, b, '+', calc(a, b, '+'));</p>
<p>printf("calc(%d,%d, %c) = %d\n", a, b, '-', calc(a, b, '-'));</p>
<p>printf("calc(%d,%d, %c) = %d\n", a, b, '*', calc(a, b, '*'));</p>
<p>printf("calc(%d,%d, %c) = %d\n", a, b, '/', calc(a, b, '/'));</p>
<p>}</p>
<p>运行结果</p>
<p> calc(100, 20, +) = 120</p>
<p> calc(100, 20, -) = 80</p>
<p> calc(100, 20, *) = 2000</p>
<p> calc(100, 20, /) = 5</p>
<p>来自: <span style="color:#1D58D1">http://hi.baidu.com/%D6%EC%CF%E9/blog/item/482290cb4b6dfeed53664fda.html</span></p>
<h2><span style="color:#3A3A3A">【转】（转）</span><span style="color:#3A3A3A">MFC</span><span style="color:#3A3A3A">中</span><span style="color:#3A3A3A">TRACE</span><span style="color:#3A3A3A">的用法</span></h2>
<p><span style="color:#454545">个人总结：最近看网络编程是碰到了</span><span style="color:#454545">TRACE</span><span style="color:#454545">语句，不知道在哪里输出，查了一晚上资料也没找出来，今天终于在</span><span style="color:#454545">CSDN</span><span style="color:#454545">上找到了，真是个高地方啊，方法如下：</span></p>
<p><span style="color:#454545">1.</span><span style="color:#454545">在</span><span style="color:#454545">MFC</span><span style="color:#454545">中加入</span><span style="color:#454545">TRACE</span><span style="color:#454545">语句</span></p>
<p><span style="color:#454545">2.</span><span style="color:#454545">在</span><span style="color:#454545">TOOLS->MFCTRACER</span><span style="color:#454545">中选择</span><span style="color:#454545">“ENABLE TRACING”</span><span style="color:#454545">点击</span><span style="color:#454545">OK</span></p>
<p><span style="color:#454545">3.</span><span style="color:#454545">进行调试运行，</span><span style="color:#454545">GO(F5)</span><span style="color:#454545">（特别注意：不是执行</span><span style="color:#454545">‘</span><span style="color:#454545">！</span><span style="color:#454545">’</span><span style="color:#454545">以前之所以不能看到</span><span style="color:#454545">TRACE</span><span style="color:#454545">内容，是因为不是调试执行，而是</span><span style="color:#454545">‘</span><span style="color:#454545">！</span><span style="color:#454545">’</span><span style="color:#454545">了，切记，切记）</span></p>
<p><span style="color:#454545">4.</span><span style="color:#454545">然后就会在</span><span style="color:#454545">OUTPUT</span><span style="color:#454545">中的</span><span style="color:#454545">DEBUG</span><span style="color:#454545">窗口中看到</span><span style="color:#454545">TRACE</span><span style="color:#454545">内容了，调试执行会自动从</span><span style="color:#454545">BUILD</span><span style="color:#454545">窗口跳到</span><span style="color:#454545">DEBUG</span><span style="color:#454545">窗口，在那里就看到</span><span style="color:#454545">TRACE</span><span style="color:#454545">的内容了，</span><span style="color:#454545">^_^</span></p>
<p><span style="color:#454545">以下是找的</span><span style="color:#454545">TRACE</span><span style="color:#454545">的详细介绍：</span></p>
<p><span style="color:#454545"> </span><span style="color:#454545">＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝</span></p>
<p><span style="color:#454545"> TRACE</span><span style="color:#454545">宏对于</span><span style="color:#454545">VC</span><span style="color:#454545">下程序调试来说是很有用的东西，有着类似</span><span style="color:#454545">printf</span><span style="color:#454545">的功能；该宏仅仅在程序的</span><span style="color:#454545">DEBUG</span><span style="color:#454545">版本中出现，当</span><span style="color:#454545">RELEASE</span><span style="color:#454545">的时候该宏就完全消息了，从而帮助你调式也在</span><span style="color:#454545">RELEASE</span><span style="color:#454545">的时候减少代码量。</span></p>
<p><span style="color:#454545">使用非常简单，格式如下：</span></p>
<p><span style="color:#454545">TRACE("DDDDDDDDDDD");</span></p>
<p><span style="color:#454545">TRACE("wewe%d",333);</span></p>
<p><span style="color:#454545">同样还存在</span><span style="color:#454545">TRACE0</span><span style="color:#454545">，</span><span style="color:#454545">TRACE1</span><span style="color:#454545">，</span><span style="color:#454545">TRACE2</span><span style="color:#454545">。。。分别对应</span><span style="color:#454545">0</span><span style="color:#454545">，</span><span style="color:#454545">1</span><span style="color:#454545">，</span><span style="color:#454545">2</span><span style="color:#454545">。。个参数</span></p>
<p><span style="color:#454545">TRACE</span><span style="color:#454545">信息输出到</span><span style="color:#454545">VC IDE</span><span style="color:#454545">环境的输出窗口（该窗口是你编译项目出错提示的哪个窗口），但仅限于你在</span><span style="color:#454545">VC</span><span style="color:#454545">中运行你的</span><span style="color:#454545">DEBUG</span><span style="color:#454545">版本的程序。</span></p>
<p><span style="color:#454545">TRACE</span><span style="color:#454545">信息还可以使用</span><span style="color:#454545">DEBUGVIEW</span><span style="color:#454545">来捕获到。这种情况下，你不能在</span><span style="color:#454545">VC</span><span style="color:#454545">的</span><span style="color:#454545">IDE</span><span style="color:#454545">环境中运行你的程序，而将</span><span style="color:#454545">BUILD</span><span style="color:#454545">好的</span><span style="color:#454545">DEBUG</span><span style="color:#454545">版本的程序单独运行，这个时候可以在</span><span style="color:#454545">DEBUGVIEW</span><span style="color:#454545">的窗口看到</span><span style="color:#454545">DEBUGVIE</span><span style="color:#454545">格式的输出了。</span></p>
<p><span style="color:#454545">VC</span><span style="color:#454545">中</span><span style="color:#454545">TRACE</span><span style="color:#454545">的用法有以下四种：</span></p>
<p><span style="color:#454545">1:</span></p>
<p><span style="color:#454545">TRACE </span><span style="color:#454545">，就是不带动态参数输出字符串</span><span style="color:#454545">, </span><span style="color:#454545">类似</span><span style="color:#454545">C</span><span style="color:#454545">的</span><span style="color:#454545">printf("</span><span style="color:#454545">输出字符串</span><span style="color:#454545">"); </span><br> <br> 2:</p>
<p><span style="color:#454545">TRACE </span><span style="color:#454545">中的字符串可以带一个参数输出</span><span style="color:#454545"> , </span><span style="color:#454545">类似</span><span style="color:#454545">C</span><span style="color:#454545">的</span><span style="color:#454545">printf("...%d",</span><span style="color:#454545">变量</span><span style="color:#454545">);</span></p>
<p><span style="color:#454545">3:</span></p>
<p><span style="color:#454545">TRACE </span><span style="color:#454545">可以带两个参数输出，类似</span><span style="color:#454545">C</span><span style="color:#454545">的</span><span style="color:#454545">printf("...%d...%f",</span><span style="color:#454545">变量</span><span style="color:#454545">1,</span><span style="color:#454545">变量</span><span style="color:#454545">2);</span></p>
<p><span style="color:#454545">4:</span></p>
<p><span style="color:#454545">TRACE </span><span style="color:#454545">可以带三个参数输出，类似</span><span style="color:#454545">C</span><span style="color:#454545">的</span><span style="color:#454545">printf("...%d</span><span style="color:#454545">，</span><span style="color:#454545">%d,%d",</span><span style="color:#454545">变量</span><span style="color:#454545">1,</span><span style="color:#454545">变量</span><span style="color:#454545">2</span><span style="color:#454545">，变量</span><span style="color:#454545">3);</span></p>
<p><span style="color:#454545">TRACE </span><span style="color:#454545">宏有点象我们以前在</span><span style="color:#454545">C</span><span style="color:#454545">语言中用的</span><span style="color:#454545">Printf</span><span style="color:#454545">函数，使程序在运行过程中输出一些调试信息，使我们能了解程序的一些状态。但有一点不同的是：</span></p>
<p><span style="color:#454545"><br> TRACE </span><span style="color:#454545">宏只有在调试状态下才有所输出，而以前用的</span><span style="color:#454545">Printf</span><span style="color:#454545">函数在任何情况下都有输出。和</span><span style="color:#454545">Printf</span><span style="color:#454545">函数一样，</span><span style="color:#454545">TRACE</span><span style="color:#454545">函数可以接受多个参数如：</span></p>
<p><span style="color:#454545">int x = 1;<br> int y = 16;<br> float z = 32.0;<br> TRACE( "This is a TRACE statement\n" );<br> TRACE( "The value of x is %d\n", x );<br> TRACE( "x = %d and y = %d\n", x, y );<br> TRACE( "x = %d and y = %x and z = %f\n", x, y, z );</span></p>
<p><span style="color:#454545">要注意的是</span><span style="color:#454545">TRACE</span><span style="color:#454545">宏只对</span><span style="color:#454545">Debug </span><span style="color:#454545">版本的工程产生作用，在</span><span style="color:#454545">Release</span><span style="color:#454545">版本的工程中，</span><span style="color:#454545">TRACE</span><span style="color:#454545">宏将被忽略。</span></p>
<h2><span style="color:#3A3A3A">linux c</span><span style="color:#3A3A3A">语言定时器</span></h2>
<p><span style="color:#454545">linux</span><span style="color:#454545">定时器的使用使用定时器的目的无非是为了周期性的执行某一任务，或者是到了一个指定时间去执行某一个任务。要达到这一目的，一般有两个常见的比较有效的方法。一个是用</span><span style="color:#454545">linux</span><span style="color:#454545">内部的三个定时器，另一个是用</span><span style="color:#454545">sleep,usleep</span><span style="color:#454545">函数让进程睡眠一段时间，其实，还有一个方法，那就是用</span><span style="color:#454545">gettimeofday,difftime</span><span style="color:#454545">等自己来计算时间间隔，然后时间到了就执行某一任务，但是这种方法效率低，所以不常用。</span></p>
<p><span style="color:#454545">首先来看看</span><span style="color:#454545">linux</span><span style="color:#454545">操作系统为每一个进程提供的</span><span style="color:#454545">3</span><span style="color:#454545">个内部计时器。</span></p>
<p><span style="color:#454545">ITIMER_REAL: </span><span style="color:#454545">给一个指定的时间间隔，按照实际的时间来减少这个计数，当时间间隔为</span><span style="color:#454545">0</span><span style="color:#454545">的时候发出</span><span style="color:#454545">SIGALRM</span><span style="color:#454545">信号</span></p>
<p><span style="color:#454545">ITIMER_VIRTUAL: </span><span style="color:#454545">给定一个时间间隔，当进程执行的时候才减少计数，时间间隔为</span><span style="color:#454545">0</span><span style="color:#454545">的时候发出</span><span style="color:#454545">SIGVTALRM</span><span style="color:#454545">信号</span></p>
<p><span style="color:#454545">ITIMER_PROF: </span><span style="color:#454545">给定一个时间间隔，当进程执行或者是系统为进程调度的时候，减少计数，时间到了，发出</span><span style="color:#454545">SIGPROF</span><span style="color:#454545">信号，这个和</span><span style="color:#454545">ITIMER_VIRTUAL</span><span style="color:#454545">联合，常用来计算系统内核时间和用户时间。</span></p>
<p><span style="color:#454545">用到的函数有：</span></p>
<p><span style="color:#454545">#include<sys/time.h><br> int getitimer(int which, struct itimerval *value);<br> int setitimer(int which, struct itimerval*newvalue, struct itimerval*oldvalue);<br> strcut timeval<br> {<br> long tv_sec; /*</span><span style="color:#454545">秒</span><span style="color:#454545">*/<br> long tv_usec; /*</span><span style="color:#454545">微秒</span><span style="color:#454545">*/<br> };<br> struct itimerval<br> {<br> struct timeval it_interval; /*</span><span style="color:#454545">时间间隔</span><span style="color:#454545">*/<br> struct timeval it_value; /*</span><span style="color:#454545">当前时间计数</span><span style="color:#454545">*/<br> };</span></p>
<p><span style="color:#454545">it_interval</span><span style="color:#454545">用来指定每隔多长时间执行任务，</span><span style="color:#454545">it_value</span><span style="color:#454545">用来保存当前时间离执行任务还有多长时间。比如说，</span><span style="color:#454545">你指定</span><span style="color:#454545">it_interval</span><span style="color:#454545">为</span><span style="color:#454545">2</span><span style="color:#454545">秒</span><span style="color:#454545">(</span><span style="color:#454545">微秒为</span><span style="color:#454545">0)</span><span style="color:#454545">，开始的时候我们把</span><span style="color:#454545">it_value</span><span style="color:#454545">的时间也设定为</span><span style="color:#454545">2</span><span style="color:#454545">秒（微秒为</span><span style="color:#454545">0</span><span style="color:#454545">），当过了一秒，</span><span style="color:#454545">it_value</span><span style="color:#454545">就减少一个为</span><span style="color:#454545">1</span><span style="color:#454545">，</span><span style="color:#454545">再过</span><span style="color:#454545">1</span><span style="color:#454545">秒，则</span><span style="color:#454545">it_value</span><span style="color:#454545">又减少</span><span style="color:#454545">1</span><span style="color:#454545">，变为</span><span style="color:#454545">0</span><span style="color:#454545">，这个时候发出信号（告诉用户时间到了，可以执行任务了），并且系统自动把</span><span style="color:#454545">it_value</span><span style="color:#454545">的时间重置为</span><span style="color:#454545">it_interval</span><span style="color:#454545">的值，即</span><span style="color:#454545">2</span><span style="color:#454545">秒，再重新计数。</span></p>
<p><span style="color:#454545">为了帮助你理解这个问题，我们来看一个例子：</span></p>
<p><span style="color:#454545">1. </span><span style="color:#454545">#include <sys/time.h></span></p>
<p><span style="color:#454545">2. </span><span style="color:#454545">#include <stdio.h></span></p>
<p><span style="color:#454545">3. </span><span style="color:#454545">#include <unistd.h></span></p>
<p><span style="color:#454545">4. </span><span style="color:#454545">#include <signal.h></span></p>
<p><span style="color:#454545">5. </span><span style="color:#454545">#include <string.h></span></p>
<p><span style="color:#454545">6. </span><span style="color:#454545"> </span></p>
<p><span style="color:#454545">7. </span><span style="color:#454545">static char msg[] = “time isrunning out\n”;</span></p>
<p><span style="color:#454545">8. </span><span style="color:#454545">static int len;</span></p>
<p><span style="color:#454545">9. </span><span style="color:#454545"> </span></p>
<p><span style="color:#454545">10. </span><span style="color:#454545">// </span><span style="color:#454545">向标准错误输出信息，告诉用户时间到了</span></p>
<p><span style="color:#454545">11. </span><span style="color:#454545">void prompt_info(int signo)</span></p>
<p><span style="color:#454545">12. </span><span style="color:#454545">{</span></p>
<p><span style="color:#454545">13. </span><span style="color:#454545">write(STDERR_FILENO, msg,len);</span></p>
<p><span style="color:#454545">14. </span><span style="color:#454545">}</span></p>
<p><span style="color:#454545">15. </span><span style="color:#454545"> </span></p>
<p><span style="color:#454545">16. </span><span style="color:#454545">// </span><span style="color:#454545">建立信号处理机制</span></p>
<p><span style="color:#454545">17. </span><span style="color:#454545">void init_sigaction(void)</span></p>
<p><span style="color:#454545">18. </span><span style="color:#454545">{</span></p>
<p><span style="color:#454545">19. </span><span style="color:#454545">struct sigaction tact;</span></p>
<p><span style="color:#454545">20. </span><span style="color:#454545"> </span></p>
<p><span style="color:#454545">21. </span><span style="color:#454545">/*</span><span style="color:#454545">信号到了要执行的任务处理函数为</span><span style="color:#454545">prompt_info*/</span></p>
<p><span style="color:#454545">22. </span><span style="color:#454545">tact.sa_handler = prompt_info;</span></p>
<p><span style="color:#454545">23. </span><span style="color:#454545">tact.sa_flags = 0;</span></p>
<p><span style="color:#454545">24. </span><span style="color:#454545">/*</span><span style="color:#454545">初始化信号集</span><span style="color:#454545">*/</span></p>
<p><span style="color:#454545">25. </span><span style="color:#454545">sigemptyset(&tact.sa_mask);</span></p>
<p><span style="color:#454545">26. </span><span style="color:#454545">/*</span><span style="color:#454545">建立信号处理机制</span><span style="color:#454545">*/</span></p>
<p><span style="color:#454545">27. </span><span style="color:#454545">sigaction(SIGALRM, &tact,NULL);</span></p>
<p><span style="color:#454545">28. </span><span style="color:#454545">}</span></p>
<p><span style="color:#454545">29. </span><span style="color:#454545"> </span></p>
<p><span style="color:#454545">30. </span><span style="color:#454545">void init_time()</span></p>
<p><span style="color:#454545">31. </span><span style="color:#454545">{</span></p>
<p><span style="color:#454545">32. </span><span style="color:#454545">struct itimerval value;</span></p>
<p><span style="color:#454545">33. </span><span style="color:#454545"> </span></p>
<p><span style="color:#454545">34. </span><span style="color:#454545">/*</span><span style="color:#454545">设定执行任务的时间间隔为</span><span style="color:#454545">2</span><span style="color:#454545">秒</span><span style="color:#454545">0</span><span style="color:#454545">微秒</span><span style="color:#454545">*/</span></p>
<p><span style="color:#454545">35. </span><span style="color:#454545">value.it_value.tv_sec = 2;</span></p>
<p><span style="color:#454545">36. </span><span style="color:#454545">value.it_value.tv_usec = 0;</span></p>
<p><span style="color:#454545">37. </span><span style="color:#454545">/*</span><span style="color:#454545">设定初始时间计数也为</span><span style="color:#454545">2</span><span style="color:#454545">秒</span><span style="color:#454545">0</span><span style="color:#454545">微秒</span><span style="color:#454545">*/</span></p>
<p><span style="color:#454545">38. </span><span style="color:#454545">value.it_interval =value.it_value;</span></p>
<p><span style="color:#454545">39. </span><span style="color:#454545">/*</span><span style="color:#454545">设置计时器</span><span style="color:#454545">ITIMER_REAL*/</span></p>
<p><span style="color:#454545">40. </span><span style="color:#454545">setitimer(ITIMER_REAL,&value, NULL);</span></p>
<p><span style="color:#454545">41. </span><span style="color:#454545">}</span></p>
<p><span style="color:#454545">42. </span><span style="color:#454545"> </span></p>
<p><span style="color:#454545">43. </span><span style="color:#454545">int main()</span></p>
<p><span style="color:#454545">44. </span><span style="color:#454545">{</span></p>
<p><span style="color:#454545">45. </span><span style="color:#454545">len = strlen(msg);</span></p>
<p><span style="color:#454545">46. </span><span style="color:#454545">init_sigaction();</span></p>
<p><span style="color:#454545">47. </span><span style="color:#454545">init_time();</span></p>
<p><span style="color:#454545">48. </span><span style="color:#454545">while ( 1 );</span></p>
<p><span style="color:#454545">49. </span><span style="color:#454545">exit(0);</span></p>
<p><span style="color:#454545">50. </span><span style="color:#454545">}</span></p>
<p><span style="color:#454545">该程序的</span><span style="color:#454545">ITMER_REAL</span><span style="color:#454545">定时器，每隔</span><span style="color:#454545">2</span><span style="color:#454545">秒钟都会发送一个</span><span style="color:#454545">SIGALRM</span><span style="color:#454545">信号，当主函数接收到了这个信号之后，调用信号处理函数</span><span style="color:#454545">prompt_info</span><span style="color:#454545">在标准错误上输出</span><span style="color:#454545">timeis running out</span><span style="color:#454545">这个字符串。</span></p>
<p><span style="color:#454545">对于</span><span style="color:#454545">ITIMER_VIRTUAL</span><span style="color:#454545">和</span><span style="color:#454545">ITIMER_PROF</span><span style="color:#454545">的使用方法类似，当你在</span><span style="color:#454545">setitimer</span><span style="color:#454545">里面设置的定时器为</span><span style="color:#454545">ITIMER_VIRTUAL</span><span style="color:#454545">的时候，你把</span><span style="color:#454545">sigaction</span><span style="color:#454545">里面的</span><span style="color:#454545">SIGALRM</span><span style="color:#454545">改为</span><span style="color:#454545">SIGVTALARM,</span><span style="color:#454545">同理，</span><span style="color:#454545">ITIMER_PROF</span><span style="color:#454545">对应</span><span style="color:#454545">SIGPROF</span><span style="color:#454545">。</span></p>
<p><span style="color:#454545">不过，你可能会注意到，当你用</span><span style="color:#454545">ITIMER_VIRTUAL</span><span style="color:#454545">和</span><span style="color:#454545">ITIMER_PROF</span><span style="color:#454545">的时候，你拿一个秒表，你会发现程序输出字符串的时间间隔会不止</span><span style="color:#454545">2</span><span style="color:#454545">秒，甚至</span><span style="color:#454545">5-6</span><span style="color:#454545">秒才会输出一个，至于为什么，自己好好琢磨一下</span><span style="color:#454545">^_^</span></p>
<p><span style="color:#454545">下面我们来看看用</span><span style="color:#454545">sleep</span><span style="color:#454545">以及</span><span style="color:#454545">usleep</span><span style="color:#454545">怎么实现定时执行任务。</span></p>
<p><span style="color:#454545">1. </span><span style="color:#454545">#include <signal.h></span></p>
<p><span style="color:#454545">2. </span><span style="color:#454545">#include <unistd.h></span></p>
<p><span style="color:#454545">3. </span><span style="color:#454545">#include <string.h></span></p>
<p><span style="color:#454545">4. </span><span style="color:#454545">#include <stdio.h></span></p>
<p><span style="color:#454545">5. </span><span style="color:#454545"> </span></p>
<p><span style="color:#454545">6. </span><span style="color:#454545">static char msg[] = “Ireceived a msg.\n”;</span></p>
<p><span style="color:#454545">7. </span><span style="color:#454545">int len;</span></p>
<p><span style="color:#454545">8. </span><span style="color:#454545">void show_msg(int signo)</span></p>
<p><span style="color:#454545">9. </span><span style="color:#454545">{</span></p>
<p><span style="color:#454545">10. </span><span style="color:#454545">write(STDERR_FILENO, msg,len);</span></p>
<p><span style="color:#454545">11. </span><span style="color:#454545">}</span></p>
<p><span style="color:#454545">12. </span><span style="color:#454545">int main()</span></p>
<p><span style="color:#454545">13. </span><span style="color:#454545">{</span></p>
<p><span style="color:#454545">14. </span><span style="color:#454545">struct sigaction act;</span></p>
<p><span style="color:#454545">15. </span><span style="color:#454545">union sigval tsval;</span></p>
<p><span style="color:#454545">16. </span><span style="color:#454545"> </span></p>
<p><span style="color:#454545">17. </span><span style="color:#454545">act.sa_handler = show_msg;</span></p>
<p><span style="color:#454545">18. </span><span style="color:#454545">act.sa_flags = 0;</span></p>
<p><span style="color:#454545">19. </span><span style="color:#454545">sigemptyset(&act.sa_mask);</span></p>
<p><span style="color:#454545">20. </span><span style="color:#454545">sigaction(50, &act, NULL);</span></p>
<p><span style="color:#454545">21. </span><span style="color:#454545"> </span></p>
<p><span style="color:#454545">22. </span><span style="color:#454545">len = strlen(msg);</span></p>
<p><span style="color:#454545">23. </span><span style="color:#454545">while ( 1 )</span></p>
<p><span style="color:#454545">24. </span><span style="color:#454545">{</span></p>
<p><span style="color:#454545">25. </span><span style="color:#454545">sleep(2); /*</span><span style="color:#454545">睡眠</span><span style="color:#454545">2</span><span style="color:#454545">秒</span><span style="color:#454545">*/</span></p>
<p><span style="color:#454545">26. </span><span style="color:#454545">/*</span><span style="color:#454545">向主进程发送信号，实际上是自己给自己发信号</span><span style="color:#454545">*/</span></p>
<p><span style="color:#454545">27. </span><span style="color:#454545">sigqueue(getpid(), 50, tsval);</span></p>
<p><span style="color:#454545">28. </span><span style="color:#454545">}</span></p>
<p><span style="color:#454545">29. </span><span style="color:#454545">return 0;</span></p>
<p><span style="color:#454545">30. </span><span style="color:#454545">}</span></p>
<p><span style="color:#454545">看到了吧，这个要比上面的简单多了，而且你用秒表测一下，时间很准，指定</span><span style="color:#454545">2</span><span style="color:#454545">秒到了就给你输出一个字符串。所以，如果你只做一般的定时，到了时间去执行一个任务，这种方法是最简单的。</span></p>
<p><span style="color:#454545">下面我们来看看，通过自己计算时间差的方法来定时：</span></p>
<p><span style="color:#454545">1. </span><span style="color:#454545">#include <signal.h></span></p>
<p><span style="color:#454545">2. </span><span style="color:#454545">#include <unistd.h></span></p>
<p><span style="color:#454545">3. </span><span style="color:#454545">#include <string.h></span></p>
<p><span style="color:#454545">4. </span><span style="color:#454545">#include <stdio.h></span></p>
<p><span style="color:#454545">5. </span><span style="color:#454545">#include <time.h></span></p>
<p><span style="color:#454545">6. </span><span style="color:#454545"> </span></p>
<p><span style="color:#454545">7. </span><span style="color:#454545">static char msg[] = “Ireceived a msg.\n”;</span></p>
<p><span style="color:#454545">8. </span><span style="color:#454545">int len;</span></p>
<p><span style="color:#454545">9. </span><span style="color:#454545">static time_t lasttime;</span></p>
<p><span style="color:#454545">10. </span><span style="color:#454545">void show_msg(int signo)</span></p>
<p><span style="color:#454545">11. </span><span style="color:#454545">{</span></p>
<p><span style="color:#454545">12. </span><span style="color:#454545">write(STDERR_FILENO, msg,len);</span></p>
<p><span style="color:#454545">13. </span><span style="color:#454545">}</span></p>
<p><span style="color:#454545">14. </span><span style="color:#454545">int main()</span></p>
<p><span style="color:#454545">15. </span><span style="color:#454545">{</span></p>
<p><span style="color:#454545">16. </span><span style="color:#454545">struct sigaction act;</span></p>
<p><span style="color:#454545">17. </span><span style="color:#454545">union sigval tsval;</span></p>
<p><span style="color:#454545">18. </span><span style="color:#454545"> </span></p>
<p><span style="color:#454545">19. </span><span style="color:#454545">act.sa_handler = show_msg;</span></p>
<p><span style="color:#454545">20. </span><span style="color:#454545">act.sa_flags = 0;</span></p>
<p><span style="color:#454545">21. </span><span style="color:#454545">sigemptyset(&act.sa_mask);</span></p>
<p><span style="color:#454545">22. </span><span style="color:#454545">sigaction(50, &act, NULL);</span></p>
<p><span style="color:#454545">23. </span><span style="color:#454545"> </span></p>
<p><span style="color:#454545">24. </span><span style="color:#454545">len = strlen(msg);</span></p>
<p><span style="color:#454545">25. </span><span style="color:#454545">time(&lasttime);</span></p>
<p><span style="color:#454545">26. </span><span style="color:#454545">while ( 1 )</span></p>
<p><span style="color:#454545">27. </span><span style="color:#454545">{</span></p>
<p><span style="color:#454545">28. </span><span style="color:#454545">time_t nowtime;</span></p>
<p><span style="color:#454545">29. </span><span style="color:#454545">/*</span><span style="color:#454545">获取当前时间</span><span style="color:#454545">*/</span></p>
<p><span style="color:#454545">30. </span><span style="color:#454545">time(&nowtime);</span></p>
<p><span style="color:#454545">31. </span><span style="color:#454545">/*</span><span style="color:#454545">和上一次的时间做比较，如果大于等于</span><span style="color:#454545">2</span><span style="color:#454545">秒，则立刻发送信号</span><span style="color:#454545">*/</span></p>
<p><span style="color:#454545">32. </span><span style="color:#454545">if (nowtime – lasttime >=2)</span></p>
<p><span style="color:#454545">33. </span><span style="color:#454545">{</span></p>
<p><span style="color:#454545">34. </span><span style="color:#454545">/*</span><span style="color:#454545">向主进程发送信号，实际上是自己给自己发信号</span><span style="color:#454545">*/</span></p>
<p><span style="color:#454545">35. </span><span style="color:#454545">sigqueue(getpid(), 50, tsval);</span></p>
<p><span style="color:#454545">36. </span><span style="color:#454545">lasttime = nowtime;</span></p>
<p><span style="color:#454545">37. </span><span style="color:#454545">}</span></p>
<p><span style="color:#454545">38. </span><span style="color:#454545">}</span></p>
<p><span style="color:#454545">39. </span><span style="color:#454545">return 0;</span></p>
<p><span style="color:#454545">40. </span><span style="color:#454545">}</span></p>
<p><span style="color:#454545">这个和上面不同之处在于，是自己手工计算时间差的，如果你想更精确的计算时间差，你可以把</span><span style="color:#454545">time </span><span style="color:#454545">函</span>数换成gettimeofday，这个可以精确到微妙。</p>
<p>上面介绍的几种定时方法各有千秋，在计时效率上、方法上和时间的精确度上也各有不同，采用哪种方法，就看你程序的需要</p>
<p>itimerval时钟的使用#include<stdio.h><br> #include<signal.h><br> #include<sys/time.h>//itimerval结构体的定义<br> <br> int handle_count=0;<br> void set_time(void)<br> {<br> struct itimerval itv;<br> itv.it_interval.tv_sec=10;//自动装载，之后每10秒响应一次<br> itv.it_interval.tv_usec=0;<br> itv.it_value.tv_sec=5;//第一次定时的时间<br> itv.it_value.tv_usec=0;<br> setitimer(ITIMER_REAL,&itv,NULL);<br> }<br> <br> void alarm_handle(int sig)<br> {<br> handle_count++;<br> printf("have handle count is %d\n",handle_count);<br> }<br> <br> void main(void)<br> {<br> <span style="color:#454545"> struct itimerval itv;<br> signal(SIGALRM,alarm_handle);<br> set_time();<br> </span><br> while(1){<br> getitimer(ITIMER_REAL,&itv);<br> printf("pass second is %d\n",(int)itv.it_value.tv_sec);<br> sleep(1);<br> }<br> <br> return;<br> }</p>
<h2><span style="color:#3A3A3A">Linux</span><span style="color:#3A3A3A">下查看文件和文件夹大小的</span><span style="color:#3A3A3A">df</span><span style="color:#3A3A3A">和</span><span style="color:#3A3A3A">du</span><span style="color:#3A3A3A">命令</span></h2>
<p><span style="color:#0066FF">来源：</span><span style="color:#0066FF"><span style="color:black">芽雨快跑</span></span> <span style="color:#0066FF">时间</span><span style="color:#0066FF">: 2009-02-09 18:07:41 </span><span style="color:#0066FF">浏览</span><span style="color:#0066FF">: 102518 </span><span style="color:#0066FF">次</span><span style="color:#0066FF"> </span><span style="color:#0066FF">评论</span><span style="color:#0066FF">: 1853 </span><span style="color:#0066FF">篇</span></p>
<p><span style="color:#0066FF">Tags : </span><span style="color:black">df</span> <span style="color:black">du</span> <span style="color:black">文件大小</span> </p>
<p> 当磁盘大小超过标准时会有报警提示，这时如果掌握df和du命令是非常明智的选择。</p>
<p> df可以查看一级文件夹大小、使用比例、档案系统及其挂入点，但对文件却无能为力。<br> du可以查看文件及文件夹的大小。</p>
<p> 两者配合使用，非常有效。比如用df查看哪个一级目录过大，然后用df查看文件夹或文件的大小，如此便可迅速确定症结。</p>
<p> 下面分别简要介绍</p>
<p> <strong>df命令可以显示目前所有文件系统的可用空间及使用情形</strong>，请看下列这个例子：</p>
<div>
<table border="0" width="95%">
<tbody>
<tr>
<td style="background:#FDFDDF"> <p><strong><span style="color:#990000">以下是代码片段：</span></strong></p> <p>[yayug@yayu ~]$ df -h<br> Filesystem Size Used Avail Use% Mounted on<br> /dev/sda1 3.9G 300M 3.4G 8% /<br> /dev/sda7 100G 188M 95G 1% /data0<br> /dev/sdb1 133G 80G 47G 64% /data1<br> /dev/sda6 7.8G 218M 7.2G 3% /var<br> /dev/sda5 7.8G 166M 7.2G 3% /tmp<br> /dev/sda3 9.7G 2.5G 6.8G 27% /usr<br> tmpfs 2.0G 0 2.0G 0% /dev/shm</p> </td>
</tr>
</tbody>
</table>
</div>
<p> 参数 -h 表示使用「Human-readable」的输出，也就是在档案系统大小使用 GB、MB 等易读的格式。</p>
<p> 上面的命令输出的第一个字段（Filesystem）及最后一个字段（Mounted on）分别是档案系统及其挂入点。我们可以看到 /dev/sda1 这个分割区被挂在根目录下。</p>
<p> 接下来的四个字段 Size、Used、Avail、及 Use% 分别是该分割区的容量、已使用的大小、剩下的大小、及使用的百分比。 FreeBSD下，当硬盘容量已满时，您可能会看到已使用的百分比超过 100%，因为 FreeBSD 会留一些空间给 root，让 root 在档案系统满时，还是可以写东西到该档案系统中，以进行管理。</p>
<p> <strong> du：查询文件或文件夹的磁盘使用空间</strong></p>
<p> 如果当前目录下文件和文件夹很多，使用不带参数du的命令，可以循环列出所有文件和文件夹所使用的空间。这对查看究竟是那个地方过大是不利的，所以得指定深入目录的层数，参数：--max-depth=，这是个极为有用的参数！如下，注意使用“*”，可以得到文件的使用空间大小.</p>
<p> <strong>提醒</strong>：一向命令比linux复杂的FreeBSD，它的du命令指定深入目录的层数却是比linux简化，为 -d。</p>
<div>
<table border="0" width="95%">
<tbody>
<tr>
<td style="background:#FDFDDF"> <p><strong><span style="color:#990000">以下是代码片段：</span></strong></p> <p>[root@bsso yayu]# du -h --max-depth=1 work/testing<br> 27M work/testing/logs<br> 35M work/testing</p> <p>[root@bsso yayu]# du -h --max-depth=1 work/testing/*<br> 8.0K work/testing/func.php<br> 27M work/testing/logs<br> 8.1M work/testing/nohup.out<br> 8.0K work/testing/testing_c.php<br> 12K work/testing/testing_func_reg.php<br> 8.0K work/testing/testing_get.php<br> 8.0K work/testing/testing_g.php<br> 8.0K work/testing/var.php</p> <p>[root@bsso yayu]# du -h --max-depth=1 work/testing/logs/<br> 27M work/testing/logs/</p> <p>[root@bsso yayu]# du -h --max-depth=1 work/testing/logs/*<br> 24K work/testing/logs/errdate.log_show.log<br> 8.0K work/testing/logs/pertime_show.log<br> 27M work/testing/logs/show.log</p> </td>
</tr>
</tbody>
</table>
</div>
<p> 值得注意的是，看见一个针对du和df命令异同的文章：《<span style="color:black">du df </span><span style="color:black">差异导致文件系统误报解决</span>》。</p>
<p> du 统计文件大小相加 <br> df 统计数据块使用情况</p>
<p> 如果有一个进程在打开一个大文件的时候,这个大文件直接被rm 或者mv掉，则du会更新统计数值，df不会更新统计数值,还是认为空间没有释放。直到这个打开大文件的进程被Kill掉。</p>
<p> 如此一来在定期删除/var/spool/clientmqueue下面的文件时，如果没有杀掉其进程，那么空间一直没有释放。</p>
<p> 使用下面的命令杀掉进程之后，系统恢复。<br> fuser -u /var/spool/clientmqueue</p>
<p><span style="color:rgb(0,153,2)">du</span><span style="color:rgb(0,153,2)">查看目录大小，</span><span style="color:rgb(0,153,2)">df</span><span style="color:rgb(0,153,2)">查看磁盘使用情况。</span><span style="color:#009902"><br> </span><span style="color:rgb(0,153,2)">我常使用的命令（必要时，</span><span style="color:rgb(0,153,2)">sudo</span><span style="color:rgb(0,153,2)">使用</span><span style="color:rgb(0,153,2)">root</span><span style="color:rgb(0,153,2)">权限），</span><span style="color:#009902"><br> 1.</span><span style="color:rgb(0,153,2)">查看某个目录的大小：</span><span style="color:rgb(0,153,2)">du -hs /home/master/documents</span><span style="color:#009902"><br> </span><span style="color:rgb(0,153,2)">查看目录下所有目录的大小并按大小降序排列：</span><span style="color:rgb(0,153,2)">sudo du -sm /etc/* | sort -nr | less</span><span style="color:#009902"><br> 2.</span><span style="color:rgb(0,153,2)">查看磁盘使用情况（文件系统的使用情况）：</span><span style="color:rgb(0,153,2)">sudo df -h</span><span style="color:#009902"><br> df --block-size=GB</span><br> <br> -h<span style="color:rgb(0,153,2)">是使输出结果更易于人类阅读；</span><span style="color:rgb(0,153,2)">du -s</span><span style="color:rgb(0,153,2)">只展示目录的使用总量（不分别展示各个子目录情况），</span><span style="color:rgb(0,153,2)">-m</span><span style="color:rgb(0,153,2)">是以</span><span style="color:rgb(0,153,2)">MB</span><span style="color:rgb(0,153,2)">为单位展示目录的大小（当然</span><span style="color:rgb(0,153,2)">-k/-g</span><span style="color:rgb(0,153,2)">就是</span><span style="color:rgb(0,153,2)">KB/GB</span><span style="color:rgb(0,153,2)">了）。</span><span style="color:#009902"><br> </span><span style="color:rgb(0,153,2)">更多信息，还是</span><span style="color:rgb(0,153,2)">man du </span><span style="color:rgb(0,153,2)">和</span><span style="color:rgb(0,153,2)"> man df </span><span style="color:rgb(0,153,2)">来获得吧。</span></p>
<h2><span style="color:#3A3A3A"><span style="color:#3A3A3A">linux </span><span style="color:#3A3A3A">查看文件属性命令</span></span></h2>
<p>1,ls<br> ls -a 查看所有文件<br> ls -l 查看详细的属性<br> <br> 2,lsattr<br> 查看文件的扩展属性,<br> 如果文件被 chattr +i 添加了写保护,<br> 用lsattr可以看到添加的属性<br> <br> 3,file<br> 查看文件的类型<br> <br> 4,stat<br> 查看文件的状态</p>
<h2><span style="color:#3A3A3A">pthread_attr_init</span><span style="color:#3A3A3A">线程属性</span></h2>
<p><span style="color:#999999">分类：</span><span style="color:#999999"> </span><span style="color:#999999"><span style="color:#CA0000">linux</span></span><span style="color:#999999">2011-08-2610:41</span><span style="color:#999999"> </span><span style="color:#999999">4390</span><span style="color:#999999">人阅读</span><span style="color:#999999"> </span><span style="color:#999999"><span style="color:#CA0000">评论</span></span>(8)<span style="color:#999999"> </span><span style="color:#999999"><span style="color:#CA0000">收藏</span></span><span style="color:#999999"> </span><span style="color:#999999"><span style="color:#CA0000">举报</span></span></p>
<p><span style="color:#CA0000; background:#EEEEEE">thread</span><span style="color:#CA0000; background:#EEEEEE">pthreads</span><span style="color:#CA0000; background:#EEEEEE">struct</span><span style="color:#CA0000; background:#EEEEEE">null</span><span style="color:#CA0000; background:#EEEEEE">join</span></p>
<p style="background:#EEEEEE">目录<span style="color:#CA0000">(?)</span><span style="color:#CA0000">[+]</span></p>
<p> </p>
<p> </p>
<p> </p>
<h3>1．线程属性</h3>
<p> 线程具有属性，用pthread_attr_t表示，在对该结构进行处理之前必须进行初始化，在使用后需要对其去除初始化。我们用pthread_attr_init函数对其初始化，用pthread_attr_destroy对其去除初始化。</p>
<p> </p>
<p>1．</p>
<table border="0" align="left">
<tbody>
<tr>
<td valign="top"> <p>名称:：</p> </td>
<td valign="top"> <p>pthread_attr_init/pthread_attr_destroy</p> </td>
</tr>
<tr>
<td valign="top"> <p>功能：</p> </td>
<td valign="top"> <p>对线程属性初始化/去除初始化</p> </td>
</tr>
<tr>
<td valign="top"> <p>头文件：</p> </td>
<td valign="top"> <p>#include<pthread.h></p> </td>
</tr>
<tr>
<td valign="top"> <p>函数原形：</p> </td>
<td valign="top"> <p>int pthread_attr_init(pthread_attr_t*attr);</p> <p>int pthread_attr_destroy(pthread_attr_t*attr);</p> </td>
</tr>
<tr>
<td valign="top"> <p>参数：</p> </td>
<td valign="top"> <p>Attr 线程属性变量</p> </td>
</tr>
<tr>
<td valign="top"> <p>返回值：</p> </td>
<td valign="top"> <p>若成功返回0，若失败返回-1。</p> </td>
</tr>
</tbody>
</table>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> 调用pthread_attr_init之后，pthread_t结构所包含的内容就是操作系统实现支持的线程所有属性的默认值。</p>
<p> 如果要去除对pthread_attr_t结构的初始化，可以调用pthread_attr_destroy函数。如果pthread_attr_init实现时为属性对象分配了动态内存空间，pthread_attr_destroy还会用无效的值初始化属性对象，因此如果经pthread_attr_destroy去除初始化之后的pthread_attr_t结构被pthread_create函数调用，将会导致其返回错误。</p>
<p> </p>
<p>线程属性结构如下：</p>
<p>typedefstruct</p>
<p>{</p>
<p> int detachstate; 线程的分离状态</p>
<p> int schedpolicy; 线程调度策略</p>
<p> structsched_param schedparam; 线程的调度参数</p>
<p> int inheritsched; 线程的继承性</p>
<p> int scope; 线程的作用域</p>
<p> size_t guardsize; 线程栈末尾的警戒缓冲区大小</p>
<p> int stackaddr_set;</p>
<p> void* stackaddr; 线程栈的位置</p>
<p> size_t stacksize; 线程栈的大小</p>
<p>}pthread_attr_t;</p>
<p> </p>
<p>每个个属性都对应一些函数对其查看或修改。下面我们分别介绍。</p>
<p> </p>
<h3>2、线程的分离状态</h3>
<p><strong> </strong>线程的分离状态决定一个线程以什么样的方式来终止自己。在默认情况下线程是非分离状态的，这种情况下，原有的线程等待创建的线程结束。只有当pthread_join（）函数返回时，创建的线程才算终止，才能释放自己占用的系统资源。</p>
<p>而分离线程不是这样子的，它没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。程序员应该根据自己的需要，选择适当的分离状态。所以如果我们在创建线程时就知道不需要了解线程的终止状态，则可以pthread_attr_t结构中的detachstate线程属性，让线程以分离状态启动。</p>
<p><strong> </strong></p>
<p>2．</p>
<table border="0" align="left">
<tbody>
<tr>
<td valign="top"> <p>名称:：</p> </td>
<td valign="top"> <p>pthread_attr_getdetachstate/pthread_attr_setdetachstate</p> </td>
</tr>
<tr>
<td valign="top"> <p>功能：</p> </td>
<td valign="top"> <p>获取/修改线程的分离状态属性</p> </td>
</tr>
<tr>
<td valign="top"> <p>头文件：</p> </td>
<td valign="top"> <p>#include<pthread.h></p> </td>
</tr>
<tr>
<td valign="top"> <p>函数原形：</p> </td>
<td valign="top"> <p>int pthread_attr_getdetachstate(const pthread_attr_t *attr,int *detachstate);</p> <p>int pthread_attr_setdetachstate(pthread_attr_t *attr,intdetachstate);</p> </td>
</tr>
<tr>
<td valign="top"> <p>参数：</p> </td>
<td valign="top"> <p>Attr 线程属性变量</p> <p>Detachstate 线程的分离状态属性</p> </td>
</tr>
<tr>
<td valign="top"> <p>返回值：</p> </td>
<td valign="top"> <p>若成功返回0，若失败返回-1。</p> </td>
</tr>
</tbody>
</table>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p>可以使用pthread_attr_setdetachstate函数把线程属性detachstate设置为下面的两个合法值之一：设置为PTHREAD_CREATE_DETACHED,以分离状态启动线程；或者设置为PTHREAD_CREATE_JOINABLE,正常启动线程。可以使用pthread_attr_getdetachstate函数获取当前的datachstate线程属性。</p>
<p> </p>
<p>以分离状态创建线程</p>
<table border="0">
<tbody>
<tr>
<td valign="top"> <p>#iinclude<pthread.h></p> <p> </p> <p>void *child_thread(void *arg)</p> <p>{</p> <p>printf(“child thread run!\n”);</p> <p>}</p> <p> </p> <p>int main(int argc,char *argv[ ])</p> <p>{</p> <p> pthread_ttid;</p> <p> pthread_attr_tattr;</p> <p> </p> <p> pthread_attr_init(&attr);</p> <p> pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);</p> <p> pthread_create(&tid,&attr,fn,arg);</p> <p> pthread_attr_destroy(&attr);</p> <p> sleep(1);</p> <p>}</p> </td>
</tr>
</tbody>
</table>
<p><strong> </strong></p>
<h3><strong>3</strong><strong>、线程的继承性</strong></h3>
<p><strong> </strong>函数pthread_attr_setinheritsched和pthread_attr_getinheritsched分别用来设置和得到线程的继承性，这两个函数的定义如下：</p>
<p> </p>
<p>3.</p>
<table border="0" align="left">
<tbody>
<tr>
<td valign="top"> <p>名称:：</p> </td>
<td valign="top"> <p>pthread_attr_getinheritsched</p> <p>pthread_attr_setinheritsched</p> </td>
</tr>
<tr>
<td valign="top"> <p>功能：</p> </td>
<td valign="top"> <p>获得/设置线程的继承性</p> </td>
</tr>
<tr>
<td valign="top"> <p>头文件：</p> </td>
<td valign="top"> <p>#include<pthread.h></p> </td>
</tr>
<tr>
<td valign="top"> <p>函数原形：</p> </td>
<td valign="top"> <p>int pthread_attr_getinheritsched(const pthread_attr_t*attr,int *inheritsched);</p> <p>int pthread_attr_setinheritsched(pthread_attr_t *attr,intinheritsched);</p> </td>
</tr>
<tr>
<td valign="top"> <p>参数：</p> </td>
<td valign="top"> <p>attr 线程属性变量</p> <p>inheritsched 线程的继承性</p> </td>
</tr>
<tr>
<td valign="top"> <p>返回值：</p> </td>
<td valign="top"> <p>若成功返回0，若失败返回-1。</p> </td>
</tr>
</tbody>
</table>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> 这两个函数具有两个参数，第1个是指向属性对象的指针，第2个是继承性或指向继承性的指针。继承性决定调度的参数是从创建的进程中继承还是使用在schedpolicy和schedparam属性中显式设置的调度信息。Pthreads不为inheritsched指定默认值，因此如果你关心线程的调度策略和参数，必须先设置该属性。</p>
<p> 继承性的可能值是PTHREAD_INHERIT_SCHED（表示新现成将继承创建线程的调度策略和参数）和PTHREAD_EXPLICIT_SCHED（表示使用在schedpolicy和schedparam属性中显式设置的调度策略和参数）。</p>
<p> 如果你需要显式的设置一个线程的调度策略或参数，那么你必须在设置之前将inheritsched属性设置为PTHREAD_EXPLICIT_SCHED.</p>
<p> 下面我来讲进程的调度策略和调度参数。我会结合下面的函数给出本函数的程序例子。</p>
<p> </p>
<p> </p>
<h3><strong>4</strong><strong>、线程的调度策略</strong></h3>
<p> 函数pthread_attr_setschedpolicy和pthread_attr_getschedpolicy分别用来设置和得到线程的调度策略。</p>
<p> </p>
<p>4.</p>
<table border="0" align="left">
<tbody>
<tr>
<td valign="top"> <p>名称:：</p> </td>
<td valign="top"> <p>pthread_attr_getschedpolicy</p> <p>pthread_attr_setschedpolicy</p> </td>
</tr>
<tr>
<td valign="top"> <p>功能：</p> </td>
<td valign="top"> <p>获得/设置线程的调度策略</p> </td>
</tr>
<tr>
<td valign="top"> <p>头文件：</p> </td>
<td valign="top"> <p>#include<pthread.h></p> </td>
</tr>
<tr>
<td valign="top"> <p>函数原形：</p> </td>
<td valign="top"> <p>int pthread_attr_getschedpolicy(const pthread_attr_t*attr,int *policy);</p> <p>int pthread_attr_setschedpolicy(pthread_attr_t *attr,intpolicy);</p> </td>
</tr>
<tr>
<td valign="top"> <p>参数：</p> </td>
<td valign="top"> <p>attr 线程属性变量</p> <p>policy 调度策略</p> </td>
</tr>
<tr>
<td valign="top"> <p>返回值：</p> </td>
<td valign="top"> <p>若成功返回0，若失败返回-1。</p> </td>
</tr>
</tbody>
</table>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> 这两个函数具有两个参数，第1个参数是指向属性对象的指针，第2个参数是调度策略或指向调度策略的指针。调度策略可能的值是先进先出（SCHED_FIFO）、轮转法（SCHED_RR）,或其它（SCHED_OTHER）。</p>
<p> SCHED_FIFO策略允许一个线程运行直到有更高优先级的线程准备好，或者直到它自愿阻塞自己。在SCHED_FIFO调度策略下，当有一个线程准备好时，除非有平等或更高优先级的线程已经在运行，否则它会很快开始执行。</p>
<p> SCHED_RR(轮循)策略是基本相同的，不同之处在于：如果有一个SCHED_RR</p>
<p>策略的线程执行了超过一个固定的时期(时间片间隔)没有阻塞，而另外的SCHED_RR或SCHBD_FIPO策略的相同优先级的线程准备好时，运行的线程将被抢占以便准备好的线程可以执行。</p>
<p> 当有SCHED_FIFO或SCHED_RR策赂的线程在一个条件变量上等持或等持加锁同一个互斥量时，它们将以优先级顺序被唤醒。即，如果一个低优先级的SCHED_FIFO线程和一个高优先织的SCHED_FIFO线程都在等待锁相同的互斥且，则当互斥量被解锁时，高优先级线程将总是被首先解除阻塞。</p>
<p> </p>
<h3><strong>5</strong><strong>、线程的调度参数</strong></h3>
<p> 函数pthread_attr_getschedparam 和pthread_attr_setschedparam分别用来设置和得到线程的调度参数。</p>
<p> </p>
<p>5.</p>
<table border="0" align="left">
<tbody>
<tr>
<td valign="top"> <p>名称:：</p> </td>
<td valign="top"> <p>pthread_attr_getschedparam</p> <p>pthread_attr_setschedparam</p> </td>
</tr>
<tr>
<td valign="top"> <p>功能：</p> </td>
<td valign="top"> <p>获得/设置线程的调度参数</p> </td>
</tr>
<tr>
<td valign="top"> <p>头文件：</p> </td>
<td valign="top"> <p>#include<pthread.h></p> </td>
</tr>
<tr>
<td valign="top"> <p>函数原形：</p> </td>
<td valign="top"> <p>int pthread_attr_getschedparam(const pthread_attr_t*attr,struct sched_param *param);</p> <p>int pthread_attr_setschedparam(pthread_attr_t *attr,conststruct sched_param *param);</p> </td>
</tr>
<tr>
<td valign="top"> <p>参数：</p> </td>
<td valign="top"> <p>attr 线程属性变量</p> <p>param sched_param结构</p> </td>
</tr>
<tr>
<td valign="top"> <p>返回值：</p> </td>
<td valign="top"> <p>若成功返回0，若失败返回-1。</p> </td>
</tr>
</tbody>
</table>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p>这两个函数具有两个参数，第1个参数是指向属性对象的指针，第2个参数是sched_param结构或指向该结构的指针。结构sched_param在文件/usr/include/bits/sched.h中定义如下：</p>
<p> </p>
<p>struct sched_param</p>
<p>{</p>
<p> intsched_priority;</p>
<p>};</p>
<p> </p>
<p>结构sched_param的子成员sched_priority控制一个优先权值，大的优先权值对应高的优先权。系统支持的最大和最小优先权值可以用sched_get_priority_max函数和sched_get_priority_min函数分别得到。</p>
<p> </p>
<p>注意：如果不是编写实时程序，不建议修改线程的优先级。因为，调度策略是一件非常复杂的事情，如果不正确使用会导致程序错误，从而导致死锁等问题。如：在多线程应用程序中为线程设置不同的优先级别，有可能因为共享资源而导致优先级倒置。</p>
<p> </p>
<p> </p>
<h2>vsnprintf</h2>
<p><span style="color:#333333">_vsnprintf</span><span style="color:#333333">，</span><span style="color:#333333"><span style="color:#136EC2">C</span><span style="color:#136EC2">语言库函数</span></span><span style="color:#333333">之一，属于可变参数。用于向字符串中打印数据、数据格式用户自定义。</span></p>
<h3>目 录</h3>
<p><span style="color:#B2B2B2">1</span><span style="color:rgb(51,51,51)">函数简介</span></p>
<p><span style="color:#B2B2B2">2</span><span style="color:rgb(51,51,51)">用法实例</span></p>
<h3>1函数简介</h3>
<p><span style="color:#333333">头文件</span><span style="color:#333333">:</span></p>
<p><span style="color:#333333">#include <stdarg.h></span></p>
<p><span style="color:#333333">函数声明</span><span style="color:#333333">:</span></p>
<pre style="background:white">int vsnprintf(char *str, size_t size, const char *format, va_list ap);</pre>
<p><span style="color:#333333">参数说明</span><span style="color:#333333">:</span></p>
<p><span style="color:#333333">1. </span><span style="color:#333333">char *str [out],</span><span style="color:#333333">把生成的格式化的字符串存放在这里</span><span style="color:#333333">.</span></p>
<p><span style="color:#333333">2. </span><span style="color:#333333">size_t size [in], buffer</span><span style="color:#333333">可接受的最大字节数</span><span style="color:#333333">,</span><span style="color:#333333">防止产生</span><span style="color:#333333"><span style="color:#136EC2">数组</span></span><span style="color:#333333">越界</span><span style="color:#333333">.</span></p>
<p><span style="color:#333333">3. </span><span style="color:#333333">const char *format [in], </span><span style="color:#333333">指定输出格式的字符串，它决定了你需要提供的可变参数的类型、个数和顺序。</span></p>
<p><span style="color:#333333">4. </span><span style="color:#333333">va_list ap [in],va_list<span style="color:#136EC2">变量</span></span>.va:variable-argument:<span style="color:#333333">可变参数</span></p>
<p><span style="color:#333333">函数功能：将可变参数格式化输出到一个字符数组。</span></p>
<p><span style="color:#333333">用法类似于</span><span style="color:#333333">vsprintf</span><span style="color:#333333">，不过加了</span><span style="color:#333333">size</span><span style="color:#333333">的限制，防止了内存溢出（</span><span style="color:#333333">size</span><span style="color:#333333">为</span><span style="color:#333333">str</span><span style="color:#333333">所指的存储空间的大小）。</span></p>
<p><span style="color:#333333">返回值：执行成功，返回写入到字符数组</span><span style="color:#333333">str</span><span style="color:#333333">中的字符个数（不包含终止符），最大不超过</span><span style="color:#333333">size</span><span style="color:#333333">；执行失败，返回负值，并置</span><span style="color:#333333"><em><span style="color:#136EC2">errno</span></em>.</span><sup><span style="color:#3366CC">[1]</span></sup></p>
<p><span style="color:#333333">备注</span><span style="color:#333333">:</span></p>
<p><span style="color:#333333">linux</span><span style="color:#333333">环境下是</span><span style="color:#333333">:vsnprintf</span></p>
<p><span style="color:#333333">VC6</span><span style="color:#333333">环境下是</span><span style="color:#333333">:_vsnprintf</span></p>
<h3>2用法实例</h3>
<p><span style="color:#333333">int mon_log(char* format, ...)</span></p>
<p><span style="color:#333333">{</span></p>
<p><span style="color:#333333"><span style="color:#136EC2">va_list</span>vArgList; //</span><span style="color:#333333">定义一个</span><span style="color:#333333">va_list</span><span style="color:#333333">型的</span><span style="color:#333333"><span style="color:#136EC2">变量</span></span>,<span style="color:#333333">这个变量是指向参数的</span><span style="color:#333333"><span style="color:#136EC2">指针</span></span>.</p>
<p><span style="color:#333333">va_start(vArgList, format); //</span><span style="color:#333333">用</span><span style="color:#333333">va_start</span><strong><span style="color:#333333">宏</span></strong><span style="color:#333333">初始化</span><span style="color:#333333"><span style="color:#136EC2">变量</span></span>,<span style="color:#333333">这个宏的第二个参数是第一个可变参数的前一个参数</span><span style="color:#333333">,</span><span style="color:#333333">是一个固定的参数</span><span style="color:#333333">.</span></p>
<p><strong><span style="color:#333333">_vsnprintf</span></strong><span style="color:#333333">(str_tmp, 3, format, vArgList);//</span><span style="color:#333333">注意</span><span style="color:#333333">,</span><span style="color:#333333">不要漏掉前面的</span><span style="color:#333333">_</span></p>
<p><span style="color:#333333">va_end(vArgList); //</span><span style="color:#333333">用</span><span style="color:#333333">va_end</span><strong><span style="color:#333333">宏</span></strong><span style="color:#333333">结束可变参数的获取</span></p>
<p><span style="color:#333333">return 0;</span></p>
<p><span style="color:#333333">}</span></p>
<p><span style="color:#333333">//</span><span style="color:#333333">调用上面的函数</span></p>
<p><span style="color:#333333">mon_log("%d,%d,%d,%d", 1,2,3,4);</span></p>
<p><span style="color:#333333">返回值用法：</span></p>
<p><span style="color:#333333">#include <stdio.h></span></p>
<p><span style="color:#333333">#include <stdlib.h></span></p>
<p><span style="color:#333333">#include <stdarg.h></span></p>
<p><span style="color:#333333">char *</span></p>
<p><span style="color:#333333">make_message(const char *fmt, ...) {</span></p>
<p><span style="color:#333333">/* </span><span style="color:#333333">初始时假设我们只需要不超过</span><span style="color:#333333">100</span><span style="color:#333333">字节大小的空间</span><span style="color:#333333"> */</span></p>
<p><span style="color:#333333">int n, size = 100;</span></p>
<p><span style="color:#333333">char *p;</span></p>
<p><span style="color:#333333">va_list ap;</span></p>
<p><span style="color:#333333">if ((p = (char *)malloc(size)) == NULL)</span></p>
<p><span style="color:#333333">return NULL;</span></p>
<p><span style="color:#333333">while (1) {</span></p>
<p><span style="color:#333333">/* </span><span style="color:#333333">尝试在申请的空间中进行打印操作</span><span style="color:#333333"> */</span></p>
<p><span style="color:#333333">va_start(ap, fmt);</span></p>
<p><span style="color:#333333">n = vsnprintf (p, size, fmt, ap);</span></p>
<p><span style="color:#333333"><span style="color:#136EC2">va_end</span>(ap);</span></p>
<p><span style="color:#333333">/* </span><span style="color:#333333">如果</span><span style="color:#333333">vsnprintf</span><span style="color:#333333">调用成功，返回该字符串</span><span style="color:#333333">*/</span></p>
<p><span style="color:#333333">if (n > -1 && n < size)</span></p>
<p><span style="color:#333333">return p;</span></p>
<p><span style="color:#333333">/* vsnprintf</span><span style="color:#333333">调用失败</span><span style="color:#333333">(n<0)</span><span style="color:#333333">或者</span><span style="color:#333333">p</span><span style="color:#333333">的空间不足够容纳</span><span style="color:#333333">size</span><span style="color:#333333">大小的字符串</span><span style="color:#333333">(n>=size)</span><span style="color:#333333">，尝试申请更大的空间</span><span style="color:#333333">*/</span></p>
<p><span style="color:#333333">size *= 2; /* </span><span style="color:#333333">两倍原来大小的空间</span><span style="color:#333333"> */</span></p>
<p><span style="color:#333333">if ((p = (char *)realloc(p, size)) == NULL)</span></p>
<p><span style="color:#333333">return NULL;</span></p>
<p><span style="color:#333333">}</span></p>
<p><span style="color:#333333">}</span></p>
<p><span style="color:#333333">int main() {</span></p>
<p><span style="color:#333333">/* </span><span style="color:#333333">调用上面的函数</span><span style="color:#333333"> */</span></p>
<p><span style="color:#333333">char* str = make_message("%d,%d,%d,%d",5,6,7,8);</span></p>
<p><span style="color:#333333">printf("%s\n",str);</span></p>
<p><span style="color:#333333">free(str); // we allocate the memory in the make_messagefunction, so we should release it by caller(main function).</span></p>
<p><span style="color:#333333">return 0;</span></p>
<p><span style="color:#333333">}</span></p>
<h2>SOCKADDR_IN</h2>
<h3>目 录</h3>
<p><span style="color:#B2B2B2">1</span><span style="color:rgb(51,51,51)">基本结构</span></p>
<p><span style="color:#B2B2B2">2</span><span style="color:rgb(51,51,51)">参数说明</span></p>
<p><span style="color:#B2B2B2">3</span><span style="color:rgb(51,51,51)">经典案例</span></p>
<h3>1基本结构</h3>
<p><span style="color:#333333">在</span><span style="color:#333333">windows/linux</span><span style="color:#333333">下有下面结构：</span></p>
<p><strong><span style="color:#333333">sockaddr</span><span style="color:#333333">结构</span></strong></p>
<p><span style="color:#333333">struct sockaddr {</span></p>
<p><span style="color:#333333">unsigned short sa_family; /* address family, AF_xxx */</span></p>
<p><span style="color:#333333">char sa_data[14]; /* 14 bytes of protocol address */</span></p>
<p><span style="color:#333333">};</span></p>
<p><span style="color:#333333">sa_family</span><span style="color:#333333">是地址家族，一般都是</span><span style="color:#333333">“AF_xxx”</span><span style="color:#333333">的形式。通常大多用的是都是</span><span style="color:#333333"><span style="color:#136EC2">AF_INET</span>,</span><span style="color:#333333">代表</span><span style="color:#333333">TCP/IP</span><span style="color:#333333">协议族。</span></p>
<p><span style="color:#333333">sa_data</span><span style="color:#333333">是</span><span style="color:#333333">14</span><span style="color:#333333">字节</span><span style="color:#333333"><span style="color:#136EC2">协议地址</span></span><span style="color:#333333">。</span></p>
<p><span style="color:#333333">此</span><span style="color:#333333"><span style="color:#136EC2">数据结构</span></span><span style="color:#333333">用做</span><span style="color:#333333">bind</span><span style="color:#333333">、</span><span style="color:#333333">connect</span><span style="color:#333333">、</span><span style="color:#333333">recvfrom</span><span style="color:#333333">、</span><span style="color:#333333">sendto</span><span style="color:#333333">等函数的参数，指明地址信息。但一般编程中并不直接针对此</span><span style="color:#333333"><span style="color:#136EC2">数据结构</span></span><span style="color:#333333">操作，而是使用另一个与</span><span style="color:#333333">sockaddr</span><span style="color:#333333">等价的数据结构</span></p>
<p><strong><span style="color:#333333">sockaddr_in</span><span style="color:#333333">（在</span><span style="color:#333333">netinet/in.h</span><span style="color:#333333">中定义）：</span></strong></p>
<p><span style="color:#333333">struct sockaddr_in {</span></p>
<p><span style="color:#333333">short sin_family; /* Address family */</span></p>
<p><span style="color:#333333">unsigned short sin_port; /* Port number */</span></p>
<p><span style="color:#333333">struct</span><span style="color:#333333"> </span><span style="color:#333333"><span style="color:#136EC2">in_addr</span></span><span style="color:#333333"> </span><span style="color:#333333">sin_addr; /* Internetaddress */</span></p>
<p><span style="color:#333333">unsigned char sin_zero[8]; /* Same size as struct sockaddr */</span></p>
<p><span style="color:#333333">};</span></p>
<p><span style="color:#333333">在</span><span style="color:#333333">linux</span><span style="color:#333333">下：</span></p>
<p><strong><span style="color:#333333">in_addr</span><span style="color:#333333">结构</span></strong></p>
<p><span style="color:#333333">typedef struct</span><span style="color:#333333"> </span><span style="color:#333333"><span style="color:#136EC2">in_addr</span>{</span></p>
<p><span style="color:#333333">unsigned long s_addr;</span></p>
<p><span style="color:#333333">};</span></p>
<p><span style="color:#333333">在</span><span style="color:#333333">windows</span><span style="color:#333333">下：</span></p>
<p><span style="color:#333333">typedef struct</span><span style="color:#333333"> </span><span style="color:#333333"><span style="color:#136EC2">in_addr</span>{</span></p>
<p><span style="color:#333333">union{</span></p>
<p><span style="color:#333333">struct{unsigned char s_b1,s_b2,s_b3,s_b4;} S_un_b;</span></p>
<p><span style="color:#333333">struct{unsigned short s_w1,s_w2;} S_un_w;</span></p>
<p><span style="color:#333333">unsigned long S_addr;</span></p>
<p><span style="color:#333333">} S_un;</span></p>
<p><span style="color:#333333">} IN_ADDR;</span></p>
<h3><span style="color:#E9E9E9">2</span>参数说明</h3>
<p><span style="color:#333333">sin_family</span><span style="color:#333333">指代协议族，在</span><span style="color:#333333">socket</span><span style="color:#333333">编程中只能是</span><span style="color:#333333">AF_INET</span></p>
<p><span style="color:#333333">sin_port</span><span style="color:#333333">存储</span><span style="color:#333333"><span style="color:#136EC2">端口号</span></span><span style="color:#333333">（使用网络</span><span style="color:#333333"><span style="color:#136EC2">字节顺序</span></span><span style="color:#333333">），在</span><span style="color:#333333">linux</span><span style="color:#333333">下，端口号的范围</span><span style="color:#333333">0~65535,</span><span style="color:#333333">同时</span><span style="color:#333333">0~1024</span><span style="color:#333333">范围的端口号已经被系统使用或保留。</span></p>
<p><span style="color:#333333">s<span style="color:#136EC2">in_addr</span></span><span style="color:#333333">存储</span><span style="color:#333333">IP</span><span style="color:#333333">地址，使用</span><span style="color:#333333">in_addr</span><span style="color:#333333">这个</span><span style="color:#333333"><span style="color:#136EC2">数据结构</span></span></p>
<p><span style="color:#333333">sin_zero</span><span style="color:#333333">是为了让</span><span style="color:#333333">sockaddr</span><span style="color:#333333">与</span><span style="color:#333333">sockaddr_in</span><span style="color:#333333">两个</span><span style="color:#333333"><span style="color:#136EC2">数据结构</span></span><span style="color:#333333">保持大小相同而保留的空字节。</span></p>
<p><span style="color:#333333">s_addr</span><span style="color:#333333">按照网络字节顺序存储</span><span style="color:#333333">IP</span><span style="color:#333333">地址</span></p>
<p><span style="color:#333333">sockaddr_in</span><span style="color:#333333">和</span><span style="color:#333333">sockaddr</span><span style="color:#333333">是并列的结构，指向</span><span style="color:#333333">sockaddr_in</span><span style="color:#333333">的</span><span style="color:#333333"><span style="color:#136EC2">结构体</span></span><span style="color:#333333">的</span><span style="color:#333333"><span style="color:#136EC2">指针</span></span><span style="color:#333333">也可以指向</span></p>
<p><span style="color:#333333">sockaddr</span><span style="color:#333333">的</span><span style="color:#333333"><span style="color:#136EC2">结构体</span></span><span style="color:#333333">，并代替它。也就是说，你可以使用</span><span style="color:#333333">sockaddr_in</span><span style="color:#333333">建立你所需要的信息</span><span style="color:#333333">,</span></p>
<p><span style="color:#333333">然后用</span><span style="color:#333333">bzero</span><span style="color:#333333">函数初始化就可以了</span><span style="color:#333333">bzero((char*)&mysock,sizeof(mysock));//</span><span style="color:#333333">初始化</span></p>
<p><span style="color:#333333">sockaddr_in mysock;</span></p>
<p><span style="color:#333333">bzero((char*)&mysock,sizeof(mysock));</span></p>
<p><span style="color:#333333">mysock.sa_family=AF_INET;</span></p>
<p><span style="color:#333333">mysock.sin_port=htons(1234);//1234</span><span style="color:#333333">是</span><span style="color:#333333"><span style="color:#136EC2">端口号</span></span></p>
<p> </p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#333333">mysock.s<span style="color:#136EC2">in_addr</span>.s_addr=inet_addr("192.168.0.1");</span></p>
<p>相关函数：inet_addr,inet_aton, inet_ntoa, htonl, htons， MAKEWORD，WSASocket, WSAHtons……</p>
<p><strong><span style="color:#E9E9E9">3</span></strong>经典案例</p>
<p><span style="color:#333333">服务端：</span></p>
<p><span style="color:#333333">int main()<br> {<br> //</span><span style="color:#333333">创建</span><span style="color:#333333">socket<br> int sockfd=socket(PF_LOCAL, SOCK_DGRAM, 0);<br> if(sockfd==-1)<br> perror("</span><span style="color:#333333">创建</span><span style="color:#333333">socket</span><span style="color:#333333">失败</span><span style="color:#333333">"),exit(-1);<br> //</span><span style="color:#333333">准备通信地址</span><span style="color:#333333"><br> struct sockaddr_un addr;<br> addr.sun_family = PF_UNIX;<br> strcpy(addr.sun_path,"a.sock");</span><span style="color:#333333"> </span><span style="color:#333333"><br> //</span><span style="color:#333333">绑定</span><span style="color:#333333"><br> int res = bind(sockfd,</span><span style="color:#333333"> </span><span style="color:#333333"><br> (struct sockaddr*)&addr, sizeof(addr));<br> if(res==-1)perror("</span><span style="color:#333333">绑定失败</span><span style="color:#333333">"),exit(-1);<br> printf("</span><span style="color:#333333">绑定成功</span><span style="color:#333333">\n");<br> //</span><span style="color:#333333">通信</span><span style="color:#333333">(</span><span style="color:#333333">用读写文件方式</span><span style="color:#333333">)<br> char buf[100] = {};<br> read(sockfd, buf, sizeof(buf));</span><span style="color:#333333"> </span><span style="color:#333333"><br> printf("</span><span style="color:#333333">收到信息</span><span style="color:#333333">:%s\n",buf);<br> //</span><span style="color:#333333">关闭</span><span style="color:#333333">socket<br> close(sockfd);</span><span style="color:#333333"> </span><span style="color:#333333"><br> }</span></p>
<p><span style="color:#333333">客户端：</span></p>
<p><span style="color:#333333">int main()<br> {<br> int sockfd=socket(PF_LOCAL, SOCK_DGRAM, 0);<br> if(sockfd==-1)<br> perror("</span><span style="color:#333333">创建</span><span style="color:#333333">socket</span><span style="color:#333333">失败</span><span style="color:#333333">"),exit(-1);<br> struct sockaddr_un addr;<br> addr.sun_family = PF_UNIX;<br> strcpy(addr.sun_path,"a.sock");</span><span style="color:#333333"> </span><span style="color:#333333"><br> //</span><span style="color:#333333">连接</span><span style="color:#333333"><br> int res = connect(sockfd,</span><span style="color:#333333"> </span><span style="color:#333333"><br> (struct sockaddr*)&addr, sizeof(addr));<br> if(res==-1)perror("</span><span style="color:#333333">失败</span><span style="color:#333333">"),exit(-1);<br> printf("</span><span style="color:#333333">成功</span><span style="color:#333333">\n");<br> write(sockfd, "Hello, Socket!", 14);<br> close(sockfd);</span><span style="color:#333333"> </span><span style="color:#333333"><br> }</span></p>
<h2><span style="color:#454545">AF_INET</span><span style="color:#454545">和</span><span style="color:#454545">PF_INET</span><span style="color:#454545">的细微不同</span></h2>
<p><span style="color:#454545">在写网络程序的时候，建立</span><span style="color:#454545">TCP socket</span><span style="color:#454545">：</span><span style="color:#454545"><br> sock = socket(PF_INET, SOCK_STREAM, 0);<br> </span><span style="color:#454545">然后在绑定本地地址或连接远程地址时需要初始化</span><span style="color:#454545">sockaddr_in</span><span style="color:#454545">结构，其中指定</span><span style="color:#454545">addressfamily</span><span style="color:#454545">时一般设置为</span><span style="color:#454545">AF_INET</span><span style="color:#454545">，即使用</span><span style="color:#454545">IP</span><span style="color:#454545">。</span></p>
<p><span style="color:#454545">相关头文件中的定义：</span><span style="color:#454545">AF = Address Family<br> PF = Protocol Family<br> AF_INET = PF_INET</span></p>
<p><span style="color:#454545">所以在</span><span style="color:#454545">windows</span><span style="color:#454545">中</span><strong><span style="color:#454545">AF</span></strong><span style="color:#454545">_INET</span><span style="color:#454545">与</span><strong><span style="color:#454545">PF</span></strong><span style="color:#454545">_INET</span><span style="color:#454545">完全一样</span><span style="color:#454545">. </span><span style="color:#454545">而在</span><span style="color:#454545">Unix/Linux</span><span style="color:#454545">系统中，在不同的版本中这两者有微小差别</span><span style="color:#454545">.</span><span style="color:#454545">对于</span><span style="color:#454545">BSD,</span><span style="color:#454545">是</span><strong><span style="color:#454545">AF</span></strong><span style="color:#454545">,</span><span style="color:#454545">对于</span><span style="color:#454545">POSIX</span><span style="color:#454545">是</span><strong><span style="color:#454545">PF.</span></strong></p>
<p><span style="color:#454545">理论上建立</span><span style="color:#454545">socket</span><span style="color:#454545">时是指定协议，应该用</span><span style="color:#454545">PF_xxxx</span><span style="color:#454545">，设置地址时应该用</span><span style="color:#454545">AF_xxxx</span><span style="color:#454545">。当然</span><span style="color:#454545">AF_INET</span><span style="color:#454545">和</span><span style="color:#454545">PF_INET</span><span style="color:#454545">的值是相同的，混用也不会有太大的问题。</span></p>
<p><span style="color:#454545">在函数</span><span style="color:#454545">socketpair</span><span style="color:#454545">与</span><span style="color:#454545">socket</span><span style="color:#454545">的</span><span style="color:#454545">domain</span><span style="color:#454545">参数中有</span><span style="color:#454545">AF_UNIX,AF_LOCAL,AF_INET,PF_UNIX,PF_LOCAL,PF_INET.<br> </span><span style="color:#454545">这几个参数有</span><span style="color:#454545">AF_UNIX=AF_LOCAL,PF_UNIX=PF_LOCAL, AF_LOCAL=PF_LOCAL<strong>,AF_INET=PF_INET.<br> </strong>**</span><span style="color:#454545">建议</span><span style="color:#454545">:</span><span style="color:#454545">对于</span><span style="color:#454545">socketpair</span><span style="color:#454545">与</span><span style="color:#454545">socket</span><span style="color:#454545">的</span><span style="color:#454545">domain</span><span style="color:#454545">参数</span><span style="color:#454545">,</span><span style="color:#454545">使用</span><span style="color:#454545">PF_LOCAL</span><span style="color:#454545">系列</span><span style="color:#454545">,<br> </span><span style="color:#454545">而在初始化套接口地址结构时</span><span style="color:#454545">,</span><span style="color:#454545">则使用</span><span style="color:#454545">AF_LOCAL.<br> </span><span style="color:#454545">例如</span><span style="color:#454545">:<br> z = socket(PF_LOCAL, SOCK_STREAM, 0);<br> adr_unix.sin_family = AF_LOCAL;</span></p>
<h2>popen</h2>
<p>计算机科学中的进程I/O函数，与pclose函数一起使用。</p>
<p>目 录</p>
<p>1<span style="color:windowtext">头文件</span></p>
<p>2<span style="color:windowtext">函数定义</span></p>
<p>3<span style="color:windowtext">函数说明</span></p>
<p>4<span style="color:windowtext">返回值</span></p>
<p>5<span style="color:windowtext">返回错误</span></p>
<p>6<span style="color:windowtext">使用举例</span></p>
<p>7<span style="color:windowtext">真实示例</span></p>
<p><span style="color:#E9E9E9">1</span>头文件</p>
<table border="0" width="659">
<tbody>
<tr>
<td> <p>1</p> </td>
<td> <p><code>#include <stdio.h></code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#E9E9E9">2</span>函数定义</p>
<table border="0" width="659">
<tbody>
<tr>
<td> <p>1</p> <p>2</p> </td>
<td> <p><code>FILE</code> <code>* popen ( const</code> <code>char</code> <code>* command , const</code> <code>char</code> <code>* type );</code></p> <p><code>int</code> <code>pclose ( FILE</code> <code>* stream );</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#E9E9E9">3</span>函数说明</p>
<p>popen() 函数通过创建一个管道，调用 fork 产生一个子进程，执行一个shell 以<span style="color:#136EC2">运行命令</span>来开启一个进程。这个进程必须由 pclose() 函数关闭，而不是 fclose() 函数。pclose() 函数关闭标准 I/O 流，等待命令执行结束，然后返回 shell 的终止状态。如果 shell 不能被执行，则 pclose() 返回的终止状态与 shell 已执行 exit 一样。</p>
<p>type<span style="color:#333333"> </span>参数只能是读或者写中的一种，得到的返回值（标准 I/O 流）也具有和 type 相应的只读或只写类型。如果 type 是 "r" 则文件指针连接到 command 的标准输出；如果 type 是 "w" 则文件指针连接到 command 的标准输入。</p>
<p>command<span style="color:#333333"> </span>参数是一个指向以 NULL 结束的 shell 命令字符串的<span style="color:#136EC2">指针</span>。这行命令将被传到 bin/sh 并使用-c 标志，shell 将执行这个命令。</p>
<p>popen<span style="color:#333333"> </span>的返回值是个标准 I/O 流，必须由<span style="color:#333333"> </span>pclose<span style="color:#333333"> </span>来终止。前面提到这个流是单向的。所以向这个流写内容相当于写入该命令的标准输入；命令的标准输出和调用<span style="color:#333333"> </span>popen<span style="color:#333333"> </span>的进程相同。与之相反的，从流中读数据相当于读取命令的标准输出；命令的标准输入和调用<span style="color:#333333"> </span>popen<span style="color:#333333"> </span>的进程相同。</p>
<p><span style="color:#E9E9E9">4</span><span style="color:#333333">返回值</span></p>
<p>如果调用 fork() 或 pipe() 失败，或者不能分配内存将返回NULL，否则返回标准 I/O 流。</p>
<p><span style="color:#E9E9E9">5</span><span style="color:#333333">返回错误</span></p>
<p>popen<span style="color:#333333"> </span>没有为<span style="color:#136EC2">内存分配</span>失败设置 errno 值。</p>
<p>如果调用 fork() 或 pipe() 时出现错误，errno 被设为相应的错误类型。</p>
<p>如果 type 参数不合法，errno将返回EINVAL。</p>
<p><span style="color:#E9E9E9">6</span><span style="color:#333333">使用举例</span></p>
<table border="0" width="659">
<tbody>
<tr>
<td> <p>1</p> <p>2</p> <p>3</p> <p>4</p> <p>5</p> <p>6</p> <p>7</p> <p>8</p> <p>9</p> <p>10</p> </td>
<td> <p><code>if((fp=popen("/usr/bin/uptime","r"))==NULL);</code></p> <p><code>{</code></p> <p><code> sprintf(buf,"error: %s\n", strerror(errno));</code></p> <p><code> ....//</code><code>异常处理</code></p> <p><code>}</code></p> <p><code>else</code></p> <p><code>{</code></p> <p><code> ....</code></p> <p><code> pclose(fp);</code></p> <p><code>}</code></p> </td>
</tr>
</tbody>
</table>
<p>7真实示例</p>
<table border="0" width="659">
<tbody>
<tr>
<td> <p>1</p> <p>2</p> <p>3</p> <p>4</p> <p>5</p> <p>6</p> <p>7</p> <p>8</p> <p>9</p> <p>10</p> <p>11</p> <p>12</p> <p>13</p> <p>14</p> <p>15</p> <p>16</p> <p>17</p> <p>18</p> <p>19</p> <p>20</p> <p>21</p> <p>22</p> <p>23</p> <p>24</p> <p>25</p> <p>26</p> <p>27</p> <p>28</p> <p>29</p> </td>
<td> <p><code>#define _LINE_LENGTH 300</code></p> <p><code>int</code> <code>get_path_total(const</code> <code>char</code> <code>*path, long</code> <code>long* total) {</code></p> <p><code> int</code> <code>err=-1;</code></p> <p><code> FILE</code> <code>*file;</code></p> <p><code> char</code> <code>line[_LINE_LENGTH];</code></p> <p><code> char</code> <code>*p;</code></p> <p><code> char</code> <code>tmp[100];</code></p> <p><code> char</code> <code>*token;</code></p> <p><code> sprintf(tmp, "df %s", path);</code></p> <p><code> file = popen(tmp, "r");</code></p> <p><code> if</code> <code>(file != NULL) {</code></p> <p><code> if</code> <code>(fgets(line, _LINE_LENGTH, file) != NULL) {</code></p> <p><code> if</code> <code>(fgets(line, _LINE_LENGTH, file) != NULL) {</code></p> <p><code> token = strtok(line, " ");</code></p> <p><code> if</code> <code>(token != NULL) {</code></p> <p><code> // printf("token=%s\n", token);</code></p> <p><code> }</code></p> <p><code> token = strtok(NULL, " ");</code></p> <p><code> if</code> <code>(token != NULL) {</code></p> <p><code> // printf("token=%s\n", token);</code></p> <p><code> *total=atoll(token)/1024;//k/1024</code></p> <p><code> err=0;</code></p> <p><code> }</code></p> <p><code> }</code></p> <p><code> }</code></p> <p><code> pclose(file);</code></p> <p><code> }</code></p> <p><code>return</code> <code>err;</code></p> <p><code>}</code></p> </td>
</tr>
</tbody>
</table>
<h2>pthread_cond_signal和pthread_cond_wait简介</h2>
<p><span style="color:#333333">原文：</span><span style="color:#333333"> </span></p>
<p><span style="color:#333333"><span style="color:#F59513">http://apps.hi.baidu.com/share/detail/19786281</span></span></p>
<p><span style="color:#333333"><span style="color:#F59513">http://hi.baidu.com/boobleoo0/blog/item/5f935039a37c58f8b311c77f.html</span> </span></p>
<p><span style="color:#333333"><span style="color:#F59513">http://topic.csdn.net/u/20110105/16/12717238-9816-4571-a03d-e8b603724946.html</span> </span></p>
<p><span style="color:#993300"> pthread_cond_wait() </span><span style="color:navy">用于阻塞当前线程，等待别的线程使用</span><span style="color:#993300">pthread_cond_signal()</span><span style="color:navy">或</span><span style="color:#FF9900">pthread_cond_broadcast</span><span style="color:#FF9900">来唤醒它</span><span style="color:navy">。</span><span style="color:#993300"> pthread_cond_wait() </span><span style="color:navy">必须与</span><span style="color:navy">pthread_mutex </span><span style="color:navy">配套使用。</span><span style="color:#FF6600">pthread_cond_wait()</span><span style="color:navy">函数一进入</span><span style="color:navy">wait</span><span style="color:navy">状态就会自动</span><span style="color:navy">release mutex</span><span style="color:navy">。当其他线程通过</span><span style="color:#FF9900">pthread_cond_signal()</span><span style="color:navy">或</span><span style="color:#FF9900">pthread_cond_broadcast</span><span style="color:navy">，把该线程唤醒，使</span><span style="color:navy">pthread_cond_wait()</span><span style="color:navy">通过（返回）时，该线程又自动获得该</span><span style="color:navy">mutex</span><span style="color:navy">。</span></p>
<p><span style="color:#333333"> </span><span style="color:fuchsia">pthread_cond_signal</span><span style="color:navy">函数的作用是发送一个信号给另外一个正在处于阻塞等待状态的线程</span><span style="color:navy">,</span><span style="color:navy">使其脱离阻塞状态</span><span style="color:navy">,</span><span style="color:navy">继续执行</span><span style="color:navy">.</span><span style="color:navy">如果没有线程处在阻塞等待状态</span><span style="color:navy">,pthread_cond_signal</span><span style="color:navy">也会成功返回。</span></p>
<p><span style="color:navy"> </span><span style="color:navy">使用</span><span style="color:navy">pthread_cond_signal</span><span style="color:navy">一般不会有</span><span style="color:navy">“</span><span style="color:navy">惊群现象</span><span style="color:navy">”</span><span style="color:navy">产生，他最多只给一个线程发信号。假如有多个线程正在阻塞等待着这个条件变量的话，那</span><span style="color:navy">么是根据各等待线程优先级的高低确定哪个线程接收到信号开始继续执行。如果各线程优先级相同，则根据等待时间的长短来确定哪个线程获得信号。但无论如何一</span><span style="color:navy">个</span><span style="color:navy">pthread_cond_signal</span><span style="color:navy">调用最多发信一次。</span></p>
<p><span style="color:#993300"> </span><span style="color:navy">但是</span><span style="color:#993300">pthread_cond_signal</span><span style="color:navy">在多处理器上可能同时唤醒多个线程，当你只能让一个线程处理某个任务时，其它被唤醒的线程就需要继续</span><span style="color:navy"> wait</span><span style="color:navy">，而且规范要求</span><span style="color:#FF6600">pthread_cond_signal</span><span style="color:navy">至少唤醒一个</span><span style="color:navy">pthread_cond_wait</span><span style="color:navy">上的线程，其实有些实现为了简单在单处理器上也会唤醒多个线程</span><span style="color:navy">. </span></p>
<p><span style="color:navy"> </span><span style="color:navy">另外，某些应用，如线程池，</span><span style="color:#FF9900">pthread_cond_broadcast</span><span style="color:navy">唤醒全部线程，但我们通常只需要一部分线程去做执行任务，所以其它的线程需要继续</span><span style="color:navy">wait.</span><span style="color:navy">所以强烈推荐对</span><span style="color:navy">pthread_cond_wait() </span><span style="color:navy">使用</span><span style="color:navy">while</span><span style="color:navy">循环来做条件判断</span><span style="color:navy">.</span></p>
<p><span style="color:#333333">以下就是一个来自</span><span style="color:#333333">MAN</span><span style="color:#333333">的示例</span></p>
<p><span style="color:#333333"> Consider two shared variables xand y, protected by the mutex mut, and a condition vari-</span></p>
<p><span style="color:#333333"> able condthat is to be signaled whenever x becomes greater than y.</span></p>
<div>
<p><span style="color:#333333"> </span><span style="color:#000088">int</span><span style="color:#333333"> x</span><span style="color:#666600">,</span><span style="color:#333333">y</span><span style="color:#666600">;</span></p>
<p><span style="color:#333333"> </span><span style="color:#660066">pthread_mutex_t</span><span style="color:#333333"> mut </span><span style="color:#666600">=</span><span style="color:#333333"> PTHREAD_MUTEX_INITIALIZER</span><span style="color:#666600">;</span></p>
<p><span style="color:#333333"> </span><span style="color:#660066">pthread_cond_t</span><span style="color:#333333"> cond </span><span style="color:#666600">=</span><span style="color:#333333"> PTHREAD_COND_INITIALIZER</span><span style="color:#666600">;</span></p>
</div>
<p><span style="color:#333333"> Waiting untilx is greater than y is performed as follows:</span></p>
<div>
<p><span style="color:#333333"> pthread_mutex_lock</span><span style="color:#666600">(&</span><span style="color:#333333">mut</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> </span><span style="color:#000088">while</span><span style="color:#666600">(</span><span style="color:#333333">x </span><span style="color:#666600"><=</span><span style="color:#333333"> y</span><span style="color:#666600">)</span><span style="color:#666600">{</span></p>
<p><span style="color:#333333"> pthread_cond_wait</span><span style="color:#666600">(&</span><span style="color:#333333">cond</span><span style="color:#666600">,</span><span style="color:#666600">&</span><span style="color:#333333">mut</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> </span><span style="color:#666600">}</span></p>
<p><span style="color:#333333"> </span><span style="color:#880000">/* operate on x and y */</span></p>
<p><span style="color:#333333"> pthread_mutex_unlock</span><span style="color:#666600">(&</span><span style="color:#333333">mut</span><span style="color:#666600">);</span></p>
</div>
<p><span style="color:#333333"> Modificationson x and y that may cause x to become greater than y should signal the con-</span></p>
<p><span style="color:#333333"> dition ifneeded:</span></p>
<div>
<p><span style="color:#333333"> pthread_mutex_lock</span><span style="color:#666600">(&</span><span style="color:#333333">mut</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> </span><span style="color:#880000">/* modify x and y */</span></p>
<p><span style="color:#333333"> </span><span style="color:#000088">if</span><span style="color:#666600">(</span><span style="color:#333333">x </span><span style="color:#666600">></span><span style="color:#333333"> y</span><span style="color:#666600">)</span><span style="color:#333333">pthread_cond_broadcast</span><span style="color:#666600">(&</span><span style="color:#333333">cond</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> pthread_mutex_unlock</span><span style="color:#666600">(&</span><span style="color:#333333">mut</span><span style="color:#666600">);</span></p>
</div>
<p><span style="color:navy">pthread_cond_signal</span><span style="color:navy">函数与条件变量的典型应用就是用来实现</span><span style="color:navy">producer/consumer</span><span style="color:navy">模型。</span></p>
<p><strong><span style="color:#333333">示例</span><span style="color:#333333">1</span></strong></p>
<div>
<p><span style="color:#880000">#include</span></p>
<p><span style="color:#880000">#include</span></p>
<p><span style="color:#880000">#include</span></p>
<p><span style="color:#880000">#include</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#880000">#define</span><span style="color:#333333"> BUFFER_SIZE </span><span style="color:#006666">8</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#000088">struct</span><span style="color:#660066">Products</span></p>
<p><span style="color:#666600">{</span></p>
<p><span style="color:#000088">int</span><span style="color:#333333"> buffer</span><span style="color:#666600">[</span><span style="color:#333333">BUFFER_SIZE</span><span style="color:#666600">];</span></p>
<p><span style="color:#880000">/*</span><span style="color:#880000">保证存取操作的原子性 互斥性*/</span></p>
<p><span style="color:#660066">pthread_mutex_t</span><span style="color:#333333"> locker</span><span style="color:#666600">;</span></p>
<p><span style="color:#880000">/*</span><span style="color:#880000">是否可读*/</span><span style="color:#333333"> </span></p>
<p><span style="color:#660066">pthread_cond_t</span><span style="color:#333333"> notEmpty</span><span style="color:#666600">;</span></p>
<p><span style="color:#880000">/*</span><span style="color:#880000">是否可写*/</span><span style="color:#333333"> </span></p>
<p><span style="color:#660066">pthread_cond_t</span><span style="color:#333333"> notFull</span><span style="color:#666600">;</span></p>
<p><span style="color:#000088">int</span><span style="color:#333333"> posReadFrom</span><span style="color:#666600">;</span></p>
<p><span style="color:#000088">int</span><span style="color:#333333"> posWriteTo</span><span style="color:#666600">;</span></p>
<p><span style="color:#666600">};</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#000088">int</span><span style="color:#660066">BufferIsFull</span><span style="color:#666600">(</span><span style="color:#000088">struct</span><span style="color:#660066">Products</span><span style="color:#666600">*</span><span style="color:#333333"> products</span><span style="color:#666600">)</span></p>
<p><span style="color:#666600">{</span></p>
<p><span style="color:#000088">if</span><span style="color:#666600">((</span><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">posWriteTo </span><span style="color:#666600">+</span><span style="color:#006666">1</span><span style="color:#666600">)</span><span style="color:#666600">%</span><span style="color:#333333"> BUFFER_SIZE </span><span style="color:#666600">==</span><span style="color:#333333"> products</span><span style="color:#666600">-></span><span style="color:#333333">posReadFrom</span><span style="color:#666600">)</span></p>
<p><span style="color:#666600">{</span></p>
<p><span style="color:#000088">return</span><span style="color:#666600">(</span><span style="color:#006666">1</span><span style="color:#666600">);</span></p>
<p><span style="color:#666600">}</span></p>
<p><span style="color:#000088">return</span><span style="color:#666600">(</span><span style="color:#006666">0</span><span style="color:#666600">);</span></p>
<p><span style="color:#666600">}</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#000088">int</span><span style="color:#660066">BufferIsEmpty</span><span style="color:#666600">(</span><span style="color:#000088">struct</span><span style="color:#660066">Products</span><span style="color:#666600">*</span><span style="color:#333333"> products</span><span style="color:#666600">)</span></p>
<p><span style="color:#666600">{</span></p>
<p><span style="color:#000088">if</span><span style="color:#666600">(</span><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">posWriteTo </span><span style="color:#666600">==</span><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">posReadFrom</span><span style="color:#666600">)</span></p>
<p><span style="color:#666600">{</span></p>
<p><span style="color:#000088">return</span><span style="color:#666600">(</span><span style="color:#006666">1</span><span style="color:#666600">);</span></p>
<p><span style="color:#666600">}</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#000088">return</span><span style="color:#666600">(</span><span style="color:#006666">0</span><span style="color:#666600">);</span></p>
<p><span style="color:#666600">}</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#880000">/*</span><span style="color:#880000">制造产品*/</span><span style="color:#666600">。</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#000088">void</span><span style="color:#660066">Produce</span><span style="color:#666600">(</span><span style="color:#000088">struct</span><span style="color:#660066">Products</span><span style="color:#666600">*</span><span style="color:#333333"> products</span><span style="color:#666600">,</span><span style="color:#000088">int</span><span style="color:#333333"> item</span><span style="color:#666600">)</span></p>
<p><span style="color:#666600">{</span></p>
<p><span style="color:#880000">/*</span><span style="color:#880000">原子操作*/</span></p>
<p><span style="color:#333333">pthread_mutex_lock</span><span style="color:#666600">(&</span><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">locker</span><span style="color:#666600">);</span></p>
<p><span style="color:#880000">/*</span><span style="color:#880000">无空间可写入*/</span></p>
<p><span style="color:#000088">while</span><span style="color:#666600">(</span><span style="color:#660066">BufferIsFull</span><span style="color:#666600">(</span><span style="color:#333333">products</span><span style="color:#666600">))</span></p>
<p><span style="color:#666600">{</span></p>
<p><span style="color:#333333">pthread_cond_wait</span><span style="color:#666600">(&</span><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">notFull</span><span style="color:#666600">,</span><span style="color:#666600">&</span><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">locker</span><span style="color:#666600">);</span></p>
<p><span style="color:#666600">}</span><span style="color:#333333"> </span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#880000">/*</span><span style="color:#880000">写入数据*/</span></p>
<p><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">buffer</span><span style="color:#666600">[</span><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">posWriteTo</span><span style="color:#666600">]</span><span style="color:#666600">=</span><span style="color:#333333"> item</span><span style="color:#666600">;</span></p>
<p><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">posWriteTo</span><span style="color:#666600">++;</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#000088">if</span><span style="color:#666600">(</span><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">posWriteTo </span><span style="color:#666600">>=</span><span style="color:#333333">BUFFER_SIZE</span><span style="color:#666600">)</span></p>
<p><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">posWriteTo </span><span style="color:#666600">=</span><span style="color:#006666">0</span><span style="color:#666600">;</span></p>
<p><span style="color:#880000">/*</span><span style="color:#880000">发信*/</span></p>
<p><span style="color:#333333">pthread_cond_signal</span><span style="color:#666600">(&</span><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">notEmpty</span><span style="color:#666600">);</span></p>
<p><span style="color:#880000">/*</span><span style="color:#880000">解锁*/</span></p>
<p><span style="color:#333333">pthread_mutex_unlock</span><span style="color:#666600">(&</span><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">locker</span><span style="color:#666600">);</span></p>
<p><span style="color:#666600">}</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#000088">int</span><span style="color:#660066">Consume</span><span style="color:#666600">(</span><span style="color:#000088">struct</span><span style="color:#660066">Products</span><span style="color:#666600">*</span><span style="color:#333333"> products</span><span style="color:#666600">)</span></p>
<p><span style="color:#666600">{</span></p>
<p><span style="color:#000088">int</span><span style="color:#333333"> item</span><span style="color:#666600">;</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#333333">pthread_mutex_lock</span><span style="color:#666600">(&</span><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">locker</span><span style="color:#666600">);</span></p>
<p><span style="color:#880000">/*</span><span style="color:#880000">为空时持续等待,</span>无数据可读*/</p>
<p><span style="color:#000088">while</span><span style="color:#666600">(</span><span style="color:#660066">BufferIsEmpty</span><span style="color:#666600">(</span><span style="color:#333333">products</span><span style="color:#666600">))</span></p>
<p><span style="color:#666600">{</span></p>
<p><span style="color:#333333">pthread_cond_wait</span><span style="color:#666600">(&</span><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">notEmpty</span><span style="color:#666600">,</span><span style="color:#666600">&</span><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">locker</span><span style="color:#666600">);</span></p>
<p><span style="color:#666600">}</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#880000">/*</span><span style="color:#880000">提取数据*/</span></p>
<p><span style="color:#333333">item </span><span style="color:#666600">=</span><span style="color:#333333"> products</span><span style="color:#666600">-></span><span style="color:#333333">buffer</span><span style="color:#666600">[</span><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">posReadFrom</span><span style="color:#666600">];</span></p>
<p><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">posReadFrom</span><span style="color:#666600">++;</span></p>
<p><span style="color:#880000">/*</span><span style="color:#880000">如果到末尾,</span>从头读取*/</p>
<p><span style="color:#000088">if</span><span style="color:#666600">(</span><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">posReadFrom </span><span style="color:#666600">>=</span><span style="color:#333333">BUFFER_SIZE</span><span style="color:#666600">)</span></p>
<p><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">posReadFrom </span><span style="color:#666600">=</span><span style="color:#006666">0</span><span style="color:#666600">;</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#333333">pthread_cond_signal</span><span style="color:#666600">(&</span><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">notFull</span><span style="color:#666600">);</span><span style="color:#333333"> </span></p>
<p><span style="color:#333333">pthread_mutex_unlock</span><span style="color:#666600">(&</span><span style="color:#333333">products</span><span style="color:#666600">-></span><span style="color:#333333">locker</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#000088">return</span><span style="color:#333333"> item</span><span style="color:#666600">;</span></p>
<p><span style="color:#666600">}</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#880000">#define</span><span style="color:#333333"> END_FLAG </span><span style="color:#666600">(-</span><span style="color:#006666">1</span><span style="color:#666600">)</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#000088">struct</span><span style="color:#660066">Products</span><span style="color:#333333"> products</span><span style="color:#666600">;</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#000088">void</span><span style="color:#666600">*</span><span style="color:#660066">ProducerThread</span><span style="color:#666600">(</span><span style="color:#000088">void</span><span style="color:#666600">*</span><span style="color:#333333">data</span><span style="color:#666600">)</span></p>
<p><span style="color:#666600">{</span></p>
<p><span style="color:#000088">int</span><span style="color:#333333"> i</span><span style="color:#666600">;</span></p>
<p><span style="color:#000088">for</span><span style="color:#666600">(</span><span style="color:#333333">i </span><span style="color:#666600">=</span><span style="color:#006666">0</span><span style="color:#666600">;</span><span style="color:#333333"> i </span><span style="color:#666600"><</span><span style="color:#006666">16</span><span style="color:#666600">;</span><span style="color:#666600">++</span><span style="color:#333333">i</span><span style="color:#666600">)</span></p>
<p><span style="color:#666600">{</span></p>
<p><span style="color:#333333">printf</span><span style="color:#666600">(</span><span style="color:#008800">"producer: %d\n"</span><span style="color:#666600">,</span><span style="color:#333333"> i</span><span style="color:#666600">);</span></p>
<p><span style="color:#660066">Produce</span><span style="color:#666600">(&</span><span style="color:#333333">products</span><span style="color:#666600">,</span><span style="color:#333333"> i</span><span style="color:#666600">);</span></p>
<p><span style="color:#666600">}</span></p>
<p><span style="color:#660066">Produce</span><span style="color:#666600">(&</span><span style="color:#333333">products</span><span style="color:#666600">,</span><span style="color:#333333">END_FLAG</span><span style="color:#666600">);</span></p>
<p><span style="color:#000088">return</span><span style="color:#333333"> NULL</span><span style="color:#666600">;</span></p>
<p><span style="color:#666600">}</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#000088">void</span><span style="color:#666600">*</span><span style="color:#660066">ConsumerThread</span><span style="color:#666600">(</span><span style="color:#000088">void</span><span style="color:#666600">*</span><span style="color:#333333">data</span><span style="color:#666600">)</span></p>
<p><span style="color:#666600">{</span></p>
<p><span style="color:#000088">int</span><span style="color:#333333"> item</span><span style="color:#666600">;</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#000088">while</span><span style="color:#666600">(</span><span style="color:#006666">1</span><span style="color:#666600">)</span></p>
<p><span style="color:#666600">{</span></p>
<p><span style="color:#333333">item </span><span style="color:#666600">=</span><span style="color:#660066">Consume</span><span style="color:#666600">(&</span><span style="color:#333333">products</span><span style="color:#666600">);</span></p>
<p><span style="color:#000088">if</span><span style="color:#666600">(</span><span style="color:#333333">END_FLAG </span><span style="color:#666600">==</span><span style="color:#333333"> item</span><span style="color:#666600">)</span></p>
<p><span style="color:#333333"> </span><span style="color:#000088">break</span><span style="color:#666600">;</span></p>
<p><span style="color:#333333">printf</span><span style="color:#666600">(</span><span style="color:#008800">"consumer: %d\n"</span><span style="color:#666600">,</span><span style="color:#333333"> item</span><span style="color:#666600">);</span></p>
<p><span style="color:#666600">}</span></p>
<p><span style="color:#000088">return</span><span style="color:#666600">(</span><span style="color:#333333">NULL</span><span style="color:#666600">);</span></p>
<p><span style="color:#666600">}</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#000088">int</span><span style="color:#333333"> main</span><span style="color:#666600">(</span><span style="color:#000088">int</span><span style="color:#333333"> argc</span><span style="color:#666600">,</span><span style="color:#000088">char</span><span style="color:#666600">*</span><span style="color:#333333"> argv</span><span style="color:#666600">[])</span></p>
<p><span style="color:#666600">{</span></p>
<p><span style="color:#660066">pthread_t</span><span style="color:#333333"> producer</span><span style="color:#666600">;</span></p>
<p><span style="color:#660066">pthread_t</span><span style="color:#333333"> consumer</span><span style="color:#666600">;</span></p>
<p><span style="color:#000088">int</span><span style="color:#333333"> result</span><span style="color:#666600">;</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#333333">pthread_create</span><span style="color:#666600">(&</span><span style="color:#333333">producer</span><span style="color:#666600">,</span><span style="color:#333333"> NULL</span><span style="color:#666600">,</span><span style="color:#666600">&</span><span style="color:#660066">ProducerThread</span><span style="color:#666600">,</span><span style="color:#333333">NULL</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333">pthread_create</span><span style="color:#666600">(&</span><span style="color:#333333">consumer</span><span style="color:#666600">,</span><span style="color:#333333">NULL</span><span style="color:#666600">,</span><span style="color:#666600">&</span><span style="color:#660066">ConsumerThread</span><span style="color:#666600">,</span><span style="color:#333333">NULL</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#333333">pthread_join</span><span style="color:#666600">(</span><span style="color:#333333">producer</span><span style="color:#666600">,</span><span style="color:#666600">(</span><span style="color:#000088">void</span><span style="color:#666600">*)&</span><span style="color:#333333">result</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333">pthread_join</span><span style="color:#666600">(</span><span style="color:#333333">consumer</span><span style="color:#666600">,</span><span style="color:#666600">(</span><span style="color:#000088">void</span><span style="color:#666600">*)&</span><span style="color:#333333">result</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#000088">exit</span><span style="color:#666600">(</span><span style="color:#333333">EXIT_SUCCESS</span><span style="color:#666600">);</span></p>
<p><span style="color:#666600">}</span></p>
</div>
<p><span style="color:#333333">示例</span><span style="color:#333333">2</span></p>
<p><span style="color:#333333">pthread_cond_broadcast</span><span style="color:#333333">的是使用</span></p>
<div>
<p><span style="color:#660066">pthread_mutex_t</span><span style="color:#333333"> mymutex1 </span><span style="color:#666600">=</span><span style="color:#333333"> PTHREAD_MUTEX_INITIALIZER</span><span style="color:#666600">;</span></p>
<p><span style="color:#660066">pthread_mutex_t</span><span style="color:#333333"> mymutex2 </span><span style="color:#666600">=</span><span style="color:#333333"> PTHREAD_MUTEX_INITIALIZER</span><span style="color:#666600">;</span></p>
<p><span style="color:#660066">pthread_cond_t</span><span style="color:#333333"> mycond </span><span style="color:#666600">=</span><span style="color:#333333"> PTHREAD_COND_INITIALIZER</span><span style="color:#666600">;</span></p>
<p><span style="color:#333333"> </span><span style="color:#000088">void</span><span style="color:#666600">*</span><span style="color:#333333">mythread1</span><span style="color:#666600">(</span><span style="color:#000088">void</span><span style="color:#666600">*</span><span style="color:#333333">param</span><span style="color:#666600">)</span></p>
<p><span style="color:#333333"> </span><span style="color:#666600">{</span></p>
<p><span style="color:#333333"> pthread_mutex_lock</span><span style="color:#666600">(&</span><span style="color:#333333">mymutex1</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> pthread_cond_wait</span><span style="color:#666600">(&</span><span style="color:#333333">mycond</span><span style="color:#666600">,&</span><span style="color:#333333">mymutex1</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> fprintf</span><span style="color:#666600">(</span><span style="color:#333333">stderr</span><span style="color:#666600">,</span><span style="color:#008800">"this is mythread1.\n"</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> pthread_mutex_unlock</span><span style="color:#666600">(&</span><span style="color:#333333">mymutex1</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> </span><span style="color:#000088">return</span><span style="color:#333333">NULL</span><span style="color:#666600">;</span></p>
<p><span style="color:#333333"> </span><span style="color:#666600">}</span></p>
<p><span style="color:#333333"> </span><span style="color:#000088">void</span><span style="color:#666600">*</span><span style="color:#333333">mythread2</span><span style="color:#666600">(</span><span style="color:#000088">void</span><span style="color:#666600">*</span><span style="color:#333333">param</span><span style="color:#666600">)</span></p>
<p><span style="color:#333333"> </span><span style="color:#666600">{</span></p>
<p><span style="color:#333333"> pthread_mutex_lock</span><span style="color:#666600">(&</span><span style="color:#333333">mymutex2</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> pthread_cond_wait</span><span style="color:#666600">(&</span><span style="color:#333333">mycond</span><span style="color:#666600">,&</span><span style="color:#333333">mymutex2</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> fprintf</span><span style="color:#666600">(</span><span style="color:#333333">stderr</span><span style="color:#666600">,</span><span style="color:#008800">"this is mythread2.\n"</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> pthread_mutex_unlock</span><span style="color:#666600">(&</span><span style="color:#333333">mymutex2</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> </span><span style="color:#000088">return</span><span style="color:#333333"> NULL</span><span style="color:#666600">;</span></p>
<p><span style="color:#333333"> </span><span style="color:#666600">}</span></p>
<p><span style="color:#333333"> </span><span style="color:#000088">int</span><span style="color:#333333"> main</span><span style="color:#666600">(</span><span style="color:#000088">int</span><span style="color:#333333"> argc</span><span style="color:#666600">,</span><span style="color:#000088">char</span><span style="color:#666600">*</span><span style="color:#333333"> argv</span><span style="color:#666600">[],</span><span style="color:#000088">char</span><span style="color:#666600">*</span><span style="color:#333333">envp</span><span style="color:#666600">[])</span></p>
<p><span style="color:#333333"> </span><span style="color:#666600">{</span></p>
<p><span style="color:#333333"> </span><span style="color:#000088">int</span><span style="color:#333333"> i</span><span style="color:#666600">;</span></p>
<p><span style="color:#333333"> </span><span style="color:#660066">pthread_t</span><span style="color:#333333">tid1</span><span style="color:#666600">,</span><span style="color:#333333">tid2</span><span style="color:#666600">;</span></p>
<p><span style="color:#333333"> pthread_create</span><span style="color:#666600">(&</span><span style="color:#333333">tid1</span><span style="color:#666600">,</span><span style="color:#333333">NULL</span><span style="color:#666600">,</span><span style="color:#333333">mythread1</span><span style="color:#666600">,</span><span style="color:#333333">NULL</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> pthread_create</span><span style="color:#666600">(&</span><span style="color:#333333">tid2</span><span style="color:#666600">,</span><span style="color:#333333">NULL</span><span style="color:#666600">,</span><span style="color:#333333">mythread2</span><span style="color:#666600">,</span><span style="color:#333333">NULL</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> sleep</span><span style="color:#666600">(</span><span style="color:#006666">2</span><span style="color:#666600">)</span></p>
<p><span style="color:#333333"> </span><span style="color:#000088">if</span><span style="color:#666600">(</span><span style="color:#333333">pthread_cond_broadcast</span><span style="color:#666600">(&</span><span style="color:#333333">mycond</span><span style="color:#666600">)){</span></p>
<p><span style="color:#333333"> printf</span><span style="color:#666600">(</span><span style="color:#008800">"error\n"</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> </span><span style="color:#000088">return</span><span style="color:#006666">1</span><span style="color:#666600">;</span></p>
<p><span style="color:#333333"> </span><span style="color:#666600">}</span></p>
<p><span style="color:#333333"> </span><span style="color:#000088">void</span><span style="color:#666600">*</span><span style="color:#333333">res</span><span style="color:#666600">;</span></p>
<p><span style="color:#333333"> pthread_join</span><span style="color:#666600">(</span><span style="color:#333333">tid1</span><span style="color:#666600">,</span><span style="color:#666600">&</span><span style="color:#333333">res</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> pthread_join</span><span style="color:#666600">(</span><span style="color:#333333">tid2</span><span style="color:#666600">,</span><span style="color:#666600">&</span><span style="color:#333333">res</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> printf</span><span style="color:#666600">(</span><span style="color:#008800">"thisis main thread.\n"</span><span style="color:#666600">);</span></p>
<p><span style="color:#333333"> </span><span style="color:#000088">return</span><span style="color:#006666">0</span><span style="color:#666600">;</span></p>
<p><span style="color:#333333"> </span><span style="color:#666600">}</span></p>
</div>
<h2>linux 下route命令</h2>
<p style="background:#BCD3E5"><span style="color:#464646"> </span><span style="color:#464646">为了让设备能访问另一个子网，需要在设备里增加路由到子网络，下面是一些资料。基本操作如下：</span></p>
<p style="background:#BCD3E5"><span style="color:#464646">一般来说，都是为了能访问别的子网才设置路由的，比如说，你的主机处于</span><span style="color:#464646">192.168.10.0/24</span><span style="color:#464646">，而你想访问</span><span style="color:#464646">192.168.20.0/24</span><span style="color:#464646">网的主机，当然你知道一个网关</span><span style="color:#464646">IP</span><span style="color:#464646">，例如</span><span style="color:#464646">192.168.10.1</span><span style="color:#464646">（必须和你主机处于同一子网），那么，你可以这样配置路由。</span></p>
<p style="background:#BCD3E5"><span style="color:#464646">添加路由</span></p>
<p style="background:#BCD3E5"><span style="color:#990030">route</span><span style="color:#464646"> </span><span style="color:#990030">add -net</span><span style="color:#464646"> </span><strong><span style="color:#464646">192.168.20.0</span></strong><span style="color:#464646"> </span><span style="color:#990030">netmask</span><span style="color:#464646"> </span><strong><span style="color:#464646">255.255.255.0</span></strong><span style="color:#464646"> </span><span style="color:#990030">gw</span><span style="color:#464646"> </span><strong><span style="color:#464646">192.168.10.1</span></strong></p>
<p style="background:#BCD3E5"><span style="color:#464646">查看路由状态</span></p>
<p style="background:#BCD3E5"><span style="color:#990030">route -n</span></p>
<p style="background:#BCD3E5"><span style="color:#464646">删除路由</span></p>
<p style="background:#BCD3E5"><span style="color:#990030">route del -net</span><span style="color:#464646"> </span><strong><span style="color:#464646">192.168.20.0</span></strong><span style="color:#464646"> </span><span style="color:#990030">netmask</span><span style="color:#464646"> </span><strong><span style="color:#464646">255.255.255.0</span></strong></p>
<p style="background:#BCD3E5"><span style="color:#464646"> </span></p>
<p style="background:#BCD3E5"><span style="color:#464646">摘自鸟哥的私房菜</span><span style="color:#464646"><br> </span><span style="color:#464646">路由修改</span><span style="color:#464646"> route <br> </span><span style="color:#464646"> </span><span style="color:#464646">我们在</span><span style="color:#464646">网路基础</span><span style="color:#464646">的时候谈过关于路由的问题，两部主机之间一定要有路由才能够互通</span><span style="color:#464646"> TCP/IP </span><span style="color:#464646">的协定，否则就无法进行连线啊！</span><span style="color:#464646"><br> </span><span style="color:#464646">一般来说，只要有网路介面，该介面就会产生一个路由，例如在鸟哥实验室内部的主机有一个</span><span style="color:#464646"> eth0 </span><span style="color:#464646">及 </span><span style="color:#464646">lo </span><span style="color:#464646">，所以：</span><span style="color:#464646"><br> [root@linux ~]# route [-nee]<br> [root@linux ~]# route add [-net|-host] [</span><span style="color:#464646">网域或主机</span><span style="color:#464646">] netmask [mask] [gw|dev]<br> [root@linux ~]# route del [-net|-host] [</span><span style="color:#464646">网域或主机</span><span style="color:#464646">] netmask [mask] [gw|dev]<br> </span><span style="color:#464646">观察的参数：</span><span style="color:#464646"><br> -n </span><span style="color:#464646">：不要使用通讯协定或主机名称，直接使用 </span><span style="color:#464646">IP </span><span style="color:#464646">或 </span><span style="color:#464646">port number</span><span style="color:#464646">；</span><span style="color:#464646"><br> -ee </span><span style="color:#464646">：使用更详细的资讯来显示</span><span style="color:#464646"><br> </span><span style="color:#464646">增加</span><span style="color:#464646"> (add) </span><span style="color:#464646">与删除 </span><span style="color:#464646">(del) </span><span style="color:#464646">路由的相关参数：</span><span style="color:#464646"><br> -net </span><span style="color:#464646">：表示后面接的路由为一个网域；</span><span style="color:#464646"><br> -host </span><span style="color:#464646">：表示后面接的为连接到单部主机的路由；</span><span style="color:#464646"><br> netmask </span><span style="color:#464646">：与网域有关，可以设定 </span><span style="color:#464646">netmask </span><span style="color:#464646">决定网域的大小；</span><span style="color:#464646"><br> gw </span><span style="color:#464646">：</span><span style="color:#464646">gateway </span><span style="color:#464646">的简写，后续接的是 </span><span style="color:#464646">IP </span><span style="color:#464646">的数值喔，与 </span><span style="color:#464646">dev </span><span style="color:#464646">不同；</span><span style="color:#464646"><br> dev </span><span style="color:#464646">：如果只是要指定由那一块网路卡连线出去，则使用这个设定，后面接 </span><span style="color:#464646">eth0 </span><span style="color:#464646">等</span><span style="color:#464646"><br> </span><span style="color:#464646">范例一：单纯的观察路由状态</span><span style="color:#464646"><br> [root@linux ~]# route -n<br> Kernel IP routing table<br> Destination Gateway Genmask Flags Metric Ref Use Iface<br> 192.168.10.0 0.0.0.0 255.255.255.0 U 0 0 0 eth0<br> 169.254.0.0 0.0.0.0 255.255.0.0 U 0 0 0 eth0<br> 0.0.0.0 192.168.10.30 0.0.0.0 UG 0 0 0 eth0<br> [root@linux ~]# route<br> Kernel IP routing table<br> Destination Gateway Genmask Flags Metric Ref Use Iface<br> 192.168.10.0 * 255.255.255.0 U 0 0 0 eth0<br> 169.254.0.0 * 255.255.0.0 U 0 0 0 eth0<br> default server.cluster </span><span style="color:#464646"> </span><span style="color:#464646"> </span><span style="color:#464646">0.0.0.0 UG 0 0 0 eth0<br> </span><span style="color:#464646"> </span><span style="color:#464646"> </span><span style="color:#464646">由上面的例子当中仔细观察</span><span style="color:#464646"> route </span><span style="color:#464646">与 </span><span style="color:#464646">route -n </span><span style="color:#464646">的输出结果，你可以发现有加 </span><span style="color:#464646">-n</span><span style="color:#464646">参数的主要是显示出 </span><span style="color:#464646">IP </span><span style="color:#464646">，至于使用 </span><span style="color:#464646">route </span><span style="color:#464646">而已的话，显示的则是『主机名称』喔！也就是说，在预设的情况下， </span><span style="color:#464646">route </span><span style="color:#464646">会去找出该 </span><span style="color:#464646">IP </span><span style="color:#464646">的主机名称，如果找不到呢？就会显示的钝钝的</span><span style="color:#464646">(</span><span style="color:#464646">有点小慢</span><span style="color:#464646">)</span><span style="color:#464646">，所以说，鸟哥通常都直接使用 </span><span style="color:#464646">route -n </span><span style="color:#464646">啦！由上面看起来，我们也知道 </span><span style="color:#464646">default = 0.0.0.0/0.0.0.0 </span><span style="color:#464646">，而上面的资讯有哪些你必须要知道的呢？</span><span style="color:#464646"><br> </span></p>
<p style="background:#BCD3E5"><span style="color:#464646">· </span><span style="color:#464646">Destination, Genmask</span><span style="color:#464646">：这两个玩意儿就是分别是 </span><span style="color:#464646">network </span><span style="color:#464646">与</span><span style="color:#464646">netmask </span><span style="color:#464646">啦！所以这两个咚咚就组合成为一个完整的网域囉！</span></p>
<p style="background:#BCD3E5"><span style="color:#464646">· </span><span style="color:#464646">Gateway</span><span style="color:#464646">：该网域是通过那个 </span><span style="color:#464646">gateway </span><span style="color:#464646">连接出去的？ </span>如果显示 <span style="color:#464646">0.0.0.0 </span><span style="color:#464646">表示该路由是直接由本机传送，亦即可以透过区域网路的 </span><span style="color:#464646">MAC </span><span style="color:#464646">直接传讯；如果有显示 </span><span style="color:#464646">IP </span><span style="color:#464646">的话，表示该路由需要经过路由器 </span><span style="color:#464646">(</span><span style="color:#464646">通讯闸</span><span style="color:#464646">) </span><span style="color:#464646">的帮忙才能够传送出去。</span></p>
<p style="background:#BCD3E5"><span style="color:#464646">· </span><span style="color:#464646">Flags</span><span style="color:#464646">：总共有多个旗标，代表的意义如下： </span></p>
<p style="background:#BCD3E5"><span style="color:#464646">o </span><span style="color:#464646">U (route is up)</span><span style="color:#464646">：该路由是启动的； </span></p>
<p style="background:#BCD3E5"><span style="color:#464646">o </span><span style="color:#464646">H (target is a host)</span><span style="color:#464646">：目标是一部主机 </span><span style="color:#464646">(IP) </span><span style="color:#464646">而非网域； </span></p>
<p style="background:#BCD3E5"><span style="color:#464646">o </span><span style="color:#464646">G (use gateway)</span><span style="color:#464646">：需要透过外部的主机 </span><span style="color:#464646">(gateway) </span><span style="color:#464646">来转递封包； </span></p>
<p style="background:#BCD3E5"><span style="color:#464646">o </span><span style="color:#464646">R (reinstate route for dynamic routing)</span><span style="color:#464646">：使用动态路由时，恢复路由资讯的旗标； </span></p>
<p style="background:#BCD3E5"><span style="color:#464646">o </span><span style="color:#464646">D (dynamically installed by daemon or redirect)</span><span style="color:#464646">：已经由服务或转 </span><span style="color:#464646">port </span><span style="color:#464646">功能设定为动态路由 </span></p>
<p style="background:#BCD3E5"><span style="color:#464646">o </span><span style="color:#464646">M (modified from routing daemon or redirect)</span><span style="color:#464646">：路由已经被修改了； </span></p>
<p style="background:#BCD3E5"><span style="color:#464646">o </span><span style="color:#464646">! (reject route)</span><span style="color:#464646">：这个路由将不会被接受</span><span style="color:#464646">(</span><span style="color:#464646">用来抵挡不安全的网域！</span><span style="color:#464646">)</span></p>
<p style="background:#BCD3E5"><span style="color:#464646">· </span><span style="color:#464646">Iface</span><span style="color:#464646">：这个路由传递封包的介面。</span></p>
<p style="background:#BCD3E5"><span style="color:#464646">此外，观察一下上面的路由排列顺序喔，依序是由小网域</span><span style="color:#464646">(192.168.10.0/24 </span><span style="color:#464646">是 </span><span style="color:#464646">Class C)</span><span style="color:#464646">，逐渐到大网域</span><span style="color:#464646">(169.254.0.0/16 Class B) </span><span style="color:#464646">最后则是预设路由 </span><span style="color:#464646">(0.0.0.0/0.0.0.0)</span><span style="color:#464646">。然后当我们要判断某个网路封包应该如何传送的时候，该封包会经由这个路由的过程来判断喔！举例来说，我上头仅有三个路由，若我有一个传往 </span><span style="color:#464646">192.168.10.20 </span><span style="color:#464646">的封包要传递，那首先会找 </span><span style="color:#464646">192.168.10.0/24 </span><span style="color:#464646">这个网域的路由，找到了！所以直接由 </span><span style="color:#464646">eth0 </span><span style="color:#464646">传送出去；如果是传送到 </span><span style="color:#464646">Yahoo </span><span style="color:#464646">的主机呢？ </span><span style="color:#464646">Yahoo </span><span style="color:#464646">的主机 </span><span style="color:#464646">IP </span><span style="color:#464646">是 </span><span style="color:#464646">202.43.195.52</span><span style="color:#464646">，我通过判断 </span></p>
<p style="background:#BCD3E5"><span style="color:#464646">1)</span><span style="color:#464646">不是</span><span style="color:#464646"> 192.168.10.0/24</span><span style="color:#464646">，</span><span style="color:#464646"><br> </span>2)<span style="color:#464646">不是 </span><span style="color:#464646">169.254.0.0/16 </span><span style="color:#464646">结果到达 </span></p>
<p style="background:#BCD3E5"><span style="color:#464646">3)0/0 </span><span style="color:#464646">时，</span><span style="color:#464646">OK</span><span style="color:#464646">！传出去了，透过 </span><span style="color:#464646">eth0 </span><span style="color:#464646">将封包传给 </span><span style="color:#464646">192.168.10.30</span><span style="color:#464646">那部 </span><span style="color:#464646">gateway </span><span style="color:#464646">主机啊！所以说，路由是有顺序的。因此当你重复设定多个同样的路由时，例如在你的主机上的两张网路卡设定为相同网域的 </span><span style="color:#464646">IP </span><span style="color:#464646">时，会出现什么情况？会出现如下的情况：</span><span style="color:#464646"><br> Kernel IP routing table<br> Destination Gateway Genmask Flags Metric Ref Use Iface<br> 192.168.10.0 0.0.0.0 255.255.255.0 U 0 0 0 eth0<br> 192.168.10.0 0.0.0.0 255.255.255.0 U 0 0 0 eth1<br> </span><span style="color:#464646">也就是说，由于路由是依照顺序来排列与传送的，所以不论封包是由那个介面</span><span style="color:#464646"> (eth0, eth1) </span><span style="color:#464646">所接收，都会由上述的 </span><span style="color:#464646">eth0 </span><span style="color:#464646">传送出去，所以，在一部主机上面设定两个相同网域的 </span><span style="color:#464646">IP </span><span style="color:#464646">本身没有什么意义！有点多此一举就是了。除非是类似虚拟主机 </span><span style="color:#464646">(Xen, VMware </span><span style="color:#464646">等软体</span><span style="color:#464646">) </span><span style="color:#464646">所架设的多主机时，才会有这个必要～</span><span style="color:#464646"><br> </span><span style="color:#464646">范例二：路由的增加与删除</span><span style="color:#464646"><br> [root@linux ~]# route del -net 169.254.0.0 netmask 255.255.0.0 dev eth0<br> # </span><span style="color:#464646">上面这个动作可以删除掉 </span><span style="color:#464646">169.254.0.0/16 </span><span style="color:#464646">这个网域！</span><span style="color:#464646"><br> # </span><span style="color:#464646">请注意，在删除的时候，需要将路由表上面出现的资讯都写入</span><span style="color:#464646"><br> # </span><span style="color:#464646">包括 </span><span style="color:#464646">netmask , dev </span><span style="color:#464646">等等参数喔！注意注意</span><span style="color:#464646"><br> [root@linux ~]# route add -net 192.168.100.0 netmask 255.255.255.0 dev eth0<br> # </span><span style="color:#464646">透过 </span><span style="color:#464646">route add </span><span style="color:#464646">来增加一个路由！请注意，这个路由必须要能够与你互通。</span><span style="color:#464646"><br> # </span><span style="color:#464646">举例来说，如果我下达底下的指令就会显示错误：</span><span style="color:#464646"><br> # route add -net 192.168.200.0 netmask 255.255.255.0 gw 192.168.200.254<br> # </span><span style="color:#464646">因为我的环境内仅有 </span><span style="color:#464646">192.168.10.100 </span><span style="color:#464646">这个 </span><span style="color:#464646">IP </span><span style="color:#464646">，所以不能与 </span><span style="color:#464646">192.168.200.254<br> # </span><span style="color:#464646">这个网段直接使用 </span><span style="color:#464646">MAC </span><span style="color:#464646">互通！这样说，可以理解喔！？</span><span style="color:#464646"><br> [root@linux ~]# route add default gw 192.168.10.30<br> # </span><span style="color:#464646">增加预设路由的方法！请注意，只要有一个预设路由就够了喔！</span><span style="color:#464646"><br> # </span><span style="color:#464646">在这个地方如果您随便设定后，记得使用底下的指令重新设定你的网路</span><span style="color:#464646"><br> # /etc/init.d/network restart<br> </span><span style="color:#464646">如果是要进行路由的删除与增加，那就得要参考上面的例子了，其实，使用</span><span style="color:#464646"> man route </span><span style="color:#464646">里面的资料就很丰富了！仔细查阅一下囉！你只要记得，当出现『</span><span style="color:#464646">SIOCADDRT: Network is unreachable</span><span style="color:#464646">』这个错误时，肯定是由于 </span><span style="color:#464646">gw </span><span style="color:#464646">后面接的 </span><span style="color:#464646">IP </span><span style="color:#464646">无法直接与您的网域沟通 </span><span style="color:#464646">(Gateway </span><span style="color:#464646">并不在你的网域内</span><span style="color:#464646">)</span><span style="color:#464646">，所以，赶紧检查一下是否输入错误啊！加油吧！</span></p>
<p style="background:#BCD3E5"><span style="color:#464646"> </span></p>
<p style="background:#BCD3E5"><span style="color:#464646"># route </span><span style="color:#464646">命令添加的路由，机器重启或者网卡重启后就没掉了，在</span><span style="color:#464646">linux</span><span style="color:#464646">下设置永久路由的方法：</span><span style="color:#464646"><br> 1.</span><span style="color:#464646">在</span><span style="color:#464646">/etc/rc.local</span><span style="color:#464646">里添加</span><span style="color:#464646"><br> 2.</span><span style="color:#464646">在</span><span style="color:#464646">/etc/sysconfig/network</span><span style="color:#464646">里添加到末尾</span><span style="color:#464646"><br> 3./etc/sysconfig/static-router :<br> any net x.x.x.x/24 gw y.y.y.y</span></p>
<p style="background:#BCD3E5"><span style="color:#464646"> </span></p>
<p style="background:#BCD3E5"><span style="color:#464646">=========================================================================================== </span>WINDOWS<span style="color:#464646">下的route</span>命令：</p>
<p style="background:#BCD3E5"><span style="color:#464646">简单的的操作如下，</span></p>
<p style="background:#BCD3E5"><span style="color:#464646">查看路由状态：route print</span></p>
<p style="background:#BCD3E5"><span style="color:#464646">只查看ipv4</span>（ipv6）路由状态：routeprint -4(-6)</p>
<p style="background:#BCD3E5"><span style="color:#464646">添加路由：route add </span>目的网络 mask 子网掩码 网关 ——重启机器或网卡失效</p>
<p style="background:#BCD3E5"><span style="color:#464646">route add 192.168.20.0 mask 255.255.255.0 192.168.10.1</span></p>
<p style="background:#BCD3E5"><span style="color:#464646">添加永久：route -p add </span>目的网络 mask 子网掩码网关</p>
<p style="background:#BCD3E5"><span style="color:#464646">route -p add 192.168.20.0 mask 255.255.255.0 192.168.10.1</span></p>
<p style="background:#BCD3E5"><span style="color:#464646">删除路由：route delete </span> 目的网络 mask 子网掩码</p>
<p style="background:#BCD3E5"><span style="color:#464646">route delete 192.168.20.0 mask 255.255.255.0</span></p>
<div>
<table border="0" width="660">
<tbody>
<tr>
<td> <h2>UNIX环境高级编程读书笔记（十一）—终端IO （3）</h2> </td>
</tr>
<tr>
<td>
<div>
<table border="0" width="80%">
</table>
</div> </td>
</tr>
<tr>
<td> <p>来源: ChinaUnix博客 日期： 2007.04.09 15:09 (共有条评论) <span style="color:#0044B6">我要评论</span></p> </td>
</tr>
<tr>
<td> <p> </p> </td>
</tr>
<tr>
<td> <p>2.<br> 名称:：<br> cfgetispeed/cfgetospeed/cfsetispeed/cfsetospeed<br> 功能：<br> 波特率函数<br> 头文件：<br> #include <br> 函数原形：<br> speed_t cfgetispeed(const struct termios *termptr);<br> speed_t cfgetospeed(const struct termios *termptr);<br> int cfsetispeed(struct termios *termotr,speed_t speed);<br> int cfsetospeed(struct termios *termotr,speed_t speed);<br> 参数：<br> <br> 返回值：<br> 返回波特率（ cfgetispeed， cfgetospeed）<br> 若成功返回0，若出错则返回-1（ cfsetispeed， cfsetospeed）<br> 波特率是一个以往采用的术语，现在它指的是“位/秒”。虽然大多数终端设备对输入和输出使用同一波特率，但是只要硬件许可，可以将它们设置为两个不同值。<br> <br> 3．<br> 名称:：<br> tcdrain/tcflow/tcflush/tcsendbreak<br> 功能：<br> 行控制函数<br> 头文件：<br> #include <br> 函数原形：<br> int tcdrain(int filedes);<br> int tcglow(int files,int action);<br> int tcflush(int files,int queue);<br> int tcsendbread(int filedes,int duration);<br> 参数：<br> filedes 终端I/O所对应的文件的文件描述符<br> 返回值：<br> 若成功返回0，若出错则返回-1<br> tcdrain函数等待所有输出都被发送。tcflow用于对输入和输出流控制进行控制。action参数应当是下列四个值：<br> TCOOFF 输出被挂起<br> TCOON 以前被挂起的输出被重新启动<br> TCIOFF 系统发送一个STOP字符。这将使终端设备暂停发送数据。<br> TCION 系统发送一个START字符。这将使终端恢复发送数据。<br> tcflush函数刷清输入缓存或输出缓存。queue参数应当是下列三个参数之一：<br> TCIFLUSH 刷清输入队列<br> TCOFLUSH 刷清输出队列<br> TCIOFLUSH 刷清输入、输出队列<br> tcsendbread函数在一个指定的时间区间内发送连续的0位流。若duration参数为0，则此种发送延续0.25~0.5秒之间。<br> <br> 4．<br> 名称:：<br> ctermid(char *ptr);<br> 功能：<br> 决定终端的名字<br> 头文件：<br> #include <br> 函数原形：<br> char *ctermid(char *ptr);<br> 参数：<br> ptr 存放控制终端名的数组<br> 返回值：<br> 若成功则返回指向控制终端名的指针，若出错则返回指向空字符串的指针。<br> ctermid可却定终端的名字。<br> 如果ptr是非空，则它被认为是一个指针，指向长度至少为L_ctermid字节的数组，进程的控制终端名存放在该数组中。参数L_ctermid定义在中。若ptr是是一个空指针，则该函数为数组分配空间。同样，进程的控制终端名存放在该数组中。<br> 大部分UNIX系统中，控制终端的名称是/dev/tty/。所以此函数的主要作用是帮助提高向其他操作系统的可移植性。<br> <br> 5．<br> 名称:：<br> isatty<br> 功能：<br> 判断文件是不是一个终端设备文件<br> 头文件：<br> #include <br> 函数原形：<br> int isatty(int filedes);<br> 参数：<br> filedes 终端I/O所对应的文件的文件描述符<br> 返回值：<br> 若终端设备则为1，否则为0。<br> isatty函数用于判断文件是不是一个终端设备。下面是实例：<br> <br> /*11_2.c*/<br> #include <br> <br> int main(void)<br> {<br> printf(“fd 0:%s\n”,isatty(0)?”tty”:”not a tty”);<br> printf(“fd 1:%s\n”,isatty(1)?”tty”,”not a tty”);<br> printf(“fd2:%s\n”,isatty(2)?”tty”,”not a tty”); <br> exit(0);<br> }<br> <br> 下面是运行结果：<br> #./11_2<br> fd 0:tty<br> fd 1:tty<br> fd 2:tty<br> #./11_2 /dev/null<br> fd 0:not a tty<br> fd: 1:tty<br> fd2:not a tty<br> <br> 6．<br> 名称:：<br> ttyname<br> 功能：<br> 判断是不是终端设备文件如果是打印路径名<br> 头文件：<br> #include <br> 函数原形：<br> char *ttyname(int filedes);<br> 参数：<br> filedes 终端I/O所对应的文件的文件描述符<br> 返回值：<br> 指向终端路径名的指针，若出错则为NULL<br> 每个文件系统有一个唯一的设备号（stat结构中的st_dev字段），文件系统每个目录项有唯一的i节点号（stat结构中的st_ino字段）。ttyname会读/dev目录，寻找具有相同设备号和i节点编号的表项。在此函数中设定当找到一个匹配的设备号和匹配的i节点号时，就找到了所希望的目录项。<br> #include <br> #include <br> #include <br> <br> int main(void)<br> {<br> char *name;<br> <br> if(isatty(0))<br> {<br> name=ttyname(0);<br> if(name==NULL)<br> name=”undefined”;<br> printf(“fd 0:%s\n”,name);<br> }<br> else<br> printf(“not a tty\n”);<br> <br> if(isatty(1))<br> {<br> name=ttyname(1);<br> if(name==NULL)<br> name=”undefined”);<br> printf(“fd 1:%s\n”,name);<br> }<br> else<br> printf(“not a tty\n”);<br> <br> if(isatty(2))<br> {<br> name=ttyname(2);<br> if(name==NULL)<br> name=”undefined”);<br> printf(“not a tty\n”);<br> }<br> else<br> printf(“not a tty\n”);<br> exit(0);<br> }<br> #./11_3<br> fd 0: /dev/tty1<br> fd 1: /dev/tty1<br> fd 2: /dev/tty1<br> #./11_3 /dev/null<br> fd 0: /dev/console<br> fd1: /dev/tty1<br> not a tty</p> </td>
</tr>
</tbody>
</table>
</div>
<h2>select()函数以及FD_ZERO、FD_SET、FD_CLR、FD_ISSET</h2>
<p><span style="color:#454545">select</span><span style="color:#454545">函数用于在非阻塞中，当一个套接字或一组套接字有信号时通知你，系统提供</span><span style="color:#454545">select</span><span style="color:#454545">函数来实现多路复用输入</span><span style="color:#454545">/</span><span style="color:#454545">输出模型，原型：</span><span style="color:#454545"> <br> #include <sys/time.h> <br> #include <unistd.h> <br> int select(int maxfd,fd_set *rdset,fd_set *wrset,fd_set *exset,struct timeval *timeout); <br> </span><span style="color:#454545">参数</span><span style="color:#454545">maxfd</span><span style="color:#454545">是需要监视的最大的文件描述符值</span><span style="color:#454545">+1</span><span style="color:#454545">；</span><span style="color:#454545">rdset,wrset,exset</span><span style="color:#454545">分别对应于需要检测的可读文件描述符的集合，可写文件描述符的集</span><span style="color:#454545"> </span><span style="color:#454545">合及异常文件描述符的集合。</span><span style="color:#454545">struct timeval</span><span style="color:#454545">结构用于描述一段时间长度，如果在这个时间内，需要监视的描述符没有事件发生则函数返回，返回值为</span><span style="color:#454545">0</span><span style="color:#454545">。</span><span style="color:#454545"> <br> fd_set</span><span style="color:#454545">（它比较重要所以先介绍一下）是一组文件描述字</span><span style="color:#454545">(fd)</span><span style="color:#454545">的集合，它用一位来表示一个</span><span style="color:#454545">fd</span><span style="color:#454545">（下面会仔细介绍），对于</span><span style="color:#454545">fd_set</span><span style="color:#454545">类型通过下面四个宏来操作：</span><span style="color:#454545"> <br> FD_ZERO(fd_set *fdset);</span><span style="color:#454545">将指定的文件描述符集清空，在对文件描述符集合进行设置前，必须对其进行初始化，如果不清空，由于在系统分配内存空间后，通常并不作清空处理，所以结果是不可知的。</span><span style="color:#454545"> <br> FD_SET(int fd, fd_set *fdset);</span><span style="color:#454545">用于在文件描述符集合中增加一个新的文件描述符。</span><span style="color:#454545"> <br> FD_CLR(int fd, fd_set *fdset);</span><span style="color:#454545">用于在文件描述符集合中删除一个文件描述符。</span><span style="color:#454545"> <br> FD_ISSET(int fd, fd_set *fdset);</span><span style="color:#454545">用于测试指定的文件描述符是否在该集合中。</span><span style="color:#454545"> <br> </span><span style="color:#454545">过去，一个</span><span style="color:#454545">fd_set</span><span style="color:#454545">通常只能包含</span><span style="color:#454545"><32</span><span style="color:#454545">的</span><span style="color:#454545">fd</span><span style="color:#454545">（文件描述字），因为</span><span style="color:#454545">fd_set</span><span style="color:#454545">其实只用了一个</span><span style="color:#454545">32</span><span style="color:#454545">位矢量来表示</span><span style="color:#454545">fd</span><span style="color:#454545">；现在</span><span style="color:#454545">,UNIX</span><span style="color:#454545">系统通常会在头文件</span><span style="color:#454545"><sys/select.h></span><span style="color:#454545">中定义常量</span><span style="color:#454545">FD_SETSIZE</span><span style="color:#454545">，它是数据类型</span><span style="color:#454545">fd_set</span><span style="color:#454545">的描述字数量，其值通常是</span><span style="color:#454545">1024</span><span style="color:#454545">，这样就能表示</span><span style="color:#454545"><1024</span><span style="color:#454545">的</span><span style="color:#454545">fd</span><span style="color:#454545">。根据</span><span style="color:#454545">fd_set</span><span style="color:#454545">的位矢量实现，我们可以重新理解操作</span><span style="color:#454545">fd_set</span><span style="color:#454545">的四个宏：</span><span style="color:#454545"> <br> fd_set set;<br> FD_ZERO(&set); <br> FD_SET(0, &set); <br> FD_CLR(4, &set); <br> FD_ISSET(5, &set); <br> ―――――――――――――――――――――――――――――――――――――――<br> </span><span style="color:#454545">注意</span><span style="color:#454545">fd</span><span style="color:#454545">的最大值必须</span><span style="color:#454545"><FD_SETSIZE</span><span style="color:#454545">。</span><span style="color:#454545"><br> ―――――――――――――――――――――――――――――――――――――――</span></p>
<p><span style="color:#454545"> select</span><span style="color:#454545">函数的接口比较简单：</span><span style="color:#454545"><br> int select(int nfds, fd_set *readset, fd_set *writeset,fd_set* exceptset, struct tim *timeout);</span></p>
<p><span style="color:#454545">功能：</span><span style="color:#454545"><br> </span><span style="color:#454545">测试指定的</span><span style="color:#454545">fd</span><span style="color:#454545">可读？可写？有异常条件待处理？</span><span style="color:#454545"> <br> </span><span style="color:#454545">参数：</span></p>
<p><span style="color:#454545">—— nfds <br> </span><span style="color:#454545">需要检查的文件描述字个数（即检查到</span><span style="color:#454545">fd_set</span><span style="color:#454545">的第几位），数值应该比三组</span><span style="color:#454545">fd_set</span><span style="color:#454545">中所含的最大</span><span style="color:#454545">fd</span><span style="color:#454545">值更大，一般设为三组</span><span style="color:#454545">fd_set</span><span style="color:#454545">中所含的最大</span><span style="color:#454545">fd</span><span style="color:#454545">值加</span><span style="color:#454545">1</span><span style="color:#454545">（如在</span><span style="color:#454545">readset,writeset,exceptset</span><span style="color:#454545">中所含最大的</span><span style="color:#454545">fd</span><span style="color:#454545">为</span><span style="color:#454545">5</span><span style="color:#454545">，则</span><span style="color:#454545">nfds=6</span><span style="color:#454545">，因为</span><span style="color:#454545">fd</span><span style="color:#454545">是从</span><span style="color:#454545">0</span><span style="color:#454545">开始的）。设这个值是为提高效率，使函数不必检查</span><span style="color:#454545">fd_set</span><span style="color:#454545">的所有</span><span style="color:#454545">1024</span><span style="color:#454545">位。</span><span style="color:#454545"><br> —— readset <br> </span><span style="color:#454545">用来检查可读性的一组文件描述字。</span><span style="color:#454545"><br> —— writeset<br> </span><span style="color:#454545">用来检查可写性的一组文件描述字。</span><span style="color:#454545"><br> —— exceptset<br> </span><span style="color:#454545">用来检查是否有异常条件出现的文件描述字。</span><span style="color:#454545">(</span><span style="color:#454545">注：错误不包括在异常条件之内</span><span style="color:#454545">)<br> —— timeout<br> </span><span style="color:#454545">用于描述一段时间长度，如果在这个时间内，需要监视的描述符没有事件发生则函数返回，返回值为</span><span style="color:#454545">0</span><span style="color:#454545">。</span><span style="color:#454545"> <br> </span><span style="color:#454545">有三种可能：</span><span style="color:#454545"><br> 1.timeout=NULL</span><span style="color:#454545">（阻塞：</span><span style="color:#454545">select</span><span style="color:#454545">将一直被阻塞，直到某个文件描述符上发生了事件）</span><span style="color:#454545"><br> 2.timeout</span><span style="color:#454545">所指向的结构设为非零时间（等待固定时间：如果在指定的时间段里有事件发生或者时间耗尽，函数均返回）</span><span style="color:#454545"><br> 3.timeout</span><span style="color:#454545">所指向的结构，时间设为</span><span style="color:#454545">0</span><span style="color:#454545">（非阻塞：仅检测描述符集合的状态，然后立即返回，并不等待外部事件的发生）</span></p>
<p><span style="color:#454545">返回值：</span><span style="color:#454545"> <br> </span><span style="color:#454545">返回对应位仍然为</span><span style="color:#454545">1</span><span style="color:#454545">的</span><span style="color:#454545">fd</span><span style="color:#454545">的总数。</span></p>
<p><span style="color:#454545">Remarks</span><span style="color:#454545">：</span><span style="color:#454545"><br> </span><span style="color:#454545">三组</span><span style="color:#454545">fd_set</span><span style="color:#454545">均将某些</span><span style="color:#454545">fd</span><span style="color:#454545">位置</span><span style="color:#454545">0</span><span style="color:#454545">，只有那些可读，可写以及有异常条件待处理的</span><span style="color:#454545">fd</span><span style="color:#454545">位仍然为</span><span style="color:#454545">1</span><span style="color:#454545">。</span></p>
<p><span style="color:#454545">举个例子，比如</span><span style="color:#454545">recv(), </span><span style="color:#454545">在没有数据到来调用它的时候</span><span style="color:#454545">,</span><span style="color:#454545">你的线程将被阻塞</span><span style="color:#454545">,</span><span style="color:#454545">如果数据一直不来</span><span style="color:#454545">,</span><span style="color:#454545">你的线程就要阻塞很久</span><span style="color:#454545">.</span><span style="color:#454545">这样显然不好</span><span style="color:#454545">. <br> </span><span style="color:#454545">所以采用</span><span style="color:#454545">select</span><span style="color:#454545">来查看套节字是否可读</span><span style="color:#454545">(</span><span style="color:#454545">也就是是否有数据读了</span><span style="color:#454545">) <br> </span><span style="color:#454545">步骤如下</span><span style="color:#454545">—— <br> socket s; <br> ..... <br> fd_set set; <br> while(1) <br> { <br> FD_ZERO(&set);//</span><span style="color:#454545">将你的套节字集合清空</span><span style="color:#454545"> <br> FD_SET(s, &set);//</span><span style="color:#454545">加入你感兴趣的套节字到集合</span><span style="color:#454545">,</span><span style="color:#454545">这里是一个读数据的套节字</span><span style="color:#454545">s <br> select(0,&set,NULL,NULL,NULL);//</span><span style="color:#454545">检查套节字是否可读</span><span style="color:#454545">, <br> //</span><span style="color:#454545">很多情况下就是是否有数据</span><span style="color:#454545">(</span><span style="color:#454545">注意</span><span style="color:#454545">,</span><span style="color:#454545">只是说很多情况</span><span style="color:#454545">) <br> //</span><span style="color:#454545">这里</span><span style="color:#454545">select</span><span style="color:#454545">是否出错没有写</span><span style="color:#454545"> <br> if(FD_ISSET(s, &set) //</span><span style="color:#454545">检查</span><span style="color:#454545">s</span><span style="color:#454545">是否在这个集合里面</span><span style="color:#454545">, <br> { //select</span><span style="color:#454545">将更新这个集合</span><span style="color:#454545">,</span><span style="color:#454545">把其中不可读的套节字去掉</span><span style="color:#454545"> <br> //</span><span style="color:#454545">只保留符合条件的套节字在这个集合里面</span><span style="color:#454545"> <br> recv(s,...); <br> } <br> //do something here <br> } </span></p>
<p><span style="color:#454545"> </span><span style="color:#454545">理解</span><span style="color:#454545">select</span><span style="color:#454545">模型的关键在于理解</span><span style="color:#454545">fd_set,</span><span style="color:#454545">为说明方便，取</span><span style="color:#454545">fd_set</span><span style="color:#454545">长度为</span><span style="color:#454545">1</span><span style="color:#454545">字节，</span><span style="color:#454545">fd_set</span><span style="color:#454545">中的每一</span><span style="color:#454545">bit</span><span style="color:#454545">可以对应一个文件描述符</span><span style="color:#454545">fd</span><span style="color:#454545">。则</span><span style="color:#454545">1</span><span style="color:#454545">字节长的</span><span style="color:#454545">fd_set</span><span style="color:#454545">最大可以对应</span><span style="color:#454545">8</span><span style="color:#454545">个</span><span style="color:#454545">fd</span><span style="color:#454545">。</span><span style="color:#454545"><br> </span><span style="color:#454545">（</span><span style="color:#454545">1</span><span style="color:#454545">）执行</span><span style="color:#454545">fd_set set; FD_ZERO(&set);</span><span style="color:#454545">则</span><span style="color:#454545">set</span><span style="color:#454545">用位表示是</span><span style="color:#454545">0000,0000</span><span style="color:#454545">。</span><span style="color:#454545"><br> </span><span style="color:#454545">（</span><span style="color:#454545">2</span><span style="color:#454545">）若</span><span style="color:#454545">fd</span><span style="color:#454545">＝</span><span style="color:#454545">5,</span><span style="color:#454545">执行</span><span style="color:#454545">FD_SET(fd,&set);</span><span style="color:#454545">后</span><span style="color:#454545">set</span><span style="color:#454545">变为</span><span style="color:#454545">0001,0000(</span><span style="color:#454545">第</span><span style="color:#454545">5</span><span style="color:#454545">位置为</span><span style="color:#454545">1)<br> </span><span style="color:#454545">（</span><span style="color:#454545">3</span><span style="color:#454545">）若再加入</span><span style="color:#454545">fd</span><span style="color:#454545">＝</span><span style="color:#454545">2</span><span style="color:#454545">，</span><span style="color:#454545">fd=1,</span><span style="color:#454545">则</span><span style="color:#454545">set</span><span style="color:#454545">变为</span><span style="color:#454545">0001,0011<br> </span><span style="color:#454545">（</span><span style="color:#454545">4</span><span style="color:#454545">）执行</span><span style="color:#454545">select(6,&set,0,0,0)</span><span style="color:#454545">阻塞等待</span><span style="color:#454545"><br> </span><span style="color:#454545">（</span><span style="color:#454545">5</span><span style="color:#454545">）若</span><span style="color:#454545">fd=1,fd=2</span><span style="color:#454545">上都发生可读事件，则</span><span style="color:#454545">select</span><span style="color:#454545">返回，此时</span><span style="color:#454545">set</span><span style="color:#454545">变为</span><span style="color:#454545">0000,0011</span><span style="color:#454545">。注意：没有事件发生的</span><span style="color:#454545">fd=5</span><span style="color:#454545">被清空。</span><span style="color:#454545"><br> </span><span style="color:#454545">基于上面的讨论，可以轻松得出</span><span style="color:#454545">select</span><span style="color:#454545">模型的特点：</span><span style="color:#454545"><br> </span><span style="color:#454545">（</span><span style="color:#454545">1)</span><span style="color:#454545">可监控的文件描述符个数取决与</span><span style="color:#454545">sizeof(fd_set)</span><span style="color:#454545">的值。我这边服务</span><span style="color:#454545"> </span><span style="color:#454545">器上</span><span style="color:#454545">sizeof(fd_set)</span><span style="color:#454545">＝</span><span style="color:#454545">512</span><span style="color:#454545">，每</span><span style="color:#454545">bit</span><span style="color:#454545">表示一个文件描述符，则我服务器上支持的最大文件描述符是</span><span style="color:#454545">512*8=4096</span><span style="color:#454545">。据说可调，另有说虽</span><span style="color:#454545"> </span><span style="color:#454545">然可调，但调整上限受于编译内核时的变量值。本人对调整</span><span style="color:#454545">fd_set</span><span style="color:#454545">的大小不太感兴趣，参考</span><span style="color:#454545"><span style="color:#5F9BCD">http://www.cppblog.com</span>/CppExplore/archive/2008/03/21/45061.html</span><span style="color:#454545">中的模型</span><span style="color:#454545">2</span><span style="color:#454545">（</span><span style="color:#454545">1</span><span style="color:#454545">）可以有效突破</span><span style="color:#454545">select</span><span style="color:#454545">可监控的文件描述符上限。</span><span style="color:#454545"><br> </span><span style="color:#454545">（</span><span style="color:#454545">2</span><span style="color:#454545">）将</span><span style="color:#454545">fd</span><span style="color:#454545">加入</span><span style="color:#454545">select</span><span style="color:#454545">监控集的同时，还要再使用一个数据结构</span><span style="color:#454545">array</span><span style="color:#454545">保存放到</span><span style="color:#454545">select</span><span style="color:#454545">监控集中的</span><span style="color:#454545">fd</span><span style="color:#454545">，一是用于再</span><span style="color:#454545">select </span><span style="color:#454545">返回后，</span><span style="color:#454545">array</span><span style="color:#454545">作为源数据和</span><span style="color:#454545">fd_set</span><span style="color:#454545">进行</span><span style="color:#454545">FD_ISSET</span><span style="color:#454545">判断。二是</span><span style="color:#454545">select</span><span style="color:#454545">返回后会把以前加入的但并无事件发生的</span><span style="color:#454545">fd</span><span style="color:#454545">清空，则每次开始</span><span style="color:#454545"> select</span><span style="color:#454545">前都要重新从</span><span style="color:#454545">array</span><span style="color:#454545">取得</span><span style="color:#454545">fd</span><span style="color:#454545">逐一加入（</span><span style="color:#454545">FD_ZERO</span><span style="color:#454545">最先），扫描</span><span style="color:#454545">array</span><span style="color:#454545">的同时取得</span><span style="color:#454545">fd</span><span style="color:#454545">最大值</span><span style="color:#454545">maxfd</span><span style="color:#454545">，用于</span><span style="color:#454545">select</span><span style="color:#454545">的第一个</span><span style="color:#454545"> </span><span style="color:#454545">参数。</span><span style="color:#454545"><br> </span><span style="color:#454545">（</span><span style="color:#454545">3</span><span style="color:#454545">）可见</span><span style="color:#454545">select</span><span style="color:#454545">模型必须在</span><span style="color:#454545">select</span><span style="color:#454545">前循环</span><span style="color:#454545">array</span><span style="color:#454545">（加</span><span style="color:#454545">fd</span><span style="color:#454545">，取</span><span style="color:#454545">maxfd</span><span style="color:#454545">），</span><span style="color:#454545">select</span><span style="color:#454545">返回后循环</span><span style="color:#454545">array</span><span style="color:#454545">（</span><span style="color:#454545">FD_ISSET</span><span style="color:#454545">判断是否有时间发生）。</span><span style="color:#454545"><br> </span><span style="color:#454545">下面给一个伪码说明基本</span><span style="color:#454545">select</span><span style="color:#454545">模型的服务器模型：</span><span style="color:#454545"><br> array[slect_len];<br> nSock=0;<br> array[nSock++]=listen_fd;(</span><span style="color:#454545">之前</span><span style="color:#454545">listen port</span><span style="color:#454545">已绑定并</span><span style="color:#454545">listen)<br> maxfd=listen_fd;<br> while{<br> FD_ZERO(&set);<br> foreach (fd in array) <br> {<br> fd</span><span style="color:#454545">大于</span><span style="color:#454545">maxfd</span><span style="color:#454545">，则</span><span style="color:#454545">maxfd=fd<br> FD_SET(fd,&set)<br> }<br> res=select(maxfd+1,&set,0,0,0)</span><span style="color:#454545">；</span><span style="color:#454545"><br> if(FD_ISSET(listen_fd,&set))<br> {<br> newfd=accept(listen_fd);<br> array[nsock++]=newfd;<br> if(--res=0) continue<br> }<br> foreach </span><span style="color:#454545">下标</span><span style="color:#454545">1</span><span style="color:#454545">开始</span><span style="color:#454545"> (fd in array) <br> {<br> if(FD_ISSET(fd,&set))<br> </span><span style="color:#454545">执行读等相关操作</span><span style="color:#454545"><br> </span><span style="color:#454545">如果错误或者关闭，则要删除该</span><span style="color:#454545">fd</span><span style="color:#454545">，将</span><span style="color:#454545">array</span><span style="color:#454545">中相应位置和最后一个元素互换就好，</span><span style="color:#454545">nsock</span><span style="color:#454545">减一</span><span style="color:#454545"><br> if(--res=0) continue<br> }<br> }<br> </span><span style="color:#454545">使用</span><span style="color:#454545">select</span><span style="color:#454545">函数的过程一般是：</span><span style="color:#454545"><br> </span><span style="color:#454545">先调用宏</span><span style="color:#454545">FD_ZERO</span><span style="color:#454545">将指定的</span><span style="color:#454545">fd_set</span><span style="color:#454545">清零，然后调用宏</span><span style="color:#454545">FD_SET</span><span style="color:#454545">将需要测试的</span><span style="color:#454545">fd</span><span style="color:#454545">加入</span><span style="color:#454545">fd_set</span><span style="color:#454545">，接着调用函数</span><span style="color:#454545">select</span><span style="color:#454545">测试</span><span style="color:#454545">fd_set</span><span style="color:#454545">中的所有</span><span style="color:#454545">fd</span><span style="color:#454545">，最后用宏</span><span style="color:#454545">FD_ISSET</span><span style="color:#454545">检查某个</span><span style="color:#454545">fd</span><span style="color:#454545">在函数</span><span style="color:#454545">select</span><span style="color:#454545">调用后，相应位是否仍然为</span><span style="color:#454545">1</span><span style="color:#454545">。</span></p>
<p><span style="color:#454545"> </span><span style="color:#454545">以下是一个测试单个文件描述字可读性的例子：</span><span style="color:#454545"><br> int isready(int fd)<br> {<br> int rc;<br> fd_set fds;<br> struct tim tv; <br> FD_ZERO(&fds);<br> FD_SET(fd,&fds);<br> tv.tv_sec = tv.tv_usec = 0; <br> rc = select(fd+1, &fds, NULL, NULL, &tv);<br> if (rc < 0) //error<br> return -1; <br> return FD_ISSET(fd,&fds) ? 1 : 0;<br> }<br> </span><span style="color:#454545">下面还有一个复杂一些的应用：</span><span style="color:#454545"><br> //</span><span style="color:#454545">这段代码将指定测试</span><span style="color:#454545">Socket</span><span style="color:#454545">的描述字的可读可写性，因为</span><span style="color:#454545">Socket</span><span style="color:#454545">使用的也是</span><span style="color:#454545">fd<br> uint32 SocketWait(TSocket *s,bool rd,bool wr,uint32 timems) <br> {<br> fd_set rfds,wfds;<br> #ifdef _WIN32<br> TIM tv;<br> #else<br> struct tim tv;<br> #endif <br> FD_ZERO(&rfds);<br> FD_ZERO(&wfds); <br> if (rd) //TRUE<br> FD_SET(*s,&rfds); //</span><span style="color:#454545">添加要测试的描述字</span><span style="color:#454545"> <br> if (wr) //FALSE<br> FD_SET(*s,&wfds); <br> tv.tv_sec=timems/1000; //second<br> tv.tv_usec=timems%1000; //ms <br> for (;;) //</span><span style="color:#454545">如果</span><span style="color:#454545">errno==EINTR</span><span style="color:#454545">，反复测试缓冲区的可读性</span><span style="color:#454545"><br> switch(select((*s)+1,&rfds,&wfds,NULL,<br> (timems==TIME_INFINITE?NULL:&tv))) //</span><span style="color:#454545">测试在规定的时间内套接口接收缓冲区中是否有数据可读</span><span style="color:#454545"><br> { //0</span><span style="color:#454545">－－超时，</span><span style="color:#454545">-1</span><span style="color:#454545">－－出错</span><span style="color:#454545"><br> case 0: <br> return 0; <br> case (-1): <br> if (SocketError()==EINTR)<br> break; <br> return 0; //</span><span style="color:#454545">有错但不是</span><span style="color:#454545">EINTR <br> default:<br> if (FD_ISSET(*s,&rfds)) //</span><span style="color:#454545">如果</span><span style="color:#454545">s</span><span style="color:#454545">是</span><span style="color:#454545">fds</span><span style="color:#454545">中的一员返回非</span><span style="color:#454545">0</span><span style="color:#454545">，否则返回</span><span style="color:#454545">0<br> return 1;<br> if (FD_ISSET(*s,&wfds))<br> return 2;<br> return 0;<br> };<br> }</span></p>
<h2>ioctl 函数</h2>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)">本函数影响由fd 参数引用的一个打开的文件。</p>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)">#include<unistd.h></p>
<p style="background:rgb(239,239,239)">int ioctl( int fd, int request, .../* void *arg */ );</p>
<p style="background:rgb(239,239,239)">返回0 ：成功 -1 ：出错</p>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)">第三个参数总是一个指针，但指针的类型依赖于request 参数。</p>
<p style="background:rgb(239,239,239)">我们可以把和网络相关的请求划分为6 类：</p>
<p style="background:rgb(239,239,239)">套接口操作</p>
<p style="background:rgb(239,239,239)">文件操作</p>
<p style="background:rgb(239,239,239)">接口操作</p>
<p style="background:rgb(239,239,239)">ARP 高速缓存操作</p>
<p style="background:rgb(239,239,239)">路由表操作</p>
<p style="background:rgb(239,239,239)">流系统</p>
<p style="background:rgb(239,239,239)">下表列出了网络相关ioctl 请求的request 参数以及arg 地址必须指向的数据类型：</p>
<p style="background:rgb(239,239,239)"> </p>
<table border="0" width="576">
<tbody>
<tr>
<td> <p>类别</p> </td>
<td> <p>Request</p> </td>
<td> <p>说明</p> </td>
<td> <p>数据类型</p> </td>
</tr>
<tr>
<td> <p><strong>套</strong></p> <p><strong>接</strong></p> <p><strong>口</strong></p> </td>
<td> <p>SIOCATMARK</p> <p>SIOCSPGRP</p> <p>SIOCGPGRP</p> </td>
<td> <p>是否位于带外标记</p> <p>设置套接口的进程ID 或进程组ID</p> <p>获取套接口的进程ID 或进程组ID</p> </td>
<td> <p>int</p> <p>int</p> <p>int</p> </td>
</tr>
<tr>
<td> <p> </p> <p><strong>文</strong></p> <p><strong> </strong></p> <p><strong>件</strong></p> <p> </p> <p> </p> </td>
<td> <p>FIONBIN</p> <p>FIOASYNC</p> <p>FIONREAD</p> <p>FIOSETOWN</p> <p>FIOGETOWN</p> <p> </p> </td>
<td> <p>设置/ 清除非阻塞I/O 标志</p> <p>设置/ 清除信号驱动异步I/O 标志</p> <p>获取接收缓存区中的字节数</p> <p>设置文件的进程ID 或进程组ID</p> <p>获取文件的进程ID 或进程组ID</p> </td>
<td> <p>int</p> <p>int</p> <p>int</p> <p>int</p> <p>int</p> </td>
</tr>
<tr>
<td> <p> </p> <p> </p> <p> </p> <p> </p> <p><strong>接</strong></p> <p><strong>口</strong></p> <p><strong> </strong></p> <p><strong> </strong></p> <p><strong> </strong></p> <p><strong> </strong></p> <p><strong> </strong></p> <p><strong> </strong></p> <p><strong> </strong></p> <p><strong> </strong></p> <p><strong> </strong></p> <p> </p> </td>
<td> <p>SIOCGIFCONF</p> <p>SIOCSIFADDR</p> <p>SIOCGIFADDR</p> <p>SIOCSIFFLAGS</p> <p>SIOCGIFFLAGS</p> <p>SIOCSIFDSTADDR</p> <p>SIOCGIFDSTADDR</p> <p>SIOCGIFBRDADDR</p> <p>SIOCSIFBRDADDR</p> <p>SIOCGIFNETMASK</p> <p>SIOCSIFNETMASK</p> <p>SIOCGIFMETRIC</p> <p>SIOCSIFMETRIC</p> <p>SIOCGIFMTU</p> <p>SIOCxxx</p> </td>
<td> <p>获取所有接口的清单</p> <p>设置接口地址</p> <p>获取接口地址</p> <p>设置接口标志</p> <p>获取接口标志</p> <p>设置点到点地址</p> <p>获取点到点地址</p> <p>获取广播地址</p> <p>设置广播地址</p> <p>获取子网掩码</p> <p>设置子网掩码</p> <p>获取接口的测度</p> <p>设置接口的测度</p> <p>获取接口MTU</p> <p>（还有很多取决于系统的实现）</p> </td>
<td> <p>struct ifconf</p> <p>struct ifreq</p> <p>struct ifreq</p> <p>struct ifreq</p> <p>struct ifreq</p> <p>struct ifreq</p> <p>struct ifreq</p> <p>struct ifreq</p> <p>struct ifreq</p> <p>struct ifreq</p> <p>struct ifreq</p> <p>struct ifreq</p> <p>struct ifreq</p> <p>struct ifreq</p> </td>
</tr>
<tr>
<td> <p> </p> <p><strong>ARP</strong></p> </td>
<td> <p>SIOCSARP</p> <p>SIOCGARP</p> <p>SIOCDARP</p> </td>
<td> <p>创建/ 修改ARP 表项</p> <p>获取ARP 表项</p> <p>删除ARP 表项</p> </td>
<td> <p>struct arpreq</p> <p>struct arpreq</p> <p>struct arpreq</p> </td>
</tr>
<tr>
<td> <p><strong>路</strong></p> <p><strong>由</strong></p> </td>
<td> <p>SIOCADDRT</p> <p>SIOCDELRT</p> </td>
<td> <p>增加路径</p> <p>删除路径</p> </td>
<td> <p>struct rtentry</p> <p>struct rtentry</p> </td>
</tr>
<tr>
<td> <p><strong>流</strong></p> </td>
<td> <p>I_xxx</p> </td>
<td> <p> </p> </td>
<td> <p> </p> </td>
</tr>
</tbody>
</table>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)"><strong>套接口操作：</strong></p>
<p style="background:rgb(239,239,239)">明确用于套接口操作的ioctl 请求有三个, 它们都要求ioctl 的第三个参数是指向某个整数的一个指针。</p>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)">SIOCATMARK: 如果本套接口的的度指针当前位于带外标记，那就通过由第三个参数指向的整数返回一个非0 值；否则返回一个0 值。POSIX 以函数sockatmark 替换本请求。</p>
<p style="background:rgb(239,239,239)">SIOCGPGRP ： 通过第三个参数指向的整数返回本套接口的进程ID 或进程组ID ，该ID 指定针对本套接口的SIGIO 或SIGURG 信号的接收进程。本请求和fcntl 的F_GETOWN 命令等效，POSIX 标准化的是fcntl 函数。</p>
<p style="background:rgb(239,239,239)">SIOCSPGRP ： 把本套接口的进程ID 或者进程组ID 设置成第三个参数指向的整数，该ID 指定针对本套接口的SIGIO 或SIGURG 信号的接收进程，本请求和fcntl 的F_SETOWN 命令等效，POSIX 标准化的是fcntl 操作。</p>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)"><strong>文件操作：</strong></p>
<p style="background:rgb(239,239,239)">以下5 个请求都要求ioctl 的第三个参数指向一个整数。</p>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)">FIONBIO ： 根据ioctl 的第三个参数指向一个0 或非0 值分别清除或设置本套接口的非阻塞标志。本请求和O_NONBLOCK 文件状态标志等效，而该标志通过fcntl 的F_SETFL 命令清除或设置。</p>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)">FIOASYNC ： 根据iocl 的第三个参数指向一个0 值或非0 值分别清除或设置针对本套接口的信号驱动异步I/O 标志，它决定是否收取针对本套接口的异步I/O 信号（SIGIO ）。本请求和O_ASYNC 文件状态标志等效，而该标志可以通过fcntl 的F_SETFL 命令清除或设置。</p>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)">FIONREAD ： 通过由ioctl 的第三个参数指向的整数返回当前在本套接口接收缓冲区中的字节数。本特性同样适用于文件，管道和终端。</p>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)">FIOSETOWN ： 对于套接口和SIOCSPGRP 等效。</p>
<p style="background:rgb(239,239,239)">FIOGETOWN ： 对于套接口和SIOCGPGRP 等效。</p>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)">接口配置：</p>
<p style="background:rgb(239,239,239)">得到系统中所有接口由SIOCGIFCONF 请求完成，该请求使用ifconf 结构，ifconf 又使用ifreq</p>
<p style="background:rgb(239,239,239)">结构，如下所示：</p>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)">Struct ifconf{</p>
<p style="background:rgb(239,239,239)"> intifc_len; // 缓冲区的大小</p>
<p style="background:rgb(239,239,239)"> union{</p>
<p style="background:rgb(239,239,239)"> caddr_tifcu_buf; // input fromuser->kernel</p>
<p style="background:rgb(239,239,239)"> struct ifreq*ifcu_req; // return of structures returned</p>
<p style="background:rgb(239,239,239)"> }ifc_ifcu;</p>
<p style="background:rgb(239,239,239)">};</p>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)">#define ifc_buf ifc_ifcu.ifcu_buf //buffer address</p>
<p style="background:rgb(239,239,239)">#define ifc_req ifc_ifcu.ifcu_req //array of structures returned</p>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)">#define IFNAMSIZ 16</p>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)">struct ifreq{</p>
<p style="background:rgb(239,239,239)"> charifr_name[IFNAMSIZ]; // interface name, e.g., “le0”</p>
<p style="background:rgb(239,239,239)"> union{</p>
<p style="background:rgb(239,239,239)"> structsockaddr ifru_addr;</p>
<p style="background:rgb(239,239,239)"> structsockaddr ifru_dstaddr;</p>
<p style="background:rgb(239,239,239)"> structsockaddr ifru_broadaddr;</p>
<p style="background:rgb(239,239,239)"> shortifru_flags;</p>
<p style="background:rgb(239,239,239)"> intifru_metric;</p>
<p style="background:rgb(239,239,239)"> caddr_tifru_data;</p>
<p style="background:rgb(239,239,239)"> }ifr_ifru;</p>
<p style="background:rgb(239,239,239)">};</p>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)">#define ifr_addr ifr_ifru.ifru_addr // address</p>
<p style="background:rgb(239,239,239)">#define ifr_dstaddr ifr_ifru.ifru_dstaddr // otner end of p-to-p link</p>
<p style="background:rgb(239,239,239)">#define ifr_broadaddrifr_ifru.ifru_broadaddr // broadcast address</p>
<p style="background:rgb(239,239,239)">#define ifr_flags ifr_ifru.ifru_flags // flags</p>
<p style="background:rgb(239,239,239)">#define ifr_metric ifr_ifru.ifru_metric // metric</p>
<p style="background:rgb(239,239,239)">#define ifr_data ifr_ifru.ifru_data // for use byinterface</p>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)">再调用ioctl 前我们必须先分撇一个缓冲区和一个ifconf 结构，然后才初始化后者。如下图</p>
<p style="background:rgb(239,239,239)">展示了一个ifconf 结构的初始化结构，其中缓冲区的大小为1024 ，ioctl 的第三个参数指向</p>
<p style="background:rgb(239,239,239)">这样一个ifconf 结构。</p>
<table border="0">
<tbody>
<tr>
<td> <p>ifc_len</p> </td>
</tr>
<tr>
<td> <p> Ifc_buf</p> </td>
</tr>
</tbody>
</table>
<p style="background:rgb(239,239,239)">1024</p>
<p style="background:rgb(239,239,239)">---------------------> 缓存</p>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)"> </p>
<p style="background:rgb(239,239,239)">假设内核返回2 个ifreq 结构，ioctl 返回时通过同一个ifconf 结构缓冲区填入了那2 个ifreq 结构，ifconf 结构的ifc_len 成员也被更新，以反映存放在缓冲区中的信息量</p>
<p style="background:rgb(239,239,239)">一般来讲ioctl在用户程序中的调用是：</p>
<p style="background:rgb(239,239,239)"><span style="color:red">ioctl(int fd,int command, (char*)argstruct)</span></p>
<p style="background:rgb(239,239,239)">ioctl调用与网络编程有关（本文只讨论这一点），文件描述符fd实际上是由socket()系统调用返回的。<span style="color:red">参数</span><span style="color:red">command</span><span style="color:red">的取值由</span><span style="color:red">/usr/include/linux/sockios.h</span> 所规定。这些command的由于功能的不同，可分为以下几个小类：<br> • 改变路由表 (例如 SIOCADDRT, SIOCDELRT), <br> • 读/更新ARP/RARP 缓存(如：SIOCDARP,SIOCSRARP), <br> • 一般的与网络接口有关的(例如 SIOCGIFNAME, SIOCSIFADDR 等等) <br> 在Gooodies目录下有很多样例程序展示了如何使用ioctl。当你看这些程序时，注意参数argstruct是与参数command相关的。例如，与 路由表相关的ioctl使用rtentry这种结构，rtentry定义在/usr/include/linux/route.h（参见例子 adddefault.c）。与ARP有关的ioctl调用使用arpreq结构，arpreq定义在/usr/include/linux /if_arp.h（参见例子arpread.c）</p>
<p style="background:rgb(239,239,239)">与网络接口有关的ioctl调用使用的command参数通常看起来像SIOCxIFyyyy的形式，这里x要 么是S（设定set，写write），要么是G（得到get，读read）。在getifinfo.c程序中就使用了这种形式的command参数来读 IP地址，硬件地址，广播地址和得到与网络接口有关的一些标志（flag）。在这些ioctl调用中，第三个参数是ifreq结构，它在/usr /include/linux/if.h中定义。在某些情况下， ioctrl调用可能会使用到在sockios.h之外的新的定义，例如，WaveLAN无线网络卡会保</p>
<p> </p>
<h2>（C语言）共用体union的用法举例</h2>
<p><span style="color:#999999">分类：</span><span style="color:#999999"> </span><span style="color:#999999"><span style="color:#336699">程序语言</span></span><span style="color:#999999">2008-10-27 15:14</span><span style="color:#999999"> </span><span style="color:#999999">16926</span><span style="color:#999999">人阅读</span><span style="color:#999999"> </span><span style="color:#999999"><span style="color:#336699">评论</span></span>(8)<span style="color:#999999"> </span><span style="color:#999999"><span style="color:#336699">收藏</span></span><span style="color:#999999"> </span><span style="color:#999999"><span style="color:#336699">举报</span></span></p>
<p><span style="color:#333333"><span style="color:#336699; background:#EEEEEE">语言</span></span><span style="color:#336699; background:#EEEEEE">c</span><span style="color:#336699; background:#EEEEEE">struct</span><span style="color:#336699; background:#EEEEEE">matrix</span><span style="color:#336699; background:#EEEEEE">float</span><span style="color:#336699; background:#EEEEEE">编程</span></p>
<p><span style="color:#333333">以前在学校学习C</span>语言的时候一直搞不懂那个共用体union有什么用的。工作之后才发现它的一些妙用，现举例如下：<br> <br> 1. 为了方便看懂代码。<br> <br> 比如说想写一个3 * 3的矩阵，可以这样写：<br> [ <span style="color:#333333">注：下面用红色部分标记的地方是后来添加上去的，谢谢</span><span style="color:#333333">yrqing718</span><span style="color:#333333">的提醒！</span><span style="color:#333333">]</span></p>
<div style="background:#F8F8F8">
<ol start="1" type="1">
<li style="color:rgb(92,92,92)"><strong><span style="color:#006699">struct</span></strong> Matrix </li>
<li style="color:#5C5C5C; background:white">{ </li>
<li style="color:rgb(92,92,92)"> <strong><span style="color:#006699">union</span></strong> </li>
<li style="color:#5C5C5C; background:white"> { </li>
<li style="color:#5C5C5C; background:white"> <span style="color:red">struct</span> </li>
<li style="color:#5C5C5C; background:white"> <span style="color:red">{</span> </li>
<li style="color:#5C5C5C; background:white"> <span style="color:black">float</span><span style="color:black"> </span><span style="color:black"> _f11, _f12, _f13, _f21, _f22, _f23, _f31, _f32, _f33;</span> </li>
<li style="color:#5C5C5C; background:white"> <span style="color:red">};</span> </li>
<li style="color:#5C5C5C; background:white"> <span style="color:black">float</span> f[3][3]; </li>
<li style="color:rgb(92,92,92)"> }_matrix; </li>
<li style="color:#5C5C5C; background:white">}; </li>
<li style="color:rgb(92,92,92)"> </li>
<li style="color:#5C5C5C; background:white"><strong><span style="color:#006699">struct</span></strong> Matrix m; </li>
<li style="color:rgb(92,92,92)"> </li>
</ol>
</div>
<p><span style="color:#333333"><br> </span><span style="color:#333333">这两个东西共同使用相同的空间，所以没有空间浪费，在需要整体用矩阵的时候可以用</span><span style="color:#333333"><br> m._matrix.f </span><span style="color:#333333">（比如说传参，或者是整体赋值等）；需要用其中的几个元素的时候可以用</span><span style="color:#333333">m._matrix._f11</span><span style="color:#333333">那样可以避免用</span><span style="color:#333333">m.f[0][0]</span><span style="color:#333333">（这样不大直观，而且容易出错）。</span><span style="color:#333333"><br> <br> 2. </span><span style="color:#333333">用在强制类型转换上（比强制类型转换更加容易看懂）</span><span style="color:#333333"><br> </span><span style="color:#333333">下面举几个例子：</span><span style="color:#333333"><br> <br> </span><span style="color:#333333">（</span><span style="color:#333333">1</span><span style="color:#333333">）</span><span style="color:#333333">. </span><span style="color:#333333">判断系统用的是</span><span style="color:#333333">bigendian </span><span style="color:#333333">还是</span><span style="color:#333333"> little endian</span><span style="color:#333333">（其定义大家可以到网上查相关资料，此略）</span></p>
<div style="background:#F8F8F8">
<ol start="1" type="1">
<li style="color:rgb(92,92,92)"><span style="color:gray">#define TRUE 1</span> </li>
<li style="color:#5C5C5C; background:white"><span style="color:gray">#define FALSE 0</span> </li>
<li style="color:rgb(92,92,92)"><span style="color:gray">#define BOOL int</span> </li>
<li style="color:rgb(92,92,92)"><span style="color:gray"><br> <br> </span></li>
<li style="color:#5C5C5C; background:white"> </li>
<li style="color:rgb(92,92,92)"><span style="color:black">BOOL</span> isBigEndian() </li>
<li style="color:#5C5C5C; background:white">{ </li>
<li style="color:rgb(92,92,92)"> <span style="color:black">int</span> i = 1; <span style="color:#008200">/* i = 0x00000001*/</span> </li>
<li style="color:#5C5C5C; background:white"> <span style="color:black">char</span> c = *(<span style="color:black">char</span> *)&i; <span style="color:#008200">/* </span><span style="color:#008200">注意不能写成</span><span style="color:#008200"> char c = (char)i; */</span> </li>
<li style="color:rgb(92,92,92)"> <strong><span style="color:#006699">return</span></strong> (<span style="color:black">int</span> )c != i; </li>
<li style="color:#5C5C5C; background:white">}</li>
</ol>
</div>
<p><span style="color:#333333">如果是</span><span style="color:#333333">littleendian</span><span style="color:#333333">字节序的话，那个</span><span style="color:#333333">i= 1</span><span style="color:#333333">；的内存从小到大依次放的是：</span><span style="color:#333333">0x010x00 0x00 0x00</span><span style="color:#333333">，如是，按照</span><span style="color:#333333">i</span><span style="color:#333333">的起始地址变成按照</span><span style="color:#333333">char*</span><span style="color:#333333">方式（</span><span style="color:#333333">1</span><span style="color:#333333">字节）存取，即得</span><span style="color:#333333">c= 0x01</span><span style="color:#333333">；</span><span style="color:#333333"><br> </span><span style="color:#333333">反之亦然</span><span style="color:#333333"><br> <br> </span><span style="color:#333333">也许看起来不是很清晰，下面来看一下这个：</span></p>
<div style="background:#F8F8F8">
<ol start="1" type="1">
<li style="color:rgb(92,92,92)"><span style="color:black">BOOL</span> isBigEndian() </li>
<li style="color:#5C5C5C; background:white">{ </li>
<li style="color:rgb(92,92,92)"> <strong><span style="color:#006699">union</span></strong> </li>
<li style="color:#5C5C5C; background:white"> { </li>
<li style="color:rgb(92,92,92)"> <span style="color:black">int</span> i; </li>
<li style="color:#5C5C5C; background:white"> <span style="color:black">char</span> c; </li>
<li style="color:rgb(92,92,92)"> }test; </li>
<li style="color:#5C5C5C; background:white"> </li>
<li style="color:rgb(92,92,92)"> test.c = 2; </li>
<li style="color:#5C5C5C; background:white"> </li>
<li style="color:rgb(92,92,92)"> <strong><span style="color:#006699">return</span></strong> test.i != 2; </li>
<li style="color:#5C5C5C; background:white">}</li>
</ol>
</div>
<p><span style="color:#333333">这里用的是</span><span style="color:#333333">union</span><span style="color:#333333">来控制这个共享布局，有个知识点就是</span><span style="color:#333333">union</span><span style="color:#333333">里面的成员</span><span style="color:#333333">c</span><span style="color:#333333">和</span><span style="color:#333333">i</span><span style="color:#333333">都是从低地址开始对齐的。同样可以得到如此结果，而且不用转换，清晰一些。</span><span style="color:#333333"><br> <br> </span><span style="color:#333333">什么，不觉得清晰？？那再看下面的例子：</span><span style="color:#333333"><br> <br> </span><span style="color:#333333">（</span><span style="color:#333333">2</span><span style="color:#333333">）</span><span style="color:#333333">. </span><span style="color:#333333">将</span><span style="color:#333333">littleendian</span><span style="color:#333333">下的</span><span style="color:#333333">longlong</span><span style="color:#333333">类型的值换成</span><span style="color:#333333"> bigendian</span><span style="color:#333333">类型的值。已经知道系统提供了下面的</span><span style="color:#333333">api</span><span style="color:#333333">：</span><span style="color:#333333">longhtonl(long lg);</span><span style="color:#333333">作用是把所有的字节序换成大端字节序。因此得出下面做法：</span></p>
<div style="background:#F8F8F8">
<ol start="1" type="1">
<li style="color:rgb(92,92,92)"><span style="color:black">long</span> <span style="color:black">long</span> htonLL(<span style="color:black">long</span> <span style="color:black">long</span> lg) </li>
<li style="color:#5C5C5C; background:white">{ </li>
<li style="color:rgb(92,92,92)"> <strong><span style="color:#006699">union</span></strong> </li>
<li style="color:#5C5C5C; background:white"> { </li>
<li style="color:rgb(92,92,92)"> <strong><span style="color:#006699">struct</span></strong> </li>
<li style="color:#5C5C5C; background:white"> { </li>
<li style="color:rgb(92,92,92)"> <span style="color:black">long</span> low; </li>
<li style="color:#5C5C5C; background:white"> <span style="color:black">long</span> high; </li>
<li style="color:rgb(92,92,92)"> }val_1; </li>
<li style="color:#5C5C5C; background:white"> <span style="color:black">long</span> <span style="color:black">long</span> val_2; </li>
<li style="color:rgb(92,92,92)"> }val_arg, val_ret; </li>
<li style="color:rgb(92,92,92)"> </li>
<li style="color:#5C5C5C; background:white"> </li>
<li style="color:rgb(92,92,92)"> <strong><span style="color:#006699">if</span></strong> ( isBigEndian() ) </li>
<li style="color:#5C5C5C; background:white"> <strong><span style="color:#006699">return</span></strong> lg; </li>
<li style="color:rgb(92,92,92)"> val_arg.val_2 = lg; </li>
<li style="color:rgb(92,92,92)"> </li>
<li style="color:#5C5C5C; background:white"> </li>
<li style="color:rgb(92,92,92)"> val_ret.val_1.low = htonl( val_arg.val_1.high ); </li>
<li style="color:#5C5C5C; background:white"> val_ret.val_1.high = htonl( val_arg.val_1.low ); </li>
<li style="color:rgb(92,92,92)"> </li>
<li style="color:rgb(92,92,92)"> <strong><span style="color:#006699">return</span></strong> val_ret.val_2; </li>
<li style="color:#5C5C5C; background:white">}</li>
</ol>
</div>
<p><span style="color:#333333">只要把内存结构的草图画出来就比较容易明白了。</span><span style="color:#333333"><br> <br> (3).</span><span style="color:#333333">为了理解</span><span style="color:#333333">c++</span><span style="color:#333333">类的布局，再看下面一个例子。有如下类：</span></p>
<div style="background:#F8F8F8">
<ol start="1" type="1">
<li style="color:rgb(92,92,92)"><strong><span style="color:#006699">class</span></strong> Test </li>
<li style="color:#5C5C5C; background:white">{ </li>
<li style="color:rgb(92,92,92)"><strong><span style="color:#006699">public</span></strong> : </li>
<li style="color:#5C5C5C; background:white"> <span style="color:black">float</span> getFVal(){ <strong><span style="color:#006699">return</span></strong> f;} </li>
<li style="color:rgb(92,92,92)"><strong><span style="color:#006699">private</span></strong> : </li>
<li style="color:#5C5C5C; background:white"> <span style="color:black">int</span> i; </li>
<li style="color:rgb(92,92,92)"> <span style="color:black">char</span> c; </li>
<li style="color:#5C5C5C; background:white"> <span style="color:black">float</span> f; </li>
<li style="color:rgb(92,92,92)">}; </li>
<li style="color:rgb(92,92,92)">Test t;</li>
</ol>
</div>
<p style="background:#E7E5DC"><span style="color:#333333"> </span></p>
<p><span style="color:#333333">不能在类</span><span style="color:#333333">Test</span><span style="color:#333333">中增加代码，给对象中的</span><span style="color:#333333">f</span><span style="color:#333333">赋值</span><span style="color:#333333">7.0f.</span></p>
<div style="background:#F8F8F8">
<ol start="1" type="1">
<li style="color:rgb(92,92,92)"><strong><span style="color:#006699">class</span></strong> Test_Cpy </li>
<li style="color:#5C5C5C; background:white">{ </li>
<li style="color:rgb(92,92,92)"> <strong><span style="color:#006699">public</span></strong> : </li>
<li style="color:#5C5C5C; background:white"> <span style="color:black">float</span> getVal(){ <strong><span style="color:#006699">return</span></strong> f;} </li>
<li style="color:rgb(92,92,92)"> <span style="color:black">float</span> setVal(<span style="color:black">float</span> f){ <strong><span style="color:#006699">this</span></strong> ->f = f;} </li>
<li style="color:#5C5C5C; background:white"><strong><span style="color:#006699">private</span></strong> : </li>
<li style="color:rgb(92,92,92)"> <span style="color:black">int</span> i; </li>
<li style="color:#5C5C5C; background:white"> <span style="color:black">char</span> c; </li>
<li style="color:rgb(92,92,92)"> <span style="color:black">float</span> f; </li>
<li style="color:#5C5C5C; background:white">}; </li>
<li style="color:rgb(92,92,92)"> </li>
<li style="color:#5C5C5C; background:white">.... </li>
<li style="color:rgb(92,92,92)"> </li>
<li style="color:#5C5C5C; background:white"><span style="color:black">int</span> main() </li>
<li style="color:rgb(92,92,92)">{ </li>
<li style="color:#5C5C5C; background:white"> Test t; </li>
<li style="color:rgb(92,92,92)"> <strong><span style="color:#006699">union</span></strong> </li>
<li style="color:#5C5C5C; background:white"> { </li>
<li style="color:rgb(92,92,92)"> Test t1, </li>
<li style="color:#5C5C5C; background:white"> Test_Cpy t2; </li>
<li style="color:rgb(92,92,92)"> }test; </li>
<li style="color:#5C5C5C; background:white"> </li>
<li style="color:rgb(92,92,92)"> test.t2.setVal(7.0f); </li>
<li style="color:#5C5C5C; background:white"> t = test.t1; </li>
<li style="color:rgb(92,92,92)"> assert( t.getVal() == 7.0f ); </li>
<li style="color:#5C5C5C; background:white"> </li>
<li style="color:rgb(92,92,92)"> <strong><span style="color:#006699">return</span></strong> 0; </li>
<li style="color:#5C5C5C; background:white">}</li>
</ol>
</div>
<p><span style="color:#333333">说明：因为在增加类的成员函数时候，那个类的对象的布局基本不变。因此可以写一个与</span><span style="color:#333333">Test</span><span style="color:#333333">类一样结构的类</span><span style="color:#333333">Test_Cpy</span><span style="color:#333333">，而多了一个成员函数</span><span style="color:#333333">setVal</span><span style="color:#333333">，再用</span><span style="color:#333333">uinon</span><span style="color:#333333">结构对齐，就可以给私有变量赋值了。（这种方法在有虚机类和虚函数机制时可能失灵，故不可移植）至于详细的讨论，网上有，这个例子在实际中没有用途，只是用来考察这个内存布局的使用而已</span><span style="color:#333333">.<br> <br> union</span><span style="color:#333333">在操作系统底层的代码中用的比较多，因为它在内存共赏布局上方便且直观。所以网络编程，协议分析，内核代码上有一些用到</span><span style="color:#333333">union</span><span style="color:#333333">都比较好懂，简化了设计。</span></p>
<p><span style="color:#333333">功能描述：</span><span style="color:#333333"> </span><span style="color:#333333"><br> </span><span style="color:#333333">获取或者设置与某个套接字关联的选</span><span style="color:#333333">项。选项可能存在于多层协议中，它们总会出现在最上面的套接字层。当操作套接字选项时，选项位于的层和选项的名称必须给出。为了操作套接字层的选项，应该</span><span style="color:#333333">将层的值指定为</span><span style="color:#333333">SOL_SOCKET</span><span style="color:#333333">。为了操作其它层的选项，控制选项的合适协议号必须给出。例如，为了表示一个选项由</span><span style="color:#333333">TCP</span><span style="color:#333333">协议解析，层应该设定为协议</span><span style="color:#333333">号</span><span style="color:#333333">TCP</span><span style="color:#333333">。</span></p>
<h2><span style="color:#333333">Linux</span><span style="color:#333333">下getsockopt/setsockopt</span>函数说明 </h2>
<p><span style="color:#333333"><br> </span><span style="color:#333333">用法：</span><span style="color:#333333"> </span><span style="color:#333333"><br> #include <sys/types.h><br> #include <sys/socket.h></span></p>
<p><span style="color:#333333">int getsockopt(int sock,int level, int optname, void *optval, socklen_t *optlen);</span></p>
<p><span style="color:#333333">int setsockopt(int sock,int level, int optname, const void *optval, socklen_t optlen);</span></p>
<p><span style="color:#333333">参数：</span><span style="color:#333333"> </span><span style="color:#333333"> </span><span style="color:#333333"><br> sock</span><span style="color:#333333">：将要被设置或者获取选项的套接字。</span><span style="color:#333333"><br> level</span><span style="color:#333333">：选项所在的协议层。</span><span style="color:#333333"><br> optname</span><span style="color:#333333">：需要访问的选项名。</span><span style="color:#333333"><br> optval</span><span style="color:#333333">：对于</span><span style="color:#333333">getsockopt()</span><span style="color:#333333">，指向返回选项值的缓冲。对于</span><span style="color:#333333">setsockopt()</span><span style="color:#333333">，指向包含新选项值的缓冲。</span><span style="color:#333333"><br> optlen</span><span style="color:#333333">：对于</span><span style="color:#333333">getsockopt()</span><span style="color:#333333">，作为入口参数时，选项值的最大长度。作为出口参数时，选项值的实际长度。对于</span><span style="color:#333333">setsockopt()</span><span style="color:#333333">，现选项的长度。</span></p>
<p><span style="color:#333333"> </span><span style="color:#333333"> </span><span style="color:#333333"><br> </span><span style="color:#333333">返回说明：</span><span style="color:#333333"> </span><span style="color:#333333"> </span><span style="color:#333333"><br> </span><span style="color:#333333">成功执行时，返回</span><span style="color:#333333">0</span><span style="color:#333333">。失败返回</span><span style="color:#333333">-1</span><span style="color:#333333">，</span><span style="color:#333333">errno</span><span style="color:#333333">被设为以下的某个值</span><span style="color:#333333"> </span><span style="color:#333333"> </span><span style="color:#333333"><br> EBADF</span><span style="color:#333333">：</span><span style="color:#333333">sock</span><span style="color:#333333">不是有效的文件描述词</span><span style="color:#333333"><br> EFAULT</span><span style="color:#333333">：</span><span style="color:#333333">optval</span><span style="color:#333333">指向的内存并非有效的进程空间</span><span style="color:#333333"><br> EINVAL</span><span style="color:#333333">：在调用</span><span style="color:#333333">setsockopt()</span><span style="color:#333333">时，</span><span style="color:#333333">optlen</span><span style="color:#333333">无效</span><span style="color:#333333"><br> ENOPROTOOPT</span><span style="color:#333333">：指定的协议层不能识别选项</span><span style="color:#333333"><br> ENOTSOCK</span><span style="color:#333333">：</span><span style="color:#333333">sock</span><span style="color:#333333">描述的不是套接字</span></p>
<p><span style="color:#333333">level</span><span style="color:#333333">指定控制套接字的层次</span><span style="color:#333333">.</span><span style="color:#333333">可以取三种值</span><span style="color:#333333">:</span><span style="color:#333333"> </span><span style="color:#333333"><br> 1)SOL_SOCKET:</span><span style="color:#333333">通用套接字选项</span><span style="color:#333333">.</span><span style="color:#333333"> </span><span style="color:#333333"><br> 2)IPPROTO_IP:IP</span><span style="color:#333333">选项</span><span style="color:#333333">.</span><span style="color:#333333"> </span><span style="color:#333333"><br> 3)IPPROTO_TCP:TCP</span><span style="color:#333333">选项</span><span style="color:#333333">.</span><span style="color:#333333"><br> optname</span><span style="color:#333333">指定控制的方式</span><span style="color:#333333">(</span><span style="color:#333333">选项的名称</span><span style="color:#333333">),</span><span style="color:#333333">我们下面详细解释 </span></p>
<p><span style="color:#333333">optval</span><span style="color:#333333">获得或者是设置套接字选项</span><span style="color:#333333">.</span><span style="color:#333333">根据选项名称的数据类型进行转换 </span></p>
<p><span style="color:#333333"><br> </span><span style="color:#333333">选项名称 说明 数据类型</span><span style="color:#333333"> </span><span style="color:#333333"><br> ========================================================================</span><span style="color:#333333"> </span><span style="color:#333333"><br> </span><span style="color:#333333">SOL_SOCKET</span><span style="color:#333333"> </span><span style="color:#333333"><br> ------------------------------------------------------------------------</span><span style="color:#333333"> </span><span style="color:#333333"><br> SO_BROADCAST</span><span style="color:#333333"> 允许发送广播数据 </span><span style="color:#333333">int</span><span style="color:#333333"> </span><span style="color:#333333"><br> SO_DEBUG</span><span style="color:#333333"> 允许调试 </span><span style="color:#333333">int</span><span style="color:#333333"> </span><span style="color:#333333"><br> SO_DONTROUTE</span><span style="color:#333333"> 不查找路由 </span><span style="color:#333333">int</span><span style="color:#333333"> </span><span style="color:#333333"><br> SO_ERROR</span><span style="color:#333333"> 获得套接字错误 </span><span style="color:#333333">int</span><span style="color:#333333"> </span><span style="color:#333333"><br> SO_KEEPALIVE</span><span style="color:#333333"> 保持连接 </span><span style="color:#333333">int</span><span style="color:#333333"> </span><span style="color:#333333"><br> SO_LINGER</span><span style="color:#333333">延迟关闭连接 </span><span style="color:#333333">structlinger</span><span style="color:#333333"> </span><span style="color:#333333"><br> SO_OOBINLINE</span><span style="color:#333333"> 带外数据放入正常数据流 </span><span style="color:#333333">int</span><span style="color:#333333"> </span><span style="color:#333333"><br> SO_RCVBUF</span><span style="color:#333333">接收缓冲区大小 </span><span style="color:#333333">int</span><span style="color:#333333"> </span><span style="color:#333333"><br> SO_SNDBUF</span><span style="color:#333333">发送缓冲区大小 </span><span style="color:#333333">int</span><span style="color:#333333"> </span><span style="color:#333333"><br> SO_RCVLOWAT</span><span style="color:#333333">接收缓冲区下限 </span><span style="color:#333333">int</span><span style="color:#333333"> </span><span style="color:#333333"><br> SO_SNDLOWAT</span><span style="color:#333333">发送缓冲区下限 </span><span style="color:#333333">int</span><span style="color:#333333"> </span><span style="color:#333333"><br> SO_RCVTIMEO</span><span style="color:#333333">接收超时 </span><span style="color:#333333">structtimeval</span><span style="color:#333333"> </span><span style="color:#333333"><br> SO_SNDTIMEO</span><span style="color:#333333">发送超时 </span><span style="color:#333333">structtimeval</span><span style="color:#333333"> </span><span style="color:#333333"><br> SO_REUSERADDR</span><span style="color:#333333">允许重用本地地址和端口 </span><span style="color:#333333">int</span><span style="color:#333333"> </span><span style="color:#333333"><br> SO_TYPE</span><span style="color:#333333">获得套接字类型 </span><span style="color:#333333">int</span><span style="color:#333333"> </span><span style="color:#333333"><br> SO_BSDCOMPAT</span><span style="color:#333333"> 与</span><span style="color:#333333">BSD</span><span style="color:#333333">系统兼容 </span><span style="color:#333333">int</span><span style="color:#333333"> </span><span style="color:#333333"><br> ========================================================================<br> </span><span style="color:#333333">IPPROTO_IP</span><span style="color:#333333"> </span><span style="color:#333333"><br> ------------------------------------------------------------------------<br> IP_HDRINCL</span><span style="color:#333333"> 在数据包中包含</span><span style="color:#333333">IP</span><span style="color:#333333">首部 </span><span style="color:#333333">int</span><span style="color:#333333"> </span><span style="color:#333333"><br> IP_OPTINOS</span><span style="color:#333333">IP</span><span style="color:#333333">首部选项 </span><span style="color:#333333">int</span><span style="color:#333333"> </span><span style="color:#333333"><br> IP_TOS</span><span style="color:#333333"> 服务类型</span><span style="color:#333333"> </span><span style="color:#333333"><br> IP_TTL</span><span style="color:#333333"> 生存时间 </span><span style="color:#333333">int</span><span style="color:#333333"> </span><span style="color:#333333"><br> ========================================================================<br> </span><span style="color:#333333">IPPRO_TCP</span><span style="color:#333333"> </span><span style="color:#333333"><br> ------------------------------------------------------------------------<br> TCP_MAXSEG</span><span style="color:#333333">TCP</span><span style="color:#333333">最大数据段的大小 </span><span style="color:#333333">int</span><span style="color:#333333"> </span><span style="color:#333333"><br> TCP_NODELAY</span><span style="color:#333333">不使用</span><span style="color:#333333">Nagle</span><span style="color:#333333">算法 </span><span style="color:#333333">int</span><span style="color:#333333"> </span><span style="color:#333333"><br> ========================================================================</span></p>
<p><span style="color:#333333">返回说明：</span><span style="color:#333333"> </span><span style="color:#333333"> </span><span style="color:#333333"><br> </span><span style="color:#333333">成功执行时，返回</span><span style="color:#333333">0</span><span style="color:#333333">。失败返回</span><span style="color:#333333">-1</span><span style="color:#333333">，</span><span style="color:#333333">errno</span><span style="color:#333333">被设为以下的某个值</span><span style="color:#333333"> </span><span style="color:#333333"> </span><span style="color:#333333"><br> EBADF</span><span style="color:#333333">：</span><span style="color:#333333">sock</span><span style="color:#333333">不是有效的文件描述词</span><span style="color:#333333"><br> EFAULT</span><span style="color:#333333">：</span><span style="color:#333333">optval</span><span style="color:#333333">指向的内存并非有效的进程空间</span><span style="color:#333333"><br> EINVAL</span><span style="color:#333333">：在调用</span><span style="color:#333333">setsockopt()</span><span style="color:#333333">时，</span><span style="color:#333333">optlen</span><span style="color:#333333">无效</span><span style="color:#333333"><br> ENOPROTOOPT</span><span style="color:#333333">：指定的协议层不能识别选项</span><span style="color:#333333"><br> ENOTSOCK</span><span style="color:#333333">：</span><span style="color:#333333">sock</span><span style="color:#333333">描述的不是套接字</span></p>
<p><span style="color:#333333">SO_RCVBUF</span><span style="color:#333333">和</span><span style="color:#333333">SO_SNDBUF</span><span style="color:#333333">每个套接口都有一个发送缓冲区和一个接收缓冲区，使用这两个套接口选项可以改变缺省缓冲区大小。</span></p>
<p><span style="color:#333333">// </span><span style="color:#333333">接收缓冲区</span><span style="color:#333333"><br> int nRecvBuf=32*1024; //</span><span style="color:#333333">设置为</span><span style="color:#333333">32K<br> setsockopt(s,SOL_SOCKET,SO_RCVBUF,(const char*)&nRecvBuf,sizeof(int));</span></p>
<p><span style="color:#333333"><br> //</span><span style="color:#333333">发送缓冲区</span><span style="color:#333333"><br> int nSendBuf=32*1024;//</span><span style="color:#333333">设置为</span><span style="color:#333333">32K<br> setsockopt(s,SOL_SOCKET,SO_SNDBUF,(const char*)&nSendBuf,sizeof(int));</span></p>
<p><span style="color:#333333">注意：</span></p>
<p><span style="color:#333333">当设置</span><span style="color:#333333">TCP</span><span style="color:#333333">套接口接收缓冲区的大小时，函数调用顺序是很重要的，因为</span><span style="color:#333333">TCP</span><span style="color:#333333">的窗口规模选项是在建立连接时用</span><span style="color:#333333">SYN</span><span style="color:#333333">与对方互换得到的。对于客户，</span><span style="color:#333333">SO_RCVBUF</span><span style="color:#333333">选项必须在</span><span style="color:#333333">connect</span><span style="color:#333333">之前设置；对于服务器，</span><span style="color:#333333">SO_RCVBUF</span><span style="color:#333333">选项必须在</span><span style="color:#333333">listen</span><span style="color:#333333">前设置。</span></p>
<h2>SVN多版本库配置问题</h2>
<p>阅读：<span style="color:red">651</span>次 时间：2012-07-3120:41:12 字体：[<span style="color:#0A0064">大</span> <span style="color:#0A0064">中</span> <span style="color:#0A0064">小</span>]</p>
<p>刚接触SVN的时候，因为对它不了解，又在Windows下面，被它的多版本库配置问题困扰很久，一直找不到完美解决方案，今天无意中在Linux下配置SVN时，发现它本身是支持的，通过配置--config-file参数指定全局的配置文件实现。写下此文来纠正以前错误的配置方式（主要是Windows系统下），分享给大家。</p>
<p>Linux和Windows下处理基本上一样的，先来看Linux下的svnserve的帮助信息：</p>
<p>1. [root@localhost ~]# svnserve --help </p>
<p>2. usage: svnserve [-d | -i | -t | -X] [options] </p>
<p>3. </p>
<p>4. Valid options: </p>
<p>5. -d [--daemon] : daemon mode </p>
<p>6. -i [--inetd] : inetd mode </p>
<p>7. -t [--tunnel] : tunnel mode </p>
<p>8. -X [--listen-once] : listen-once mode (useful for debugging) </p>
<p>9. -r [--root] ARG : root of directory to serve </p>
<p>10. -R [--read-only] : force read only, overriding repository config file </p>
<p>11. --config-file ARG : read configuration from file ARG </p>
<p>12. --listen-port ARG : listen port </p>
<p>13. [mode: daemon, listen-once] </p>
<p>14. --listen-host ARG : listen hostname or IP address </p>
<p>15. [mode: daemon, listen-once] </p>
<p>16. -T [--threads] : use threads instead of fork [mode: daemon] </p>
<p>17. --foreground : run in foreground (useful for debugging) </p>
<p>18. [mode: daemon] </p>
<p>19. --log-file ARG : svnserve log file </p>
<p>20. --pid-file ARG : write server process ID to file ARG </p>
<p>21. [mode: daemon, listen-once] </p>
<p>22. --tunnel-user ARG : tunnel username (default is current uid's name) </p>
<p>23. [mode: tunnel] </p>
<p>24. -h [--help] : display this help </p>
<p>25. --version : show program version information </p>
<p>通常启动SVN服务，仅指定SVN版本库的根目录，如下：</p>
<p>1. svnserve -d -r /data/svn </p>
<p>然后在/data/svn下创建多个版本库：</p>
<p>1. cd /data/svn </p>
<p>2. svnadmin create repos1 </p>
<p>3. svnadmin create repos2 </p>
<p>再依次配置repos1和repos2等版本库下的conf/svnserve.conf、conf/passwd、conf/authz文件。</p>
<p>问题便来了，因为大多数的时候，同一个用户需要用相同的帐号和密码去访问不同的版本库，这时的权限配置就不好处理了，以前看其他人的解决方法是在svnserve.conf中指定passwd和authz的路径时用相对路径指到同一个文件。这是一个可行的方法，但新增版本库的时候，就得更改svnserve.conf文件，不方便。</p>
<p>仔细看svnserve的帮助信息，大家都会发现有一个--config-file参数，这个参数就是用来指定svnserve.conf路径的，说到这，问题已经明了，只要在启动SVN服务的时候，指定--config-file参数，只要指定了此参数，所有的权限都由参数指定的svnserve.conf控制，而每个版本库conf目录下的svnserve.conf的配置都会忽略掉。</p>
<p>1. svnserve -d -r /data/svn --config-file /data/svn/svnserve.conf </p>
<p>Windows下使用的是CollabNet的Subversion Server，它安装的服务，指定的ImagePath形式为："d:Program Files (x86)CollabNetSubversionServersvnserve.exe" --service -r "e:svn_repository"--listen-port "3690" ，是没有指定--config-file参数的，因此导致我等刚接触SVN的新手会被多版本库的配置问题纠结，现在只要到注册表更改一下SVN所在服务的ImagePath参数，追加上--config-file参数：</p>
<p>1. "d:Program Files (x86)CollabNetSubversion Serversvnserve.exe" --service -r "e:svn_repository" --listen-port "3690" --config-file "e:svn_repositoryconfsvnserve.conf" </p>
<p>以上中使用的路径等，请自行转换成各自对应的路径。</p>
<h2>windows 下本机配置svn以及多版本库的创建</h2>
<p><span style="color:#454545">软件下载</span><span style="color:#454545"><br> <br> </span><span style="color:#454545">服务器和客户端安装</span><span style="color:#454545"><br> <br> </span><span style="color:#454545">建立版本库（</span><span style="color:#454545">Repository</span><span style="color:#454545">）</span><span style="color:#454545"><br> <br> </span><span style="color:#454545">配置用户和权限</span><span style="color:#454545"><br> <br> </span><span style="color:#454545">运行独立服务器</span><span style="color:#454545"><br> <br> </span><span style="color:#454545">初始化导入</span><span style="color:#454545"><br> <br> </span><span style="color:#454545">基本客户端操作</span></p>
<p><span style="color:#454545">建立多版本库</span><span style="color:#454545"><br> <br> <br> 1</span><span style="color:#454545">、软件下载</span><span style="color:#454545"><br> <br> </span><span style="color:#454545">下载</span><span style="color:#454545">Subversion</span><span style="color:#454545">服务器程序。</span><span style="color:#454545"><br> <br> <br> </span><span style="color:#454545">下载</span><span style="color:#454545">Subversion</span><span style="color:#454545">的</span><span style="color:#454545">Windows</span><span style="color:#454545">客户端</span><span style="color:#454545">TortoiseSVN</span><span style="color:#454545">及简体中文语言安装包。</span><span style="color:#454545"><br> <br> http://tortoisesvn.net/downloads<br> <br> svnservice</span><span style="color:#454545">下载</span><span style="color:#454545"><br> <br> http://bbs.iusesvn.com/attachment.php?aid=12<br> <br> 2</span><span style="color:#454545">、服务器和客户端安装</span><span style="color:#454545"><br> <br> </span><span style="color:#454545">服务器安装，直接运行安装程序，根据提示安装即可，这样我们就有了一套服务器可以运行的环境。</span><span style="color:#454545"><br> <br> </span><span style="color:#454545">安装</span><span style="color:#454545">TortoiseSVN</span><span style="color:#454545">，同样直接运行安装程序，按照提示安装即可，不过最后完成后会提示是否重启，其实重启只是使</span><span style="color:#454545">svn</span><span style="color:#454545">工作拷贝在</span><span style="color:#454545">windows</span><span style="color:#454545">中的特殊样式生效，与所有的实际功能无关，这里为了立刻看到好的效果，还是重新启动机器。</span><span style="color:#454545"><br> <br> </span><span style="color:#454545">重启完毕后安装简体中文语言包</span><span style="color:#454545">,</span><span style="color:#454545">然后在随便一个目录右击</span><span style="color:#454545">,</span><span style="color:#454545">就会发现多出了一些</span><span style="color:#454545">SVN</span><span style="color:#454545">相关菜单</span><span style="color:#454545">, </span><span style="color:#454545">选择其中的</span><span style="color:#454545">TortoiseSVN,</span><span style="color:#454545">再选择子菜单</span><span style="color:#454545">"Settings",</span><span style="color:#454545">设置</span><span style="color:#454545">Language</span><span style="color:#454545">为</span><span style="color:#454545">"</span><span style="color:#454545">中文</span><span style="color:#454545">(</span><span style="color:#454545">简体</span><span style="color:#454545">)"</span><span style="color:#454545">。</span><span style="color:#454545"><br> <br> 3</span><span style="color:#454545">、建立版本库（</span><span style="color:#454545">Repository</span><span style="color:#454545">）</span><span style="color:#454545"><br> <br> </span><span style="color:#454545">运行</span><span style="color:#454545">Subversion</span><span style="color:#454545">服务器需要首先要建立一个版本库（</span><span style="color:#454545">Repository</span><span style="color:#454545">），可以看作服务器上存放数据的数据库，在安装了</span><span style="color:#454545">Subversion</span><span style="color:#454545">服务器之后，可以直接运行，如：</span><span style="color:#454545"><br> <br> svnadmin create F:\svn\repository<br> <br> </span><span style="color:#454545">就会在目录</span><span style="color:#454545">F:\svn\repository</span><span style="color:#454545">下创建一个版本库。</span><span style="color:#454545"><br> <br> </span><span style="color:#454545">我们也可以使用</span><span style="color:#454545">TortoiseSVN</span><span style="color:#454545">图形化的完成这一步：</span><span style="color:#454545"><br> <br> </span><span style="color:#454545">在目录</span><span style="color:#454545">D:\svn\repository</span><span style="color:#454545">下</span><span style="color:#454545">"</span><span style="color:#454545">右键</span><span style="color:#454545">->TortoiseSVN-></span><span style="color:#454545">在此创建文件库</span><span style="color:#454545">"</span><span style="color:#454545">，然后可以选择版本库模式，这里使用默认</span><span style="color:#454545">,fsfs</span><span style="color:#454545">方式即可，然后就创建了一系列目录和文件。</span><span style="color:#454545"> </span><span style="color:#454545"><br> <br> 4</span><span style="color:#454545">、配置用户和权限</span><span style="color:#454545"><br> <br> </span><span style="color:#454545">打开</span><span style="color:#454545">F:\svn\repository,</span><span style="color:#454545">你会发现已经多了一些目录和文件</span><span style="color:#454545">,</span><span style="color:#454545">打开</span><span style="color:#454545">conf</span><span style="color:#454545">子目录</span><span style="color:#454545">, </span><span style="color:#454545">打开</span><span style="color:#454545">svnserve.conf</span><span style="color:#454545">文件</span><span style="color:#454545">, </span><span style="color:#454545">这里行前凡是有</span><span style="color:#454545">#</span><span style="color:#454545">的都等于是被注释忽略了</span><span style="color:#454545">, </span><span style="color:#454545">你可以把</span><span style="color:#454545">#</span><span style="color:#454545">去掉让那一行生效</span><span style="color:#454545">, </span><span style="color:#454545">或者自己新添加行</span><span style="color:#454545">. </span> <span style="color:#454545">里面的英文注释已经详细说明了各种设置的含义</span><span style="color:#454545">,</span><span style="color:#454545">最后你设置</span><span style="color:#454545">[general]</span><span style="color:#454545">小节中行前没有</span><span style="color:#454545">#</span><span style="color:#454545">号的内容为</span><span style="color:#454545">:<br> <br> anon-access = none<br> auth-access = write<br> password-db = passwd<br> </span><span style="color:#454545">一定要把空格给删了，否则会出错</span><span style="color:#454545">svnserve.conf:12:Option expected</span></p>
<p><span style="color:#454545"><br> </span><span style="color:#454545">含义是</span><span style="color:#454545">:<br> <br> </span><span style="color:#454545">未验证用户无任何权限</span><span style="color:#454545">(</span><span style="color:#454545">如果把</span><span style="color:#454545">none</span><span style="color:#454545">修改为</span><span style="color:#454545">read</span><span style="color:#454545">就是给予读权限</span><span style="color:#454545">)<br> </span><span style="color:#454545">已验证用户给予写权限</span><span style="color:#454545">(</span><span style="color:#454545">当然也能读</span><span style="color:#454545">)<br> </span><span style="color:#454545">密码数据存放到</span><span style="color:#454545">passwd</span><span style="color:#454545">文件中</span><span style="color:#454545"><br> <br> </span><span style="color:#454545">然后打开同目录的</span><span style="color:#454545">passwd</span><span style="color:#454545">文件来设置帐户</span><span style="color:#454545">:<br> <br> </span><span style="color:#454545">同样</span><span style="color:#454545">, </span> <span style="color:#454545">设置</span><span style="color:#454545">[users]</span><span style="color:#454545">小节中行前没有</span><span style="color:#454545">#</span><span style="color:#454545">号的内容</span><span style="color:#454545">, </span><span style="color:#454545">例如</span><span style="color:#454545">:</span></p>
<p><span style="color:#454545">admin =ren<br> <br> </span><span style="color:#454545">含义是</span><span style="color:#454545">:<br> <br> </span><span style="color:#454545">用户</span><span style="color:#454545">admin</span><span style="color:#454545">的密码为</span><span style="color:#454545">ren<br> <br> 5</span><span style="color:#454545">、运行独立服务器</span><span style="color:#454545"><br> <br> </span><span style="color:#454545">安装</span><span style="color:#454545">subversion</span><span style="color:#454545">的</span><span style="color:#454545">bin</span><span style="color:#454545">目录下不知为何没有</span><span style="color:#454545">svnservice.exe</span><span style="color:#454545">，将</span><span style="color:#454545">svnservice.exe</span><span style="color:#454545">放在</span><span style="color:#454545">subversion</span><span style="color:#454545">的</span><span style="color:#454545">bin</span><span style="color:#454545">目录下。</span><span style="color:#454545"><br> <br> </span><span style="color:#454545">在</span><span style="color:#454545">dos</span><span style="color:#454545">控制台状态下</span><span style="color:#454545">cd </span><span style="color:#454545">进入</span><span style="color:#454545">subversion</span><span style="color:#454545">的安装目录的</span><span style="color:#454545">bin</span><span style="color:#454545">目录，</span></p>
<p><span style="color:#454545">svnservice -install -d-r F:\svn\repository (</span><span style="color:#454545">该操作中可能出现</span><span style="color:#454545">CreateServicefailed - Commandline set: "-d" "-r" "F:\svn\repository"</span><span style="color:#454545">错误，此时执行</span><span style="color:#454545">svnservice-remove</span><span style="color:#454545">命令即可</span><span style="color:#454545">)</span></p>
<p><span style="color:#454545">sc config svnservicestart= auto</span></p>
<p><span style="color:#454545">net start svnservice</span></p>
<p><em><span style="color:#454545">在</span><span style="color:#454545">win7</span><span style="color:#454545">下可能出现如下问题</span></em></p>
<p><em><span style="color:#454545">OpenSCManagerFAILED 5: Access is denied.</span></em></p>
<p><span style="color:#454545">怀疑是</span><span style="color:#454545">win7</span><span style="color:#454545">和</span><span style="color:#454545">vista</span><span style="color:#454545">的</span><span style="color:#454545">UAC</span><span style="color:#454545">问题，打开开始菜单，找到命令行的快捷方式，右键，以管理员身份运行，</span></p>
<p><span style="color:#454545">svnserivce -install -d-r </span><span style="color:#454545">。。。。。。</span></p>
<p><span style="color:#454545"><br> 6</span><span style="color:#454545">、初始化导入</span><span style="color:#454545"><br> <br> </span><span style="color:#454545">打开</span><span style="color:#454545">"</span><span style="color:#454545">我的电脑</span><span style="color:#454545">",</span><span style="color:#454545">在你需要进行版本控制的目录上右击</span><span style="color:#454545">,</span><span style="color:#454545">选择</span><span style="color:#454545">TortoiseSVN,</span><span style="color:#454545">再选择子菜单</span><span style="color:#454545">"</span><span style="color:#454545">导入</span><span style="color:#454545">...",</span><span style="color:#454545">设置</span><span style="color:#454545">"</span><span style="color:#454545">文件库</span><span style="color:#454545">url"</span><span style="color:#454545">为</span><span style="color:#454545">svn://localhost</span><span style="color:#454545">点确定后就会提示文件正在导入</span><span style="color:#454545">. </span><br> <br> <span style="color:#454545">需要注意的是，这里是</span><span style="color:#454545">svn</span><span style="color:#454545">文件库与</span><span style="color:#454545">svn</span><span style="color:#454545">服务是同一台计算机的情况</span><span style="color:#454545">, </span><span style="color:#454545">所以可用</span><span style="color:#454545">localhost,</span><span style="color:#454545">其它机器如果要访问</span><span style="color:#454545">svn</span><span style="color:#454545">服务</span><span style="color:#454545">, </span><span style="color:#454545">应该用</span><span style="color:#454545">svn://svn</span><span style="color:#454545">服务器的</span><span style="color:#454545">IP</span><span style="color:#454545">地址</span><span style="color:#454545">, </span><span style="color:#454545">例如</span><span style="color:#454545">svn://192.168.1.125<br> <br> 7</span><span style="color:#454545">、基本客户端操作</span><span style="color:#454545"><br> <br> <br> </span><span style="color:#454545">创建一个准备用来存放版本控制工程的目录</span><span style="color:#454545">,</span><span style="color:#454545">例如</span><span style="color:#454545">d:\project,</span><span style="color:#454545">然后在</span><span style="color:#454545">"</span><span style="color:#454545">我的电脑</span><span style="color:#454545">"</span><span style="color:#454545">中右击这个目录</span><span style="color:#454545">, </span><span style="color:#454545">选择</span><span style="color:#454545">"SVN</span><span style="color:#454545">取出</span><span style="color:#454545">...",</span><span style="color:#454545">设置</span><span style="color:#454545">"</span><span style="color:#454545">文件库</span><span style="color:#454545">url"</span><span style="color:#454545">为</span><span style="color:#454545">svn://svn</span><span style="color:#454545">服务器的</span><span style="color:#454545">IP</span><span style="color:#454545">地址</span><span style="color:#454545">, </span><span style="color:#454545">接下来会问你用户名和帐号</span><span style="color:#454545">, </span><span style="color:#454545">你就填写前面搭建服务器端所设置的用户</span><span style="color:#454545">admin</span><span style="color:#454545">密码</span><span style="color:#454545">zhang<br> <br> </span><span style="color:#454545">点确定后就会提示文件正在取出到</span><span style="color:#454545">d:\project<br> <br> </span><span style="color:#454545">至此</span><span style="color:#454545">, SVN</span><span style="color:#454545">客户端配置完成</span><span style="color:#454545">, </span><span style="color:#454545">你会看到</span><span style="color:#454545">d:\project</span><span style="color:#454545">及其下面的文件都被标记了绿色对勾</span><span style="color:#454545"><br> <br> </span><span style="color:#454545">简单日常使用</span><span style="color:#454545">:<br> <br> </span><span style="color:#454545">要取得工程的当前的最新版本</span><span style="color:#454545">,</span><span style="color:#454545">右击</span><span style="color:#454545">d:\project,</span><span style="color:#454545">选择</span><span style="color:#454545">"SVN</span><span style="color:#454545">更新</span><span style="color:#454545">"<br> <br> </span><span style="color:#454545">你更改工程后</span><span style="color:#454545">,</span><span style="color:#454545">要将你的修改更新到</span><span style="color:#454545">SVN,</span><span style="color:#454545">右击</span><span style="color:#454545">d:\project,</span><span style="color:#454545">选择</span><span style="color:#454545">"SVN</span><span style="color:#454545">提交</span><span style="color:#454545">" </span><span style="color:#454545">，谨慎的话请先更新到</span><span style="color:#454545">SVN</span><span style="color:#454545">最新版本后再提交。</span></p>
<p><span style="color:#454545">8</span><span style="color:#454545">、建立多版本库</span></p>
<p><span style="color:#454545">svn </span><span style="color:#454545">在一个版本库下管理多个工程，不会为每个工程建一个版本库，这样会导致版本库跳跃，所以有时必须建立多个版本库</span></p>
<p><span style="color:#454545">svn </span><span style="color:#454545">在一个版本库下管理多个工程会导致版本库跳跃，所以有时必须建立多个版本库</span></p>
<p><span style="color:#454545">(1)</span><span style="color:#454545">、把所有的版本库的放在一个统一的目录下</span><span style="color:#454545">(</span><span style="color:#454545">如</span><span style="color:#454545">F:\svn)</span><span style="color:#454545">，在此目录下我们要建立两个工程的版本库</span><span style="color:#454545">Respontory1</span><span style="color:#454545">和</span><span style="color:#454545">Respontory2</span><span style="color:#454545">（必须先建好这两个文件夹）。</span></p>
<p><span style="color:#454545">(2)</span><span style="color:#454545">、创建第一个项目</span><span style="color:#454545">project1</span><span style="color:#454545">版本库，命令：</span><span style="color:#454545">svnadmincreate F\svnroot\Respontory1</span></p>
<p><span style="color:#454545">(3)</span><span style="color:#454545">、创建第二个项目</span><span style="color:#454545">project2</span><span style="color:#454545">版本库，命令：</span><span style="color:#454545">svnadmincreate F:\svnroot\Respontory2</span><span style="color:#454545">，当然这两步也可以用</span><span style="color:#454545">TortoiseSVN</span><span style="color:#454545">建立</span></p>
<p><span style="color:#454545">(4)</span><span style="color:#454545">、为了便于管理，将所有版本库的密码和权限设置在同一个文件下面，操作步骤如下：</span></p>
<p><span style="color:#454545"> A</span><span style="color:#454545">、取出</span><span style="color:#454545">Respontory1</span><span style="color:#454545">下面</span><span style="color:#454545">conf</span><span style="color:#454545">文件夹下的</span><span style="color:#454545">authz</span><span style="color:#454545">和</span><span style="color:#454545">passwd</span><span style="color:#454545">两个文件到</span><span style="color:#454545">svn</span><span style="color:#454545">根目录下面</span></p>
<p><span style="color:#454545"> B</span><span style="color:#454545">、修改每个版本库目录</span><span style="color:#454545">conf</span><span style="color:#454545">文件夹下面的</span><span style="color:#454545">svnserve.conf</span><span style="color:#454545">文件，</span><span style="color:#454545">将</span></p>
<p><span style="color:#454545"> # anon-access = read</span><span style="color:#454545">，</span><span style="color:#454545">#auth-access = write</span><span style="color:#454545">，</span><span style="color:#454545">#password-db = passwd</span><span style="color:#454545">，</span><span style="color:#454545">#authz-db = authz</span></p>
<p><span style="color:#454545"> </span><span style="color:#454545">修改为：</span></p>
<p><span style="color:#454545"> anon-access = none</span><span style="color:#454545">，</span><span style="color:#454545">auth-access= write</span><span style="color:#454545">，</span><span style="color:#454545">password-db= ../../passwd</span><span style="color:#454545">，</span><span style="color:#454545">authz-db= ../../authz</span></p>
<p><span style="color:#454545"> (password-db = ../../passwd</span><span style="color:#454545">，</span><span style="color:#454545">authz-db= ../../authz</span><span style="color:#454545">代表相对路径而非绝对路径</span><span style="color:#454545">)</span></p>
<p><span style="color:#454545"> </span><span style="color:#454545">如果不需要分角色，那么可以不设置</span><span style="color:#454545">authz-db</span></p>
<p><span style="color:#454545">(5)</span><span style="color:#454545">、</span><span style="color:#454545">dos</span><span style="color:#454545">控制台状态下</span><span style="color:#454545">cd </span><span style="color:#454545">进入</span><span style="color:#454545">subversion</span><span style="color:#454545">的安装目录的</span><span style="color:#454545">bin</span><span style="color:#454545">目录，</span></p>
<p><span style="color:#454545">svnservice -install -d-r F:\svn\ (</span><span style="color:#454545">该操作中可能出现</span><span style="color:#454545">CreateServicefailed - Commandline set: "-d" "-r" "F:\svn\repository"</span><span style="color:#454545">错误，此时执行</span><span style="color:#454545">svnservice-remove</span><span style="color:#454545">命令即可</span><span style="color:#454545">)</span></p>
<p><span style="color:#454545">sc config svnservicestart= auto</span></p>
<p><span style="color:#454545">net start svnservice</span></p>
<p><span style="color:#454545">到此为止就配置成功了你可以将两个工程导入到这两个版本库中，而且版本号不相互影响。</span></p>
<h2>【C/C++】Linux下使用system()函数一定要谨慎</h2>
<p><em><strong><span style="color:#AA0000">15</span></strong></em><span style="color:#666666">人收藏此文章</span><span style="color:#666666">,</span><span style="color:#666666"> </span><span style="color:#666666"><span style="color:#AA0000">我要收藏</span></span><span style="color:#666666">发表于</span><span style="color:#666666">1</span><span style="color:#666666">年前</span><span style="color:#666666">(2012-04-15 00:35) , </span><span style="color:#666666">已有</span><strong><span style="color:#AA0000">16021</span></strong><span style="color:#666666">次阅读</span><span style="color:#666666">，共</span><strong><span style="color:#AA0000"><span style="color:#AA0000">3</span></span></strong><span style="color:#666666">个评论</span></p>
<p><span style="color:#333333">曾经的曾经，被</span><span style="color:#333333">system()</span><span style="color:#333333">函数折磨过，之所以这样，是因为对</span><span style="color:#333333">system()</span><span style="color:#333333">函数了解不够深入。只是简单的知道用这个函数执行一个系统命令，这远远不够，它的返回值、它所执行命令的返回值以及命令执行失败原因如何定位，这才是重点。当初因为这个函数风险较多，故抛弃不用，改用其他的方法。这里先不说我用了什么方法，这里必须要搞懂</span><span style="color:#333333">system()</span><span style="color:#333333">函数，因为还是有很多人用了</span><span style="color:#333333">system()</span><span style="color:#333333">函数，有时你不得不面对它。</span></p>
<p><span style="color:#333333"> </span></p>
<p><strong><span style="color:#333333">先来看一下</span><span style="color:#333333">system()</span><span style="color:#333333">函数的简单介绍：</span></strong></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>1</code></p> </td>
<td> <p><code>#include <stdlib.h></code></p> </td>
</tr>
<tr>
<td> <p><code>2</code></p> </td>
<td colspan="2"> <p><code>int</code> <code>system(const</code> <code>char</code> <code>*command);</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333">system() executes a command specified in command bycalling /bin/sh -c command, and returns after the command has been completed.During execution of the command, SIGCHLD will be blocked, and SIGINT andSIGQUIT will be ignored.</span></p>
<p><span style="color:#333333">system()</span><span style="color:#333333">函数调用</span><span style="color:#333333">/bin/sh</span><span style="color:#333333">来执行参数指定的命令，</span><span style="color:#333333">/bin/sh </span><span style="color:#333333">一般是一个软连接，指向某个具体的</span><span style="color:#333333">shell</span><span style="color:#333333">，比如</span><span style="color:#333333">bash</span><span style="color:#333333">，</span><span style="color:#333333">-c</span><span style="color:#333333">选项是告诉</span><span style="color:#333333">shell</span><span style="color:#333333">从字符串</span><span style="color:#333333">command</span><span style="color:#333333">中读取命令；</span></p>
<p><span style="color:#333333">在该</span><span style="color:#333333">command</span><span style="color:#333333">执行期间，</span><span style="color:#333333">SIGCHLD</span><span style="color:#333333">是被阻塞的，好比在说：</span><span style="color:#333333">hi</span><span style="color:#333333">，内核，这会不要给我送</span><span style="color:#333333">SIGCHLD</span><span style="color:#333333">信号，等我忙完再说；</span></p>
<p><span style="color:#333333">在该</span><span style="color:#333333">command</span><span style="color:#333333">执行期间，</span><span style="color:#333333">SIGINT</span><span style="color:#333333">和</span><span style="color:#333333">SIGQUIT</span><span style="color:#333333">是被忽略的，意思是进程收到这两个信号后没有任何动作。</span></p>
<p><span style="color:#333333"> </span></p>
<p><strong><span style="color:#333333">再来看一下</span><span style="color:#333333">system()</span><span style="color:#333333">函数返回值：</span></strong></p>
<p><span style="color:#333333">The value returned is -1 on error (e.g. fork(2) failed), and thereturn status of the command otherwise. This latter return status is in theformat specified in wait(2). Thus, the exit code of the command will beWEXITSTATUS(status). In case /bin/sh could not be executed, the exit statuswill be that of a command that does exit(127).</span></p>
<p><span style="color:#333333">If the value of command is NULL, system() returns nonzero if theshell is available, and zero if not.</span></p>
<p><span style="color:#333333">为了更好的理解</span><span style="color:#333333">system()</span><span style="color:#333333">函数返回值，需要了解其执行过程，实际上</span><span style="color:#333333">system()</span><span style="color:#333333">函数执行了三步操作：</span></p>
<p><span style="color:#333333">1.fork</span><span style="color:#333333">一个子进程；</span></p>
<p><span style="color:#333333">2.</span><span style="color:#333333">在子进程中调用</span><span style="color:#333333">exec</span><span style="color:#333333">函数去执行</span><span style="color:#333333">command</span><span style="color:#333333">；</span></p>
<p><span style="color:#333333">3.</span><span style="color:#333333">在父进程中调用</span><span style="color:#333333">wait</span><span style="color:#333333">去等待子进程结束。</span></p>
<p><span style="color:#333333">对于</span><span style="color:#333333">fork</span><span style="color:#333333">失败，</span><span style="color:#333333">system()</span><span style="color:#333333">函数返回</span><span style="color:#333333">-1</span><span style="color:#333333">。</span></p>
<p><span style="color:#333333">如果</span><span style="color:#333333">exec</span><span style="color:#333333">执行成功，也即</span><span style="color:#333333">command</span><span style="color:#333333">顺利执行完毕，则返回</span><span style="color:#333333">command</span><span style="color:#333333">通过</span><span style="color:#333333">exit</span><span style="color:#333333">或</span><span style="color:#333333">return</span><span style="color:#333333">返回的值。</span></p>
<p><span style="color:#333333">（注意，</span><span style="color:#333333">command</span><span style="color:#333333">顺利执行不代表执行成功，比如</span><span style="color:#333333">command</span><span style="color:#333333">：</span><span style="color:#333333">"rm debuglog.txt"</span><span style="color:#333333">，不管文件存不存在该</span><span style="color:#333333">command</span><span style="color:#333333">都顺利执行了）</span></p>
<p><span style="color:#333333">如果</span><span style="color:#333333">exec</span><span style="color:#333333">执行失败，也即</span><span style="color:#333333">command</span><span style="color:#333333">没有顺利执行，比如被信号中断，或者</span><span style="color:#333333">command</span><span style="color:#333333">命令根本不存在，</span><span style="color:#333333">system()</span><span style="color:#333333">函数返回</span><span style="color:#333333">127.</span></p>
<p><span style="color:#333333">如果</span><span style="color:#333333">command</span><span style="color:#333333">为</span><span style="color:#333333">NULL</span><span style="color:#333333">，则</span><span style="color:#333333">system()</span><span style="color:#333333">函数返回非</span><span style="color:#333333">0</span><span style="color:#333333">值，一般为</span><span style="color:#333333">1.</span></p>
<p><span style="color:#333333"> </span></p>
<p><strong><span style="color:#333333">看一下</span><span style="color:#333333">system()</span><span style="color:#333333">函数的源码</span></strong></p>
<p><span style="color:#333333">看完这些，我想肯定有人对</span><span style="color:#333333">system()</span><span style="color:#333333">函数返回值还是不清楚，看源码最清楚，下面给出一个</span><span style="color:#333333">system()</span><span style="color:#333333">函数的实现：</span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>01</code></p> </td>
<td colspan="2"> <p><code>int</code> <code>system(const</code> <code>char</code> <code>* cmdstring)</code></p> </td>
</tr>
<tr>
<td> <p><code>02</code></p> </td>
<td> <p><code>{</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>03</code></p> </td>
<td> <p><code> pid_t pid;</code></p> </td>
</tr>
<tr>
<td> <p><code>04</code></p> </td>
<td colspan="2"> <p><code> int</code> <code>status;</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>05</code></p> </td>
<td> <p> </p> </td>
</tr>
<tr>
<td> <p><code>06</code></p> </td>
<td colspan="2"> <p><code>if(cmdstring == NULL)</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>07</code></p> </td>
<td> <p><code>{</code></p> </td>
</tr>
<tr>
<td> <p><code>08</code></p> </td>
<td colspan="2"> <p><code> return</code> <code>(1);</code> <code>//</code><code>如果cmdstring为空，返回非零值，一般为1</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>09</code></p> </td>
<td> <p><code>}</code></p> </td>
</tr>
<tr>
<td> <p><code>10</code></p> </td>
<td> <p> </p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>11</code></p> </td>
<td colspan="2"> <p><code>if((pid = fork())<0)</code></p> </td>
</tr>
<tr>
<td> <p><code>12</code></p> </td>
<td> <p><code>{</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>13</code></p> </td>
<td colspan="2"> <p><code> status = -1;</code> <code>//fork</code><code>失败，返回-1</code></p> </td>
</tr>
<tr>
<td> <p><code>14</code></p> </td>
<td> <p><code>}</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>15</code></p> </td>
<td colspan="2"> <p><code>else</code> <code>if(pid == 0)</code></p> </td>
</tr>
<tr>
<td> <p><code>16</code></p> </td>
<td> <p><code>{</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>17</code></p> </td>
<td> <p><code> execl("/bin/sh",</code> <code>"sh",</code> <code>"-c", cmdstring, (char</code> <code>*)0);</code></p> </td>
</tr>
<tr>
<td> <p><code>18</code></p> </td>
<td colspan="2"> <p><code> _exit(127);</code> <code>// exec</code><code>执行失败返回127，注意exec只在失败时才返回现在的进程，成功的话现在的进程就不存在啦~~</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>19</code></p> </td>
<td> <p><code>}</code></p> </td>
</tr>
<tr>
<td> <p><code>20</code></p> </td>
<td colspan="2"> <p><code>else</code> <code>//</code><code>父进程</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>21</code></p> </td>
<td> <p><code>{</code></p> </td>
</tr>
<tr>
<td> <p><code>22</code></p> </td>
<td colspan="2"> <p><code> while(waitpid(pid, &status, 0) < 0)</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>23</code></p> </td>
<td> <p><code> {</code></p> </td>
</tr>
<tr>
<td> <p><code>24</code></p> </td>
<td colspan="2"> <p><code> if(errno</code> <code>!= EINTR)</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>25</code></p> </td>
<td> <p><code> {</code></p> </td>
</tr>
<tr>
<td> <p><code>26</code></p> </td>
<td colspan="2"> <p><code> status = -1;</code> <code>//</code><code>如果waitpid被信号中断，则返回-1</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>27</code></p> </td>
<td colspan="2"> <p><code> break;</code></p> </td>
</tr>
<tr>
<td> <p><code>28</code></p> </td>
<td> <p><code> }</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>29</code></p> </td>
<td colspan="2"> <p><code> }</code></p> </td>
</tr>
<tr>
<td> <p><code>30</code></p> </td>
<td> <p><code>}</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>31</code></p> </td>
<td> <p> </p> </td>
</tr>
<tr>
<td> <p><code>32</code></p> </td>
<td colspan="2"> <p><code> return</code> <code>status;</code> <code>//</code><code>如果waitpid成功，则返回子进程的返回状态</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>33</code></p> </td>
<td> <p><code>}</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333">仔细看完这个</span><span style="color:#333333">system()</span><span style="color:#333333">函数的简单实现，那么该函数的返回值就清晰了吧，那么什么时候</span><span style="color:#333333">system()</span><span style="color:#333333">函数返回</span><span style="color:#333333">0</span><span style="color:#333333">呢？只在</span><span style="color:#333333">command</span><span style="color:#333333">命令返回</span><span style="color:#333333">0</span><span style="color:#333333">时。</span></p>
<p><span style="color:#333333"> </span></p>
<p><strong><span style="color:#333333">看一下该怎么监控</span><span style="color:#333333">system()</span><span style="color:#333333">函数执行状态</span></strong></p>
<p><span style="color:#333333">这里给我出的做法：</span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>01</code></p> </td>
<td> <p><code>int</code> <code>status;</code></p> </td>
</tr>
<tr>
<td> <p><code>02</code></p> </td>
<td colspan="2"> <p><code>if(NULL == cmdstring)</code> <code>//</code><code>如果cmdstring为空趁早闪退吧，尽管system()函数也能处理空指针</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>03</code></p> </td>
<td> <p><code>{</code></p> </td>
</tr>
<tr>
<td> <p><code>04</code></p> </td>
<td colspan="2"> <p><code> return</code> <code>XXX;</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>05</code></p> </td>
<td> <p><code>}</code></p> </td>
</tr>
<tr>
<td> <p><code>06</code></p> </td>
<td colspan="2"> <p><code>status =</code> <code>system(cmdstring);</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>07</code></p> </td>
<td colspan="2"> <p><code>if(status < 0)</code></p> </td>
</tr>
<tr>
<td> <p><code>08</code></p> </td>
<td> <p><code>{</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>09</code></p> </td>
<td colspan="2"> <p><code> printf("cmd: %s\t error: %s", cmdstring,</code> <code>strerror(errno));</code> <code>// </code><code>这里务必要把errno信息输出或记入Log</code></p> </td>
</tr>
<tr>
<td> <p><code>10</code></p> </td>
<td> <p><code> return</code> <code>XXX;</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>11</code></p> </td>
<td> <p><code>}</code></p> </td>
</tr>
<tr>
<td> <p><code>12</code></p> </td>
<td> <p> </p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>13</code></p> </td>
<td colspan="2"> <p><code>if(WIFEXITED(status))</code></p> </td>
</tr>
<tr>
<td> <p><code>14</code></p> </td>
<td> <p><code>{</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>15</code></p> </td>
<td colspan="2"> <p><code> printf("normal termination, exit status = %d\n", WEXITSTATUS(status));</code> <code>//</code><code>取得cmdstring执行结果</code></p> </td>
</tr>
<tr>
<td> <p><code>16</code></p> </td>
<td> <p><code>}</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>17</code></p> </td>
<td colspan="2"> <p><code>else</code> <code>if(WIFSIGNALED(status))</code></p> </td>
</tr>
<tr>
<td> <p><code>18</code></p> </td>
<td> <p><code>{</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>19</code></p> </td>
<td colspan="2"> <p><code> printf("abnormal termination,signal number =%d\n", WTERMSIG(status));</code> <code>//</code><code>如果cmdstring被信号中断，取得信号值</code></p> </td>
</tr>
<tr>
<td> <p><code>20</code></p> </td>
<td> <p><code>}</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>21</code></p> </td>
<td colspan="2"> <p><code>else</code> <code>if(WIFSTOPPED(status))</code></p> </td>
</tr>
<tr>
<td> <p><code>22</code></p> </td>
<td> <p><code>{</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333"> </span></p>
<table border="0">
<tbody>
<tr>
<td> <p><code>23</code></p> </td>
<td colspan="2"> <p><code> printf("process stopped, signal number =%d\n", WSTOPSIG(status));</code> <code>//</code><code>如果cmdstring被信号暂停执行，取得信号值</code></p> </td>
</tr>
<tr>
<td> <p><code>24</code></p> </td>
<td> <p><code>}</code></p> </td>
</tr>
</tbody>
</table>
<p><span style="color:#333333">到于取得子进程返回值的相关介绍可以参考另一篇文章：</span><span style="color:#333333"><span style="color:#4466BB">http://my.oschina.net/renhc/blog/35116</span></span></p>
<p><span style="color:#333333"> </span></p>
<p><span style="color:#333333">system()</span><span style="color:#333333">函数用起来很容易出错，返回值太多，而且返回值很容易跟</span><span style="color:#333333">command</span><span style="color:#333333">的返回值混淆。这里推荐使用</span><span style="color:#333333">popen()</span><span style="color:#333333">函数替代，关于</span><span style="color:#333333">popen()</span><span style="color:#333333">函数的简单使用也可以通过上面的链接查看。</span></p>
<p><span style="color:#333333">popen()</span><span style="color:#333333">函数较于</span><span style="color:#333333">system()</span><span style="color:#333333">函数的优势在于使用简单，</span><span style="color:#333333">popen()</span><span style="color:#333333">函数只返回两个值：</span><span style="color:#333333"><br> </span><span style="color:#333333">成功返回子进程的</span><span style="color:#333333">status</span><span style="color:#333333">，使用</span><span style="color:#333333">WIFEXITED</span><span style="color:#333333">相关宏就可以取得</span><span style="color:#333333">command</span><span style="color:#333333">的返回结果；</span><span style="color:#333333"><br> </span><span style="color:#333333">失败返回</span><span style="color:#333333">-1</span><span style="color:#333333">，我们可以使用</span><span style="color:#333333">perro()</span><span style="color:#333333">函数或</span><span style="color:#333333">strerror()</span><span style="color:#333333">函数得到有用的错误信息。</span></p>
<p><span style="color:#333333">这篇文章只涉及了</span><span style="color:#333333">system()</span><span style="color:#333333">函数的简单使用，还没有谈及</span><span style="color:#333333">SIGCHLD</span><span style="color:#333333">、</span><span style="color:#333333">SIGINT</span><span style="color:#333333">和</span><span style="color:#333333">SIGQUIT</span><span style="color:#333333">对</span><span style="color:#333333">system()</span><span style="color:#333333">函数的影响，事实上，之所以今天写这篇文章，是因为项目中因有人使用了</span><span style="color:#333333">system()</span><span style="color:#333333">函数而造成了很严重的事故。现像是</span><span style="color:#333333">system()</span><span style="color:#333333">函数执行时会产生一个错误：</span><span style="color:#333333">“</span><span style="color:#333333">No child processes</span><span style="color:#333333">”</span><span style="color:#333333">。</span></p>
<p><span style="color:#333333">关于这个错误的分析，感兴趣的朋友可以看一下：</span><span style="color:#333333"><span style="color:#4466BB">http://my.oschina.net/renhc/blog/54582</span></span></p>
<p><span style="color:#333333">返回值：</span><span style="color:#333333">若成功调用一次则返回两个值，子进程返回</span><span style="color:#333333">0</span><span style="color:#333333">，</span><span style="color:#333333"><span style="color:#136EC2">父进程</span></span><span style="color:#333333">返回子进程</span><span style="color:#333333">ID</span><span style="color:#333333">；否则，出错返</span><strong></strong></p>
<p> </p>
<h2>fork()函数 UNIX </h2>
<h3>头文件：</h3>
<p><span style="color:#333333">#<strong>include</strong><unistd.h></span></p>
<p><span style="color:#333333">#<strong>include</strong><sys/types.h></span></p>
<h3>函数原型：</h3>
<p><em><span style="color:#333333">pid_t fork</span></em><span style="color:#333333">(</span><span style="color:#333333"> </span><strong><span style="color:#333333">void</span></strong><span style="color:#333333">);</span></p>
<p><span style="color:#333333">（</span><span style="color:#333333">pid_t</span><span style="color:#333333">是一个</span><span style="color:#333333"><span style="color:#136EC2">宏定义</span></span><span style="color:#333333">，其实质是</span><span style="color:#333333">int </span><span style="color:#333333">被定义在</span><span style="color:#333333">#<strong>include</strong><<em>sys/types.h</em>></span><span style="color:#333333">中）</span></p>
<p><span style="color:#333333">返回值：</span><span style="color:#333333">若成功调用一次则返回两个值，子进程返回</span><span style="color:#333333">0</span><span style="color:#333333">，</span><span style="color:#333333"><span style="color:#136EC2">父进程</span></span><span style="color:#333333">返回子进程</span><span style="color:#333333">ID</span><span style="color:#333333">；否则，出错返回</span><span style="color:#333333">-1</span></p>
<h3>函数说明：</h3>
<p><span style="color:#333333">一个现有进程可以调用</span><span style="color:#333333">fork</span><span style="color:#333333">函数创建一个新进程。由</span><span style="color:#333333">fork</span><span style="color:#333333">创建的新进程被称为子进程（</span><span style="color:#333333">childprocess</span><span style="color:#333333">）。</span><span style="color:#333333">fork</span><span style="color:#333333">函数被调用一次但返回两次。两次返回的唯一区别是子进程中返回</span><span style="color:#333333">0</span><span style="color:#333333">值而</span><span style="color:#333333"><span style="color:#136EC2">父进程</span></span><span style="color:#333333">中返回子进程</span><span style="color:#333333">ID</span><span style="color:#333333">。</span></p>
<p><span style="color:#333333">子进程是</span><span style="color:#333333"><span style="color:#136EC2">父进程</span></span><span style="color:#333333">的副本，它将获得父进程数据空间、堆、栈等资源的副本。注意，子进程持有的是上述</span><span style="color:#333333"><span style="color:#136EC2">存储空间</span></span><span style="color:#333333">的</span><span style="color:#333333">“</span><span style="color:#333333">副本</span><span style="color:#333333">”</span><span style="color:#333333">，这意味着父子进程间不共享这些存储空间。</span></p>
<p><span style="color:#333333">UNIX</span><span style="color:#333333">将复制</span><span style="color:#333333"><span style="color:#136EC2">父进程</span></span><span style="color:#333333">的</span><span style="color:#333333"><span style="color:#136EC2">地址空间</span></span><span style="color:#333333">内容给子进程，因此，子进程有了独立的地址空间。在不同的</span><span style="color:#333333">UNIX(Like)</span><span style="color:#333333">系统下，我们无法确定</span><span style="color:#333333">fork</span><span style="color:#333333">之后是子进程先运行还是父进程先运行，这依赖于系统的实现。所以在移植代码的时候我们不应该对此作出任何的假设。</span></p>
<h3>为什么fork会返回两次？</h3>
<p><span style="color:#333333">由于在复制时复制了</span><span style="color:#333333"><span style="color:#136EC2">父进程</span></span><span style="color:#333333">的</span><span style="color:#333333"><span style="color:#136EC2">堆栈段</span></span><span style="color:#333333">，所以两个进程都停留在</span><span style="color:#333333">fork</span><span style="color:#333333">函数中，等待返回。因此</span><span style="color:#333333">fork</span><span style="color:#333333">函数会返回两次，一次是在</span><span style="color:#333333"><span style="color:#136EC2">父进程</span></span><span style="color:#333333">中返回，另一次是在子进程中返回，这两次的返回值是不一样的。过程如下图</span></p>
<p><span style="color:#333333"></span></p>
<p><span style="color:#333333">调用</span><span style="color:#333333">fork</span><span style="color:#333333">之后，数据、</span><span style="color:#333333"><span style="color:#136EC2">堆栈</span></span><span style="color:#333333">有两份，代码仍然为一份但是这个</span><span style="color:#333333"><span style="color:#136EC2">代码段</span></span><span style="color:#333333">成为两个进程的共享代码段都从</span><span style="color:#333333">fork</span><span style="color:#333333">函数中返回，箭头表示各自的执行处。当父子进程有一个想要修改数据或者堆栈时，两个进程真正分裂。</span></p>
<p><span style="color:#333333">示例代码：</span></p>
<p><span style="color:#333333">#<strong>include</strong><<em>sys/types.h</em>> //</span><span style="color:#333333">对于此程序而言此头文件用不到</span></p>
<p><span style="color:#333333">#<strong>include</strong><<em>unistd.h</em>></span></p>
<p><span style="color:#333333">#<strong>include</strong><<em>stdio.h</em>></span></p>
<p><strong><span style="color:#333333">#include</span></strong><span style="color:#333333"><stdlib.h></span></p>
<p><strong><span style="color:#333333">int</span><span style="color:#333333"> </span></strong><span style="color:#333333">main(<strong>int</strong></span><strong><span style="color:#333333"> </span></strong><span style="color:#333333">argc,</span><span style="color:#333333"> </span><strong><span style="color:#333333">char</span><span style="color:#333333"> </span></strong><span style="color:#333333">**argv )</span></p>
<p><span style="color:#333333">{</span></p>
<p><strong><span style="color:#333333">pid_t</span><span style="color:#333333"> </span></strong><span style="color:#333333">pid= fork();</span></p>
<p><strong><span style="color:#333333">if</span><span style="color:#333333"> </span></strong><span style="color:#333333">(pid< 0)</span></p>
<p><span style="color:#333333">{</span></p>
<p><span style="color:#333333">fprintf(stderr, "error!");</span></p>
<p><span style="color:#333333">}</span></p>
<p><strong><span style="color:#333333">else</span><span style="color:#333333"> </span><span style="color:#333333">if</span></strong><span style="color:#333333">(0 == pid )</span></p>
<p><span style="color:#333333">{</span></p>
<p><span style="color:#333333">printf("This is the child process!");</span></p>
<p><span style="color:#333333">_exit(0);</span></p>
<p><span style="color:#333333">}</span></p>
<p><strong><span style="color:#333333">else</span></strong></p>
<p><strong><span style="color:#333333">{</span></strong></p>
<p><span style="color:#333333">printf("This is the parent process! child process id =%d", pid);</span></p>
<p><span style="color:#333333">}</span></p>
<p><span style="color:#333333">//</span><span style="color:#333333">可能需要时候</span><span style="color:#333333">wait</span><span style="color:#333333">或</span><span style="color:#333333">waitpid</span><span style="color:#333333">函数等待子进程的结束并获取结束状态</span></p>
<p><strong><span style="color:#333333">exit(</span></strong><span style="color:#333333">0);</span></p>
<p><span style="color:#333333">}</span></p>
<p><span style="color:#333333">注意！样例代码仅供参考，样例代码存在着父进程在子进程结束前结束的可能性。必要的时候可以使用</span><span style="color:#333333">wait</span><span style="color:#333333">或</span><span style="color:#333333"> waitpid</span><span style="color:#333333">函数让父进程等待子进程的结束并获取子进程的返回状态。</span></p>
<p><span style="color:#333333">fork()</span><span style="color:#333333">在</span><span style="color:#333333">Linux</span><span style="color:#333333">系统中的返回值是没有</span><span style="color:#333333">NULL</span><span style="color:#333333">的</span><span style="color:#333333">.</span></p>
<p><span style="color:#333333">Error Codes</span></p>
<p><span style="color:#333333">出错返回</span><span style="color:#333333"><span style="color:#136EC2">错误信息</span></span><span style="color:#333333">如下</span><span style="color:#333333">:</span></p>
<p><em><span style="color:#333333">EAGAIN</span></em></p>
<p><span style="color:#333333">达到进程数上限</span><span style="color:#333333">.</span></p>
<p><em><span style="color:#333333">ENOMEM</span></em></p>
<p><span style="color:#333333">没有足够空间给一个新进程分配</span><span style="color:#333333">.</span></p>
<p><span style="color:#333333">fork</span><span style="color:#333333">函数的特点概括起来就是</span><span style="color:#333333">“</span><span style="color:#333333">调用一次，返回两次</span><span style="color:#333333">”</span><span style="color:#333333">，在</span><span style="color:#333333"><span style="color:#136EC2">父进程</span></span><span style="color:#333333">中调用一次，在父进程和子进程中各返回一次。</span></p>
<p><span style="color:#333333">fork</span><span style="color:#333333">的另一个特性是所有由</span><span style="color:#333333"><span style="color:#136EC2">父进程</span></span><span style="color:#333333">打开的描述符都被复制到子进程中。父、子进程中相同编号的</span><span style="color:#333333"><span style="color:#136EC2">文件描述符</span></span><span style="color:#333333">在</span><span style="color:#333333"><span style="color:#136EC2">内核</span></span><span style="color:#333333">中指向同一个</span><span style="color:#333333">file<span style="color:#136EC2">结构体</span></span><span style="color:#333333">，也就是说，</span><span style="color:#333333">file</span><span style="color:#333333">结构体的</span><span style="color:#333333"><span style="color:#136EC2">引用计数</span></span><span style="color:#333333">要增加。</span></p>
<h2>Linux下/proc目录简介</h2>
<p><span style="color:#999999">分类：</span><span style="color:#999999"> </span><span style="color:#999999"><span style="color:#336699">Java</span></span><span style="color:#999999">2012-07-1502:22</span><span style="color:#999999"> </span><span style="color:#999999">7896</span><span style="color:#999999">人阅读</span><span style="color:#999999"> </span><span style="color:#999999"><span style="color:#336699">评论</span></span>(0)<span style="color:#999999"> </span><span style="color:#999999"><span style="color:#336699">收藏</span></span><span style="color:#999999"> </span><span style="color:#999999"><span style="color:#336699">举报</span></span></p>
<p><span style="color:#333333"><span style="color:#336699; background:#EEEEEE">linux</span><span style="color:#336699; background:#EEEEEE">linux</span><span style="color:#336699; background:#EEEEEE">内核</span></span><span style="color:#336699; background:#EEEEEE">filesystems</span><span style="color:#336699; background:#EEEEEE">protocols</span><span style="color:#336699; background:#EEEEEE">cache</span><span style="color:#336699; background:#EEEEEE">timer</span></p>
<p><span style="color:#555555">1. /proc</span><span style="color:#555555">目录</span><span style="color:#555555"><br> Linux </span><span style="color:#555555">内核提供了一种通过</span><span style="color:#555555"> /proc </span><span style="color:#555555">文件系统，在运行时访问内核内部数据结构、改变内核设置的机制。</span><span style="color:#555555">proc</span><span style="color:#555555">文件系统是一个伪文件系统，它只存在内存当中，而不占用外存空间。它以文件系统的方式为访问系统内核数据的操作提供接口。</span></p>
<p><span style="color:#555555">用户和应用程序可以通过</span><span style="color:#555555">proc</span><span style="color:#555555">得到系统的信息，并可以改变内核的某些参数。由于系统的信息，如进程，是动态改变的，所以用户或应用程序读取</span><span style="color:#555555">proc</span><span style="color:#555555">文件时，</span><span style="color:#555555">proc</span><span style="color:#555555">文件系统是动态从系统内核读出所需信息并提交的。下面列出的这些文件或子文件夹，并不是都是在你的系统中存在，这取决于你的内核配置和装载的模块。另外，在</span><span style="color:#555555">/proc</span><span style="color:#555555">下还有三个很重要的目录：</span><span style="color:#555555">net</span><span style="color:#555555">，</span><span style="color:#555555">scsi</span><span style="color:#555555">和</span><span style="color:#555555">sys</span><span style="color:#555555">。</span><span style="color:#555555"> Sys</span><span style="color:#555555">目录是可写的，可以通过它来访问或修改内核的参数，而</span><span style="color:#555555">net</span><span style="color:#555555">和</span><span style="color:#555555">scsi</span><span style="color:#555555">则依赖于内核配置。例如，如果系统不支持</span><span style="color:#555555">scsi</span><span style="color:#555555">，则</span><span style="color:#555555">scsi </span><span style="color:#555555">目录不存在。</span></p>
<p><span style="color:#555555">除了以上介绍的这些，还有的是一些以数字命名的目录，它们是进程目录。系统中当前运行的每一个进程都有对应的一个目录在</span><span style="color:#555555">/proc</span><span style="color:#555555">下，以进程的</span><span style="color:#555555"> PID</span><span style="color:#555555">号为目录名，它们是读取进程信息的接口。而</span><span style="color:#555555">self</span><span style="color:#555555">目录则是读取进程本身的信息接口，是一个</span><span style="color:#555555">link</span><span style="color:#555555">。</span></p>
<p><span style="color:#555555">2. </span><span style="color:#555555">子文件或子文件夹</span><span style="color:#555555"><br> /proc/buddyinfo </span><span style="color:#555555">每个内存区中的每个</span><span style="color:#555555">order</span><span style="color:#555555">有多少块可用，和内存碎片问题有关</span></p>
<p><span style="color:#555555">/proc/cmdline </span><span style="color:#555555">启动时传递给</span><span style="color:#555555">kernel</span><span style="color:#555555">的参数信息</span></p>
<p><span style="color:#555555">/proc/cpuinfo cpu</span><span style="color:#555555">的信息</span></p>
<p><span style="color:#555555">/proc/crypto </span><span style="color:#555555">内核使用的所有已安装的加密密码及细节</span></p>
<p><span style="color:#555555">/proc/devices </span><span style="color:#555555">已经加载的设备并分类</span></p>
<p><span style="color:#555555"><br> /proc/dma </span><span style="color:#555555">已注册使用的</span><span style="color:#555555">ISA DMA</span><span style="color:#555555">频道列表</span></p>
<p><span style="color:#555555">/proc/execdomains Linux</span><span style="color:#555555">内核当前支持的</span><span style="color:#555555">execution domains</span></p>
<p><span style="color:#555555">/proc/fb </span><span style="color:#555555">帧缓冲设备列表，包括数量和控制它的驱动</span></p>
<p><span style="color:#555555">/proc/filesystems </span><span style="color:#555555">内核当前支持的文件系统类型</span></p>
<p><span style="color:#555555">/proc/interrupts x86</span><span style="color:#555555">架构中的每个</span><span style="color:#555555">IRQ</span><span style="color:#555555">中断数</span></p>
<p><span style="color:#555555">/proc/iomem </span><span style="color:#555555">每个物理设备当前在系统内存中的映射</span></p>
<p><span style="color:#555555">/proc/ioports </span><span style="color:#555555">一个设备的输入输出所使用的注册端口范围</span></p>
<p><span style="color:#555555">/proc/kcore </span><span style="color:#555555">代表系统的物理内存，存储为核心文件格式，里边显示的是字节数，等于</span><span style="color:#555555">RAM</span><span style="color:#555555">大小加上</span><span style="color:#555555">4kb</span></p>
<p><span style="color:#555555">/proc/kmsg </span><span style="color:#555555">记录内核生成的信息，可以通过</span><span style="color:#555555">/sbin/klogd</span><span style="color:#555555">或</span><span style="color:#555555">/bin/dmesg</span><span style="color:#555555">来处理</span></p>
<p><span style="color:#555555">/proc/loadavg </span><span style="color:#555555">根据过去一段时间内</span><span style="color:#555555">CPU</span><span style="color:#555555">和</span><span style="color:#555555">IO</span><span style="color:#555555">的状态得出的负载状态，与</span><span style="color:#555555">uptime</span><span style="color:#555555">命令有关</span></p>
<p><span style="color:#555555">/proc/locks </span><span style="color:#555555">内核锁住的文件列表</span></p>
<p><span style="color:#555555">/proc/mdstat </span><span style="color:#555555">多硬盘，</span><span style="color:#555555">RAID</span><span style="color:#555555">配置信息</span><span style="color:#555555">(md=multipledisks)</span></p>
<p><span style="color:#555555">/proc/meminfo RAM</span><span style="color:#555555">使用的相关信息</span></p>
<p><span style="color:#555555">/proc/misc </span><span style="color:#555555">其他的主要设备</span><span style="color:#555555">(</span><span style="color:#555555">设备号为</span><span style="color:#555555">10)</span><span style="color:#555555">上注册的驱动</span></p>
<p><span style="color:#555555">/proc/modules </span><span style="color:#555555">所有加载到内核的模块列表</span></p>
<p><span style="color:#555555">/proc/mounts </span><span style="color:#555555">系统中使用的所有挂载</span></p>
<p><span style="color:#555555">/proc/mtrr </span><span style="color:#555555">系统使用的</span><span style="color:#555555">Memory Type Range Registers (MTRRs)</span></p>
<p><span style="color:#555555">/proc/partitions </span><span style="color:#555555">分区中的块分配信息</span></p>
<p><span style="color:#555555">/proc/pci </span><span style="color:#555555">系统中的</span><span style="color:#555555">PCI</span><span style="color:#555555">设备列表</span></p>
<p><span style="color:#555555">/proc/slabinfo </span><span style="color:#555555">系统中所有活动的</span><span style="color:#555555"> slab </span><span style="color:#555555">缓存信息</span></p>
<p><span style="color:#555555">/proc/stat </span><span style="color:#555555">所有的</span><span style="color:#555555">CPU</span><span style="color:#555555">活动信息</span></p>
<p><span style="color:#555555">/proc/sysrq-trigger </span><span style="color:#555555">使用</span><span style="color:#555555">echo</span><span style="color:#555555">命令来写这个文件的时候，远程</span><span style="color:#555555">root</span><span style="color:#555555">用户可以执行大多数的系统请求关键命令，就好像在本地终端执行一样。要写入这个文件，需要把</span><span style="color:#555555">/proc/sys/kernel/sysrq</span><span style="color:#555555">不能设置为</span><span style="color:#555555">0</span><span style="color:#555555">。这个文件对</span><span style="color:#555555">root</span><span style="color:#555555">也是不可读的</span></p>
<p><span style="color:#555555">/proc/uptime </span><span style="color:#555555">系统已经运行了多久</span></p>
<p><span style="color:#555555">/proc/swaps </span><span style="color:#555555">交换空间的使用情况</span></p>
<p><span style="color:#555555">/proc/version Linux</span><span style="color:#555555">内核版本和</span><span style="color:#555555">gcc</span><span style="color:#555555">版本</span></p>
<p><span style="color:#555555">/proc/bus </span><span style="color:#555555">系统总线</span><span style="color:#555555">(Bus)</span><span style="color:#555555">信息，例如</span><span style="color:#555555">pci/usb</span><span style="color:#555555">等</span></p>
<p><span style="color:#555555">/proc/driver </span><span style="color:#555555">驱动信息</span></p>
<p><span style="color:#555555">/proc/fs </span><span style="color:#555555">文件系统信息</span></p>
<p><span style="color:#555555">/proc/ide ide</span><span style="color:#555555">设备信息</span></p>
<p><span style="color:#555555">/proc/irq </span><span style="color:#555555">中断请求设备信息</span></p>
<p><span style="color:#555555">/proc/net </span><span style="color:#555555">网卡设备信息</span></p>
<p><span style="color:#555555">/proc/scsi scsi</span><span style="color:#555555">设备信息</span></p>
<p><span style="color:#555555">/proc/tty tty</span><span style="color:#555555">设备信息</span></p>
<p><span style="color:#555555">/proc/net/dev </span><span style="color:#555555">显示网络适配器及统计信息</span></p>
<p><span style="color:#555555">/proc/vmstat </span><span style="color:#555555">虚拟内存统计信息</span></p>
<p><span style="color:#555555">/proc/vmcore </span><span style="color:#555555">内核</span><span style="color:#555555">panic</span><span style="color:#555555">时的内存映像</span></p>
<p><span style="color:#555555">/proc/diskstats </span><span style="color:#555555">取得磁盘信息</span></p>
<p><span style="color:#555555">/proc/schedstat kernel</span><span style="color:#555555">调度器的统计信息</span></p>
<p><span style="color:#555555">/proc/zoneinfo </span><span style="color:#555555">显示内存空间的统计信息，对分析虚拟内存行为很有用</span></p>
<p><span style="color:#555555">以下是</span><span style="color:#555555">/proc</span><span style="color:#555555">目录中进程</span><span style="color:#555555">N</span><span style="color:#555555">的信息</span></p>
<p><span style="color:#555555">/proc/N pid</span><span style="color:#555555">为</span><span style="color:#555555">N</span><span style="color:#555555">的进程信息</span></p>
<p><span style="color:#555555">/proc/N/cmdline </span><span style="color:#555555">进程启动命令</span></p>
<p><span style="color:#555555">/proc/N/cwd </span><span style="color:#555555">链接到进程当前工作目录</span></p>
<p><span style="color:#555555">/proc/N/environ </span><span style="color:#555555">进程环境变量列表</span></p>
<p><span style="color:#555555">/proc/N/exe </span><span style="color:#555555">链接到进程的执行命令文件</span></p>
<p><span style="color:#555555">/proc/N/fd </span><span style="color:#555555">包含进程相关的所有的文件描述符</span></p>
<p><span style="color:#555555">/proc/N/maps </span><span style="color:#555555">与进程相关的内存映射信息</span></p>
<p><span style="color:#555555">/proc/N/mem </span><span style="color:#555555">指代进程持有的内存，不可读</span></p>
<p><span style="color:#555555">/proc/N/root </span><span style="color:#555555">链接到进程的根目录</span></p>
<p><span style="color:#555555">/proc/N/stat </span><span style="color:#555555">进程的状态</span></p>
<p><span style="color:#555555">/proc/N/statm </span><span style="color:#555555">进程使用的内存的状态</span></p>
<p><span style="color:#555555">/proc/N/status </span><span style="color:#555555">进程状态信息，比</span><span style="color:#555555">stat/statm</span><span style="color:#555555">更具可读性</span></p>
<p><span style="color:#555555">/proc/self </span><span style="color:#555555">链接到当前正在运行的进程</span></p>
<p><span style="color:#555555">3. </span><span style="color:#555555">例子</span><span style="color:#555555"><br> 3.1 /proc/<br> <span style="color:#015F91">yafang@QA:~$</span> ls/proc/</span></p>
<p><span style="color:#555555">1 16819 21242 2180 2494 8768 interrupts partitions</span></p>
<p><span style="color:#555555">116 16820 21244 2181 2524 885 iomem sched_debug</span></p>
<p><span style="color:#555555">11740 17901 21245 21810 2525 acpi ioports scsi</span></p>
<p><span style="color:#555555">11742 17903 21247 21812 3 asound irq self</span></p>
<p><span style="color:#555555">11743 17904 2131 21813 39 buddyinfo kallsyms slabinfo</span></p>
<p><span style="color:#555555">13452 18362 21319 21923 4 bus kcore stat</span></p>
<p><span style="color:#555555">13454 18364 2132 2193 41 cgroups key-users swaps</span></p>
<p><span style="color:#555555">13455 18365 2139 21933 42 cmdline kmsg sys</span></p>
<p><span style="color:#555555">149 19451 2142 2209 5 cpuinfo kpagecount sysrq-trigger</span></p>
<p><span style="color:#555555">150 19453 21572 2212 5330 crypto kpageflags sysvipc</span></p>
<p><span style="color:#555555">151 19454 21574 2219 596 devices loadavg timer_list</span></p>
<p><span style="color:#555555">152 2 21575 2243 597 diskstats locks timer_stats</span></p>
<p><span style="color:#555555">15771 2083 2158 2260 6 dma meminfo tty</span></p>
<p><span style="color:#555555">15773 2092 21625 2261 617 driver misc uptime</span></p>
<p><span style="color:#555555">15774 2101 21627 2262 619 execdomains modules version</span></p>
<p><span style="color:#555555">16232 21112 21628 2263 7 fb mounts vmallocinfo</span></p>
<p><span style="color:#555555">16234 21115 2165 2264 804 filesystems mtrr vmstat</span></p>
<p><span style="color:#555555">16235 21116 2167 2265 8765 fs net zoneinfo</span></p>
<p><span style="color:#555555">16811 2112 2177 2338 8767 ide pagetypeinfo</span></p>
<p><span style="color:#555555">3.2 /proc/sys<br> </span><span style="color:#555555">系统信息和内核参数</span></p>
<p><span style="color:#555555"><span style="color:#015F91">yafang@QA:~$</span> ls/proc/sys</span></p>
<p><span style="color:#555555">debug dev fs kernel net vm</span></p>
<p><span style="color:#555555">3.3 /proc/net<br> </span><span style="color:#555555">网卡设备信息</span></p>
<p><span style="color:#555555"><span style="color:#015F91">yafang@QA:~$</span> ls/proc/net</span></p>
<p><span style="color:#555555">anycast6 ip6_flowlabel netfilter raw6 sockstat6 udplite</span></p>
<p><span style="color:#555555">arp ip6_mr_cache netlink route softnet_stat udplite6</span></p>
<p><span style="color:#555555">dev ip6_mr_vif netstat rt6_stats stat unix</span></p>
<p><span style="color:#555555">dev_mcast ip_mr_cache packet rt_acct tcp vlan</span></p>
<p><span style="color:#555555">dev_snmp6 ip_mr_vif protocols rt_cache tcp6 wireless</span></p>
<p><span style="color:#555555">if_inet6 ipv6_route psched snmp tr_rif</span></p>
<p><span style="color:#555555">igmp mcfilter ptype snmp6 udp</span></p>
<p><span style="color:#555555">igmp6 mcfilter6 raw sockstat udp6</span></p>
<p><span style="color:#555555">3.4 /proc/scsi<br> SCSI</span><span style="color:#555555">设备信息</span></p>
<p><span style="color:#555555"><span style="color:#015F91">yafang@QA:~$</span> ls/proc/scsi</span></p>
<p><span style="color:#555555">device_info scsi</span></p>
<p><span style="color:#555555">3.5 /proc/modules <br> </span><span style="color:#555555">所有加载到内核的模块列表</span></p>
<p><span style="color:#555555"><span style="color:#015F91">root@BDSP-A-2-1-2</span>:~# cat /proc/modules</span></p>
<p><span style="color:#555555">bdspboard 8486 2 dspcontrol, Live 0xe134c000</span></p>
<p><span style="color:#555555">dspcontrol 9575 1 clkmon, Live 0xe135b000</span></p>
<p><span style="color:#555555">clkmon 6765 1 - Live 0xe136c000</span></p>
<p><span style="color:#555555">diagint 6635 1 - Live 0xe1379000</span></p>
<p><span style="color:#555555">bdsprio 10775 2 srioif,tsi577, Live 0xe9389000</span></p>
<p><span style="color:#555555">tsi577 17998 1 srioif, Live 0xe939e000</span></p>
<p><span style="color:#555555">srioif 7329 0 - Live 0xe93b2000</span></p>
<p><span style="color:#555555">linux_kernel_bde 54666 1 linux_user_bde, Live 0xf1417000(P)</span></p>
<p><span style="color:#555555">linux_user_bde 17849 0 - Live 0xf1427000 (P)</span></p>
<p><span style="color:#555555"><span style="color:#015F91">root@BDSP-A-2-1-2</span>:~#</span></p>
<p><span style="color:#555555">3.6 /proc/devices <br> </span><span style="color:#555555">已经加载的设备并分类</span></p>
<p><span style="color:#555555"><span style="color:#015F91">root@BCNMB-A</span>:~#cat /proc/devices</span></p>
<p><span style="color:#555555"><br> Character devices:</span></p>
<p><span style="color:#555555"> 1 mem</span></p>
<p><span style="color:#555555"> 2 pty</span></p>
<p><span style="color:#555555"> 3 ttyp</span></p>
<p><span style="color:#555555"> 4 /dev/vc/0</span></p>
<p><span style="color:#555555"> 4 tty</span></p>
<p><span style="color:#555555"> 4 ttyS</span></p>
<p><span style="color:#555555"> 5 /dev/tty</span></p>
<p><span style="color:#555555"> 5 /dev/console</span></p>
<p><span style="color:#555555"> 5 /dev/ptmx</span></p>
<p><span style="color:#555555"> 7 vcs</span></p>
<p><span style="color:#555555"> 10 misc</span></p>
<p><span style="color:#555555"> 13 input</span></p>
<p><span style="color:#555555"> 89 i2c</span></p>
<p><span style="color:#555555"> 90 mtd</span></p>
<p><span style="color:#555555">116 linux-user-bde2</span></p>
<p><span style="color:#555555">117 linux-kernel-bde2</span></p>
<p><span style="color:#555555">126 linux-user-bde</span></p>
<p><span style="color:#555555">127 linux-kernel-bde</span></p>
<p><span style="color:#555555">128 ptm</span></p>
<p><span style="color:#555555">136 pts</span></p>
<p><span style="color:#555555">180 usb</span></p>
<p><span style="color:#555555">189 usb_device</span></p>
<p><span style="color:#555555">245 ext_alarm</span></p>
<p><span style="color:#555555">251 ipmidev</span></p>
<p><span style="color:#555555">252 usb_endpoint</span></p>
<p><span style="color:#555555">253 usbmon</span></p>
<p><span style="color:#555555">254 rtc</span></p>
<p><span style="color:#555555"> </span></p>
<p><span style="color:#555555">Block devices:</span></p>
<p><span style="color:#555555"> 1 ramdisk</span></p>
<p><span style="color:#555555"> 8 sd</span></p>
<p><span style="color:#555555"> 31 mtdblock</span></p>
<p><span style="color:#555555"> 65 sd</span></p>
<p><span style="color:#555555"> 66 sd</span></p>
<p><span style="color:#555555"> 67 sd</span></p>
<p><span style="color:#555555"> 68 sd</span></p>
<p><span style="color:#555555"> 69 sd</span></p>
<p><span style="color:#555555"> 70 sd</span></p>
<p><span style="color:#555555"> 71 sd</span></p>
<p><span style="color:#555555">128 sd</span></p>
<p><span style="color:#555555">129 sd</span></p>
<p><span style="color:#555555">130 sd</span></p>
<p><span style="color:#555555">131 sd</span></p>
<p><span style="color:#555555">132 sd</span></p>
<p><span style="color:#555555">133 sd</span></p>
<p><span style="color:#555555">134 sd</span></p>
<p><span style="color:#555555">135 sd</span></p>
<p><span style="color:#555555"> </span></p>
<p><span style="color:#555555"><br> <span style="color:#015F91">root@BCNMB-A</span>:~#</span></p>
<p><span style="color:#555555">3.7 /proc/partitions <br> </span><span style="color:#555555">分区中的块分配信息</span></p>
<p><span style="color:#555555"><span style="color:#015F91">root@BDSP-A-2-1-2</span>:~# cat /proc/partitions</span></p>
<p><span style="color:#555555">major minor #blocks name</span></p>
<p><span style="color:#555555"> 31 0 512 mtdblock0</span></p>
<p><span style="color:#555555"> 31 1 512 mtdblock1</span></p>
<p><span style="color:#555555"> 31 2 123904 mtdblock2</span></p>
<p><span style="color:#555555"> 31 3 4096 mtdblock3</span></p>
<p><span style="color:#555555"> 31 4 1024 mtdblock4</span></p>
<p><span style="color:#555555"> 31 5 1024 mtdblock5</span></p>
<p><span style="color:#555555"> 31 6 512 mtdblock6</span></p>
<p><span style="color:#555555"> 31 7 512 mtdblock7</span></p>
<p><span style="color:#555555"> 31 8 123904 mtdblock8</span></p>
<p><span style="color:#555555"> 31 9 4096 mtdblock9</span></p>
<p><span style="color:#555555"> 31 10 1024 mtdblock10</span></p>
<p><span style="color:#555555"> 31 11 1024 mtdblock11</span></p>
<p><span style="color:#555555"> 31 12 1048576 mtdblock12</span></p>
<p><span style="color:#555555"><span style="color:#015F91">root@BDSP-A-2-1-2</span>:~#</span></p>
<p><span style="color:#555555">3.8 /proc/version<br> Linux</span><span style="color:#555555">内核版本和</span><span style="color:#555555">gcc</span><span style="color:#555555">版本</span></p>
<p><span style="color:#555555"><span style="color:#015F91">root@BDSP-A-2-1-2</span>:~# cat /proc/version</span></p>
<p><span style="color:#555555">Linux version 2.6.34.6-WR4.0.0.0_standard (<span style="color:#015F91">satomi@CharlieBrown</span>)(gcc version 4.4.1 (Wind River Linux Sourcery G++ 4.4-291) ) #1 SMP PREEMPT FriNov 26 16:07:47 CST 2010</span></p>
<p><span style="color:#555555"><span style="color:#015F91">root@BDSP-A-2-1-2</span>:~#</span></p>
<p><span style="color:#555555">3.9 /proc/sys/fs/file-max<br> </span><span style="color:#555555">该文件指定了可以分配的文件句柄的最大数目。如果用户得到的错误消息声明由于打开文件数已经达到了最大值，从而他们不能打开更多文件，则可能需要增加该值。可将这个值设置成有任意多个文件，并且能通过将一个新数字值写入该文件来更改该值。默认设置时</span><span style="color:#555555">4096</span><span style="color:#555555">。</span></p>
<p><span style="color:#555555">改变内核的参数，用</span><span style="color:#555555">vi</span><span style="color:#555555">编辑或</span><span style="color:#555555">echo</span><span style="color:#555555">参数重定向到文件中。</span></p>
<p><span style="color:#555555"># cat /proc/sys/fs/file-max</span></p>
<p><span style="color:#555555">4096</span></p>
<p><span style="color:#555555"># echo 8192 > /proc/sys/fs/file-max</span></p>
<p><span style="color:#555555"># cat /proc/sys/fs/file-max</span></p>
<p><span style="color:#555555">8192 </span></p>
<p><span style="color:#555555">如果优化了参数，则可以把它们写成添加到文件</span><span style="color:#555555">rc.local</span><span style="color:#555555">中，使它在系统启动时自动完成修改</span></p>
<p>shell的条件分支语句：<br> iflist1<br> then <br> list2<br> fi<br> 其中list1其实就是一个命令列表，列表只有一项时就是单个命令。if的条件就是列表中最后一个命令执行的返回值。<br> 所以要判断某个命令执行的返回值，只要直接把命令放在if后面就行了，千万不要画蛇添足地加上反引号！看例子：</p>
<p style="background:rgb(247,247,247)">1. $if true; then echo TRUE; fi</p>
<p style="background:rgb(247,247,247)">2. TRUE</p>
<p style="background:rgb(247,247,247)">3. </p>
<p style="background:rgb(247,247,247)">4. $if true; false; then echo TRUE; else echo FALSE; fi</p>
<p style="background:rgb(247,247,247)">5. FALSE</p>
<p style="background:rgb(247,247,247)">6. </p>
<p style="background:rgb(247,247,247)">7. $if true; false; true; then echo TRUE; else echo FALSE; fi</p>
<p style="background:rgb(247,247,247)">8. TRUE</p>
<p style="background:rgb(247,247,247)">复制代码</p>
<p><br> <br> `cmd`及其另一种形式$(cmd)，叫做“命令替换”，就是把其中的命令执行后的“标准输出”(注意不是“返回值”！)代换到命令行，然后再执行代换后得到的新命令行。<br> <br> 所以:<br> if `ls foo`; then do sth; fi<br> 这种写法是很奇怪的，也不能说它是错的，而且它确实能够执行，但起码可以认为该写法概念不清、逻辑混乱。</p>
<p><br> shell判断文件file存在：<br> 其实关于判断文件存在与否，shell有专用的测试方法：<br> if [ -e file ]; then cmd; fi<br> 判断file存在，且是普通文件：<br> if [ -f file ]; then cmd; fi<br> 判断目录存在：<br> if [ -d path ]; then cmd; fi<br> 判断文件存在且可执行：<br> if [ -x file ]; then cmd; fi</p>
<div style="background:#F5F6F7">
<h1>在 /dev 中创建设备</h1>
</div>
<h2>6.8.1. 创建初始设备节点</h2>
<p><span style="color:#333333">内核在引导时要求某些设备节点必须存在</span><span style="color:#333333">(</span><span style="color:#333333">特别是</span><span style="color:#333333"> </span><tt><span style="color:#333333">console</span></tt><span style="color:#333333"> </span><span style="color:#333333">和</span><span style="color:#333333"> </span><tt><span style="color:#333333">null</span></tt><span style="color:#333333"> </span><span style="color:#333333">)</span><span style="color:#333333">，这些设备节点必须创建在硬盘上才能使得内核在</span><span style="color:#333333"> </span><strong>udev</strong><span style="color:#333333"> </span><span style="color:#333333">尚未启动之前就可以使用它们，特别是当系统以单用户模式启动</span><span style="color:#333333">(</span><span style="color:#333333">仅允许使用</span><span style="color:#333333"> </span><tt><span style="color:#333333">console</span></tt><span style="color:#333333">)</span><span style="color:#333333">的时候更是如此。使用下面的命令来创建这些节点：</span></p>
<div style="background:#E5E5E5">
<pre style="background:#E5E5E5"><strong><span style="color:#101310">mknod -m 600 /dev/console c 5 1</span></strong></pre>
<pre style="background:#E5E5E5"><strong><span style="color:#101310">mknod -m 666 /dev/null c 1 3</span></strong></pre>
</div>
<h2>6.8.2. 挂载 ramfs 并填充 /dev 目录</h2>
<p><span style="color:#333333">推荐的向</span><span style="color:#333333"> </span><tt><span style="color:#333333">/dev</span></tt><span style="color:#333333"> </span><span style="color:#333333">目录填充设备的方法是在</span><span style="color:#333333"> </span><tt><span style="color:#333333">/dev</span></tt><span style="color:#333333"> </span><span style="color:#333333">上挂载一个虚拟文件系统</span><span style="color:#333333">(</span><span style="color:#333333">比如</span><span style="color:#333333"> </span><tt><span style="color:#333333">tmpfs</span></tt><span style="color:#333333">)</span><span style="color:#333333">，然后在设备被检测到或被访问到的时候</span><span style="color:#333333">(</span><span style="color:#333333">通常是在系统引导的过程中</span><span style="color:#333333">)</span><span style="color:#333333">动态创建设备节点。既然现在新的系统尚未被引导，那么就有必要通过挂载</span><span style="color:#333333"> </span><tt><span style="color:#333333">/dev</span></tt><span style="color:#333333"> </span><span style="color:#333333">来手工完成</span><span style="color:#333333"> LFS-Bootscripts </span><span style="color:#333333">将来要做的事情：</span></p>
<div style="background:#E5E5E5">
<pre style="background:#E5E5E5"><strong><span style="color:#101310">mount -nvt tmpfs none /dev</span></strong></pre>
</div>
<p><span style="color:#333333">Udev</span><span style="color:#333333">软件包是实际用于在</span><span style="color:#333333"> </span><tt><span style="color:#333333">/dev</span></tt><span style="color:#333333"> </span><span style="color:#333333">目录中添加设备的工具。但是由于它要在后面的步骤中才被安装，我们现在必须手动创建一个必需的设备文件的最小集合，以便继续构建我们的系统。</span><span style="color:#333333">[</span><span style="color:#333333">注意</span><span style="color:#333333">]</span><span style="color:#333333">前面创建的</span><span style="color:#333333"> console </span><span style="color:#333333">和</span><span style="color:#333333"> null </span><span style="color:#333333">设备文件</span><span style="color:#333333">(</span><span style="color:#333333">保存在硬盘上</span><span style="color:#333333">)</span><span style="color:#333333">被新挂载的</span><span style="color:#333333"> tmpfs </span><span style="color:#333333">文件系统隐藏了，所以这里还要再创建一次。</span></p>
<div style="background:#E5E5E5">
<pre style="background:#E5E5E5"><strong><span style="color:#101310">mknod -m 622 /dev/console c 5 1</span></strong></pre>
<pre style="background:#E5E5E5"><strong><span style="color:#101310">mknod -m 666 /dev/null c 1 3</span></strong></pre>
<pre style="background:#E5E5E5"><strong><span style="color:#101310">mknod -m 666 /dev/zero c 1 5</span></strong></pre>
<pre style="background:#E5E5E5"><strong><span style="color:#101310">mknod -m 666 /dev/ptmx c 5 2</span></strong></pre>
<pre style="background:#E5E5E5"><strong><span style="color:#101310">mknod -m 666 /dev/tty c 5 0</span></strong></pre>
<pre style="background:#E5E5E5"><strong><span style="color:#101310">mknod -m 444 /dev/random c 1 8</span></strong></pre>
<pre style="background:#E5E5E5"><strong><span style="color:#101310">mknod -m 444 /dev/urandom c 1 9</span></strong></pre>
<pre style="background:#E5E5E5"><strong><span style="color:#101310">chown -v root:tty /dev/{console,ptmx,tty}</span></strong></pre>
</div>
<p><span style="color:#333333">有一些在系统启动的时候由</span><span style="color:#333333"> LFS-Bootscripts </span><span style="color:#333333">创建的符号连接和目录是</span><span style="color:#333333"> LFS </span><span style="color:#333333">系统所必须的。既然目前只是</span><span style="color:#333333"> chroot </span><span style="color:#333333">后的环境而不是真实启动后的环境，那么就需要在这里先创建他们：</span></p>
<div style="background:#E5E5E5">
<pre style="background:#E5E5E5"><strong><span style="color:#101310">ln -sv /proc/self/fd /dev/fd</span></strong></pre>
<pre style="background:#E5E5E5"><strong><span style="color:#101310">ln -sv /proc/self/fd/0 /dev/stdin</span></strong></pre>
<pre style="background:#E5E5E5"><strong><span style="color:#101310">ln -sv /proc/self/fd/1 /dev/stdout</span></strong></pre>
<pre style="background:#E5E5E5"><strong><span style="color:#101310">ln -sv /proc/self/fd/2 /dev/stderr</span></strong></pre>
<pre style="background:#E5E5E5"><strong><span style="color:#101310">ln -sv /proc/kcore /dev/core</span></strong></pre>
<pre style="background:#E5E5E5"><strong><span style="color:#101310">mkdir -v /dev/pts</span></strong></pre>
<pre style="background:#E5E5E5"><strong><span style="color:#101310">mkdir -v /dev/shm</span></strong></pre>
</div>
<p><span style="color:#333333">最后在新建的目录中挂载虚拟内核文件系统：</span></p>
<div style="background:#E5E5E5">
<pre style="background:#E5E5E5"><strong><span style="color:#101310">mount -vt devpts -o gid=4,mode=620 none /dev/pts</span></strong></pre>
<pre style="background:#E5E5E5"><strong><span style="color:#101310">mount -vt tmpfs none /dev/shm</span></strong></pre>
</div>
<p><span style="color:#333333">上面的</span><span style="color:#333333"> </span><strong>mount</strong><span style="color:#333333"> </span><span style="color:#333333">命令可能会导致下面的警告信息：</span></p>
<div style="background:#E9E9E9">
<pre style="background:#E9E9E9"><tt>can't open /etc/fstab: No such file or directory.</tt></pre>
</div>
<p><span style="color:#333333">因为在挂载文件系统时需要</span><span style="color:#333333"> </span><tt><span style="color:#333333">/etc/fstab</span></tt><span style="color:#333333"> </span><span style="color:#333333">文件的指示，但是该文件目前尚未被创建，不过你可以安全的忽略它，该文件系统仍然会被正确的挂载。</span></p>
<p>linux <span style="color:windowtext">目录树</span><span style="color:#565656"> </span><span style="color:#BBBABA">2013-05-31 19:54:24</span></p>
<p><span style="color:#19599B">分类：</span><span style="color:#19599B"> </span><span style="color:#BBBABA">LINUX</span></p>
<p><span style="color:#666666">linux</span><span style="color:#666666">根文件系统中一般有下面的几个目录：</span></p>
<p><span style="color:#666666">/bin</span></p>
<p><span style="color:#666666">该目录下的命令可以被root</span>与一般账号所使用，由于这些命令在挂接其它文件系统之前就可以使用，所以/bin目录必须和根文件系统在同一个分区中。</p>
<p><span style="color:#666666">/bin</span><span style="color:#666666">目录下常用的命令有：cat</span>、chgrp、chmod、cp、ls、sh、kill、mount、umount、mkdir、[、test等。其中“[”命令就是test命令，我们在利用Busybox制作根文件系统时，在生成的bin目录下，可以看到一些可执行的文件，也就是可用的一些命令。</p>
<p><span style="color:#666666"> /sbin</span><span style="color:#666666"> </span><span style="color:#666666">目录</span></p>
<p><span style="color:#666666">该目录下存放系统命令，即只有系统管理员（俗称最高权限的root</span>）能够使用的命令，系统命令还可以存放在/usr/sbin,/usr/local/sbin目录下，/sbin目录中存放的是基本的系统命令，它们用于启动系统和修复系统等，与/bin目录相似，在挂接其他文件系统之前就可以使用/sbin，所以/sbin目录必须和根文件系统在同一个分区中。</p>
<p><span style="color:#666666">/sbin</span><span style="color:#666666">目录下常用的命令有：shutdown</span>、reboot、fdisk、fsck、init等，<span style="color:windowtext">本地用户</span>自己安装的系统命令放在/usr/local/sbin目录下。</p>
<p><span style="color:#666666">/dev</span><span style="color:#666666">目录</span></p>
<p><span style="color:#666666">该目录下存放的是设备与设备接口的文件，设备文件是Linux</span>中特有的文件类型，在Linux系统下，以文件的方式访问各种设备，即通过读写某个设备文件操作某个具体硬件。比如通过"dev/ttySAC0"文件可以操作串口0，通过"/dev/mtdblock1"可以访问MTD设备的第2个分区。比较重要的文件有/dev/null, /dev/zero, /dev/tty,/dev/lp*等。</p>
<p><span style="color:#666666">/etc</span><span style="color:#666666">目录</span></p>
<p><span style="color:#666666">该目录下存放着系统主要的配置文件，例如人员的账号密码文件、各种服务的其实文件等。一般来说，此目录的各文件属性是可以让一般用户查阅的，但是只有root</span>有权限修改。对于PC上的Linux系统，/etc目录下的文件和目录非常多，这些目录文件是可选的，它们依赖于系统中所拥有的应用程序，依赖于这些程序是否需要配置文件。在<span style="color:windowtext">嵌入式系统</span>中，这些内容可以大为精减。</p>
<p><span style="color:#666666">/lib</span><span style="color:#666666">目录</span></p>
<p><span style="color:#666666">该目录下存放共享库和可加载（<span style="color:windowtext">驱动程序</span></span>），共享库用于启动系统。运行根文件系统中的可执行程序，比如：/bin /sbin<span style="color:#666666"> </span><span style="color:#666666">目录下的程序。</span></p>
<p><span style="color:#666666">/home</span><span style="color:#666666">目录</span></p>
<p><span style="color:#666666">系统默认的用户文件夹，它是可选的，对于每个普通用户，在/home</span>目录下都有一个以用户名命名的子目录，里面存放用户相关的配置文件</p>
<p><span style="color:#666666">/root</span><span style="color:#666666">目录</span></p>
<p><span style="color:#666666">系统管理员（root</span>）的主文件夹，即是根用户的目录，与此对应，普通用户的目录是/home下的某个子目录。</p>
<p><span style="color:#666666">/usr</span><span style="color:#666666">目录</span></p>
<p><span style="color:#666666">/usr</span><span style="color:#666666">目录的内容可以存在另一个分区中，在系统启动后再挂接到根文件系统中的/usr</span>目录下。里面存放的是共享、只读的程序和数据，这表明/usr目录下的内容可以在多个主机间共享，这些主要也符合<span style="color:windowtext">FHS</span>标准的。/usr中的文件应该是只读的，其他主机相关的，可变的文件应该保存在其他目录下，比如/var。/usr目录在<span style="color:windowtext">嵌入式</span>中可以精减。</p>
<p><span style="color:#666666">/var</span><span style="color:#666666">目录</span></p>
<p><span style="color:#666666">与/usr</span>目录相反，/var目录中存放可变的数据，比如spool目录（mail,news），log文件，临时文件。</p>
<p><span style="color:#666666">/proc</span><span style="color:#666666">目录</span></p>
<p><span style="color:#666666">这是一个空目录，常作为proc</span>文件系统的挂接点，proc文件系统是个虚拟的文件系统，它没有实际的存储设备，里面的目录，文件都是由<span style="color:windowtext">内核</span></p>
<p><span style="color:#666666">临时生成的，用来表示系统的运行状态，也可以操作其中的文件控制系统。</span></p>
<p><span style="color:#666666">/mnt</span><span style="color:#666666">目录</span></p>
<p><span style="color:#666666">用于临时挂载某个文件系统的挂接点，通常是空目录，也可以在里面创建一引起空的子目录，比如/mnt/cdram /mnt/hda1</span><span style="color:#666666"> </span><span style="color:#666666">。用来临时挂载光盘、移动存储设备等。</span></p>
<p><span style="color:#666666">/tmp</span><span style="color:#666666">目录</span></p>
<p><span style="color:#666666">用于存放临时文件，通常是空目录，一些需要生成临时文件的程序用到的/tmp</span>目录下，所以/tmp目录必须存在并可以访问。</p>
<p><span style="color:#666666">内核分区表：</span></p>
<p><span style="color:#666666">0x000000000000-0x000000100000 : "mtdblock0 u-boot1MB"</span></p>
<p><span style="color:#666666">0x000000100000-0x000001000000 : "mtdblock1 kernel15MB"</span></p>
<p><span style="color:#666666">0x000001000000-0x000002400000 : "mtdblock2 ramdisk20MB"</span></p>
<p><span style="color:#666666">0x000002400000-0x000003800000 : "mtdblock3 cramfs20MB"</span></p>
<p><span style="color:#666666">0x000003800000-0x000006000000 : "mtdblock4 jffs220MB"</span></p>
<p><span style="color:#666666">0x000006000000-0x000008800000 : "mtdblock5 yaffs240MB"</span></p>
<p><span style="color:#666666">0x000008800000-0x00000b000000 : "mtdblock6 ubifs40MB"</span></p>
<p><span style="color:#666666">0x00000b000000-0x00000e200000 : "mtdblock7 apps50MB"</span></p>
<p><span style="color:#666666">0x00000e200000-0x000011400000 : "mtdblock8 data50MB"</span></p>
<p><span style="color:#666666">1.</span><span style="color:#666666">首先创建目录树框架</span></p>
<p><span style="color:#666666">[lingyun@localhost rootfs]$ tree</span></p>
<p><span style="color:#666666">.</span></p>
<p><span style="color:#666666">|-- apps</span></p>
<p><span style="color:#666666">|-- bin</span></p>
<p><span style="color:#666666">|-- data</span></p>
<p><span style="color:#666666">|-- dev</span></p>
<p><span style="color:#666666">|-- etc</span></p>
<p><span style="color:#666666">| </span><span style="color:#666666"> </span><span style="color:#666666">`-- init.d</span></p>
<p><span style="color:#666666">|-- lib</span></p>
<p><span style="color:#666666">|-- mnt</span></p>
<p><span style="color:#666666">| </span><span style="color:#666666"> </span><span style="color:#666666">|-- dev</span></p>
<p><span style="color:#666666">| </span><span style="color:#666666"> </span><span style="color:#666666">|-- nfs</span></p>
<p><span style="color:#666666">| </span><span style="color:#666666"> </span><span style="color:#666666">|-- sdc</span></p>
<p><span style="color:#666666">| </span><span style="color:#666666"> </span><span style="color:#666666">`-- usb</span></p>
<p><span style="color:#666666">|-- proc</span></p>
<p><span style="color:#666666">|-- root</span></p>
<p><span style="color:#666666">|-- sbin</span></p>
<p><span style="color:#666666">|-- sys</span></p>
<p><span style="color:#666666">|-- tmp</span></p>
<p><span style="color:#666666">|-- usr</span></p>
<p><span style="color:#666666">| </span><span style="color:#666666"> </span><span style="color:#666666">|-- bin</span></p>
<p><span style="color:#666666">| </span><span style="color:#666666"> </span><span style="color:#666666">|-- lib</span></p>
<p><span style="color:#666666">| </span><span style="color:#666666"> </span><span style="color:#666666">|-- sbin</span></p>
<p><span style="color:#666666">|</span><span style="color:#666666"> </span><span style="color:#666666"> `--share</span></p>
<p><span style="color:#666666">`-- var</span></p>
<p><span style="color:#666666">2.</span><span style="color:#666666">在/dev</span>目录下创建设备节点：</p>
<p><span style="color:#666666">[lingyun@localhost dev]$ sudo mknod -m 755 console c 5 1</span></p>
<p><span style="color:#666666">[lingyun@localhost dev]$ sudo mknod -m 755 null c 1 3</span></p>
<p><span style="color:#666666">[lingyun@localhost dev]$ sudo mknod -m 755 ttyS0 c 4 64</span></p>
<p><span style="color:#666666">[lingyun@localhost dev]$ sudo mknod mtdblock0 b 31 0</span></p>
<p><span style="color:#666666">[lingyun@localhost dev]$ sudo mknod mtdblock1 b 31 1</span></p>
<p><span style="color:#666666">[lingyun@localhost dev]$ sudo mknod mtdblock2 b 31 2</span></p>
<p><span style="color:#666666">[lingyun@localhost dev]$ sudo mknod mtdblock3 b 31 3</span></p>
<p><span style="color:#666666">[lingyun@localhost dev]$ sudo mknod mtdblock4 b 31 4</span></p>
<p><span style="color:#666666">[lingyun@localhost dev]$ sudo mknod mtdblock5 b 31 5</span></p>
<p><span style="color:#666666">[lingyun@localhost dev]$ sudo mknod mtdblock6 b 31 6</span></p>
<p><span style="color:#666666">[lingyun@localhost dev]$ sudo mknod mtdblock7 b 31 7</span></p>
<p><span style="color:#666666">[lingyun@localhost dev]$ sudo mknod mtdblock8 b 31 8</span></p>
<p><span style="color:#666666">3.</span><span style="color:#666666">在var</span><span style="color:#666666"> </span><span style="color:#666666">目录下创建符号链接文件:</span></p>
<p><span style="color:#666666">[lingyun@localhost var]$ ln -s ../tmp lock</span></p>
<p><span style="color:#666666">[lingyun@localhost var]$ ln -s ../tmp log</span></p>
<p><span style="color:#666666">[lingyun@localhost var]$ ln -s ../tmp run</span></p>
<p><span style="color:#666666">[lingyun@localhost var]$ ln -s ../tmp tmp</span></p>
<p><span style="color:#666666">[lingyun@localhost var]$ ls -l</span></p>
<p><span style="color:#666666">total 0</span></p>
<p><span style="color:#666666">lrwxrwxrwx 1 lingyun trainning 6 May 27 13:39 lock ->../tmp</span></p>
<p><span style="color:#666666">lrwxrwxrwx 1 lingyun trainning 6 May 27 13:39 log ->../tmp</span></p>
<p><span style="color:#666666">lrwxrwxrwx 1 lingyun trainning 6 May 27 13:39 run ->../tmp</span></p>
<p><span style="color:#666666">lrwxrwxrwx 1 lingyun trainning 6 May 27 13:39 tmp ->../tmp</span></p>
<p><span style="color:#666666">/var/tmp</span><span style="color:#666666"> </span><span style="color:#666666"><br> </span><span style="color:#666666"> 比/tmp</span>大或需要存较长时间的临时文件.</p>
<p><span style="color:#666666">/var/lock</span><span style="color:#666666"> </span><span style="color:#666666"><br> </span><span style="color:#666666"> 锁定文件.</span>许多程序遵循在/var/lock<span style="color:#666666"> </span><span style="color:#666666">中产生一个锁定文件的约定，以支持他们正在使用某个特定的设备或文件.</span>其他程序注意到这个锁定文件，将不试图使用这个设备或文件.</p>
<p><span style="color:#666666">/var/log</span><span style="color:#666666"> </span><span style="color:#666666"><br> </span><span style="color:#666666"> 各种程序的log</span>文件，特别是login (/var/log/wtmp log所有到系统的登录和注销)<span style="color:#666666"> </span><span style="color:#666666">和syslog (/var/log/messages</span><span style="color:#666666"> </span><span style="color:#666666">里存储所有核心和系统程序信息. /var/log</span><span style="color:#666666"> </span><span style="color:#666666">里的文件经常不确定地增长，应该定期清除</span></p>
<p><span style="color:#666666">/var/run</span><span style="color:#666666"> </span><span style="color:#666666"><br> </span><span style="color:#666666"> 保存到下次引导前有效的关于系统的信息文件.</span>例如，/var/run/utmp<span style="color:#666666"> </span><span style="color:#666666">包含当前登录的用户的信息.</span></p>
<p><span style="color:#666666">4.</span><span style="color:#666666">在/etc</span>目录下增加fstab，hostname，inittab，mdev.conf，passwd，protocols，resolv.conf，services，</p>
<p><span style="color:#666666">group</span><span style="color:#666666">，hosts</span>，issue，mtab，profile，shadow文件</p>
<p><span style="color:#666666">inittab</span><span style="color:#666666">文件:</span></p>
<p><span style="color:#666666"># /etc/inittab</span></p>
<p><span style="color:#666666"># mount all the file systems specified in /etc/fstab</span></p>
<p><span style="color:#666666">::sysinit:/bin/mount </span><span style="color:#666666">–a </span><span style="color:#666666"> </span><span style="color:#666666"> //</span><span style="color:#666666">系统启动后自动挂载fstab</span>文件中指定的虚拟文件系统</p>
<p><span style="color:#666666">#Use mdev as hotplug to auto mount USB storage or SD card</span><span style="color:#666666"> </span><span style="color:#666666"> //</span><span style="color:#666666">系统使能hotplug</span>功能，当然还需要一些挂载脚本文件</p>
<p><span style="color:#666666">::sysinit:/bin/echo /sbin/mdev >/proc/sys/kernel/hotplug</span></p>
<p><span style="color:#666666">::sysinit:/sbin/mdev -s</span></p>
<p><span style="color:#666666">#make shm, pts support</span></p>
<p><span style="color:#666666">::sysinit:/bin/mkdir -p /dev/pts</span></p>
<p><span style="color:#666666">::sysinit:/bin/mkdir -p /dev/shm</span></p>
<p><span style="color:#666666">::sysinit:/bin/mount -t devpts devpts /dev/pts</span></p>
<p><span style="color:#666666">#Mount our apps/infopartition </span><span style="color:#666666"> </span><span style="color:#666666"> //</span><span style="color:#666666">挂载nand flash</span><span style="color:#666666"> </span><span style="color:#666666">分区</span></p>
<p><span style="color:#666666">null::wait:/bin/mount -o sync,noatime,ro -t jffs2/dev/mtdblock7 /apps</span></p>
<p><span style="color:#666666">null::wait:/bin/mount -o sync,noatime,ro -t jffs2/dev/mtdblock8 /data</span></p>
<p><span style="color:#666666">#Set hostname</span></p>
<p><span style="color:#666666">null::sysinit:/bin/hostname -F /etc/hostname</span></p>
<p><span style="color:#666666">#Initialize the user account files</span></p>
<p><span style="color:#666666">#null::wait:/usr/sbin/initpwd</span></p>
<p><span style="color:#666666">#Enable console logon</span></p>
<p><span style="color:#666666">null::respawn:/sbin/getty -L ttyS0 115200vt100 </span></p>
<p><span style="color:#666666">null::sysinit:/bin/mkdir -p /tmp/logs</span></p>
<p><span style="color:#666666">null::sysinit:/bin/mkdir -p /tmp/stat</span></p>
<p><span style="color:#666666"># now run any rc scripts</span></p>
<p><span style="color:#666666">null::wait:/etc/init.d/rcS</span></p>
<p><span style="color:#666666"># system daemon</span></p>
<p><span style="color:#666666">null::respawn:/sbin/syslogd -n</span></p>
<p><span style="color:#666666">null::respawn:/sbin/klogd -n</span></p>
<p><span style="color:#666666"># Stuff to do before rebooting</span></p>
<p><span style="color:#666666">null::shutdown:/bin/umount /apps</span></p>
<p><span style="color:#666666">null::shutdown:/bin/umount /data</span></p>
<p><span style="color:#666666">null::shutdown:/bin/killall klogd</span></p>
<p><span style="color:#666666">null::shutdown:/bin/killall syslogd</span></p>
<p><span style="color:#666666">null::shutdown:/bin/umount -a -r</span></p>
<p><span style="color:#666666">fstab</span><span style="color:#666666">文件:</span></p>
<p><span style="color:#666666">/etc/fstab: static file system information.</span></p>
<p><span style="color:#666666">#</span><span style="color:#666666"> </span><span style="color:#666666"> </span><span style="color:#666666"> </span><span style="color:#666666"> </span><span style="color:#666666"> </span><span style="color:#666666"> </span></p>
<p><span style="color:#666666">/dev/root </span><span style="color:#666666"> </span><span style="color:#666666">/ </span><span style="color:#666666"> </span><span style="color:#666666">ext2 </span><span style="color:#666666"> </span><span style="color:#666666">rw,noauto </span><span style="color:#666666"> </span><span style="color:#666666">0 </span><span style="color:#666666"> </span><span style="color:#666666">1</span></p>
<p><span style="color:#666666">proc </span><span style="color:#666666"> </span><span style="color:#666666">/proc </span><span style="color:#666666"> </span><span style="color:#666666">proc </span><span style="color:#666666"> </span><span style="color:#666666">defaults </span><span style="color:#666666"> </span><span style="color:#666666">0 </span><span style="color:#666666"> </span><span style="color:#666666">0</span></p>
<p><span style="color:#666666">tmpfs </span><span style="color:#666666"> </span><span style="color:#666666"> /dev </span><span style="color:#666666"> </span><span style="color:#666666"> tmpfs </span><span style="color:#666666"> </span><span style="color:#666666">defaults </span><span style="color:#666666"> </span><span style="color:#666666">0 </span><span style="color:#666666"> </span><span style="color:#666666">0</span></p>
<p><span style="color:#666666">ramfs </span><span style="color:#666666"> </span><span style="color:#666666">/tmp </span><span style="color:#666666"> </span><span style="color:#666666"> ramfs </span><span style="color:#666666"> </span><span style="color:#666666">defaults </span><span style="color:#666666"> </span><span style="color:#666666">0 </span><span style="color:#666666"> </span><span style="color:#666666">0</span></p>
<p><span style="color:#666666">sysfs </span><span style="color:#666666"> </span><span style="color:#666666">/sys </span><span style="color:#666666"> </span><span style="color:#666666">sysfs </span><span style="color:#666666"> </span><span style="color:#666666">defaults </span><span style="color:#666666"> </span><span style="color:#666666">0 </span><span style="color:#666666"> </span><span style="color:#666666">0</span></p>
<p><span style="color:#666666">hostname</span><span style="color:#666666">文件:</span></p>
<p><span style="color:#666666">MINI2440</span></p>
<p><span style="color:#666666">shadow</span><span style="color:#666666">文件: </span></p>
<p><span style="color:#666666">修改虚拟机root</span>用户的密码：</p>
<p><span style="color:#666666">[lingyun@localhost etc]$ sudo passwd root</span></p>
<p><span style="color:#666666">Changing password for user root.</span></p>
<p><span style="color:#666666">New password:</span></p>
<p><span style="color:#666666">BAD PASSWORD: it is based on a dictionary word</span></p>
<p><span style="color:#666666">BAD PASSWORD: is too simple</span></p>
<p><span style="color:#666666">Retype new password:</span></p>
<p><span style="color:#666666">passwd: all authentication tokens updated successfully.</span></p>
<p><span style="color:#666666">[lingyun@localhost etc]$ sudo head -n 2 /etc/shadow</span></p>
<p><span style="color:#666666">root:$6$4o1aUL4K$fexvf1D74DjTIAfXZkEyrPuQWu38iPx2CrfC91Sx09331RBDDV0iEZ/GIX9vWMaIRij6VSaHbhuEM98X6ag9B.:15852:0:99999:7:::</span></p>
<p><span style="color:#666666">bin:*:15513:0:99999:7:::</span></p>
<p><span style="color:#666666">将以上两行内容拷贝到制作的根文件系统/etc/shadow</span>中。注意：我现在是在虚拟机上做文件系统。</p>
<p><span style="color:#666666">group</span><span style="color:#666666">文件: </span><span style="color:#666666"> </span><span style="color:#666666"> </span></p>
<p><span style="color:#666666">root:x:0: </span><span style="color:#666666"> </span><span style="color:#666666"> //</span><span style="color:#666666">为root</span>用户创建一个分组</p>
<p><span style="color:#666666">passwd</span><span style="color:#666666">文件:</span></p>
<p><span style="color:#666666">root:x:0:0:root:/root:/bin/sh </span><span style="color:#666666"> </span><span style="color:#666666"> //</span><span style="color:#666666">每个系统都必需有个root</span>用户</p>
<p><span style="color:#666666">hosts</span><span style="color:#666666">文件:</span></p>
<p><span style="color:#666666">127.0.0.1 </span><span style="color:#666666"> </span><span style="color:#666666">localhost </span><span style="color:#666666"> </span><span style="color:#666666"> //pinglocalhost</span><span style="color:#666666">就相当于ping 127.0.0.1<br> <br> <br> </span></p>
<p><span style="color:#666666">issue</span><span style="color:#666666">文件: </span><span style="color:#666666"> </span><span style="color:#666666"> //</span><span style="color:#666666">文件中的内容为系统登录时的提示信息</span></p>
<p><span style="color:#666666">Welcome to LinuxWorld!!! </span></p>
<p><span style="color:#666666">mdev.conf</span><span style="color:#666666">文件: </span><span style="color:#666666"> </span><span style="color:#666666"> //</span><span style="color:#666666">系统自动挂载文件，比如我们插上U</span>盘后，自动挂载</p>
<p><span style="color:#666666">sd[a-h]*[0-9] </span><span style="color:#666666"> </span><span style="color:#666666">0:00660 </span><span style="color:#666666"> </span><span style="color:#666666">*(/usr/sbin/hotplug /media/usb)</span></p>
<p><span style="color:#666666">sd[a-h] </span><span style="color:#666666"> </span><span style="color:#666666">0:00660 </span><span style="color:#666666"> </span><span style="color:#666666">*(/usr/sbin/hotplug /media/usb)</span></p>
<p><span style="color:#666666">ub[a-h]*[0-9] </span><span style="color:#666666"> </span><span style="color:#666666">0:00660 </span><span style="color:#666666"> </span><span style="color:#666666">*(/usr/sbin/hotplug /media/usb)</span></p>
<p><span style="color:#666666">ub[a-h] </span><span style="color:#666666"> </span><span style="color:#666666">0:00660 </span><span style="color:#666666"> </span><span style="color:#666666">*(/usr/sbin/hotplug /media/usb)</span></p>
<p><span style="color:#666666">mmcblk[0-9]p[0-9] 0:00660 </span><span style="color:#666666"> </span><span style="color:#666666">@(/bin/mount /dev/$MDEV /media/mmc)</span></p>
<p><span style="color:#666666">mmcblk[0-9] </span><span style="color:#666666"> </span><span style="color:#666666">0:00660 </span><span style="color:#666666"> </span><span style="color:#666666">$(/bin/umount/media/mmc) </span></p>
<p><span style="color:#666666">profile</span><span style="color:#666666">文件: </span></p>
<p><span style="color:#666666">export PATH=\</span></p>
<p><span style="color:#666666">/bin:\</span></p>
<p><span style="color:#666666">/sbin:\</span></p>
<p><span style="color:#666666">/usr/bin:\</span></p>
<p><span style="color:#666666">/usr/sbin:\</span></p>
<p><span style="color:#666666">/apps/tools:\</span></p>
<p><span style="color:#666666">/apps/bin:\</span></p>
<p><span style="color:#666666">export PS1='\w >: '</span></p>
<p><span style="color:#666666">export USER=`id -un`</span></p>
<p><span style="color:#666666">export LOGNAME=$USER</span></p>
<p><span style="color:#666666">export HOSTNAME=`/bin/hostname`</span></p>
<p><span style="color:#666666">export HISTSIZE=500</span></p>
<p><span style="color:#666666">export HISTFILESIZE=500</span></p>
<p><span style="color:#666666">export PAGER='/bin/more '</span></p>
<p><span style="color:#666666">export EDITOR='/bin/vi'</span></p>
<p><span style="color:#666666">export INPUTRC=/etc/inputrc</span></p>
<p><span style="color:#666666">export network_cfg_dir=/apps/etc/network</span></p>
<p><span style="color:#666666">export LD_LIBRARY_PATH=/lib:/usr/lib:/apps/lib:/apps/libs</span></p>
<p><span style="color:#666666">### Some aliases</span></p>
<p><span style="color:#666666">alias vim='vi'</span></p>
<p><span style="color:#666666">alias ll='ls -l'</span></p>
<p><span style="color:#666666">alias l.='ls -d .*'</span></p>
<p><span style="color:#666666">alias df='df -h' </span></p>
<p><span style="color:#666666">protocols</span><span style="color:#666666">文件: </span><span style="color:#666666"> </span><span style="color:#666666"> //</span><span style="color:#666666">指定协议端口号</span></p>
<p><span style="color:#666666"># /etc/protocols:</span></p>
<p><span style="color:#666666">ip </span><span style="color:#666666"> </span><span style="color:#666666">0 </span><span style="color:#666666"> </span><span style="color:#666666">IP </span></p>
<p><span style="color:#666666">icmp </span><span style="color:#666666"> </span><span style="color:#666666">1 </span><span style="color:#666666"> </span><span style="color:#666666">ICMP </span></p>
<p><span style="color:#666666">igmp </span><span style="color:#666666"> </span><span style="color:#666666">2 </span><span style="color:#666666"> </span><span style="color:#666666">IGMP </span></p>
<p><span style="color:#666666">ggp </span><span style="color:#666666"> </span><span style="color:#666666">3 </span><span style="color:#666666"> </span><span style="color:#666666">GGP </span><span style="color:#666666"> </span><span style="color:#666666"> </span></p>
<p><span style="color:#666666">ipencap 4 </span><span style="color:#666666"> </span><span style="color:#666666"> IP-ENCAP </span></p>
<p><span style="color:#666666">st </span><span style="color:#666666"> </span><span style="color:#666666">5 </span><span style="color:#666666"> </span><span style="color:#666666">ST </span></p>
<p><span style="color:#666666">tcp </span><span style="color:#666666"> </span><span style="color:#666666">6 </span><span style="color:#666666"> </span><span style="color:#666666">TCP </span></p>
<p><span style="color:#666666">egp </span><span style="color:#666666"> </span><span style="color:#666666">8 </span><span style="color:#666666"> </span><span style="color:#666666"> EGP </span><span style="color:#666666"> </span><span style="color:#666666"> </span></p>
<p><span style="color:#666666">pup </span><span style="color:#666666"> </span><span style="color:#666666">12 </span><span style="color:#666666"> </span><span style="color:#666666">PUP </span></p>
<p><span style="color:#666666">udp </span><span style="color:#666666"> </span><span style="color:#666666">17 </span><span style="color:#666666"> </span><span style="color:#666666">UDP </span><span style="color:#666666"> </span><span style="color:#666666"> </span></p>
<p><span style="color:#666666">hmp </span><span style="color:#666666"> </span><span style="color:#666666">20 </span><span style="color:#666666"> </span><span style="color:#666666">HMP </span><span style="color:#666666"> </span><span style="color:#666666"> </span></p>
<p><span style="color:#666666">xns-idp 22 </span><span style="color:#666666"> </span><span style="color:#666666"> XNS-IDP </span></p>
<p><span style="color:#666666">rdp </span><span style="color:#666666"> </span><span style="color:#666666">27 </span><span style="color:#666666"> </span><span style="color:#666666">RDP </span><span style="color:#666666"> </span><span style="color:#666666"> </span></p>
<p><span style="color:#666666">iso-tp4 29 </span><span style="color:#666666"> </span><span style="color:#666666">ISO-TP4 </span></p>
<p><span style="color:#666666">xtp </span><span style="color:#666666"> </span><span style="color:#666666">36 </span><span style="color:#666666"> </span><span style="color:#666666">XTP </span><span style="color:#666666"> </span><span style="color:#666666"> </span></p>
<p><span style="color:#666666">ddp </span><span style="color:#666666"> </span><span style="color:#666666">37</span><span style="color:#666666"> </span><span style="color:#666666"> DDP </span><span style="color:#666666"> </span><span style="color:#666666"> </span></p>
<p><span style="color:#666666">idpr-cmtp </span><span style="color:#666666"> </span><span style="color:#666666">39 </span><span style="color:#666666"> </span><span style="color:#666666">IDPR-CMTP </span></p>
<p><span style="color:#666666">rspf </span><span style="color:#666666"> </span><span style="color:#666666">73 </span><span style="color:#666666"> </span><span style="color:#666666">RSPF </span></p>
<p><span style="color:#666666">vmtp </span><span style="color:#666666"> </span><span style="color:#666666">81 </span><span style="color:#666666"> </span><span style="color:#666666">VMTP </span><span style="color:#666666"> </span><span style="color:#666666"> </span></p>
<p><span style="color:#666666">ospf </span><span style="color:#666666"> </span><span style="color:#666666">89 </span><span style="color:#666666"> </span><span style="color:#666666">OSPFIGP </span><span style="color:#666666"> </span><span style="color:#666666"> </span></p>
<p><span style="color:#666666">ipip </span><span style="color:#666666"> </span><span style="color:#666666">94 </span><span style="color:#666666"> </span><span style="color:#666666">IPIP </span><span style="color:#666666"> </span><span style="color:#666666"> </span></p>
<p><span style="color:#666666">encap </span><span style="color:#666666"> </span><span style="color:#666666">98 </span><span style="color:#666666"> </span><span style="color:#666666">ENCAP</span></p>
<p><span style="color:#666666">resolv.conf</span><span style="color:#666666">文件：</span></p>
<p><span style="color:#666666">nameserver 4.2.2.2</span></p>
<p><span style="color:#666666">nameserver 8.8.8.8</span></p>
<p><span style="color:#666666">servers</span><span style="color:#666666">文件：</span></p>
<p><span style="color:#666666">这个文件我们直接用虚拟机中/etc/servers</span>文件，主要是提供的相关服务，比如ftp</p>
<p><span style="color:#666666">mtab</span><span style="color:#666666">文件：</span></p>
<p><span style="color:#666666">不需要加任何内容，它</span>记载的是现在系统已经装载的文件系统，包括操作系统建立的虚拟文件等；而/etc/fstab是系统准备装载的。直接使用mount就是通过查询它而来的。</p>
<p><span style="color:#666666">4.</span><span style="color:#666666">在init.d</span>目录下增加文件rcS <span style="color:#666666"> </span><span style="color:#666666">S01_network</span><span style="color:#666666"> </span><span style="color:#666666"> S99_rcsApp</span></p>
<p><span style="color:#666666">[lingyun@localhost init.d]$ cat rcS</span></p>
<p><span style="color:#666666">#!/bin/sh</span></p>
<p><span style="color:#666666">for i in /etc/init.d/S??* ;do</span></p>
<p><span style="color:#666666"> </span><span style="color:#666666"> </span><span style="color:#666666">$i</span></p>
<p><span style="color:#666666">done</span></p>
<p><span style="color:#666666">[lingyun@localhost init.d]$ cat S99_rcsApp</span></p>
<p><span style="color:#666666">#!/bin/sh</span></p>
<p><span style="color:#666666">if (test -d /apps/etc/init.d)</span></p>
<p><span style="color:#666666">then</span></p>
<p><span style="color:#666666"> </span><span style="color:#666666"> </span><span style="color:#666666">for i in /apps/etc/init.d/S??* ;do</span></p>
<p><span style="color:#666666"> </span><span style="color:#666666"> </span><span style="color:#666666"> $i</span></p>
<p><span style="color:#666666"> </span><span style="color:#666666"> </span><span style="color:#666666">done</span></p>
<p><span style="color:#666666">fi</span></p>
<p><span style="color:#666666">5.</span><span style="color:#666666">编译busybox</span>，根文件系统的命令都来自busybox</p>
<p><span style="color:#666666"><br> <br> <br> <br> <br> <br> <br> </span><span style="color:#666666">静态编译，并指定交叉编译器的路径<br> <br> <br> <br> </span></p>
<p><span style="color:#666666">指定命令的安装路径<br> <br> <br> </span>注意：busybox-1.20.2目录和rootfs目录在同一个目录下！<br> 在make ，make install之后,，rootfs中的bin，sbin 目录，就有了文件系统需要的命令！<br> <br> Init进程<br> <br> <br> 以上已经成功的创建了一个根文件系统目录树。</p>
<h2>虚拟内存盘</h2>
<p><strong><span style="color:#333333">ramdisk</span></strong><span style="color:#333333">即虚拟内存盘（虚拟内存盘）。</span></p>
<p><span style="color:#333333">虚拟内存盘是通过软件将一部分</span><span style="color:#333333"><span style="color:#136EC2">内存</span></span><span style="color:#333333">（</span><span style="color:#333333">RAM</span><span style="color:#333333">）模拟为</span><span style="color:#333333"><span style="color:#136EC2">硬盘</span></span><span style="color:#333333">来使用的一种技术。相对于直接的硬盘文件访问来说，这种技术可以极大的提高在其上进行的文件访问的速度。但是</span><span style="color:#333333">RAM</span><span style="color:#333333">的易失性也意味着当关闭电源后这部分数据将会丢失。但是在一般情况下，传递到</span><span style="color:#333333">RAM</span><span style="color:#333333">盘上的数据都是在硬盘或别处永久贮存的文件的一个拷贝。经由适当的配置，可以实现当系统重启后重新建立虚拟盘。</span></p>
<p><strong>简介</strong></p>
<p><sup><span style="color:#3366CC">[1]</span></sup><span style="color:#333333">虚拟内存盘是通过软件将一部分</span><span style="color:#333333"><span style="color:#136EC2">内存</span></span><span style="color:#333333">（</span><span style="color:#333333">RAM</span><span style="color:#333333">）模拟为</span><span style="color:#333333"><span style="color:#136EC2">硬盘</span></span><span style="color:#333333">来使用的一种技术。相对于直接的硬盘文件访问来说，这种技术可以极大的提高在其上进行的文件访问的速度。但是</span><span style="color:#333333">RAM</span><span style="color:#333333">的易失性也意味着当关闭电源后这部分数据将会丢失。但是在一般情况下，传递到</span><span style="color:#333333">RAM</span><span style="color:#333333">盘上的数据都是在硬盘或别处永久贮存的文件的一个拷贝。经由适当的配置，可以实现当系统重启后重新建立虚拟盘。</span></p>
<p><strong>原理和用途</strong></p>
<p><span style="color:#333333">虚拟内存盘使用计算机内存的一部分来模拟一个硬盘。在</span><span style="color:#333333">DOS/windows</span><span style="color:#333333">下由相应的软件利用系统分配给它的内存空间来实现这种模拟。</span><span style="color:#333333">linux</span><span style="color:#333333">系统可以使用其</span><span style="color:#333333"><span style="color:#136EC2">内核</span></span><span style="color:#333333">支持的机制来实现。</span></p>
<p><span style="color:#333333">虚拟内存盘还可以使用带有压缩机制的</span><span style="color:#333333"><span style="color:#136EC2">文件系统</span></span><span style="color:#333333">，例如：</span><span style="color:#333333">cramfs</span><span style="color:#333333">。这是因为一般的</span><span style="color:#333333">RAM</span><span style="color:#333333">盘的容量一般都较小，且</span><span style="color:#333333">RAM</span><span style="color:#333333">的存储空间比硬盘的要宝贵得多，价格也比硬盘要来得高，所以这样做是很合理的。</span></p>
<p><span style="color:#333333">虚拟内存盘的一个用途是做为</span><span style="color:#333333">Web<span style="color:#136EC2">缓存</span></span><span style="color:#333333">，这样可以提高加载页面的速度，因为硬盘的存取速度远小于内存（</span><span style="color:#333333">RAM</span><span style="color:#333333">）的存取速度</span><sup><span style="color:#3366CC">[2]</span></sup><span style="color:#333333">。由于</span><span style="color:#333333">RAM</span><span style="color:#333333">的易失性，这一措施还带来了安全性上的好处</span><sup><span style="color:#3366CC">[3]</span></sup><span style="color:#333333">。</span></p>
<p><strong>实现及软件</strong></p>
<p><span style="color:#333333">DOS</span><span style="color:#333333">系统：</span><span style="color:#333333">XMSDSK</span><span style="color:#333333">；</span></p>
<p><span style="color:#333333">Windows</span><span style="color:#333333">系统：</span><span style="color:#333333">VSuite</span><span style="color:#333333"> </span><span style="color:#333333"><span style="color:#136EC2">Ramdisk</span></span><span style="color:#333333">；</span></p>
<p><span style="color:#333333">linux</span><span style="color:#333333">系统：直接</span><span style="color:#333333"><span style="color:#136EC2">格式化</span></span><span style="color:#333333">并挂载</span><span style="color:#333333">/dev/ramX</span><span style="color:#333333">即可（</span><span style="color:#333333">X</span><span style="color:#333333">是内存盘序号）</span></p>
<h2><span style="color:#9ABAE6">CramFS </span> <span style="color:#9ABAE6">文件系统的制作</span> </h2>
<p><span style="color:#659AE3">2010-11-0415:06:56| </span><span style="color:#659AE3">分类：</span><span style="color:#659AE3"> </span><span style="color:#659AE3"><span style="color:#0F75DD">Linux file syste</span></span><span style="color:#184B75">|</span><span style="color:#0F75DD">字号</span><span style="color:#0F75DD"> </span><span style="color:#0F75DD">订阅</span></p>
<p>1. 准备根文件系统</p>
<p> 创建工作目录：$mkdir /rootfs</p>
<p> 创建根文件系统的目录：$cd /rootfs</p>
<p> $mkdirbin dev etc home lib mnt proc sbin sys tmp var usr (12个目录）</p>
<p> $mkdir etc/init.d</p>
<p>2. 创建设备文件</p>
<p> 复制当前系统的设备文件：$cp -dpR /dev/rootfs/dev</p>
<p> 如果使用 linux 2.6.x.x 内核，应该有节点 console、null 。如果在 /rootfs/dev 目录下没有这些节点，则转到 /rootfs/dev/目录来创建：</p>
<p> $mknodconsole c 5 1</p>
<p> $mknod null c 1 3</p>
<p> 缺少这些设备，会在启动 shell 时出现提示“Warning: unable to open an initialconsole. Kernel panic- not syncing: Attempted to kill init！” 的错误。</p>
<p>3. 准备目录系统启动所要的文件：linuxrc、rcS、inittab、fstab 四个文件。</p>
<p> linuxrc 文件（位于 "/"）的内容如下：</p>
<p> #！/bin/sh</p>
<p> echo "mount /etc as ramfs"</p>
<p> /bin/mount -f -t cramfs -o remount, ro /dev/bon/2 /</p>
<p> /bin/mount -t ramfs ramfs /var</p>
<p> /bin/mkdir -p /var/tmp</p>
<p> /bin/mkdir -p /var/run</p>
<p> /bin/mkdir-p /var/log</p>
<p> /bin/mkdir -p /var/lock</p>
<p> /bin/mkdir-p /var/empty</p>
<p> #/bin/mount-t usbdevfs none /proc/bus/usb exec /sbin/init</p>
<p> rcS 文件位于/etc/init.d/)的内容如下：</p>
<p> #！/bin/sh</p>
<p> /bin/mount-a</p>
<p> 这连个文件生成后，应该使其具有执行的权限，用chmod 来修改</p>
<p> inittab 文件位于 /etc 的内容如下：</p>
<p> #This is run first except when booting</p>
<p> ::sysinit:/etcinit.d/rcS</p>
<p> #Start an "askfirst" shell on the console</p>
<p> #::askfirst: ~/bin/bash</p>
<p> ::askfirst:~/bin/sh</p>
<p> #Stuffto do when restarting the init process</p>
<p> ::restart: /sbin/init</p>
<p> #Stuff to do before rebooting</p>
<p> :: ctrlaltdel: /sbin/reboot</p>
<p> :: shutdown: /bin/umount -a -r</p>
<p> fstab 文件位于 /etc 的内容如下所示：</p>
<p> none /proc proc defaults 0 0</p>
<p> none /dev/pts devpts mode=0622 0 0</p>
<p> tmpfs /dev/shm tmpfs defaults 0 0</p>
<p>4. 将编译好的 BusyBox 的_install 目录下的三个文件夹用 tar 命令打包复制到 /rootfs 目录，解压后删除打包文件。</p>
<p>5. 将一些常用的 lib 文件复制到 /rootfs/lib/ 目录下，例如： ld-2.5.so、libc-2.5.so等文件以及其符号链接。注意这些lib 文件指的是交叉编译工具链的 lib 文件，即位于 /arm-linux-gcc/lib 下的lib 文件。在复制时应该注意采用打包后解包方式复制，以保证符号链接的正确性和完整性。</p>
<p>6. 生成CramFS 文件系统映像文件 cram.img</p>
<p> $ mkcramfs/rootfs cram.img</p>
<p> 将工作目录 rootfs 作为根目录制作 CramFS 文件系统，这将经历一个处理和压缩的过程。压缩完成后，就可以测试下生成的 cram.img 文件了。</p>
<p> 下面命令挂载 CramFS 的文件系统：</p>
<p> $mount -o loop-t cramfs /cram.img/mnt 将cram.img 文件系统加载到 /mnt</p>
<p> $ ls /mnt</p>
<p>7. 将映像文件 cram.img 下载并写入目标板的 root 分区，正确配置 Linux 的内核启动参数，启动。 </p>
<h2>【摘】编程质量--内存移动函数 </h2>
<p><span style="color:#4992B4">2009-11-0811:39:34| </span><span style="color:#4992B4">分类：</span><span style="color:#4992B4"> </span><span style="color:#4992B4"><span style="color:#0C4468">c</span><span style="color:#0C4468">语言杂记</span></span><span style="color:#7196A7">|</span><span style="color:#0C4468">字号</span><span style="color:#0C4468"> </span><span style="color:#0C4468">订阅</span></p>
<p> </p>
<p>写一个函数，完成内存移动，并为其写一个简单的测试用例来进行测试。</p>
<p>够简单的吧？有的同学很快就写出了答案，详见程序清单1与程序清单2。</p>
<p>程序清单 1 V0.1版程序</p>
<p>void MyMemMove(char *dst,char *src,intcount)</p>
<p>{</p>
<p>while(count--)</p>
<p>{</p>
<p>*dst++ = *src++;</p>
<p>}</p>
<p>}</p>
<p>程序清单 2 测试用例</p>
<p>void Test()</p>
<p>{</p>
<p>char p1[256] = ”hello,world!”;</p>
<p>char p2[256] = {0};</p>
<p>MyMemMove(p2,p1,strlen(p1));</p>
<p>printf(“%s”,p2);</p>
<p>}</p>
<p>客观地讲，相比那些交白卷或者函数声明都不会写的同学来说，能够写出这段代码的同学已经非常不错了，至少在C语言这门课程上已经达到了现行高校的教育目标，但是离企业的用人要求还有一定的距离。我们不妨将上面的程序称为V0.1版本，看看还有没有什么地方可以改进。</p>
<p>首先我们看看函数声明是否合理，V0.1版的程序将源地址和目的地址都用char *来表示，这样当然也没有什么问题，但是让其他人使用起来却很不方便，假如现在要将count个连续的结构体对象移动到另外一个地方去，如果要使用v0.1的程序的话，正确的写法如下：</p>
<p>MyMemMove((char *)dst,(char *)src,sizeof(TheStruct)*count)</p>
<p>也就是说我们需要将结构体指针强制转换成char * 才能够正常工作，这样除了字符串以外其它的类型都不可避免地要进行指针强制转换，否则编译器就会呱呱叫，比如在VC++2008下就会出现这样的错误：</p>
<p>error C2664: 'MyMemMove' : cannot convertparameter 1 from 'TheStruct *' to 'char *'</p>
<p>那么如何解决这个问题呢？其实很简单，我们知道有一种特别的指针，任何类型的指针都可以对它赋值，那就是void *，所以应该将源地址和目的地址都用void*来表示。当然函数体的内容也要作相应的改变，这样我们就得到了V0.2版的程序。</p>
<p>程序清单 3 V0.2版程序</p>
<p>void MyMemMove(void *dst,void *src,intcount)</p>
<p>{</p>
<p>while (count--)</p>
<p>{</p>
<p>*(char *)dst = *(char *)src;</p>
<p>dst = (char *)dst + 1;</p>
<p>src = (char *)src + 1;</p>
<p>}</p>
<p>}</p>
<p>有的同学可能会问，这里面不是还有指针强制转换吗？只不过是换了地方。没错，强制指针转换确实是从使用者的代码转移到了库的代码里，但我们可以将MyMemMove理解为库，而将Test理解为使用者，事实上通过调整之后的效果却有天壤之别，V0.1是一逸永劳，而V0.2是一劳永逸！</p>
<p>还有几个细节需要注意，为了实现链式表达式，我们应该将返回值也改为void *。此外，如果我们不小心将“*(char*)dst = *(char *)src;”写反了，写成“*(char *)src = *(char *)dst;”编译照样通过，而为了找出这个错误又得花费不少时间。注意到src所指向的内容在这个函数内不应该被改变，所有对src所指的内容赋值都应该被禁止，所以这个参数应该用const修饰，如果有类似的错误在编译时就能够被发现：</p>
<p>error C3892: 'src' : you cannot assign to avariable that is const</p>
<p>作为程序员犯错误在所难免，但是我们可以利用相对难犯错误的机器，也就是编译器来降低犯错误的概率，这样我们就得到了V0.3版的程序。</p>
<p>程序清单 4 V0.3版程序</p>
<p>void * MyMemMove(void *dst,const void*src,int count)</p>
<p>{</p>
<p>void *ret=dst;</p>
<p>while (count--)</p>
<p>{</p>
<p>*(char *)dst = *(char *)src;</p>
<p>dst = (char *)dst + 1;</p>
<p>src = (char *)src + 1;</p>
<p>}</p>
<p>return ret;</p>
<p>}</p>
<p>现在再来考虑这样一种情况，有使用者这样调用库：MyMemMove(NULL,src, count)，这是完全可能的，因为一般来说这些地址都是程序计算出来的，那就难免会算错，出现零地址或者其它的非法地址也不足为奇。可以预料的是，如果出现这种情况的话，则程序马上就会down掉，更糟糕的是你不知道错误出在哪里，于是不得不投入大量的精力在浩瀚的代码中寻找bug。解决这类问题的通用办法是对输入参数作合法性检查，也就是V0.4版程序。</p>
<p>程序清单 5 V0.4版程序</p>
<p>void * MyMemMove(void *dst,const void*src,int count)</p>
<p>{</p>
<p>void *ret=dst;</p>
<p>if (NULL==dst||NULL ==src)</p>
<p>{</p>
<p>return dst;</p>
<p>}</p>
<p>while (count--)</p>
<p>{</p>
<p>*(char *)dst = *(char *)src;</p>
<p>dst = (char *)dst + 1;</p>
<p>src = (char *)src + 1;</p>
<p>}</p>
<p>return ret;</p>
<p>}</p>
<p>上面之所以写成“if(NULL==dst||NULL ==src)”而不是写成“if (dst == NULL || src == NULL)”，也是为了降低犯错误的概率。我们知道，在C语言里面“==”和“=”都是合法的运算符，如果我们不小心写成了“if (dst = NULL || src = NULL)”还是可以编译通过，而意思却完全不一样了，但是如果写成“if (NULL=dst||NULL =src)”，则编译的时候就通不过了，所以我们要养成良好的程序设计习惯：常量与变量作条件判断时应该把常量写在前面。</p>
<p>V0.4版的代码首先对参数进行合法性检查，如果不合法就直接返回，这样虽然程序dwon掉的可能性降低了，但是性能却大打折扣了，因为每次调用都会进行一次判断，特别是频繁的调用和性能要求比较高的场合，它在性能上的损失就不可小觑。</p>
<p>如果通过长期的严格测试，能够保证使用者不会使用零地址作为参数调用MyMemMove函数，则希望有简单的方法关掉参数合法性检查。我们知道宏就有这种开关的作用，所以V0.5版程序也就出来了。</p>
<p>程序清单 6 V0.5版程序</p>
<p>void * MyMemMove(void *dst,const void*src,int count)</p>
<p>{</p>
<p>void *ret=dst;</p>
<p>#ifdef DEBUG</p>
<p>if (NULL==dst||NULL ==src)</p>
<p>{</p>
<p>return dst;</p>
<p>}</p>
<p>#endif</p>
<p>while (count--)</p>
<p>{</p>
<p>*(char *)dst = *(char *)src;</p>
<p>dst = (char *)dst + 1;</p>
<p>src = (char *)src + 1;</p>
<p>}</p>
<p>return ret;</p>
<p>}</p>
<p>如果在调试时我们加入“#defineDEBUG”语句，增强程序的健壮性，那么在调试通过�</p>
</div>
</div>
</div>
</div>
</div>
<!--PC和WAP自适应版-->
<div id="SOHUCS" sid="1276502833553752064"></div>
<script type="text/javascript" src="/views/front/js/chanyan.js"></script>
<!-- 文章页-底部 动态广告位 -->
<div class="youdao-fixed-ad" id="detail_ad_bottom"></div>
</div>
<div class="col-md-3">
<div class="row" id="ad">
<!-- 文章页-右侧1 动态广告位 -->
<div id="right-1" class="col-lg-12 col-md-12 col-sm-4 col-xs-4 ad">
<div class="youdao-fixed-ad" id="detail_ad_1"> </div>
</div>
<!-- 文章页-右侧2 动态广告位 -->
<div id="right-2" class="col-lg-12 col-md-12 col-sm-4 col-xs-4 ad">
<div class="youdao-fixed-ad" id="detail_ad_2"></div>
</div>
<!-- 文章页-右侧3 动态广告位 -->
<div id="right-3" class="col-lg-12 col-md-12 col-sm-4 col-xs-4 ad">
<div class="youdao-fixed-ad" id="detail_ad_3"></div>
</div>
</div>
</div>
</div>
</div>
</div>
<div class="container">
<h4 class="pt20 mb15 mt0 border-top">你可能感兴趣的:(Linux)</h4>
<div id="paradigm-article-related">
<div class="recommend-post mb30">
<ul class="widget-links">
<li><a href="/article/1835513699826233344.htm"
title="android系统selinux中添加新属性property" target="_blank">android系统selinux中添加新属性property</a>
<span class="text-muted">辉色投像</span>
<div>1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property</div>
</li>
<li><a href="/article/1835509391361667072.htm"
title="Linux下QT开发的动态库界面弹出操作（SDL2）" target="_blank">Linux下QT开发的动态库界面弹出操作（SDL2）</a>
<span class="text-muted">13jjyao</span>
<a class="tag" taget="_blank" href="/search/QT%E7%B1%BB/1.htm">QT类</a><a class="tag" taget="_blank" href="/search/qt/1.htm">qt</a><a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E8%AF%AD%E8%A8%80/1.htm">开发语言</a><a class="tag" taget="_blank" href="/search/sdl2/1.htm">sdl2</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a>
<div>需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口</div>
</li>
<li><a href="/article/1835504596898902016.htm"
title="linux sdl windows.h,Windows下的SDL安装" target="_blank">linux sdl windows.h,Windows下的SDL安装</a>
<span class="text-muted">奔跑吧linux内核</span>
<a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a><a class="tag" taget="_blank" href="/search/sdl/1.htm">sdl</a><a class="tag" taget="_blank" href="/search/windows.h/1.htm">windows.h</a>
<div>首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第</div>
</li>
<li><a href="/article/1835503712899002368.htm"
title="linux中sdl的使用教程,sdl使用入门" target="_blank">linux中sdl的使用教程,sdl使用入门</a>
<span class="text-muted">Melissa Corvinus</span>
<a class="tag" taget="_blank" href="/search/linux%E4%B8%ADsdl%E7%9A%84%E4%BD%BF%E7%94%A8%E6%95%99%E7%A8%8B/1.htm">linux中sdl的使用教程</a>
<div>本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一</div>
</li>
<li><a href="/article/1835502578050363392.htm"
title="PHP环境搭建详细教程" target="_blank">PHP环境搭建详细教程</a>
<span class="text-muted">好看资源平台</span>
<a class="tag" taget="_blank" href="/search/%E5%89%8D%E7%AB%AF/1.htm">前端</a><a class="tag" taget="_blank" href="/search/php/1.htm">php</a>
<div>PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这</div>
</li>
<li><a href="/article/1835501948011376640.htm"
title="使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器）" target="_blank">使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器）</a>
<span class="text-muted">编程经验分享</span>
<a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E5%B7%A5%E5%85%B7/1.htm">开发工具</a><a class="tag" taget="_blank" href="/search/%E6%9C%8D%E5%8A%A1%E5%99%A8/1.htm">服务器</a><a class="tag" taget="_blank" href="/search/ssh/1.htm">ssh</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a>
<div>目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能</div>
</li>
<li><a href="/article/1835493373906087936.htm"
title="libyuv之linux编译" target="_blank">libyuv之linux编译</a>
<span class="text-muted">jaronho</span>
<a class="tag" taget="_blank" href="/search/Linux/1.htm">Linux</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a><a class="tag" taget="_blank" href="/search/%E8%BF%90%E7%BB%B4/1.htm">运维</a><a class="tag" taget="_blank" href="/search/%E6%9C%8D%E5%8A%A1%E5%99%A8/1.htm">服务器</a>
<div>文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko</div>
</li>
<li><a href="/article/1835489588169240576.htm"
title="ARM驱动学习之5 LEDS驱动" target="_blank">ARM驱动学习之5 LEDS驱动</a>
<span class="text-muted">JT灬新一</span>
<a class="tag" taget="_blank" href="/search/%E5%B5%8C%E5%85%A5%E5%BC%8F/1.htm">嵌入式</a><a class="tag" taget="_blank" href="/search/C/1.htm">C</a><a class="tag" taget="_blank" href="/search/%E5%BA%95%E5%B1%82/1.htm">底层</a><a class="tag" taget="_blank" href="/search/arm%E5%BC%80%E5%8F%91/1.htm">arm开发</a><a class="tag" taget="_blank" href="/search/%E5%AD%A6%E4%B9%A0/1.htm">学习</a><a class="tag" taget="_blank" href="/search/%E5%8D%95%E7%89%87%E6%9C%BA/1.htm">单片机</a>
<div>ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三</div>
</li>
<li><a href="/article/1835485681187647488.htm"
title="【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面" target="_blank">【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面</a>
<span class="text-muted">一个射手座的程序媛</span>
<a class="tag" taget="_blank" href="/search/%E7%A8%8B%E5%BA%8F%E5%91%98/1.htm">程序员</a><a class="tag" taget="_blank" href="/search/%E5%8D%8E%E4%B8%BAod/1.htm">华为od</a><a class="tag" taget="_blank" href="/search/%E9%9D%A2%E8%AF%95/1.htm">面试</a><a class="tag" taget="_blank" href="/search/%E8%81%8C%E5%9C%BA%E5%92%8C%E5%8F%91%E5%B1%95/1.htm">职场和发展</a>
<div>最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获</div>
</li>
<li><a href="/article/1835482277870661632.htm"
title="简介Shell、zsh、bash" target="_blank">简介Shell、zsh、bash</a>
<span class="text-muted">zhaosuningsn</span>
<a class="tag" taget="_blank" href="/search/Shell/1.htm">Shell</a><a class="tag" taget="_blank" href="/search/zsh/1.htm">zsh</a><a class="tag" taget="_blank" href="/search/bash/1.htm">bash</a><a class="tag" taget="_blank" href="/search/shell/1.htm">shell</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a><a class="tag" taget="_blank" href="/search/bash/1.htm">bash</a>
<div>Shell是Linux和Unix的外壳，类似衣服，负责外界与Linux和Unix内核的交互联系。例如接收终端用户及各种应用程序的命令，把接收的命令翻译成内核能理解的语言，传递给内核，并把内核处理接收的命令的结果返回给外界，即Shell是外界和内核沟通的桥梁或大门。Linux和Unix提供了多种Shell，其中有种bash，当然还有其他好多种。Mac电脑中不但有bash，还有一个zsh，预装的，据说</div>
</li>
<li><a href="/article/1835479000600899584.htm"
title="Linux MariaDB使用OpenSSL安装SSL证书" target="_blank">Linux MariaDB使用OpenSSL安装SSL证书</a>
<span class="text-muted">Meta39</span>
<a class="tag" taget="_blank" href="/search/MySQL/1.htm">MySQL</a><a class="tag" taget="_blank" href="/search/Oracle/1.htm">Oracle</a><a class="tag" taget="_blank" href="/search/MariaDB/1.htm">MariaDB</a><a class="tag" taget="_blank" href="/search/Linux/1.htm">Linux</a><a class="tag" taget="_blank" href="/search/Windows/1.htm">Windows</a><a class="tag" taget="_blank" href="/search/ssl/1.htm">ssl</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a><a class="tag" taget="_blank" href="/search/mariadb/1.htm">mariadb</a>
<div>进入到证书存放目录，批量删除.pem证书警告：确保已经进入到证书存放目录find.-typef-iname\*.pem-delete查看是否安装OpenSSLopensslversion没有则安装yuminstallopensslopenssl-devel开启SSL编辑/etc/my.cnf文件（没有的话就创建，但是要注意，在/etc/my.cnf.d/server.cnf配置了datadir的，</div>
</li>
<li><a href="/article/1835469294436184064.htm"
title="【从浅识到熟知Linux】Linux发展史" target="_blank">【从浅识到熟知Linux】Linux发展史</a>
<span class="text-muted">Jammingpro</span>
<a class="tag" taget="_blank" href="/search/%E4%BB%8E%E6%B5%85%E5%AD%A6%E5%88%B0%E7%86%9F%E7%9F%A5Linux/1.htm">从浅学到熟知Linux</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a><a class="tag" taget="_blank" href="/search/%E8%BF%90%E7%BB%B4/1.htm">运维</a><a class="tag" taget="_blank" href="/search/%E6%9C%8D%E5%8A%A1%E5%99%A8/1.htm">服务器</a>
<div>归属专栏：从浅学到熟知Linux个人主页：Jammingpro每日努力一点点，技术变化看得见文章前言：本篇文章记录Linux发展的历史，因在介绍Linux过程中涉及的其他操作系统及人物，本文对相关内容也有所介绍。文章目录Unix发展史Linux发展史开源Linux官网企业应用情况发行版本在学习Linux前，我们可能都会问Linux从哪里来？它是如何发展的。但在介绍Linux之前，需要先介绍一下Un</div>
</li>
<li><a href="/article/1835467782687387648.htm"
title="linux 发展史" target="_blank">linux 发展史</a>
<span class="text-muted">种树的猴子</span>
<a class="tag" taget="_blank" href="/search/%E5%86%85%E6%A0%B8/1.htm">内核</a><a class="tag" taget="_blank" href="/search/java/1.htm">java</a><a class="tag" taget="_blank" href="/search/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/1.htm">操作系统</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a><a class="tag" taget="_blank" href="/search/%E5%A4%A7%E6%95%B0%E6%8D%AE/1.htm">大数据</a>
<div>linux发展史说明此前对linux认识模糊一知半解，近期通过学习将自己对于linux的发展总结一下方便大家日后的学习。那Linux是目前一款非常火热的开源操作系统，可是linux是什么时候出现的，又是因为什么样的原因被开发出来的呢。以下将对linux的发展历程进行详细的讲解。目录一、Linux发展背景二、UINIX的诞生三、UNIX的重要分支-BSD的诞生四、Minix的诞生五、GNU与Free</div>
</li>
<li><a href="/article/1835466523163062272.htm"
title="Linux sh命令" target="_blank">Linux sh命令</a>
<span class="text-muted">fengyehongWorld</span>
<a class="tag" taget="_blank" href="/search/Linux/1.htm">Linux</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a>
<div>目录一.基本语法二.选项2.1-c字符串中读取内容，并执行2.1.1基本用法2.1.2获取当前目录下失效的超链接2.2-x每个命令执行之前，将其打印出来2.3结合Here文档使用一.基本语法⏹Linux和Unix系统中用于执行shell脚本或运行命令的命令。sh[选项][脚本文件][参数...]⏹选项-c：从字符串中读取内容，并执行。-x：在每个命令执行之前，将其打印出来。-s：从标准流中读取内容</div>
</li>
<li><a href="/article/1835466270955368448.htm"
title="Linux vi常用命令" target="_blank">Linux vi常用命令</a>
<span class="text-muted">fengyehongWorld</span>
<a class="tag" taget="_blank" href="/search/Linux/1.htm">Linux</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a>
<div>参考资料viコマンド（vimコマンド）リファレンス目录一.保存系命令二.删除系命令三.移动系命令四.复制粘贴系命令一.保存系命令⏹保存并退出:wq⏹强制保存并退出:wq!⏹退出(文件未编辑):q⏹强制退出(忽略已编辑内容):q!⏹另存为:w新文件名二.删除系命令⏹删除当前行dd⏹清空整个文档gg：移动到文档顶部dG：删除到最后一行ggdG三.移动系命令⏹移动到文档顶部gg⏹移动到文档底部#方式1G</div>
</li>
<li><a href="/article/1835452402178813952.htm"
title="Linux查看服务器日志" target="_blank">Linux查看服务器日志</a>
<span class="text-muted">TPBoreas</span>
<a class="tag" taget="_blank" href="/search/%E8%BF%90%E7%BB%B4/1.htm">运维</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a><a class="tag" taget="_blank" href="/search/%E8%BF%90%E7%BB%B4/1.htm">运维</a>
<div>一、tail这个是我最常用的一种查看方式用法如下：tail-n10test.log查询日志尾部最后10行的日志;tail-n+10test.log查询10行之后的所有日志;tail-fn10test.log循环实时查看最后1000行记录(最常用的)一般还会配合着grep用，(实时抓包)例如:tail-fn1000test.log|grep'关键字'（动态抓包）tail-fn1000test.log</div>
</li>
<li><a href="/article/1835443696431099904.htm"
title="笋丁网页自动回复机器人V3.0.0免授权版源码" target="_blank">笋丁网页自动回复机器人V3.0.0免授权版源码</a>
<span class="text-muted">希希分享</span>
<a class="tag" taget="_blank" href="/search/%E8%BD%AF%E5%B8%8C%E7%BD%9158soho_cn/1.htm">软希网58soho_cn</a><a class="tag" taget="_blank" href="/search/%E6%BA%90%E7%A0%81%E8%B5%84%E6%BA%90/1.htm">源码资源</a><a class="tag" taget="_blank" href="/search/%E7%AC%8B%E4%B8%81%E7%BD%91%E9%A1%B5%E8%87%AA%E5%8A%A8%E5%9B%9E%E5%A4%8D%E6%9C%BA%E5%99%A8%E4%BA%BA/1.htm">笋丁网页自动回复机器人</a>
<div>笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安</div>
</li>
<li><a href="/article/1835417097660887040.htm"
title="Linux CTF逆向入门" target="_blank">Linux CTF逆向入门</a>
<span class="text-muted">蚁景网络安全</span>
<a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a><a class="tag" taget="_blank" href="/search/%E8%BF%90%E7%BB%B4/1.htm">运维</a><a class="tag" taget="_blank" href="/search/CTF/1.htm">CTF</a>
<div>1.ELF格式我们先来看看ELF文件头，如果想详细了解，可以查看ELF的manpage文档。关于ELF更详细的说明：e_shoff：节头表的文件偏移量（字节）。如果文件没有节头表，则此成员值为零。sh_offset：表示了该section（节）离开文件头部位置的距离+-------------------+|ELFheader|---++--------->+-------------------</div>
</li>
<li><a href="/article/1835415332345442304.htm"
title="NPM私库搭建-verdaccio（Linux）" target="_blank">NPM私库搭建-verdaccio（Linux）</a>
<span class="text-muted">Beam007</span>
<a class="tag" taget="_blank" href="/search/npm/1.htm">npm</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a><a class="tag" taget="_blank" href="/search/%E5%89%8D%E7%AB%AF/1.htm">前端</a>
<div>1、安装nodelinux服务器安装nodea)、官网下载所需的node版本https://nodejs.org/dist/v14.21.0/b)、解压安装包若下载的是xxx.tar.xz文件，解压命令为tar-xvfxxx.tar.xzc)、修改环境变量修改：/etc/profile文件#SETPATHFORNODEJSexportNODE_HOME=NODEJS解压安装的路径exportPAT</div>
</li>
<li><a href="/article/1835400463676174336.htm"
title="C++常见知识掌握" target="_blank">C++常见知识掌握</a>
<span class="text-muted">nfgo</span>
<a class="tag" taget="_blank" href="/search/c%2B%2B/1.htm">c++</a><a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E8%AF%AD%E8%A8%80/1.htm">开发语言</a>
<div>1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映</div>
</li>
<li><a href="/article/1835399577818198016.htm"
title="linux脚本sed替换变量,sed 命令中替换值为shell变量" target="_blank">linux脚本sed替换变量,sed 命令中替换值为shell变量</a>
<span class="text-muted">诺坎普之约</span>
<a class="tag" taget="_blank" href="/search/linux%E8%84%9A%E6%9C%ACsed%E6%9B%BF%E6%8D%A2%E5%8F%98%E9%87%8F/1.htm">linux脚本sed替换变量</a>
<div>文章目录sed命令中替换值为shell变量替换基本语法sed中替换使用shell变量总结参考文档sed命令中替换值为shell变量替换基本语法大家都是sed有很多用法，最多就应该是替换一些值了。让我们先回忆sed的替换语法。在sed进行替换的时候sed-i's/old/new/g'1.txtecho"hellooldfrank"|sed's/old/new/g'结果如下：hellonewfrank</div>
</li>
<li><a href="/article/1835398694636187648.htm"
title="RK3229_Android9.0_Box 4G模块EC200A调试" target="_blank">RK3229_Android9.0_Box 4G模块EC200A调试</a>
<span class="text-muted">suifen_</span>
<a class="tag" taget="_blank" href="/search/%E7%BD%91%E7%BB%9C/1.htm">网络</a>
<div>0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en</div>
</li>
<li><a href="/article/1835390878806536192.htm"
title="linux 安装Sublime Text 3" target="_blank">linux 安装Sublime Text 3</a>
<span class="text-muted">hhyiyuanyu</span>
<a class="tag" taget="_blank" href="/search/Python%E5%AD%A6%E4%B9%A0/1.htm">Python学习</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a><a class="tag" taget="_blank" href="/search/sublime/1.htm">sublime</a><a class="tag" taget="_blank" href="/search/text/1.htm">text</a>
<div>方法/步骤打开官网http://www.sublimetext.com/3，选择64位进行下载执行命令wgethttps://download.sublimetext.com/sublime_text_3_build_3126_x64.tar.bz2进行下载3、下载完成进行解压,执行tar-xvvfsublime_text_3_build_3126_x64.tar.bz解压4、解压完成以后，移动到</div>
</li>
<li><a href="/article/1835378901174546432.htm"
title="KVM虚拟机源代码分析【转】" target="_blank">KVM虚拟机源代码分析【转】</a>
<span class="text-muted">xidianjiapei001</span>
<a class="tag" taget="_blank" href="/search/%23/1.htm">#</a><a class="tag" taget="_blank" href="/search/%E8%99%9A%E6%8B%9F%E5%8C%96%E6%8A%80%E6%9C%AF/1.htm">虚拟化技术</a>
<div>1.KVM结构及工作原理1.1KVM结构KVM基本结构有两部分组成。一个是KVMDriver，已经成为Linux内核的一个模块。负责虚拟机的创建，虚拟内存的分配，虚拟CPU寄存器的读写以及虚拟CPU的运行等。另外一个是稍微修改过的Qemu，用于模拟PC硬件的用户空间组件，提供I/O设备模型以及访问外设的途径。KVM基本结构如图1所示。其中KVM加入到标准的Linux内核中，被组织成Linux中标准</div>
</li>
<li><a href="/article/1835369569800253440.htm"
title="史上最全git命令,git回滚,git命令大全" target="_blank">史上最全git命令,git回滚,git命令大全</a>
<span class="text-muted">騒周</span>
<a class="tag" taget="_blank" href="/search/%E5%85%B6%E4%BB%96/1.htm">其他</a><a class="tag" taget="_blank" href="/search/git/1.htm">git</a>
<div>git命令大全一、Git整体理解二、由暂存区本地仓库三、由本地仓->远程仓库四、冲突处理五、Git分支操作六、bug的分支七、feature分支八、暂存的使用九、远程仓的操作十、标签的使用十一、Git配置全局信息十二、Linux的一些简单操作和一些符号的解释十三、符号解释十四、显示安装详细信息十五、gitconfig十六、Gitclone十七、Gitinit十八、gitstatus十九、gitre</div>
</li>
<li><a href="/article/1835369443379736576.htm"
title="【显示 后台运行 & 的命令】" target="_blank">【显示 后台运行 & 的命令】</a>
<span class="text-muted">晨春计</span>
<a class="tag" taget="_blank" href="/search/debug/1.htm">debug</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a><a class="tag" taget="_blank" href="/search/%E6%9C%8D%E5%8A%A1%E5%99%A8/1.htm">服务器</a><a class="tag" taget="_blank" href="/search/%E8%BF%90%E7%BB%B4/1.htm">运维</a>
<div>目录背景步骤详解示例背景当你在Linuxshell中使用&符号将一个命令放到后台运行时，你可以使用jobs命令来查看这些后台进程的状态。但是，jobs命令并不会直接显示进程的PID（进程ID）。它会显示一个作业列表，其中包括每个作业的状态和一个作业标识符（通常是百分号%后面跟着一个数字），但不会直接显示PID。获取后台进程的PID步骤：1、使用jobs命令查看后台作业。2、使用ps命令配合grep</div>
</li>
<li><a href="/article/1835369316342657024.htm"
title="Android shell 常用 debug 命令" target="_blank">Android shell 常用 debug 命令</a>
<span class="text-muted">晨春计</span>
<a class="tag" taget="_blank" href="/search/Audio/1.htm">Audio</a><a class="tag" taget="_blank" href="/search/debug/1.htm">debug</a><a class="tag" taget="_blank" href="/search/android/1.htm">android</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a>
<div>目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin</div>
</li>
<li><a href="/article/1835353690366636032.htm"
title="【nginx】ngx_http_proxy_connect_module 正向代理" target="_blank">【nginx】ngx_http_proxy_connect_module 正向代理</a>
<span class="text-muted">等风来不如迎风去</span>
<a class="tag" taget="_blank" href="/search/%E7%BD%91%E7%BB%9C%E6%9C%8D%E5%8A%A1%E5%85%A5%E9%97%A8%E4%B8%8E%E5%AE%9E%E6%88%98/1.htm">网络服务入门与实战</a><a class="tag" taget="_blank" href="/search/nginx/1.htm">nginx</a><a class="tag" taget="_blank" href="/search/http/1.htm">http</a><a class="tag" taget="_blank" href="/search/%E8%BF%90%E7%BB%B4/1.htm">运维</a>
<div>50.65无法访问服务器，(403错误)50.196可以访问服务器。那么，配置65通过196访问。需要一个nginx作为代理【nginx】搭配okhttp配置反向代理发送原生的nginx是不支持okhttp的CONNECT请求的。大神竟然给出了一个java工程GINX编译ngx_http_proxy_connect_module及做正向代理是linux构建的。是windows构建的：编译Windo</div>
</li>
<li><a href="/article/1835336292490113024.htm"
title="linux下好用的任务管理器htop" target="_blank">linux下好用的任务管理器htop</a>
<span class="text-muted">WittXie</span>
<a class="tag" taget="_blank" href="/search/Linux/1.htm">Linux</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a><a class="tag" taget="_blank" href="/search/%E6%9C%8D%E5%8A%A1%E5%99%A8/1.htm">服务器</a><a class="tag" taget="_blank" href="/search/%E8%BF%90%E7%BB%B4/1.htm">运维</a>
<div>给大家推荐个好用的任务管理器htop，简直好用的不得了。完虐top。不解释了，看文章！！！在Linux系统中，top命令用来显示系统中正在运行的进程的实时状态，它显示了一些非常有用的信息，比如CPU利用情况、内存消耗情况，以及每个进程情况等。但是，你知道吗？还有另外一个命令行工具'htop'，它与传统的top命令功能一样，但它有更加强大的功能及能显示更多的信息。这篇文章，我们会用实例来讨论这个'h</div>
</li>
<li><a href="/article/1835335914407161856.htm"
title="Linux下使用U盘" target="_blank">Linux下使用U盘</a>
<span class="text-muted">WittXie</span>
<a class="tag" taget="_blank" href="/search/Linux/1.htm">Linux</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a><a class="tag" taget="_blank" href="/search/%E8%BF%90%E7%BB%B4/1.htm">运维</a><a class="tag" taget="_blank" href="/search/%E6%9C%8D%E5%8A%A1%E5%99%A8/1.htm">服务器</a>
<div>第一步：插入U盘，如果能够识别出U盘，则会打印出一些信息；第二步：查看U盘系统分配给U盘的设备名；输入如下命令进行查看：fdisk-l/dev/sda如果打印出如下信息：Disk/dev/sda:4233MB,4233101312bytes165heads,34sectors/track,1473cylindersUnits=cylindersof5610*512=2872320bytesDevi</div>
</li>
<li><a href="/article/47.htm"
title="jdk tomcat 环境变量配置" target="_blank">jdk tomcat 环境变量配置</a>
<span class="text-muted">Array_06</span>
<a class="tag" taget="_blank" href="/search/java/1.htm">java</a><a class="tag" taget="_blank" href="/search/jdk/1.htm">jdk</a><a class="tag" taget="_blank" href="/search/tomcat/1.htm">tomcat</a>
<div>Win7 下如何配置java环境变量
1。准备jdk包，win7系统，tomcat安装包（均上网下载即可）
2。进行对jdk的安装，尽量为默认路径（但要记住啊！！以防以后配置用。。。）
3。分别配置高级环境变量。
电脑-->右击属性-->高级环境变量-->环境变量。
分别配置 :
path
&nbs</div>
</li>
<li><a href="/article/174.htm"
title="Spring调SDK包报java.lang.NoSuchFieldError错误" target="_blank">Spring调SDK包报java.lang.NoSuchFieldError错误</a>
<span class="text-muted">bijian1013</span>
<a class="tag" taget="_blank" href="/search/java/1.htm">java</a><a class="tag" taget="_blank" href="/search/spring/1.htm">spring</a>
<div> 在工作中调另一个系统的SDK包，出现如下java.lang.NoSuchFieldError错误。
org.springframework.web.util.NestedServletException: Handler processing failed; nested exception is java.l</div>
</li>
<li><a href="/article/301.htm"
title="LeetCode[位运算] - #136 数组中的单一数" target="_blank">LeetCode[位运算] - #136 数组中的单一数</a>
<span class="text-muted">Cwind</span>
<a class="tag" taget="_blank" href="/search/java/1.htm">java</a><a class="tag" taget="_blank" href="/search/%E9%A2%98%E8%A7%A3/1.htm">题解</a><a class="tag" taget="_blank" href="/search/%E4%BD%8D%E8%BF%90%E7%AE%97/1.htm">位运算</a><a class="tag" taget="_blank" href="/search/LeetCode/1.htm">LeetCode</a><a class="tag" taget="_blank" href="/search/Algorithm/1.htm">Algorithm</a>
<div>原题链接：#136 Single Number
要求：
给定一个整型数组，其中除了一个元素之外，每个元素都出现两次。找出这个元素
注意：算法的时间复杂度应为O(n)，最好不使用额外的内存空间
难度：中等
分析：
题目限定了线性的时间复杂度，同时不使用额外的空间，即要求只遍历数组一遍得出结果。由于异或运算 n XOR n = 0, n XOR 0 = n，故将数组中的每个元素进</div>
</li>
<li><a href="/article/428.htm"
title="qq登陆界面开发" target="_blank">qq登陆界面开发</a>
<span class="text-muted">15700786134</span>
<a class="tag" taget="_blank" href="/search/qq/1.htm">qq</a>
<div>今天我们来开发一个qq登陆界面，首先写一个界面程序，一个界面首先是一个Frame对象，即是一个窗体。然后在这个窗体上放置其他组件。代码如下：
public class First { public void initul(){ jf=ne</div>
</li>
<li><a href="/article/555.htm"
title="Linux的程序包管理器RPM" target="_blank">Linux的程序包管理器RPM</a>
<span class="text-muted">被触发</span>
<a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a>
<div>在早期我们使用源代码的方式来安装软件时，都需要先把源程序代码编译成可执行的二进制安装程序，然后进行安装。这就意味着每次安装软件都需要经过预处理-->编译-->汇编-->链接-->生成安装文件--> 安装，这个复杂而艰辛的过程。为简化安装步骤，便于广大用户的安装部署程序，程序提供商就在特定的系统上面编译好相关程序的安装文件并进行打包，提供给大家下载，我们只需要根据自己的</div>
</li>
<li><a href="/article/682.htm"
title="socket通信遇到EOFException" target="_blank">socket通信遇到EOFException</a>
<span class="text-muted">肆无忌惮_</span>
<a class="tag" taget="_blank" href="/search/EOFException/1.htm">EOFException</a>
<div>java.io.EOFException
at java.io.ObjectInputStream$PeekInputStream.readFully(ObjectInputStream.java:2281)
at java.io.ObjectInputStream$BlockDataInputStream.readShort(ObjectInputStream.java:</div>
</li>
<li><a href="/article/809.htm"
title="基于spring的web项目定时操作" target="_blank">基于spring的web项目定时操作</a>
<span class="text-muted">知了ing</span>
<a class="tag" taget="_blank" href="/search/java/1.htm">java</a><a class="tag" taget="_blank" href="/search/Web/1.htm">Web</a>
<div>废话不多说，直接上代码，很简单 配置一下项目启动就行
1，web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="h</div>
</li>
<li><a href="/article/936.htm"
title="树形结构的数据库表Schema设计" target="_blank">树形结构的数据库表Schema设计</a>
<span class="text-muted">矮蛋蛋</span>
<a class="tag" taget="_blank" href="/search/schema/1.htm">schema</a>
<div>原文地址：
http://blog.csdn.net/MONKEY_D_MENG/article/details/6647488
程序设计过程中，我们常常用树形结构来表征某些数据的关联关系，如企业上下级部门、栏目结构、商品分类等等，通常而言，这些树状结构需要借助于数据库完成持久化。然而目前的各种基于关系的数据库，都是以二维表的形式记录存储数据信息，</div>
</li>
<li><a href="/article/1063.htm"
title="maven将jar包和源码一起打包到本地仓库" target="_blank">maven将jar包和源码一起打包到本地仓库</a>
<span class="text-muted">alleni123</span>
<a class="tag" taget="_blank" href="/search/maven/1.htm">maven</a>
<div>http://stackoverflow.com/questions/4031987/how-to-upload-sources-to-local-maven-repository
<project>
...
<build>
<plugins>
<plugin>
<groupI</div>
</li>
<li><a href="/article/1190.htm"
title="java IO操作 与 File 获取文件或文件夹的大小，可读，等属性！！！" target="_blank">java IO操作 与 File 获取文件或文件夹的大小，可读，等属性！！！</a>
<span class="text-muted">百合不是茶</span>
<div>类 File
File是指文件和目录路径名的抽象表示形式。
1，何为文件：
标准文件（txt doc mp3...）
目录文件（文件夹）
虚拟内存文件
2，File类中有可以创建文件的 createNewFile（）方法,在创建新文件的时候需要try{} catch(）{}因为可能会抛出异常；也有可以判断文件是否是一个标准文件的方法isFile();这些防抖都</div>
</li>
<li><a href="/article/1317.htm"
title="Spring注入有继承关系的类（2）" target="_blank">Spring注入有继承关系的类（2）</a>
<span class="text-muted">bijian1013</span>
<a class="tag" taget="_blank" href="/search/java/1.htm">java</a><a class="tag" taget="_blank" href="/search/spring/1.htm">spring</a>
<div>被注入类的父类有相应的属性，Spring可以直接注入相应的属性，如下所例：1.AClass类
package com.bijian.spring.test4;
public class AClass {
private String a;
private String b;
public String getA() {
retu</div>
</li>
<li><a href="/article/1444.htm"
title="30岁转型期你能否成为成功人士" target="_blank">30岁转型期你能否成为成功人士</a>
<span class="text-muted">bijian1013</span>
<a class="tag" taget="_blank" href="/search/%E6%88%90%E9%95%BF/1.htm">成长</a><a class="tag" taget="_blank" href="/search/%E5%8A%B1%E5%BF%97/1.htm">励志</a>
<div> 很多人由于年轻时走了弯路，到了30岁一事无成，这样的例子大有人在。但同样也有一些人，整个职业生涯都发展得很优秀，到了30岁已经成为职场的精英阶层。由于做猎头的原因，我们接触很多30岁左右的经理人，发现他们在职业发展道路上往往有很多致命的问题。在30岁之前，他们的职业生涯表现很优秀，但从30岁到40岁这一段，很多人</div>
</li>
<li><a href="/article/1571.htm"
title="【Velocity四】Velocity与Java互操作" target="_blank">【Velocity四】Velocity与Java互操作</a>
<span class="text-muted">bit1129</span>
<a class="tag" taget="_blank" href="/search/velocity/1.htm">velocity</a>
<div>Velocity出现的目的用于简化基于MVC的web应用开发，用于替代JSP标签技术，那么Velocity如何访问Java代码.本篇继续以Velocity三http://bit1129.iteye.com/blog/2106142中的例子为基础，
POJO
package com.tom.servlets;
public</div>
</li>
<li><a href="/article/1698.htm"
title="【Hive十一】Hive数据倾斜优化" target="_blank">【Hive十一】Hive数据倾斜优化</a>
<span class="text-muted">bit1129</span>
<a class="tag" taget="_blank" href="/search/hive/1.htm">hive</a>
<div>什么是Hive数据倾斜问题
操作：join,group by,count distinct
现象：任务进度长时间维持在99%（或100%），查看任务监控页面，发现只有少量（1个或几个）reduce子任务未完成；查看未完成的子任务，可以看到本地读写数据量积累非常大，通常超过10GB可以认定为发生数据倾斜。
原因：key分布不均匀
倾斜度衡量：平均记录数超过50w且</div>
</li>
<li><a href="/article/1825.htm"
title="在nginx中集成lua脚本：添加自定义Http头，封IP等" target="_blank">在nginx中集成lua脚本：添加自定义Http头，封IP等</a>
<span class="text-muted">ronin47</span>
<a class="tag" taget="_blank" href="/search/nginx+lua+csrf/1.htm">nginx lua csrf</a>
<div>Lua是一个可以嵌入到Nginx配置文件中的动态脚本语言，从而可以在Nginx请求处理的任何阶段执行各种Lua代码。刚开始我们只是用Lua 把请求路由到后端服务器，但是它对我们架构的作用超出了我们的预期。下面就讲讲我们所做的工作。 强制搜索引擎只索引mixlr.com
Google把子域名当作完全独立的网站，我们不希望爬虫抓取子域名的页面，降低我们的Page rank。
location /{</div>
</li>
<li><a href="/article/1952.htm"
title="java-3.求子数组的最大和" target="_blank">java-3.求子数组的最大和</a>
<span class="text-muted">bylijinnan</span>
<a class="tag" taget="_blank" href="/search/java/1.htm">java</a>
<div>package beautyOfCoding;
public class MaxSubArraySum {
/**
* 3.求子数组的最大和
题目描述：
输入一个整形数组，数组里有正数也有负数。
数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。
求所有子数组的和的最大值。要求时间复杂度为O(n)。
例如输入的数组为1, -2, 3, 10, -4,</div>
</li>
<li><a href="/article/2079.htm"
title="Netty源码学习-FileRegion" target="_blank">Netty源码学习-FileRegion</a>
<span class="text-muted">bylijinnan</span>
<a class="tag" taget="_blank" href="/search/java/1.htm">java</a><a class="tag" taget="_blank" href="/search/netty/1.htm">netty</a>
<div>今天看org.jboss.netty.example.http.file.HttpStaticFileServerHandler.java
可以直接往channel里面写入一个FileRegion对象，而不需要相应的encoder：
//pipeline（没有诸如“FileRegionEncoder”的handler）：
public ChannelPipeline ge</div>
</li>
<li><a href="/article/2206.htm"
title="使用ZeroClipboard解决跨浏览器复制到剪贴板的问题" target="_blank">使用ZeroClipboard解决跨浏览器复制到剪贴板的问题</a>
<span class="text-muted">cngolon</span>
<a class="tag" taget="_blank" href="/search/%E8%B7%A8%E6%B5%8F%E8%A7%88%E5%99%A8/1.htm">跨浏览器</a><a class="tag" taget="_blank" href="/search/%E5%A4%8D%E5%88%B6%E5%88%B0%E7%B2%98%E8%B4%B4%E6%9D%BF/1.htm">复制到粘贴板</a><a class="tag" taget="_blank" href="/search/Zero+Clipboard/1.htm">Zero Clipboard</a>
<div>Zero Clipboard的实现原理
Zero Clipboard 利用透明的Flash让其漂浮在复制按钮之上，这样其实点击的不是按钮而是 Flash ，这样将需要的内容传入Flash，再通过Flash的复制功能把传入的内容复制到剪贴板。
Zero Clipboard的安装方法
首先需要下载 Zero Clipboard的压缩包，解压后把文件夹中两个文件：ZeroClipboard.js </div>
</li>
<li><a href="/article/2333.htm"
title="单例模式" target="_blank">单例模式</a>
<span class="text-muted">cuishikuan</span>
<a class="tag" taget="_blank" href="/search/%E5%8D%95%E4%BE%8B%E6%A8%A1%E5%BC%8F/1.htm">单例模式</a>
<div>第一种（懒汉，线程不安全）：
public class Singleton { 2 private static Singleton instance; 3 pri</div>
</li>
<li><a href="/article/2460.htm"
title="spring+websocket的使用" target="_blank">spring+websocket的使用</a>
<span class="text-muted">dalan_123</span>
<div>一、spring配置文件
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.or</div>
</li>
<li><a href="/article/2587.htm"
title="细节问题：ZEROFILL的用法范围。" target="_blank">细节问题：ZEROFILL的用法范围。</a>
<span class="text-muted">dcj3sjt126com</span>
<a class="tag" taget="_blank" href="/search/mysql/1.htm">mysql</a>
<div> 1、zerofill把月份中的一位数字比如1，2，3等加前导0
mysql> CREATE TABLE t1 (year YEAR(4), month INT(2) UNSIGNED ZEROFILL, -> day</div>
</li>
<li><a href="/article/2714.htm"
title="Android开发10——Activity的跳转与传值" target="_blank">Android开发10——Activity的跳转与传值</a>
<span class="text-muted">dcj3sjt126com</span>
<a class="tag" taget="_blank" href="/search/Android%E5%BC%80%E5%8F%91/1.htm">Android开发</a>
<div>Activity跳转与传值，主要是通过Intent类，Intent的作用是激活组件和附带数据。
一、Activity跳转
方法一Intent intent = new Intent(A.this, B.class); startActivity(intent)
方法二Intent intent = new Intent();intent.setCla</div>
</li>
<li><a href="/article/2841.htm"
title="jdbc 得到表结构、主键" target="_blank">jdbc 得到表结构、主键</a>
<span class="text-muted">eksliang</span>
<a class="tag" taget="_blank" href="/search/jdbc+%E5%BE%97%E5%88%B0%E8%A1%A8%E7%BB%93%E6%9E%84%E3%80%81%E4%B8%BB%E9%94%AE/1.htm">jdbc 得到表结构、主键</a>
<div>转自博客：http://blog.csdn.net/ocean1010/article/details/7266042
假设有个con DatabaseMetaData dbmd = con.getMetaData(); rs = dbmd.getColumns(con.getCatalog(), schema, tableName, null); rs.getSt</div>
</li>
<li><a href="/article/2968.htm"
title="Android 应用程序开关GPS" target="_blank">Android 应用程序开关GPS</a>
<span class="text-muted">gqdy365</span>
<a class="tag" taget="_blank" href="/search/android/1.htm">android</a>
<div>要在应用程序中操作GPS开关需要权限：
<uses-permission android:name="android.permission.WRITE_SECURE_SETTINGS" />
但在配置文件中添加此权限之后会报错，无法再eclipse里面正常编译，怎么办？
1、方法一：将项目放到Android源码中编译；
2、方法二：网上有人说cl</div>
</li>
<li><a href="/article/3095.htm"
title="Windows上调试MapReduce" target="_blank">Windows上调试MapReduce</a>
<span class="text-muted">zhiquanliu</span>
<a class="tag" taget="_blank" href="/search/mapreduce/1.htm">mapreduce</a>
<div>1.下载hadoop2x-eclipse-plugin https://github.com/winghc/hadoop2x-eclipse-plugin.git 把 hadoop2.6.0-eclipse-plugin.jar 放到eclipse plugin 目录中。 2.下载 hadoop2.6_x64_.zip http://dl.iteye.com/topics/download/d2b</div>
</li>
<li><a href="/article/3222.htm"
title="如何看待一些知名博客推广软文的行为？" target="_blank">如何看待一些知名博客推广软文的行为？</a>
<span class="text-muted">justjavac</span>
<a class="tag" taget="_blank" href="/search/%E5%8D%9A%E5%AE%A2/1.htm">博客</a>
<div>本文来自我在知乎上的一个回答：http://www.zhihu.com/question/23431810/answer/24588621
互联网上的两种典型心态：
当初求种像条狗，如今撸完嫌人丑
当初搜贴像条犬，如今读完嫌人软
你为啥感觉不舒服呢？
难道非得要作者把自己的劳动成果免费给你用，你才舒服？
就如同 Google 关闭了 Gooled Reader，那是</div>
</li>
<li><a href="/article/3349.htm"
title="sql优化总结" target="_blank">sql优化总结</a>
<span class="text-muted">macroli</span>
<a class="tag" taget="_blank" href="/search/sql/1.htm">sql</a>
<div>为了是自己对sql优化有更好的原则性，在这里做一下总结，个人原则如有不对请多多指教。谢谢！
要知道一个简单的sql语句执行效率，就要有查看方式，一遍更好的进行优化。
一、简单的统计语句执行时间
declare @d datetime ---定义一个datetime的变量set @d=getdate() ---获取查询语句开始前的时间select user_id</div>
</li>
<li><a href="/article/3476.htm"
title="Linux Oracle中常遇到的一些问题及命令总结" target="_blank">Linux Oracle中常遇到的一些问题及命令总结</a>
<span class="text-muted">超声波</span>
<a class="tag" taget="_blank" href="/search/oracle/1.htm">oracle</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a>
<div>1.linux更改主机名
(1)#hostname oracledb 临时修改主机名
(2) vi /etc/sysconfig/network 修改hostname
(3) vi /etc/hosts 修改IP对应的主机名
2.linux重启oracle实例及监听的各种方法
（注意操作的顺序应该是先监听，后数据库实例）
&nbs</div>
</li>
<li><a href="/article/3603.htm"
title="hive函数大全及使用示例" target="_blank">hive函数大全及使用示例</a>
<span class="text-muted">superlxw1234</span>
<a class="tag" taget="_blank" href="/search/hadoop/1.htm">hadoop</a><a class="tag" taget="_blank" href="/search/hive%E5%87%BD%E6%95%B0/1.htm">hive函数</a>
<div>
具体说明及示例参 见附件文档。
文档目录：
目录
一、关系运算： 4
1. 等值比较: = 4
2. 不等值比较: <> 4
3. 小于比较: < 4
4. 小于等于比较: <= 4
5. 大于比较: > 5
6. 大于等于比较: >= 5
7. 空值判断: IS NULL 5</div>
</li>
<li><a href="/article/3730.htm"
title="Spring 4.2新特性-使用@Order调整配置类加载顺序" target="_blank">Spring 4.2新特性-使用@Order调整配置类加载顺序</a>
<span class="text-muted">wiselyman</span>
<a class="tag" taget="_blank" href="/search/spring+4/1.htm">spring 4</a>
<div>4.1 @Order
Spring 4.2 利用@Order控制配置类的加载顺序
4.2 演示
两个演示bean
package com.wisely.spring4_2.order;
public class Demo1Service {
}
package com.wisely.spring4_2.order;
public class</div>
</li>
</ul>
</div>
</div>
</div>
<div>
<div class="container">
<div class="indexes">
<strong>按字母分类：</strong>
<a href="/tags/A/1.htm" target="_blank">A</a><a href="/tags/B/1.htm" target="_blank">B</a><a href="/tags/C/1.htm" target="_blank">C</a><a
href="/tags/D/1.htm" target="_blank">D</a><a href="/tags/E/1.htm" target="_blank">E</a><a href="/tags/F/1.htm" target="_blank">F</a><a
href="/tags/G/1.htm" target="_blank">G</a><a href="/tags/H/1.htm" target="_blank">H</a><a href="/tags/I/1.htm" target="_blank">I</a><a
href="/tags/J/1.htm" target="_blank">J</a><a href="/tags/K/1.htm" target="_blank">K</a><a href="/tags/L/1.htm" target="_blank">L</a><a
href="/tags/M/1.htm" target="_blank">M</a><a href="/tags/N/1.htm" target="_blank">N</a><a href="/tags/O/1.htm" target="_blank">O</a><a
href="/tags/P/1.htm" target="_blank">P</a><a href="/tags/Q/1.htm" target="_blank">Q</a><a href="/tags/R/1.htm" target="_blank">R</a><a
href="/tags/S/1.htm" target="_blank">S</a><a href="/tags/T/1.htm" target="_blank">T</a><a href="/tags/U/1.htm" target="_blank">U</a><a
href="/tags/V/1.htm" target="_blank">V</a><a href="/tags/W/1.htm" target="_blank">W</a><a href="/tags/X/1.htm" target="_blank">X</a><a
href="/tags/Y/1.htm" target="_blank">Y</a><a href="/tags/Z/1.htm" target="_blank">Z</a><a href="/tags/0/1.htm" target="_blank">其他</a>
</div>
</div>
</div>
<footer id="footer" class="mb30 mt30">
<div class="container">
<div class="footBglm">
<a target="_blank" href="/">首页</a> -
<a target="_blank" href="/custom/about.htm">关于我们</a> -
<a target="_blank" href="/search/Java/1.htm">站内搜索</a> -
<a target="_blank" href="/sitemap.txt">Sitemap</a> -
<a target="_blank" href="/custom/delete.htm">侵权投诉</a>
</div>
<div class="copyright">版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.
<!-- <a href="https://beian.miit.gov.cn/" rel="nofollow" target="_blank">京ICP备09083238号</a><br>-->
</div>
</div>
</footer>
<!-- 代码高亮 -->
<script type="text/javascript" src="/static/syntaxhighlighter/scripts/shCore.js"></script>
<script type="text/javascript" src="/static/syntaxhighlighter/scripts/shLegacy.js"></script>
<script type="text/javascript" src="/static/syntaxhighlighter/scripts/shAutoloader.js"></script>
<link type="text/css" rel="stylesheet" href="/static/syntaxhighlighter/styles/shCoreDefault.css"/>
<script type="text/javascript" src="/static/syntaxhighlighter/src/my_start_1.js"></script>
</body>
</html>
