数据加载中……

睡眠唤醒

Linux进程的睡眠和唤醒

1 Linux进程的睡眠和唤醒
在Linux中,仅等待CPU时间的进程称为就绪进程,它们被放置在一个运行队列中,一个就绪进程的状态标志位为TASK_RUNNING。一旦一个运行中的进程时间片用完, Linux 内核的调度器会剥夺这个进程对CPU的控制权,并且从运行队列中选择一个合适的进程投入运行。
当然,一个进程也可以主动释放CPU的控制权。函数schedule()是一个调度函数,它可以被一个进程主动调用,从而调度其它进程占用CPU。一旦这个主动放弃CPU的进程被重新调度占用 CPU,那么它将从上次停止执行的位置开始执行,也就是说它将从调用schedule()的下一行代码处开始执行。
有时候,进程需要等待直到某个特定的事件发生,例如设备初始化完成、I/O 操作完成或定时器到时等。在这种情况下,进程则必须从运行队列移出,加入到一个等待队列中,这个时候进程就进入了睡眠状态。
Linux 中的进程睡眠状态有两种:一种是可中断的睡眠状态,其状态标志位TASK_INTERRUPTIBLE;
另一种是不可中断的睡眠状态,其状态标志位为TASK_UNINTERRUPTIBLE。可中断的睡眠状态的进程会睡眠直到某个条件变为真,比如说产生一个硬件中断、释放进程正在等待的系统资源或是传递一个信号都可以是唤醒进程的条件。不可中断睡眠状态与可中断睡眠状态类似,但是它有一个例外,那就是把信号传递到这种睡眠状态的进程不能改变它的状态,也就是说它不响应信号的唤醒。不可中断睡眠状态一般较少用到,但在一些特定情况下这种状态还是很有用的,比如说:进程必须等待,不能被中断,直到某个特定的事件发生。
在现代的Linux操作系统中,进程一般都是用调用schedule()的方法进入睡眠状态的,下面的代码演
示了如何让正在运行的进程进入睡眠状态。
sleeping_task = current;
set_current_state(TASK_INTERRUPTIBLE);
schedule();
func1();
/* Rest of the code ... */
在第一个语句中,程序存储了一份进程结构指针sleeping_task,current 是一个宏,它指向正在执行
的进程结构。set_current_state()将该进程的状态从执行状态TASK_RUNNING 变成睡眠状态
TASK_INTERRUPTIBLE。如果schedule()是被一个状态为TASK_RUNNING 的进程调度,那么schedule()将调度另外一个进程占用CPU;如果schedule()是被一个状态为TASK_INTERRUPTIBLE 或TASK_UNINTERRUPTIBLE 的进程调度,那么还有一个附加的步骤将被执行:当前执行的进程在另外一个进程被调度之前会被从运行队列中移出,这将导致正在运行的那个进程进入睡眠,因为它已经不在运行队列中了。
我们可以使用下面的这个函数将刚才那个进入睡眠的进程唤醒。
wake_up_process(sleeping_task);
在调用了wake_up_process()以后,这个睡眠进程的状态会被设置为TASK_RUNNING,而且调度器
会把它加入到运行队列中去。当然,这个进程只有在下次被调度器调度到的时候才能真正地投入运行。

2 无效唤醒
几乎在所有的情况下,进程都会在检查了某些条件之后,发现条件不满足才进入睡眠。可是有的时候
进程却会在判定条件为真后开始睡眠,如果这样的话进程就会无限期地休眠下去,这就是所谓的无效唤醒问题。在操作系统中,当多个进程都企图对共享数据进行某种处理,而最后的结果又取决于进程运行的顺序时,就会发生竞争条件,这是操作系统中一个典型的问题,无效唤醒恰恰就是由于竞争条件导致的。
设想有两个进程A 和B,A 进程正在处理一个链表,它需要检查这个链表是否为空,如果不空就对链
表里面的数据进行一些操作,同时B进程也在往这个链表添加节点。当这个链表是空的时候,由于无数据可操作,这时A进程就进入睡眠,当B进程向链表里面添加了节点之后它就唤醒A 进程,其代码如下:
A进程:
1 spin_lock(&list_lock);
2 if(list_empty(&list_head)) {
3 spin_unlock(&list_lock);
4 set_current_state(TASK_INTERRUPTIBLE);
5 schedule();
6 spin_lock(&list_lock);
7 }
8
9 /* Rest of the code ... */
10 spin_unlock(&list_lock);
B进程:
100 spin_lock(&list_lock);
101 list_add_tail(&list_head, new_node);
102 spin_unlock(&list_lock);
103 wake_up_process(processa_task);
这里会出现一个问题,假如当A进程执行到第3行后第4行前的时候,B进程被另外一个处理器调度
投入运行。在这个时间片内,B进程执行完了它所有的指令,因此它试图唤醒A进程,而此时的A进程还没有进入睡眠,所以唤醒操作无效。在这之后,A 进程继续执行,它会错误地认为这个时候链表仍然是空的,于是将自己的状态设置为TASK_INTERRUPTIBLE然后调用schedule()进入睡眠。由于错过了B进程唤醒,它将会无限期的睡眠下去,这就是无效唤醒问题,因为即使链表中有数据需要处理,A 进程也还是睡眠了。

3 避免无效唤醒
如何避免无效唤醒问题呢?我们发现无效唤醒主要发生在检查条件之后和进程状态被设置为睡眠状
态之前,本来B进程的wake_up_process()提供了一次将A进程状态置为TASK_RUNNING 的机会,可惜这个时候A进程的状态仍然是TASK_RUNNING,所以wake_up_process()将A进程状态从睡眠状态转变为运行状态的努力没有起到预期的作用。要解决这个问题,必须使用一种保障机制使得判断链表为空和设置进程状态为睡眠状态成为一个不可分割的步骤才行,也就是必须消除竞争条件产生的根源,这样在这之后出现的wake_up_process ()就可以起到唤醒状态是睡眠状态的进程的作用了。
找到了原因后,重新设计一下A进程的代码结构,就可以避免上面例子中的无效唤醒问题了。
A进程:
1 set_current_state(TASK_INTERRUPTIBLE);
2 spin_lock(&list_lock);
3 if(list_empty(&list_head)) {
4 spin_unlock(&list_lock);
5 schedule();
6 spin_lock(&list_lock);
7 }
8 set_current_state(TASK_RUNNING);
9
10 /* Rest of the code ... */
11 spin_unlock(&list_lock);
可以看到,这段代码在测试条件之前就将当前执行进程状态转设置成TASK_INTERRUPTIBLE了,并且在链表不为空的情况下又将自己置为TASK_RUNNING状态。这样一来如果B进程在A进程进程检查
了链表为空以后调用wake_up_process(),那么A进程的状态就会自动由原来TASK_INTERRUPTIBLE
变成TASK_RUNNING,此后即使进程又调用了schedule(),由于它现在的状态是TASK_RUNNING,所以仍然不会被从运行队列中移出,因而不会错误的进入睡眠,当然也就避免了无效唤醒问题。

4 Linux内核的例子
在Linux操作系统中,内核的稳定性至关重要,为了避免在Linux操作系统内核中出现无效唤醒问题,
Linux内核在需要进程睡眠的时候应该使用类似如下的操作:
/* ‘q’是我们希望睡眠的等待队列 */
DECLARE_WAITQUEUE(wait,current);
add_wait_queue(q, &wait);
set_current_state(TASK_INTERRUPTIBLE);
/* 或TASK_INTERRUPTIBLE */
while(!condition) /* ‘condition’ 是等待的条件*/
schedule();
set_current_state(TASK_RUNNING);
remove_wait_queue(q, &wait);
上面的操作,使得进程通过下面的一系列步骤安全地将自己加入到一个等待队列中进行睡眠:首先调
用DECLARE_WAITQUEUE ()创建一个等待队列的项,然后调用add_wait_queue()把自己加入到等待队列中,并且将进程的状态设置为 TASK_INTERRUPTIBLE 或者TASK_INTERRUPTIBLE。然后循环检查条件是否为真:如果是的话就没有必要睡眠,如果条件不为真,就调用schedule()。当进程检查的条件满足后,进程又将自己设置为TASK_RUNNING 并调用remove_wait_queue()将自己移出等待队列。
从上面可以看到,Linux的内核代码维护者也是在进程检查条件之前就设置进程的状态为睡眠状态,
然后才循环检查条件。如果在进程开始睡眠之前条件就已经达成了,那么循环会退出并用set_current_state()将自己的状态设置为就绪,这样同样保证了进程不会存在错误的进入睡眠的倾向,当然也就不会导致出现无效唤醒问题。
下面让我们用linux 内核中的实例来看看Linux 内核是如何避免无效睡眠的,这段代码出自Linux2.6的内核(linux-2.6.11/kernel/sched.c: 4254):
4253 /* Wait for kthread_stop */
4254 set_current_state(TASK_INTERRUPTIBLE);
4255 while (!kthread_should_stop()) {
4256 schedule();
4257 set_current_state(TASK_INTERRUPTIBLE);
4258 }
4259 __set_current_state(TASK_RUNNING);
4260 return 0;
上面的这些代码属于迁移服务线程migration_thread,这个线程不断地检查kthread_should_stop(),
直到kthread_should_stop()返回1它才可以退出循环,也就是说只要kthread_should_stop()返回0该进程就会一直睡眠。从代码中我们可以看出,检查kthread_should_stop()确实是在进程的状态被置为TASK_INTERRUPTIBLE后才开始执行的。因此,如果在条件检查之后但是在schedule()之前有其他进程试图唤醒它,那么该进程的唤醒操作不会失效。

小结
通过上面的讨论,可以发现在Linux 中避免进程的无效唤醒的关键是在进程检查条件之前就将进程的
状态置为TASK_INTERRUPTIBLE或TASK_UNINTERRUPTIBLE,并且如果检查的条件满足的话就应该
将其状态重新设置为TASK_RUNNING。这样无论进程等待的条件是否满足, 进程都不会因为被移出就绪队列而错误地进入睡眠状态,从而避免了无效唤醒问题。

posted @ 2010-10-06 17:38 doublezxh 阅读(757) | 评论 (0)编辑 收藏
内核同步措施



为了避免并发,防止竞争。内核提供了一组同步方法来提供对共享数据的保护。 我们的重点不是介绍这些方法的详细用法,而是强调为什么使用这些方法和它们之间的差别。
Linux 使用的同步机制可以说从2.0到2.6以来不断发展完善。从最初的原子操作,到后来的信号量,从大内核锁到今天的自旋锁。这些同步机制的发展伴随 Linux从单处理器到对称多处理器的过度;伴随着从非抢占内核到抢占内核的过度。锁机制越来越有效,也越来越复杂。
目前来说内核中原子操作多用来做计数使用,其它情况最常用的是两种锁以及它们的变种:一个是自旋锁,另一个是信号量。我们下面就来着重介绍一下这两种锁机制。


自旋锁
------------------------------------------------------
    自旋锁是专为防止多处理器并发而引入的一种锁,它在内核中大量应用于中断处理等部分(对于单处理器来说,防止中断处理中的并发可简单采用关闭中断的方式,不需要自旋锁)。
自旋锁最多只能被一个内核任务持有,如果一个内核任务试图请求一个已被争用(已经被持有)的自旋锁,那么这个任务就会一直进行忙循环——旋转——等待锁重新可用。
要是锁未被争用,请求它的内核任务便能立刻得到它并且继续进行。自旋锁可以在任何时刻防止多于一个的内核任务同时进入临界区,因此这种锁可有效地避免多处理器上并发运行的内核任务竞争共享资源。
事实上,自旋锁的初衷就是:在短期间内进行轻量级的锁定。一个被争用的自旋锁使得请求它的线程在等待锁重新可用的期间进行自旋(特别浪费处理器时间),所以自旋锁不应该被持有时间过长。如果需要长时间锁定的话, 最好使用信号量。
自旋锁的基本形式如下:
spin_lock(&mr_lock);
//临界区
spin_unlock(&mr_lock);

因为自旋锁在同一时刻只能被最多一个内核任务持有,所以一个时刻只有一个线程允许存在于临界区中。这点很好地满足了对称多处理机器需要的锁定服务。在单处 理器上,自旋锁仅仅当作一个设置内核抢占的开关。如果内核抢占也不存在,那么自旋锁会在编译时被完全剔除出内核。
简单的说,自旋锁在内核中主要用来防止多处理器中并发访问临界区,防止内核抢占造成的竞争。另外自旋锁不允许任务睡眠(持有自旋锁的任务睡眠会造成自死锁——因为睡眠有可能造成持有锁的内核任务被重新调度,而再次申请自己已持有的锁),它能够在中断上下文中使用
死锁:假设有一个或多个内核任务和一个或多个资源,每个内核都在等待其中的一个资源,但所有的资源都已经被占用了。这便会发生所有内核任务都在相互等待, 但它们永远不会释放已经占有的资源,于是任何内核任务都无法获得所需要的资源,无法继续运行,这便意味着死锁发生了。自死琐是说自己占有了某个资源,然后 自己又申请自己已占有的资源,显然不可能再获得该资源,因此就自缚手脚了。


信号量
------------------------------------------------------
Linux中的信号量是一种睡眠锁。如果有一个任务试图获得一个已被持有的信号量时,信号量会将其推入等待队列,然后让其睡眠。这时处理器获得自由去执行 其它代码。当持有信号量的进程将信号量释放后,在等待队列中的一个任务将被唤醒,从而便可以获得这个信号量。
信号量的睡眠特性,使得信号量适用于锁会被长时间持有的情况;只能在进程上下文中使用,因为中断上下文中是不能被调度的;另外当代码持有信号量时,不可以再持有自旋锁。

信号量基本使用形式为:
static DECLARE_MUTEX(mr_sem);//声明互斥信号量
if(down_interruptible(&mr_sem))
//可被中断的睡眠,当信号来到,睡眠的任务被唤醒 
//临界区
up(&mr_sem);


信号量和自旋锁区别
------------------------------------------------------
虽然听起来两者之间的使用条件复杂,其实在实际使用中信号量和自旋锁并不易混淆。注意以下原则:
如果代码需要睡眠——这往往是发生在和用户空间同步时——使用信号量是唯一的选择。由于不受睡眠的限制,使用信号量通常来说更加简单一些。如果需要在自旋 锁和信号量中作选择,应该取决于锁被持有的时间长短。理想情况是所有的锁都应该尽可能短的被持有,但是如果锁的持有时间较长的话,使用信号量是更好的选 择。另外,信号量不同于自旋锁,它不会关闭内核抢占,所以持有信号量的代码可以被抢占。这意味者信号量不会对影响调度反应时间带来负面影响。


自旋锁对信号量
------------------------------------------------------
需求                     建议的加锁方法

低开销加锁               优先使用自旋锁
短期锁定                 优先使用自旋锁
长期加锁                 优先使用信号量
中断上下文中加锁          使用自旋锁
持有锁是需要睡眠、调度     使用信号量

小A,小B,小C,小D 同住一个屋子,可屋子只有一间茅房和一个马桶。他们谁想"便"的时候谁就要把茅房的门锁上,然后占据马桶,比如小A正在占有,聚精会神,非常惬意。碰巧小 B此时甚急,但没办法,因为小A已经把门上了锁。于是小B在门口急得打转,即为"自旋"。注意这个"自旋"两个字用的好,小B不是一看门被上锁就回屋睡觉 去了,而是在门口"自旋"。... 最终的结果是小A开锁,小B占用。而且在开锁闭锁过程中动作干净利落,不容他人抢在前面。

如此周而复始......

    这里的 小A,B,C,D 即为处理器,茅房的锁即为自旋锁。当其他处理器想访问这个公共的资源的时候就要先获取这个锁。如果锁被占用,则自旋(循环)等待。

小A的聚精会神代表了IRQL为2,开关锁动作快表示为原子操作

posted @ 2010-10-06 17:16 doublezxh 阅读(205) | 评论 (0)编辑 收藏
Linux进程的睡眠和唤醒

Linux进程的睡眠和唤醒
2010-01-29 17:45
1 Linux进程的睡眠和唤醒
在Linux中,仅等待CPU时间的进程称为就绪进程,它们被放置在一个运行队列中,一个就绪进程的状 态标志位为TASK_RUNNING。一旦一个运行中的进程时间片用完, Linux 内核的调度器会剥夺这个进程对CPU的控制权,并且从运行队列中选择一个合适的进程投入运行。
当然,一个进程也可以主动释放CPU的控制权。函数 schedule()是一个调度函数,它可以被一个进程主动调用,从而调度其它进程占用CPU。一旦这个主动放弃CPU的进程被重新调度占用 CPU,那么它将从上次停止执行的位置开始执行,也就是说它将从调用schedule()的下一行代码处开始执行。
有时候,进程需要等待直到某个特定的事件发生,例如设备初始化完成、I/O 操作完成或定时器到时等。在这种情况下,进程则必须从运行队列移出,加入到一个等待队列中,这个时候进程就进入了睡眠状态。
Linux 中的进程睡眠状态有两种:一种是可中断的睡眠状态,其状态标志位TASK_INTERRUPTIBLE;
另一种是不可中断 的睡眠状态,其状态标志位为TASK_UNINTERRUPTIBLE。可中断的睡眠状态的进程会睡眠直到某个条件变为真,比如说产生一个硬件中断、释放 进程正在等待的系统资源或是传递一个信号都可以是唤醒进程的条件。不可中断睡眠状态与可中断睡眠状态类似,但是它有一个例外,那就是把信号传递到这种睡眠 状态的进程不能改变它的状态,也就是说它不响应信号的唤醒。不可中断睡眠状态一般较少用到,但在一些特定情况下这种状态还是很有用的,比如说:进程必须等 待,不能被中断,直到某个特定的事件发生。
在现代的Linux操作系统中,进程一般都是用调用schedule()的方法进入睡眠状态的,下面的代码演
示了如何让正在运行的进程进入睡眠状态。
sleeping_task = current;
set_current_state(TASK_INTERRUPTIBLE);
schedule();
func1();
/* Rest of the code ... */
在第一个语句中,程序存储了一份进程结构指针sleeping_task,current 是一个宏,它指向正在执行
的进程结构。set_current_state()将该进程的状态从执行状态TASK_RUNNING 变成睡眠状态
TASK_INTERRUPTIBLE。 如果schedule()是被一个状态为TASK_RUNNING 的进程调度,那么schedule()将调度另外一个进程占用CPU;如果schedule()是被一个状态为TASK_INTERRUPTIBLE 或TASK_UNINTERRUPTIBLE 的进程调度,那么还有一个附加的步骤将被执行:当前执行的进程在另外一个进程被调度之前会被从运行队列中移出,这将导致正在运行的那个进程进入睡眠,因为 它已经不在运行队列中了。
我们可以使用下面的这个函数将刚才那个进入睡眠的进程唤醒。
wake_up_process(sleeping_task);
在调用了wake_up_process()以后,这个睡眠进程的状态会被设置为TASK_RUNNING,而且调度器
会把它加入到运行队列中去。当然,这个进程只有在下次被调度器调度到的时候才能真正地投入运行。

2 无效唤醒
几乎在所有的情况下,进程都会在检查了某些条件之后,发现条件不满足才进入睡眠。可是有的时候
进程却会在 判定条件为真后开始睡眠,如果这样的话进程就会无限期地休眠下去,这就是所谓的无效唤醒问题。在操作系统中,当多个进程都企图对共享数据进行某种处理,而 最后的结果又取决于进程运行的顺序时,就会发生竞争条件,这是操作系统中一个典型的问题,无效唤醒恰恰就是由于竞争条件导致的。
设想有两个进程A 和B,A 进程正在处理一个链表,它需要检查这个链表是否为空,如果不空就对链
表里面的数据进行一些操作,同时B进程也在往这个链表添加节点。当这个链表是空的时候,由于无数据可操作,这时A进程就进入睡眠,当B进程向链表里面添加了节点之后它就唤醒A 进程,其代码如下:
A进程:
1 spin_lock(&list_lock);
2 if(list_empty(&list_head)) {
3 spin_unlock(&list_lock);
4 set_current_state(TASK_INTERRUPTIBLE);
5 schedule();
6 spin_lock(&list_lock);
7 }
8
9 /* Rest of the code ... */
10 spin_unlock(&list_lock);
B进程:
100 spin_lock(&list_lock);
101 list_add_tail(&list_head, new_node);
102 spin_unlock(&list_lock);
103 wake_up_process(processa_task);
这里会出现一个问题,假如当A进程执行到第3行后第4行前的时候,B进程被另外一个处理器调度
投 入运行。在这个时间片内,B进程执行完了它所有的指令,因此它试图唤醒A进程,而此时的A进程还没有进入睡眠,所以唤醒操作无效。在这之后,A 进程继续执行,它会错误地认为这个时候链表仍然是空的,于是将自己的状态设置为TASK_INTERRUPTIBLE然后调用schedule()进入睡 眠。由于错过了B进程唤醒,它将会无限期的睡眠下去,这就是无效唤醒问题,因为即使链表中有数据需要处理,A 进程也还是睡眠了。

3 避免无效唤醒
如何避免无效唤醒问题呢?我们发现无效唤醒主要发生在检查条件之后和进程状态被设置为睡眠状
态之前, 本来B进程的wake_up_process()提供了一次将A进程状态置为TASK_RUNNING 的机会,可惜这个时候A进程的状态仍然是TASK_RUNNING,所以wake_up_process()将A进程状态从睡眠状态转变为运行状态的努力 没有起到预期的作用。要解决这个问题,必须使用一种保障机制使得判断链表为空和设置进程状态为睡眠状态成为一个不可分割的步骤才行,也就是必须消除竞争条 件产生的根源,这样在这之后出现的wake_up_process ()就可以起到唤醒状态是睡眠状态的进程的作用了。
找到了原因后,重新设计一下A进程的代码结构,就可以避免上面例子中的无效唤醒问题了。
A进程:
1 set_current_state(TASK_INTERRUPTIBLE);
2 spin_lock(&list_lock);
3 if(list_empty(&list_head)) {
4 spin_unlock(&list_lock);
5 schedule();
6 spin_lock(&list_lock);
7 }
8 set_current_state(TASK_RUNNING);
9
10 /* Rest of the code ... */
11 spin_unlock(&list_lock);
可以看到,这段代码在测试条件之前就将当前执行进程状态转设置成TASK_INTERRUPTIBLE了,并且在链表不为空的情况下又将自己置为TASK_RUNNING状态。这样一来如果B进程在A进程进程检查
了链表为空以后调用wake_up_process(),那么A进程的状态就会自动由原来TASK_INTERRUPTIBLE
变成TASK_RUNNING,此后即使进程又调用了schedule(),由于它现在的状态是TASK_RUNNING,所以仍然不会被从运行队列中移出,因而不会错误的进入睡眠,当然也就避免了无效唤醒问题。

4 Linux内核的例子
在Linux操作系统中,内核的稳定性至关重要,为了避免在Linux操作系统内核中出现无效唤醒问题,
Linux内核在需要进程睡眠的时候应该使用类似如下的操作:
/* ‘q’是我们希望睡眠的等待队列 */
DECLARE_WAITQUEUE(wait,current);
add_wait_queue(q, &wait);
set_current_state(TASK_INTERRUPTIBLE);
/* 或TASK_INTERRUPTIBLE */
while(!condition) /* ‘condition’ 是等待的条件*/
schedule();
set_current_state(TASK_RUNNING);
remove_wait_queue(q, &wait);
上面的操作,使得进程通过下面的一系列步骤安全地将自己加入到一个等待队列中进行睡眠:首先调
用DECLARE_WAITQUEUE ()创建一个等待队列的项,然后调用add_wait_queue()把自己加入到等待队列中,并且将进程的状态设置为 TASK_INTERRUPTIBLE 或者TASK_INTERRUPTIBLE。然后循环检查条件是否为真:如果是的话就没有必要睡眠,如果条件不为真,就调用schedule()。当进程 检查的条件满足后,进程又将自己设置为TASK_RUNNING 并调用remove_wait_queue()将自己移出等待队列。
从上面可以看到,Linux的内核代码维护者也是在进程检查条件之前就设置进程的状态为睡眠状态,
然后才循环检查条件。如果在进程开始睡眠之前条件就已经达成了,那么循环会退出并用set_current_state()将自己的状态设置为就绪,这样同样保证了进程不会存在错误的进入睡眠的倾向,当然也就不会导致出现无效唤醒问题。
下面让我们用linux 内核中的实例来看看Linux 内核是如何避免无效睡眠的,这段代码出自Linux2.6的内核(linux-2.6.11/kernel/sched.c: 4254):
4253 /* Wait for kthread_stop */
4254 set_current_state(TASK_INTERRUPTIBLE);
4255 while (!kthread_should_stop()) {
4256 schedule();
4257 set_current_state(TASK_INTERRUPTIBLE);
4258 }
4259 __set_current_state(TASK_RUNNING);
4260 return 0;
上面的这些代码属于迁移服务线程migration_thread,这个线程不断地检查kthread_should_stop(),
直 到kthread_should_stop()返回1它才可以退出循环,也就是说只要kthread_should_stop()返回0该进程就会一直睡 眠。从代码中我们可以看出,检查kthread_should_stop()确实是在进程的状态被置为TASK_INTERRUPTIBLE后才开始执行 的。因此,如果在条件检查之后但是在schedule()之前有其他进程试图唤醒它,那么该进程的唤醒操作不会失效。

小结
通过上面的讨论,可以发现在Linux 中避免进程的无效唤醒的关键是在进程检查条件之前就将进程的
状态置为TASK_INTERRUPTIBLE或TASK_UNINTERRUPTIBLE,并且如果检查的条件满足的话就应该
将其状态重新设置为TASK_RUNNING。这样无论进程等待的条件是否满足, 进程都不会因为被移出就绪队列而错误地进入睡眠状态,从而避免了无效唤醒问题。

posted @ 2010-10-06 17:15 doublezxh 阅读(289) | 评论 (0)编辑 收藏
linux select

二.I/O多路转接

       如果我们想从多个文件描述符读或写数据,如果我们用以前学过的函数(read,write等)去处理可能会阻塞在一个文件描述符上,不能处理其他的文件描述符。那是因为我们以前学的I/O处理函数,都是阻塞的I/O处理函数,它们的特点是,如果缓冲区里有数据它们就会把数据写到文件中,如果缓存区没有数据他们就会等待(阻塞)直到有数据可读。这就造成了他们无法对多个文件描述符进行操作。而对多个文件描述符进行操作在网络通信方面却是执关重要的。

       一种比较好的解决方案就是I/O多路转接技术。它现构造一张有关文件描述符的列表,然后调用一个函数,直到这些描述符中的一个已经准备好进行I/O时,该函数才返回。在返回时,它告诉进程那些描述符已经准备好可以进行I/Opoll,selsct,pselect这三个函数使我们能够执行I/O多路转接,下面就分别介绍它们。

 

2

名称:

select

功能

指行I/O多路转接

头文件

#include <sys/select.h>

函数原形

int select(int maxfdpl,fd_set *restrict readfds,fd_set *restrict writefds,fd_set *testrict exceptfds,struct timeval *testrict tvptr);

参数

maxfdpl   最大描述符加1

readfds     读描述符集   

writefds    写描述符集

excepfds    异常描述符集

tvptr      愿意等待的时间

返回值:

准备就绪的文件描述符数,若超时则返回0,若出错则返回-1

      

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 select函数使我们可以执行I/O多路转接。传向select的参数告诉内核:我们所关系的描述符。对于每个描述符我们所关心的状态。以及我们愿意等待的时间。从select返回时,内核告诉我们:以准备好的描述符的数量。对于读、写或异常这三个状态中的每一个,那些描述符已经准备好。

       这个函数比较复杂,我们一个一个参数的看。

       第一个参数maxfdp1的意思是“最大描述符加1。也可将第一个参数设置为FD_SETSIZE,这是<sys/select.h>中的一个常数,它说明了最大的描述符数(经常是1024)。如果将第三个参数设置为我们所关注的最大描述符编号值加一,内核就只需在此范围内寻找打开的位,而不必在三个描述符集中的数百位内搜索。

       中间的三个参数readfdswritefdsexceptfds是指向描述符集的指针。这三个描述符集说明了我们关心的可读(readfds)、可写(writefd)或处于异常条件(wxcepfds)的各个描述符。每个描述符集存放在一个fd_set数据类型中。这种结构相当于一个描述符的数组,它为每个可能的描述符设置1位。

               fd0     fd1     fd2     fd3       fdn

0

0

0

0

readfdsà

 

               fd0     fd1     fd2     fd3       fdn

0

0

0

0

writefdsà

 

               fd0     fd1     fd2     fd3       fdn

0

0

0

0

excepfdsà

 

       可用下面4个函数对描述符集进行操作。

 

       select的中间三个参数中的任意一个或全部都可以是空指针,这表示对相应状态不关系。如果所有三个指针都是空指针,则select提供了较sleep更精确的计时器。其等待时间可以小于1秒。

      

       tuptr指定最后等待的时间,它的结构是:

struct timeval{

       long tv_sec;

       long tv_usec; 微秒

};

有三种情况:

(1) tvptr==NULL:永远等待。如果捕捉到一个信号则中断此无限等待。当所指定的描述符中的一个已经准备好或捕捉到一个信号则返回。如果捕捉到一个信号,则select返回-1errno设置为EINTR.

(2) tvptr->tv_sec==0&&tvptr_usec==0 完全不等待。测试所有的描述符并立即返回。这是得到多个描述符的状态而不阻塞select函数的轮询方法。

(3tvptr->tv_sec!=0||tvptr_usec!=0 等待指定的秒数或微秒数。当指定的描述符之一已准备好,或当指定的时间值已超过时立即返回。如果在超时还没有一个描述符准备好,则返回值是0

 

3

名称:

FD_ISSET/FD_CLR/FD_SET/FD_ZERO

功能

描述符集处理函数

头文件

#include <sys/select.h>

函数原形

int FD_ISSET(int fd,fd_set *fdset);

void FD_CLR(int fd,fd_set *fdset);

void FD_SET(int fd,fd_set *fdset);

void FD_ZERO(fd_set *fdset);

参数

fdset     描述符集

fd        描述符

返回值:

fd在描述符集中则返回非0值,否则返回0FD_ISSET

      

 

 

 

 

 

 

 

 

 

 

 

 

 

 调用FD_ZERO将一个指定的fd_set变量的所有位设置为0。调用FD_SET设置一个fd_set变量的指定位。调用FD_CLR将一指定位清除。最后调用FD_ISSET测试一指定位是否设置。声明了一个描述符集后,必须用FD_ZERO清除其所有位,然后在其中设置我们关心的各个位。

       下面是select函数实现I/O多路转接的一个例子

/*12_3.c*/

#include <sys/time.h>

#include <stdio.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

 

int main()

{

int keyboard;

int ret=0;

char c;

fd_set readfd;

struct timeval timeout;

if((keyboard=open(“/dev/tty”,O_RDONLY|O_NONBLOCK))<0) /*打开标准输入(键盘)的文件描述符*/

    exit(1);/如果失败则退出程序*/

while(1)

{

    timeout.tv_sec=3;/*设置等待时间为3*/

    timeout.usec=0;

    FD_ZERO(&readfd);/*初始化描述符集*/

    FD_SET(keyboard,&readfd);/*把标准输入(键盘)加入到描述符集中*/

   

    ret=select(keyboard+1,&readfd,NULL,NULL,&timeout);

    if(ret==0)/*如果超时打印下面的语句*/

        printf(“Time out!\n”);

    if(FD_ISSET(keyboard,&readfd))/*如果描述符集readfdkeyboard位被设置*/

    {

        read(keyboard,&c,1);/*从键盘上读如一个字符*/

        if(c==’\n’)

            continue;

        printf(“You input is %c\n”,c);

        if(c==’q’)

            break;

    }

}

}

       程序执行后等待用户输入。如果用户输入程序就会把它打印到屏幕上。如果用户在3秒钟未输入任何字符,程序就打印“Time out!”.

       本程序实现了一个文件描述符的非阻塞I/O

 

posted @ 2010-09-26 20:24 doublezxh 阅读(2753) | 评论 (0)编辑 收藏
Linux select()详解

 
    select系统调用是用来让我们的程序监视多个文件句柄(file descriptor)的状态变化的。程序会停在select这里等待,直到被监视的文件句柄有某一个或多个发生了状态改变。

文件在句柄在Linux里很多,如果你man某个函数,在函数返回值部分说到成功后有一个文件句柄被创建的都是的,如man socket可以看到“On success, a file descriptor for the new socket is returned.”而man 2 open可以看到“open() and creat() return the new file descriptor”,其实文件句柄就是一个整数,看socket函数的声明就明白了:
int socket(int domain, int type, int protocol);
当然,我们最熟悉的句柄是0、1、2三个,0是标准输入,1是标准输出,2是标准错误输出。0、1、2是整数表示的,对应的FILE *结构的表示就是stdin、stdout、stderr,0就是stdin,1就是stdout,2就是stderr。
比如下面这两段代码都是从标准输入读入9个字节字符:


#include <stdio.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char ** argv)
{
        char buf[10] = "";
        read(0, buf, 9); /* 从标准输入 0 读入字符 */
        fprintf(stdout, "%s\n", buf); /* 向标准输出 stdout 写字符 */
        return 0;
}
/* **上面和下面的代码都可以用来从标准输入读用户输入的9个字符** */
#include <stdio.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char ** argv)
{
        char buf[10] = "";
        fread(buf, 9, 1, stdin); /* 从标准输入 stdin 读入字符 */
        write(1, buf, strlen(buf));
        return 0;
}
   继续上面说的select,就是用来监视某个或某些句柄的状态变化的。select函数原型如下:
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
函数的最后一个参数timeout显然是一个超时时间值,其类型是struct timeval *,即一个struct timeval结构的变量的指针,所以我们在程序里要申明一个struct timeval tv;然后把变量tv的地址&tv传递给select函数。struct timeval结构如下:


struct timeval {
             long    tv_sec;         /* seconds */
             long    tv_usec;        /* microseconds */
         };
   第2、3、4三个参数是一样的类型: fd_set *,即我们在程序里要申明几个fd_set类型的变量,比如rdfds, wtfds, exfds,然后把这个变量的地址&rdfds, &wtfds, &exfds 传递给select函数。这三个参数都是一个句柄的集合,第一个rdfds是用来保存这样的句柄的:当句柄的状态变成可读的时系统就会告诉select函数返回,同理第二个wtfds是指有句柄状态变成可写的时系统就会告诉select函数返回,同理第三个参数exfds是特殊情况,即句柄上有特殊情况发生时系统会告诉select函数返回。特殊情况比如对方通过一个socket句柄发来了紧急数据。如果我们程序里只想检测某个socket是否有数据可读,我们可以这样:

fd_set rdfds; /* 先申明一个 fd_set 集合来保存我们要检测的 socket句柄 */
struct timeval tv; /* 申明一个时间变量来保存时间 */
int ret; /* 保存返回值 */
FD_ZERO(&rdfds); /* 用select函数之前先把集合清零 */
FD_SET(socket, &rdfds); /* 把要检测的句柄socket加入到集合里 */
tv.tv_sec = 1;
tv.tv_usec = 500; /* 设置select等待的最大时间为1秒加500毫秒 */
ret = select(socket + 1, &rdfds, NULL, NULL, &tv); /* 检测我们上面设置到集合rdfds里的句柄是否有可读信息 */
if(ret < 0) perror("select");/* 这说明select函数出错 */
else if(ret == 0) printf("超时\n"); /* 说明在我们设定的时间值1秒加500毫秒的时间内,socket的状态没有发生变化 */
else { /* 说明等待时间还未到1秒加500毫秒,socket的状态发生了变化 */
    printf("ret=%d\n", ret); /* ret这个返回值记录了发生状态变化的句柄的数目,由于我们只监视了socket这一个句柄,所以这里一定ret=1,如果同时有多个句柄发生变化返回的就是句柄的总和了 */
    /* 这里我们就应该从socket这个句柄里读取数据了,因为select函数已经告诉我们这个句柄里有数据可读 */
    if(FD_ISSET(socket, &rdfds)) { /* 先判断一下socket这外被监视的句柄是否真的变成可读的了 */
        /* 读取socket句柄里的数据 */
        recv(...);
    }
}
   注意select函数的第一个参数,是所有加入集合的句柄值的最大那个值还要加1。比如我们创建了3个句柄:
/************关于本文档********************************************
*filename: Linux网络编程一步一步学-select详解
*purpose: 详细说明select的用法
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2007-02-03 19:40
*Note: 任何人可以任意复制代码并运用这些文档,当然包括你的商业用途
* 但请遵循GPL
*Thanks to:Google
*Hope:希望越来越多的人贡献自己的力量,为科学技术发展出力
* 科技站在巨人的肩膀上进步更快!感谢有开源前辈的贡献!
*********************************************************************/

int sa, sb, sc;
sa = socket(...); /* 分别创建3个句柄并连接到服务器上 */
connect(sa,...);
sb = socket(...);
connect(sb,...);
sc = socket(...);
connect(sc,...);

FD_SET(sa, &rdfds);/* 分别把3个句柄加入读监视集合里去 */
FD_SET(sb, &rdfds);
FD_SET(sc, &rdfds);
   在使用select函数之前,一定要找到3个句柄中的最大值是哪个,我们一般定义一个变量来保存最大值,取得最大socket值如下:

int maxfd = 0;
if(sa > maxfd) maxfd = sa;
if(sb > maxfd) maxfd = sb;
if(sc > maxfd) maxfd = sc;
   然后调用select函数:
ret = select(maxfd + 1, &rdfds, NULL, NULL, &tv); /* 注意是最大值还要加1 */
   同样的道理,如果我们要检测用户是否按了键盘进行输入,我们就应该把标准输入0这个句柄放到select里来检测,如下:

FD_ZERO(&rdfds);
FD_SET(0, &rdfds);
tv.tv_sec = 1;
tv.tv_usec = 0;
ret = select(1, &rdfds, NULL, NULL, &tv); /* 注意是最大值还要加1 */
if(ret < 0) perror("select");/* 出错 */
else if(ret == 0) printf("超时\n"); /* 在我们设定的时间tv内,用户没有按键盘 */
else { /* 用户有按键盘,要读取用户的输入 */
    scanf("%s", buf);

posted @ 2010-09-26 20:16 doublezxh 阅读(429) | 评论 (0)编辑 收藏
fcntl()用来操作文件描述词的一些特性。

fcntl()用来操作文件描述词的一些特性。参数fd代表欲设置的文件描述词,参数cmd代表欲操作的指令。

文件描述词,当一个文件打开后,系统会分配一部分资源来保存该文件的信息.以后对文件的操作就可以直接引用该部分资源了,文件描述词可以认为是该部分资源的一个索引,在打开文件时返回.fcntl是用来对文件的一些属性进行设置的,需要一个文件描述词参数.

有以下几种情况:
F_DUPFD用来查找大于或等于参数arg的最小且仍未使用的文件描述词,并且复制参数fd的文件描述词。执行成功则返回新复制的文件描述词。请参考dup2()。F_GETFD取得close-on-exec旗标。若此旗标的FD_CLOEXEC位为0,代表在调用exec()相关函数时文件将不会关闭。
F_SETFD 设置close-on-exec 旗标。该旗标以参数arg 的FD_CLOEXEC位决定。
F_GETFL 取得文件描述词状态旗标,此旗标为open()的参数flags。
F_SETFL 设置文件描述词状态旗标,参数arg为新旗标,但只允许O_APPEND、O_NONBLOCK和O_ASYNC位的改变,其他位的改变将不受影响。
F_GETLK 取得文件锁定的状态。
F_SETLK 设置文件锁定的状态。此时flcok 结构的l_type 值必须是F_RDLCK、F_WRLCK或F_UNLCK。如果无法建立锁定,则返回-1,错误代码为EACCES 或EAGAIN。
F_SETLKW F_SETLK 作用相同,但是无法建立锁定时,此调用会一直等到锁定动作成功为止。若在等待锁定的过程中被信号中断时,会立即返回-1,错误代码为EINTR。参数lock指针为flock 结构指针,定义如下
struct flcok
{
short int l_type; /* 锁定的状态*/
short int l_whence;/*决定l_start位置*/
off_t l_start; /*锁定区域的开头位置*/
off_t l_len; /*锁定区域的大小*/
pid_t l_pid; /*锁定动作的进程*/
};
l_type 有三种状态:
F_RDLCK 建立一个供读取用的锁定
F_WRLCK 建立一个供写入用的锁定
F_UNLCK 删除之前建立的锁定
l_whence 也有三种方式:
SEEK_SET 以文件开头为锁定的起始位置。
SEEK_CUR 以目前文件读写位置为锁定的起始位置
SEEK_END 以文件结尾为锁定的起始位置。

返回值 成功则返回0,若有错误则返回-1,错误原因存于errno.


该函数可以改变已打开的文件的性质。
#include
int fcntl(int fields, int cmd, .../* int arg */); //若成功则依赖于cmd,若出错则返回-1

第三个参数总是一个整数,与上面所示函数原型中的注释部分相对应。但是在作为记录锁用时,第三个参数则是指向一个结构的指针。
fcntl函数有5种功能:
1.复制一个现有的描述符(cmd=F_DUPFD).
2.获得/设置文件描述符标记(cmd=F_GETFD或F_SETFD).
3.获得/设置文件状态标记(cmd=F_GETFL或F_SETFL).
4.获得/设置异步I/O所有权(cmd=F_GETOWN或F_SETOWN).
5.获得/设置记录锁(cmd=F_GETLK,F_SETLK或F_SETLKW).

#include
#include
#include
#include
using namespace std;

int main(int argc,char* argv[])
{
int fd,var;
// fd=open("new",O_RDWR);

if (argc!=2)
{
perror("--");
cout<<"请输入参数,即文件名!"<}

if((var=fcntl(atoi(argv[1]), F_GETFL, 0))<0)
{
strerror(errno);
cout<<"fcntl file error."<}

switch(var & O_ACCMODE)
{
case O_RDONLY : cout<<"Read only.."<break;

case O_WRONLY : cout<<"Write only.."<break;

case O_RDWR : cout<<"Read wirte.."<break;

default : break;
}

if (val & O_APPEND)
cout<<",append"<

if (val & O_NONBLOCK)
cout<<",noblocking"<

cout<<"exit 0"<

exit(0);
}

 

fcntl文件锁有两种类型:建议性锁和强制性锁
建议性锁是这样规定的:每个使用上锁文件的进程都要检查是否有锁存在,当然还得尊重已有的锁。内核和系统总体上都坚持不使用建议性锁,它们依靠程序员遵守这个规定。
强制性锁是由内核执行的。当文件被上锁来进行写入操作时,在锁定该文件的进程释放该锁之前,内核会阻止任何对该文件的读或写访问,每次读或写访问都得检查锁是否存在。

系统默认fcntl都是建议性锁,强制性锁是非POSIX标准的。如果要使用强制性锁,要使整个系统可以使用强制性锁,那么得需要重新挂载文件系统, mount使用参数 -0 mand打开强制性锁,或者关闭已加锁文件的组执行权限并且打开该文件的set-GID权限位。
建议性锁只在cooperating processes之间才有用,对cooperating process的理解是最重要的,它指的是会影响其它进程的进程或被别的进程所影响的进程,举两个例子:
(1)我们可以同时在两个窗口中运行同一个命令,对同一个文件进行操作,那么这两个进程就是cooperating processes;
(2) cat file | sort, 那么cat和sort产生的进程就是使用了pipe的cooperating processes。

使用fcntl文件锁进行I/O操作必须小心:进程在开始任何I/O操作前如何去处理锁,在对文件解锁前如何完成所有的操作,是必须考虑的。如果在设置锁之前打开文件,或者读取该锁之后关闭文件,另一个进程就可能在上锁/解锁操作和打开/关闭操作之间的几分之一秒内访问该文件。当一个进程对文件加锁后,无论它是否释放所加的锁,只要文件关闭,内核都会自动释放加在文件上的建议性锁(这也是建议性锁和强制性锁的最大区别), 所以不要想设置建议性锁来达到永久不让别的进程访问文件的目的(强制性锁才可以)^_^;强制性锁则对所有进程起作用。

fcntl使用三个参数 F_SETLK/F_SETLKW, F_UNLCK和F_GETLK, 来分别要求、释放、测试record locks, record locks是对文件一部分而不是整个文件的锁,这种细致的控制使得进程更好地协作以共享文件资源。fcntl能够用于读取锁和写入锁,read lock也叫shared lock(共享锁), 因为多个cooperating process能够在文件的同一部分建立读取锁;write lock被称为exclusive lock(排斥锁), 因为任何时刻只能有一个cooperating process在文件的某部分上建立写入锁。如果cooperating processes对文件进行操作,那么它们可以同时对文件加read lock, 在一个cooperating process加write lock之前,必须释放别的cooperating process加在该文件的read lock和wrtie lock, 也就是说,对于文件只能有一个write lock存在,read lock和wrtie lock不能共存。

posted @ 2010-09-26 18:09 doublezxh 阅读(215) | 评论 (0)编辑 收藏
linux文件设备与I/O:fcntl函数

linux文件设备与I/O:fcntl函数
2009年05月07日 星期四 14:24
可以用fcntl 函数改变一个已打开的文件的属性,可以重新设置读、写、追加、非阻塞等标志(这些标志称为File StatusFlag),而不必重新open 文件。
#include <unistd.h>
#include <fcntl.h>
int fcntl(int fd, int cmd);
int fcntl(int fd, int cmd, long arg);
int fcntl(int fd, int cmd, struct flock *lock);


这个函数和open 一样,也是用可变参数实现的,可变参数的类型和个数取决于前面的cmd 参数。

针对第2个参数,int cmd fcntl函数有五种功能:
• 复制一个现存的描述符(cmd=F_DUPFD)    。
• 获得/设置文件描述符标记(cmd=F_GETFD或F_SETFD)   。
• 获得/设置文件状态标志(cmd=F_GETFL或F_SETFL) 。
• 获得/设置异步I/O有权(cmd=F_GETOWN或F_SETOWN) 。
• 获得/设置记录锁(cmd=F_GETLK,F_SETLK或F_SETLKW)。

我们将涉及与进程表项中各文件描述符相关联的文件描述符标志, 以及每个文件表项中的文件状态标志,

一~复制文件描述符
• F_DUPFD 复制文件描述符filedes,新文件描述符作为函数值返回。它是尚未打开的各
描述符中大于或等于第三个参数值(取为整型值)中各值的最小值。新描述符与 filedes 共享同
一文件表项。但是,新描述符有它自己的一套文件描述符标志,其 F D _ C L O E X E C
文件描述符标志则被清除。
• F_GETFD 对应于filedes 的文件描述符标志作为函数值返回。当前只定义了一个文件描
述符标志FD_CLOEXEC。
• F_SETFD 对于filedes 设置文件描述符标志。新标志值按第三个参数 (取为整型值)设置。
应当了解很多现存的涉及文件描述符标志的程序并不使用常数 F D _ C L O E X E C,而是将此
标志设置为0(系统默认,在exec时不关闭)或1(在exec时关闭)。

二~文件描述符号,套接口 属性相关
• F_GETFL 对应于filedes 的文件状态标志作为函数值返回。在说明 open函数时,已说明
了文件状态标志   不幸的是,三个存取方式标志 (O_RDONLY,O_WRONLY,以及O_RDWR)并不各占1位。(正
如前述,这三种标志的值各是 0、1和2,由于历史原因。这三种值互斥 — 一个文件只能有这
三种值之一。 )因此首先必须用屏蔽字 O_ACCMODE相与 取得存取方式位,然后将结果与这三种值
相比较。
• F_SETFL 将文件状态标志设置为第三个参数的值 (取为整型值)。 可以更改的几个标志是:
O_APPEND,O_NONBLOCK,O_SYNC和O_ASYNC。

fcntl的文件状态标志共有7个,O_RDONLY,O_WRONLY,O_RDWR,O_APPEND,O_NONBLOCK,O_SYNC和O_ASYNC


三~信号驱动I/O , 带外数据,设置套接口接受信号的属主
SIGIO,跟信号驱动I/O有关
SIGURG, 和接受带外数据有关
• F_GETOWN 取当前接收SIGIO和SIGURG信号的进程ID或进程组ID。12.6.2节将论述这
两种4.3+BSD异步I/O信号。
• F_SETOWN 设置接收SIGIO和SIGURG信号的进程ID或进程组ID。正的arg指定一个进
程ID,负的arg表示等于arg绝对值的一个进程组ID。



下面的例子使用F_GETFL和F_SETFL这两种fcntl 命令改变STDIN_FILENO的属性,上O_NONBLOCK 选项,实现非阻塞读终端的功能。

用fcntl改变File Status Flag
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#define MSG_TRY "try again\n"
int main(void)
{
char buf[10];
int n;
int flags;
flags = fcntl(STDIN_FILENO, F_GETFL);
flags |= O_NONBLOCK;
if (fcntl(STDIN_FILENO, F_SETFL, flags) == -1)
{
perror("fcntl");
exit(1);
}
tryagain:
n = read(STDIN_FILENO, buf, 10);
if (n < 0) 
{
if (errno == EAGAIN)
{
sleep(1);
write(STDOUT_FILENO, MSG_TRY,strlen(MSG_TRY));
goto tryagain;
}
perror("read stdin");
exit(1);
}
write(STDOUT_FILENO, buf, n);
return 0;
}

posted @ 2010-09-26 18:08 doublezxh 阅读(602) | 评论 (0)编辑 收藏
[精华收藏] 写给Linux内核新手-关于Linux内核学习的误区

常想学习内核有:
  1, 关于操作系统理论的最初级的知识。不需要通读并理解《操作系统概念》《现代操作系统》等巨著,但总要知道分时(time-shared)和实时(real-time)的区别是什么,进程是个什么东西,CPU和系统总线、内存的关系(很粗略即可),等等。
  2, 关于C语言。不需要已经很精通C语言,只要能熟练编写C程序,能看懂链表、散列表等数据结构的C实现,用过gcc编译器,就可以了。当然,如果已经精通C语言显然是大占便宜的。
  3, 关于CPU的知识。这块儿可以在学习内核过程中补,但这样的话你就需要看讲解很详细的书,比方后面将会提到的《情景分析》。你是否熟悉Intel 80386 CPU?尝试着回答这几个问题来判断一下:1)说出80386的中断门和陷阱门的区别;2)说出保护模式与实模式的区别;3)多处理器机器上,普通的读-改-写回一块内存这样的动作,为什么需要特殊的手段来保护。等等。讲解基于其它CPU的Linux内核的书,目前好象只有一本《IA64Linux内核:设计与实现》──也还是Intel的,其它都是讲解基于IA32的。
  以上算是知识方面吧,如果还要再补充一条,我想就是:动手编译过内核。


  好了,我们接下来走。好多人装上Linux之后,第一件事找到内核源码所在的路径,打开一个C程序文件,开始哗哗哗翻页,看看大名鼎鼎的Linux内核代码到底长啥模样──然后关闭。这是可理解的,但却不是学习的方法。刚开始,必须从读书入手。[color=red]至少要对内核有一个Overview之后,才有可能带着问题去试图阅读源代码本身。 [/color]下面就讲一下我读过的几本书:
  1, 《Linux内核设计与实现》,英文名Linux Kernel Development(所以有人叫它LKD),机械工业出版社,¥35, 美国Robert Love著,陈莉君译者。 评说:
  此书是当今首屈一指的入门最佳图书。作者是为2.6内核加入了抢占的人,对调度部分非常精通,而调度是整个系统的核心,因此本书是很权威的。这本书讲解浅显易懂,全书没有列举一条汇编语句,但是给出了整个Linux操作系统2.6内核的概观,使你能通过阅读迅速获得一个overview。而且对内核中较为混乱的部分(如下半部),它的讲解是最透彻的。对没怎么深入内核的人来说,这是强烈推荐的一本书。
   翻译:翻译水平、负责任程度都不错,但是印刷存在一些错误。买了此书的朋友可以参考我在Linux高级应用版的《Linux内核设计与实现中文版勘误》:
http://bbs.chinaunix.net/forum/viewtopic.php?t=541234
另外,此书2005年有了第二版,目前尚无中译本面世。我就是对照着2nd-en勘误1st-cn的。

  2, 《Linux内核源代码情景分析》上、下。毛德操、胡希明著,浙江大学出版社,上册¥80,下册¥70.   评说:
  本书是基于2.4.0内核的,比较早,也没听说会出第二版。上册讲解内存管理、中断、异常与系统调用、进程控制、文件系统与传统Unix IPC;下册讲解socket、设备驱动、SMP和引导。关于这套书的评价褒贬不一,我个人认为其深度是同类著作中最优秀的。本书基于Intel IA32体系,由于厚度大,很多体系上的知识都捎带讲解了,所以如果你想深入了解内核的工作机制而又不非常熟悉Intel  CPU的体系构造,本书是最合适的。缺点是:版本较老,没有TCP/IP协议栈部分(它讲的socket只是Unix域协议的),图表太少,不适合初学者入门。还有就是对学生朋友来说,可能书价偏高,这样的话可以考虑先买上册,因为上册是核心部分,下册一大部分都在讲具体PCI/ISA/USB设备的驱动。
  翻译:没什么翻译,作者是国人,而且行文流畅。本人书桌上诸多计算机经典图书当中,这套是唯一又经典又无阅读障碍的。
  www.linuxforum.net内核版好多朋友已经把这书读到六七遍了,我很惭愧,上册差不多读熟了,下册就SMP部分还看过──但这就花费了整整1年的时间,还有好多弄不懂的。这里顺便说明另外一个研究内核常见的误区:目标太庞大。要知道Linux内核(最新的2.6.13)bzip2压缩之后37M,解压缩之后244M,根本不是哪个人能够吃透的。即使是内核的核心开发团队中,恐怕也只Linus Torvalds、Alan Cox、David Miller、Ingo Molnar寥寥数人会有比较全面的了解,其它人都是做自己专门的部分。 我自己来说,目前已经决定放弃内存管理的全部(slab层、LRU、rbtree等)、文件系统部分、外设驱动部分,暂时也没打算弄IA32以外的其它体系的部分。

  3, 《深入理解Linux内核》第二版。中国电力出版社。也是陈莉君译。此书是Linux内核黑客在推荐图书时的首选。 评说:
  此书C版的converse兄送了我一本第一版,因此就没买第二版,比较后悔。因此只就第一版说一说,第一版基于2.2,第二版2.4 。我见O'Reilly官方主页上说第三版的英文版将于2005年11月出版,也不知咱们何时才能见到。此书图表很多,形象地给出了关键数据结构的定义,与《情景分析》相比,本书内容紧凑,不会一个问题讲解动辄上百页,有提纲挈领的功用,但是深度上要逊于《情景分析》。

  4, 其它的几本书。市面上能见到的其它的Linux内核的图书,象《Linux设备驱动程序》、《Linux内核源代码完全注释》以及新出的《Linux内核分析及编程》等。
  《Linux设备驱动程序》第二版是基于2.4的,中文翻译不错,中国电力出版。这书强调动手实践,但它是讲解“设备驱动”的,不是最核心的东西,而且有些东西没硬件的话无法实践,可能更适合驱动开发的程序员吧,不太适合那些For fun and profit的人。此书有第三版英文版,东南大学出版社影印,讲解2.6的,行文流畅,讲解的面也比第二版更广泛,我读过其中关于同步与互斥、内存分配的部分,感觉很不错。
  《Linux内核源代码完全注释》(机械工业出版社)是同济大学的博士生赵炯的著作,讲解0.1Linux内核,我没买也没看,有看过的朋友说一说。
  《Linux内核分析及编程》(电子工业出版社)是刚刚出版的,国人写的,讲解2.6.11 。很多人说好,但有人说不够系统,我没买,不敢评说。
  还有一本清华出的《Linux内核编程指南(第三版)》,原书应该是好书,但是翻译、排版十分糟烂,脱字跳行,根本没法看,我买了一本又扔掉了。

  5, 其它资源。 TLDP(The Linux Documentation Project)有大量文档,其中不少是关于内核的,有些是在国外出版过的,象《Linux Kernel Interls》《The Linux Kernel》《Linux Kernel Module Programming Guide》等,作者都是亲身参加开发的人,著作较为可信。
Http://www.linuxforum.net
  中国Linux论坛的内核版。该版是研究内核的中文Linux社区中水平最高的,有很多专家级别的牛人,强烈推荐去学习一下(但建议不要问太过分简单的问题,人家脾气再好也会烦的^_^),它的置顶贴简直是一个包罗万象的FAQ,精华区也有很多资料。只可惜太过曲高和寡,人气不是很旺。

  6, 一本不是讲解Linux的书:《现代体系结构上的Unix系统:内核程序员的SMP和Caching技术》,人民邮电出版社2003版,定价¥39. 本书虽然不是讲解Linux,但是对所有Unix内核都是适用的,适合对SMP和CPU的Cache这些组成原理知识不是很熟的朋友,而且是很多国外牛人推荐的书。中文版翻译非常负责。


  还有个很重要的问题:怎样浏览内核源代码。有的朋友喜欢在Windows上工作,用Source Insight;有的在Linux,用Source Navigator;还有专门浏览源代码的软件,象lxr(Linux Cross Reference);还有用ctags/ectags/cscope等,这些都是很优秀的软件。我个人用Vim + ctags浏览(参考了www.linuxforum.net内核版wheelz大侠的文档,)。

  此外,前边已经提到的一个重要的问题是:你研究内核的目的是什么, 开发? 乐趣?如果是开发,而且是国内做开发,把kernel API熟悉一下就差不太多了(你也知道国内的水平有多差),比方说copy_from_user()、kmalloc()函数等,kernel API在Internet上找得到,编译内核时也可以用DocBook生成(具体请参考内核源代码包下的README文件);如果是研究,那就差别很大了,需要下很大的苦功:会用kmalloc()绝不说明你懂得Linux内核的虚存管理子系统,正如同会讲汉语不说明你懂中国文化一样。




  说完了,发现前面讲的太罗嗦了,简化一下:
  1, 动手编译内核
  2, 精读《Linux内核设计与实现》
  3, 上www.linuxforum.net内核版看置顶贴与精华区
  此外就凭自己兴趣选择吧。

下面是一篇没写完的《Linux内核模块编程入门》,不补写了,将就着看吧。

[size=4][color=Red] 2006年3月更新: [/color][/size]

写这篇文章的时候, LKD2已经看完了, 《情景分析》也大体翻过相关章节。 只是ULK2看的很少。 我是去年10月份买这本书的中文版的:《深入理解linux内核-第二版》, 越看越觉得后悔买的晚了, 到现在大概读完了2/3吧, 准备最迟下个月读完。 此书非常系统, 在代码罗列讲解上不如《情景分析》, 可是图表很多, 讲解深入浅出, 这一点不是《情景分析》能比的。 考虑到可能有些朋友被我这篇文章误导, 所以在这里补充一下, 并强烈推荐此书。

据说东南大学出版社3月底要影印此书3RD英文版, 期待中。

posted @ 2010-09-25 19:10 doublezxh 阅读(202) | 评论 (0)编辑 收藏
Linux下Socket编程

什么是Socket
   Socket接口是TCP/IP网络的API,Socket接口定义了许多函数或例程,程序员可以用它们来开发TCP/IP网络上的应用程序。要学Internet上的TCP/IP网络编程,必须理解Socket接口。
Socket接口设计者最先是将接口放在Unix操作系统里面的。如果了解Unix系统的输入和输出的话,就很容易了解Socket了。网络的 Socket数据传输是一种特殊的I/O,Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用Socket(),该函数返回一个整型的Socket描述符,随后的连接建立、数据传输等操作都是通过该Socket实现的。常用的Socket类型有两种:流式Socket (SOCK_STREAM)和数据报式Socket(SOCK_DGRAM)。流式是一种面向连接的Socket,针对于面向连接的TCP服务应用;数据报式Socket是一种无连接的Socket,对应于无连接的UDP服务应用。

Socket建立
  为了建立Socket,程序可以调用Socket函数,该函数返回一个类似于文件描述符的句柄。socket函数原型为:
   int socket(int domain, int type, int protocol);
domain指明所使用的协议族,通常为PF_INET,表示互联网协议族(TCP/IP协议族);type参数指定socket的类型: SOCK_STREAM 或SOCK_DGRAM,Socket接口还定义了原始Socket(SOCK_RAW),允许程序使用低层协议;protocol通常赋值"0"。 Socket()调用返回一个整型socket描述符,你可以在后面的调用使用它。
   Socket描述符是一个指向内部数据结构的指针,它指向描述符表入口。调用Socket函数时,socket执行体将建立一个Socket,实际上"建立一个Socket"意味着为一个Socket数据结构分配存储空间。Socket执行体为你管理描述符表。
  两个网络程序之间的一个网络连接包括五种信息:通信协议、本地协议地址、本地主机端口、远端主机地址和远端协议端口。Socket数据结构中包含这五种信息。

Socket配置
通过socket调用返回一个socket描述符后,在使用socket进行网络传输以前,必须配置该socket。面向连接的socket客户端通过调用Connect函数在socket数据结构中保存本地和远端信息。无连接socket的客户端和服务端以及面向连接socket的服务端通过调用 bind函数来配置本地信息。
Bind函数将socket与本机上的一个端口相关联,随后你就可以在该端口监听服务请求。Bind函数原型为:
   int bind(int sockfd,struct sockaddr *my_addr, int addrlen);
   Sockfd是调用socket函数返回的socket描述符,my_addr是一个指向包含有本机IP地址及端口号等信息的sockaddr类型的指针;addrlen常被设置为sizeof(struct sockaddr)。
   struct sockaddr结构类型是用来保存socket信息的:
   struct sockaddr {
   unsigned short sa_family; /* 地址族, AF_xxx */
char sa_data[14]; /* 14 字节的协议地址 */
};
   sa_family一般为AF_INET,代表Internet(TCP/IP)地址族;sa_data则包含该socket的IP地址和端口号。
   另外还有一种结构类型:
   struct sockaddr_in {
   short int sin_family; /* 地址族 */
   unsigned short int sin_port; /* 端口号 */
   struct in_addr sin_addr; /* IP地址 */
   unsigned char sin_zero[8]; /* 填充0 以保持与struct sockaddr同样大小 */
   };
这个结构更方便使用。sin_zero用来将sockaddr_in结构填充到与struct sockaddr同样的长度,可以用bzero()或memset()函数将其置为零。指向sockaddr_in 的指针和指向sockaddr的指针可以相互转换,这意味着如果一个函数所需参数类型是sockaddr时,你可以在函数调用的时候将一个指向 sockaddr_in的指针转换为指向sockaddr的指针;或者相反。
  使用bind函数时,可以用下面的赋值实现自动获得本机IP地址和随机获取一个没有被占用的端口号:
   my_addr.sin_port = 0; /* 系统随机选择一个未被使用的端口号 */
   my_addr.sin_addr.s_addr = INADDR_ANY; /* 填入本机IP地址 */
通过将my_addr.sin_port置为0,函数会自动为你选择一个未占用的端口来使用。同样,通过将my_addr.sin_addr.s_addr置为INADDR_ANY,系统会自动填入本机IP地址。
注意在使用bind函数是需要将sin_port和sin_addr转换成为网络字节优先顺序;而sin_addr则不需要转换。
  计算机数据存储有两种字节优先顺序:高位字节优先和低位字节优先。Internet上数据以高位字节优先顺序在网络上传输,所以对于在内部是以低位字节优先方式存储数据的机器,在Internet上传输数据时就需要进行转换,否则就会出现数据不一致。
   下面是几个字节顺序转换函数:
·htonl():把32位值从主机字节序转换成网络字节序
·htons():把16位值从主机字节序转换成网络字节序
·ntohl():把32位值从网络字节序转换成主机字节序
·ntohs():把16位值从网络字节序转换成主机字节序
   Bind()函数在成功被调用时返回0;出现错误时返回"-1"并将errno置为相应的错误号。需要注意的是,在调用bind函数时一般不要将端口号置为小于1024的值,因为1到1024是保留端口号,你可以选择大于1024中的任何一个没有被占用的端口号。

连接建立
  面向连接的客户程序使用Connect函数来配置socket并与远端服务器建立一个TCP连接,其函数原型为:
   int connect(int sockfd, struct sockaddr *serv_addr,int addrlen);
Sockfd 是socket函数返回的socket描述符;serv_addr是包含远端主机IP地址和端口号的指针;addrlen是远端地质结构的长度。 Connect函数在出现错误时返回-1,并且设置errno为相应的错误码。进行客户端程序设计无须调用bind(),因为这种情况下只需知道目的机器的IP地址,而客户通过哪个端口与服务器建立连接并不需要关心,socket执行体为你的程序自动选择一个未被占用的端口,并通知你的程序数据什么时候到打断口。
   Connect函数启动和远端主机的直接连接。只有面向连接的客户程序使用socket时才需要将此socket与远端主机相连。无连接协议从不建立直接连接。面向连接的服务器也从不启动一个连接,它只是被动的在协议端口监听客户的请求。
   Listen函数使socket处于被动的监听模式,并为该socket建立一个输入数据队列,将到达的服务请求保存在此队列中,直到程序处理它们。
   int listen(int sockfd, int backlog);
Sockfd 是Socket系统调用返回的socket 描述符;backlog指定在请求队列中允许的最大请求数,进入的连接请求将在队列中等待accept()它们(参考下文)。Backlog对队列中等待服务的请求的数目进行了限制,大多数系统缺省值为20。如果一个服务请求到来时,输入队列已满,该socket将拒绝连接请求,客户将收到一个出错信息。
当出现错误时listen函数返回-1,并置相应的errno错误码。
   accept()函数让服务器接收客户的连接请求。在建立好输入队列后,服务器就调用accept函数,然后睡眠并等待客户的连接请求。
   int accept(int sockfd, void *addr, int *addrlen);
sockfd是被监听的socket描述符,addr通常是一个指向sockaddr_in变量的指针,该变量用来存放提出连接请求服务的主机的信息(某台主机从某个端口发出该请求);addrten通常为一个指向值为sizeof(struct sockaddr_in)的整型指针变量。出现错误时accept函数返回-1并置相应的errno值。
  首先,当accept函数监视的 socket收到连接请求时,socket执行体将建立一个新的socket,执行体将这个新socket和请求连接进程的地址联系起来,收到服务请求的初始socket仍可以继续在以前的 socket上监听,同时可以在新的socket描述符上进行数据传输操作。

数据传输
   Send()和recv()这两个函数用于面向连接的socket上进行数据传输。
   Send()函数原型为:
   int send(int sockfd, const void *msg, int len, int flags);
Sockfd是你想用来传输数据的socket描述符;msg是一个指向要发送数据的指针;Len是以字节为单位的数据的长度;flags一般情况下置为0(关于该参数的用法可参照man手册)。
   Send()函数返回实际上发送出的字节数,可能会少于你希望发送的数据。在程序中应该将send()的返回值与欲发送的字节数进行比较。当send()返回值与len不匹配时,应该对这种情况进行处理。
char *msg = "Hello!";
int len, bytes_sent;
……
len = strlen(msg);
bytes_sent = send(sockfd, msg,len,0);
……
   recv()函数原型为:
   int recv(int sockfd,void *buf,int len,unsigned int flags);
   Sockfd是接受数据的socket描述符;buf 是存放接收数据的缓冲区;len是缓冲的长度。Flags也被置为0。Recv()返回实际上接收的字节数,当出现错误时,返回-1并置相应的errno值。
Sendto()和recvfrom()用于在无连接的数据报socket方式下进行数据传输。由于本地socket并没有与远端机器建立连接,所以在发送数据时应指明目的地址。
sendto()函数原型为:
   int sendto(int sockfd, const void *msg,int len,unsigned int flags,const struct sockaddr *to, int tolen);
  该函数比send()函数多了两个参数,to表示目地机的IP地址和端口号信息,而tolen常常被赋值为sizeof (struct sockaddr)。Sendto 函数也返回实际发送的数据字节长度或在出现发送错误时返回-1。
   Recvfrom()函数原型为:
   int recvfrom(int sockfd,void *buf,int len,unsigned int flags,struct sockaddr *from,int *fromlen);
from是一个struct sockaddr类型的变量,该变量保存源机的IP地址及端口号。fromlen常置为sizeof (struct sockaddr)。当recvfrom()返回时,fromlen包含实际存入from中的数据字节数。Recvfrom()函数返回接收到的字节数或当出现错误时返回-1,并置相应的errno。
如果你对数据报socket调用了connect()函数时,你也可以利用send()和recv()进行数据传输,但该socket仍然是数据报socket,并且利用传输层的UDP服务。但在发送或接收数据报时,内核会自动为之加上目地和源地址信息。

结束传输
  当所有的数据操作结束以后,你可以调用close()函数来释放该socket,从而停止在该socket上的任何数据操作:
close(sockfd);
  你也可以调用shutdown()函数来关闭该socket。该函数允许你只停止在某个方向上的数据传输,而一个方向上的数据传输继续进行。如你可以关闭某socket的写操作而允许继续在该socket上接受数据,直至读入所有数据。
   int shutdown(int sockfd,int how);
   Sockfd是需要关闭的socket的描述符。参数 how允许为shutdown操作选择以下几种方式:
   ·0-------不允许继续接收数据
   ·1-------不允许继续发送数据
   ·2-------不允许继续发送和接收数据,
   ·均为允许则调用close ()
   shutdown在操作成功时返回0,在出现错误时返回-1并置相应errno。

Socket编程实例
   代码实例中的服务器通过socket连接向客户端发送字符串"Hello, you are connected!"。只要在服务器上运行该服务器软件,在客户端运行客户软件,客户端就会收到该字符串。
   该服务器软件代码如下:
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
#define SERVPORT 3333 /*服务器监听端口号 */
#define BACKLOG 10 /* 最大同时连接请求数 */
main()
{
  int sockfd,client_fd; /*sock_fd:监听socket;client_fd:数据传输socket */
  struct sockaddr_in my_addr; /* 本机地址信息 */
  struct sockaddr_in remote_addr; /* 客户端地址信息 */
  if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
   perror("socket创建出错!"); exit(1);
  }
  my_addr.sin_family=AF_INET;
  my_addr.sin_port=htons(SERVPORT);
  my_addr.sin_addr.s_addr = INADDR_ANY;
  bzero(&(my_addr.sin_zero),8);
  if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) {
    perror("bind出错!");
    exit(1);
  }
  if (listen(sockfd, BACKLOG) == -1) {
    perror("listen出错!");
    exit(1);
  }
  while(1) {
   sin_size = sizeof(struct sockaddr_in);
   if ((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size)) == -1) {
      perror("accept出错");
      continue;
   }
   printf("received a connection from %s\n", inet_ntoa(remote_addr.sin_addr));
   if (!fork()) { /* 子进程代码段 */
     if (send(client_fd, "Hello, you are connected!\n", 26, 0) == -1)
     perror("send出错!");
     close(client_fd);
     exit(0);
   }
   close(client_fd);
   }
  }
}
服务器的工作流程是这样的:首先调用socket函数创建一个Socket,然后调用bind函数将其与本机地址以及一个本地端口号绑定,然后调用 listen在相应的socket上监听,当accpet接收到一个连接服务请求时,将生成一个新的socket。服务器显示该客户机的IP地址,并通过新的socket向客户端发送字符串"Hello,you are connected!"。最后关闭该socket。
  代码实例中的fork()函数生成一个子进程来处理数据传输部分,fork()语句对于子进程返回的值为0。所以包含fork函数的if语句是子进程代码部分,它与if语句后面的父进程代码部分是并发执行的。

客户端程序代码如下:
#include<stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define SERVPORT 3333
#define MAXDATASIZE 100 /*每次最大数据传输量 */
main(int argc, char *argv[]){
  int sockfd, recvbytes;
  char buf[MAXDATASIZE];
  struct hostent *host;
  struct sockaddr_in serv_addr;
  if (argc < 2) {
fprintf(stderr,"Please enter the server's hostname!\n");
exit(1);
}
  if((host=gethostbyname(argv[1]))==NULL) {
herror("gethostbyname出错!");
exit(1);
}
  if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
perror("socket创建出错!");
exit(1);
}
  serv_addr.sin_family=AF_INET;
  serv_addr.sin_port=htons(SERVPORT);
  serv_addr.sin_addr = *((struct in_addr *)host->h_addr);
  bzero(&(serv_addr.sin_zero),8);
  if (connect(sockfd, (struct sockaddr *)&serv_addr, \
   sizeof(struct sockaddr)) == -1) {
perror("connect出错!");
exit(1);
}
  if ((recvbytes=recv(sockfd, buf, MAXDATASIZE, 0)) ==-1) {
perror("recv出错!");
exit(1);
}
  buf[recvbytes] = '\0';
  printf("Received: %s",buf);
  close(sockfd);
}
  客户端程序首先通过服务器域名获得服务器的IP地址,然后创建一个socket,调用connect函数与服务器建立连接,连接成功之后接收从服务器发送过来的数据,最后关闭socket。
  函数gethostbyname()是完成域名转换的。由于IP地址难以记忆和读写,所以为了方便,人们常常用域名来表示主机,这就需要进行域名和IP地址的转换。函数原型为:
   struct hostent *gethostbyname(const char *name);
   函数返回为hosten的结构类型,它的定义如下:
   struct hostent {
  char *h_name; /* 主机的官方域名 */
   char **h_aliases; /* 一个以NULL结尾的主机别名数组 */
   int h_addrtype; /* 返回的地址类型,在Internet环境下为AF-INET */
   int h_length; /* 地址的字节长度 */
   char **h_addr_list; /* 一个以0结尾的数组,包含该主机的所有地址*/
   };
   #define h_addr h_addr_list[0] /*在h-addr-list中的第一个地址*/
   当 gethostname()调用成功时,返回指向struct hosten的指针,当调用失败时返回-1。当调用gethostbyname时,你不能使用perror()函数来输出错误信息,而应该使用herror()函数来输出。

  无连接的客户/服务器程序的在原理上和连接的客户/服务器是一样的,两者的区别在于无连接的客户/服务器中的客户一般不需要建立连接,而且在发送接收数据时,需要指定远端机的地址。

阻塞和非阻塞
阻塞函数在完成其指定的任务以前不允许程序调用另一个函数。例如,程序执行一个读数据的函数调用时,在此函数完成读操作以前将不会执行下一程序语句。当服务器运行到accept语句时,而没有客户连接服务请求到来,服务器就会停止在accept语句上等待连接服务请求的到来。这种情况称为阻塞(blocking)。而非阻塞操作则可以立即完成。比如,如果你希望服务器仅仅注意检查是否有客户在等待连接,有就接受连接,否则就继续做其他事情,则可以通过将Socket设置为非阻塞方式来实现。非阻塞socket在没有客户在等待时就使accept调用立即返回。
   #include <unistd.h>
   #include <fcntl.h>
   ……
sockfd = socket(AF_INET,SOCK_STREAM,0);
fcntl(sockfd,F_SETFL,O_NONBLOCK);
……
通过设置socket为非阻塞方式,可以实现"轮询"若干Socket。当企图从一个没有数据等待处理的非阻塞Socket读入数据时,函数将立即返回,返回值为-1,并置errno值为EWOULDBLOCK。但是这种"轮询"会使CPU处于忙等待方式,从而降低性能,浪费系统资源。而调用 select()会有效地解决这个问题,它允许你把进程本身挂起来,而同时使系统内核监听所要求的一组文件描述符的任何活动,只要确认在任何被监控的文件描述符上出现活动,select()调用将返回指示该文件描述符已准备好的信息,从而实现了为进程选出随机的变化,而不必由进程本身对输入进行测试而浪费 CPU开销。Select函数原型为:
int select(int numfds,fd_set *readfds,fd_set *writefds,
fd_set *exceptfds,struct timeval *timeout);
其中readfds、writefds、exceptfds分别是被select()监视的读、写和异常处理的文件描述符集合。如果你希望确定是否可以从标准输入和某个socket描述符读取数据,你只需要将标准输入的文件描述符0和相应的sockdtfd加入到readfds集合中;numfds的值是需要检查的号码最高的文件描述符加1,这个例子中numfds的值应为sockfd+1;当select返回时,readfds将被修改,指示某个文件描述符已经准备被读取,你可以通过FD_ISSSET()来测试。为了实现fd_set中对应的文件描述符的设置、复位和测试,它提供了一组宏:
   FD_ZERO(fd_set *set)----清除一个文件描述符集;
   FD_SET(int fd,fd_set *set)----将一个文件描述符加入文件描述符集中;
   FD_CLR(int fd,fd_set *set)----将一个文件描述符从文件描述符集中清除;
   FD_ISSET(int fd,fd_set *set)----试判断是否文件描述符被置位。
   Timeout参数是一个指向struct timeval类型的指针,它可以使select()在等待timeout长时间后没有文件描述符准备好即返回。struct timeval数据结构为:
   struct timeval {
   int tv_sec; /* seconds */
   int tv_usec; /* microseconds */
};

POP3客户端实例
  下面的代码实例基于POP3的客户协议,与邮件服务器连接并取回指定用户帐号的邮件。与邮件服务器交互的命令存储在字符串数组POPMessage中,程序通过一个do-while循环依次发送这些命令。
#include<stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define POP3SERVPORT 110
#define MAXDATASIZE 4096

main(int argc, char *argv[]){
int sockfd;
struct hostent *host;
struct sockaddr_in serv_addr;
char *POPMessage[]={
"USER userid\r\n",
"PASS password\r\n",
"STAT\r\n",
"LIST\r\n",
"RETR 1\r\n",
"DELE 1\r\n",
"QUIT\r\n",
NULL
};
int iLength;
int iMsg=0;
int iEnd=0;
char buf[MAXDATASIZE];

if((host=gethostbyname("your.server"))==NULL) {
perror("gethostbyname error");
exit(1);
}
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
perror("socket error");
exit(1);
}
serv_addr.sin_family=AF_INET;
serv_addr.sin_port=htons(POP3SERVPORT);
serv_addr.sin_addr = *((struct in_addr *)host->h_addr);
bzero(&(serv_addr.sin_zero),8);
if (connect(sockfd, (struct sockaddr *)&serv_addr,sizeof(struct sockaddr))==-1){
perror("connect error");
exit(1);
}

do {
send(sockfd,POPMessage[iMsg],strlen(POPMessage[iMsg]),0);
printf("have sent: %s",POPMessage[iMsg]);

iLength=recv(sockfd,buf+iEnd,sizeof(buf)-iEnd,0);
iEnd+=iLength;
buf[iEnd]='\0';
printf("received: %s,%d\n",buf,iMsg);

iMsg++;
} while (POPMessage[iMsg]);

close(sockfd);
}




Unix/Linux环境下的Socket编程

网络的Socket数据传输是一种特殊的I/O,Socket也是一种文件描述符。 Socket也具有一个类似于打开文件的函数调用Socket(),该函数返回一个整型的Socket描述符,随后的连接建立、数据传输等操作都是通过该 Socket实现的。常用的Socket类型有两种:流式Socket (SOCK_STREAM)和数据报式Socket(SOCK_DGRAM)。流式是一种面向连接的Socket,针对于面向连接的TCP服务应用;数据报式Socket是一种无连接的Socket,对应于无连接的UDP服务应用。

    Socket描述符是一个指向内部数据结构的指针,它指向描述符表入口。调用Socket函数时,socket执行体将建立一个Socket,实际上"建立一个Socket"意味着为一个Socket数据结构分配存储空间。Socket执行体为你管理描述符表。两个网络程序之间的一个网络连接包括五种信息:通信协议、本地协议地址、本地主机端口、远端主机地址和远端协议端口。Socket数据结构中包含这五种信息。

   struct sockaddr结构类型是用来保存socket信息的:
    struct sockaddr {
     unsigned short sa_family; /* 地址族, AF_xxx */ 
        char sa_data[14]; /* 14 字节的协议地址 */
    };

  sa_family一般为AF_INET,代表Internet(TCP/IP)地址族;sa_data则包含该socket的IP地址和
端口号。
   另外还有一种结构类型:
    struct sockaddr_in {
   short int sin_family; /* 地址族 */
   unsigned short int sin_port; /* 端口号 */
   struct in_addr sin_addr; /* IP地址 */
   unsigned char sin_zero[8]; /* 填充0 以保持与struct sockaddr同样大小 */ 
     };

    可以用bzero()或memset()函数将其置为零。指向sockaddr_in 的指针和指向sockaddr的指针可以相
互转换,这意味着如果一个函数所需参数类型是sockaddr时,
你可以在函数调用的时候将一个指向
sockaddr_in的指针转换为指向sockaddr的指针;或者相反。

   在使用bind函数是需要将sin_port和sin_addr转换成为网络字节优先顺序;而sin_addr则不需要转换。

   计算机数据存储有两种字节优先顺序:高位字节优先和低位字节优先。Internet上数据以高位字节
优先顺序在网络上传输,所以对于在内部是以低位字节优先方式存储数据的机器,在Internet上传输数
据时就需要进行转换,否则就会出现数据不一致。
  下面是几个字节顺序转换函数:
·htonl():把32位值从主机字节序转换成网络字节序
·htons():把16位值从主机字节序转换成网络字节序
·ntohl():把32位值从网络字节序转换成主机字节序
·ntohs():把16位值从网络字节序转换成主机字节序

Bind()函数在成功被调用时返回0;出现错误时返回"-1"并将errno置为相应的错误号。需要注意的
是,在调用bind函数时一般不要将端口号置为小于1024的值,因为1到1024是保留端口号,你可以选择
大于1024中的任何一个没有被占用的端口号。

连接建立
  面向连接的客户程序使用Connect函数来配置socket并与远端服务器建立一个TCP连接,其函数原型为:
int connect(int sockfd, struct sockaddr *serv_addr,int addrlen);
Sockfd是socket函数返回的socket描述符;serv_addr是包含远端主机IP地址和端口号的指针;addrlen是远端地址结构的长度。Connect函数在出现错误时返回-1,并且设置errno为相应的错误码。进行客户端程序设计无须调用bind(),因为这种情况下只需知道目的机器的IP地址,而客户通过哪个端口与服务器建立连接并不需要关心,socket执行体为你的程序自动选择一个未被占用的端口,并通知你的程序数据什么时候到打断口。Connect 函数启动和远端主机的直接连接。只有面向连接的客户程序使用socket时才需要将此socket与远端主机相连。无连接协议从不建立直接连接。面向连接的务器也从不启动一个连接,它只是被动的在协议端口监听客户的请求。                              

        Listen函数使socket处于被动的监听模式,并为该socket建立一个输入数据队列,将到达的服务请求
保存在此队列中,直到程序处理它们。
int listen(int sockfd, int backlog); Sockfd 是Socket系统调用返回的socket 描述符;backlog指定在请求队列中允许的最大请求数,进入的连接请求将在队列中等待accept()它们(参考下文)。Backlog对队列中等待服务的请求的数目进行了限制,大多数系统缺省值为20。如果一个服务请求到来时,输入队列已满,该 socket将拒绝连接请求,客户将收到一个出错信息。当出现错误时listen函数返回-1,并置相应的errno错误码。

       accept()函数让服务器接收客户的连接请求。在建立好输入队列后,服务器就调用accept函数,然后
睡眠并等待客户的连接请求。
int accept(int sockfd, void *addr, int *addrlen); sockfd是被监听的socket描述符,addr通常是一个指向sockaddr_in变量的指针,该变量用来存放提出连接请求服务的主机的信息(某台主机从某个端口发出该请求);addrlen通常为一个指向值为sizeof(struct sockaddr_in)的整型指针变量。出现错误时accept函数返回-1并置相应的errno值。当accept函数监视的socket收到连接请求时,socket执行体将建立一个新的socket,执行体将这个新socket和请求连接进程的地址联系起来,收到服务请求的初始socket仍可以继续在以前的 socket上监听,同时可以在新的socket描述符上进行数据传输操作。

数据传输 

(面向连接TCP)

       send()和recv()这两个函数用于面向连接的socket上进行数据传输。Send()函数原型为:
  int send(int sockfd, const void *msg, int len, int flags); Sockfd是你想用来传输数据的socket描述符;msg是一个指向要发送数据的指针;Len是以字节为单位的数据的长度;flags一般情况下置为0。
Send()函数返回实际上发送出的字节数,可能会少于你希望发送的数据。在程序中应该将send()的返回值与欲发送的字节数进行比较。当send()返回值与len不匹配时,应该对这种情况进行处理。
  int recv(int sockfd,void *buf,int len,unsigned int flags); Sockfd是接受数据的socket描述符;buf 是存放接收数据的缓冲区;len是缓冲的长度。Flags也被置为0。Recv()返回实际上接收的字节数,当出现错误时,返回-1并置相应的errno值。

(无连接UDP)

        sendto()和recvfrom()用于在无连接的数据报socket方式下进行数据传输。由于本地socket并没有与远端机器建立连接,所以在发送数据时应指明目的地址。
        int sendto(int sockfd, const void *msg,int len,unsigned int flags,const struct sockaddr *to, int tolen);该函数比send()函数多了两个参数,to表示目地机的IP地址和端口号信息,而tolen常常被赋值为sizeof (struct sockaddr)。sendto函数也返回实际发送的数据字节长度或在出现发送错误时返回-1

        int recvfrom(int sockfd,void *buf,int len,unsigned int flags,struct sockaddr *from,int *fromlen); from是一个struct sockaddr类型的变量,该变量保存源机的IP地址及端口号。fromlen常置为sizeof (struct sockaddr)。当recvfrom()返回时,fromlen包含实际存入from中的数据字节数。
Recvfrom()函数返回接收到的字节数或当出现错误时返回-1,并置相应的errno。

结束传输

      当所有的数据操作结束以后,你可以调用close()函数来释放该socket,从而停止在该socket上的任
何数据操作:close(sockfd); 也可以调用shutdown()函数来关闭该socket。该函数允许你只停止在某个方向上的数据传输,而一个方向上的数据传输继续进行。如你可以关闭某socket的写操作而允许继续在该socket上接受数据,直至读入所有数据。
Sockfd 是需要关闭的socket的描述符。参数 how允许为shutdown操作选择以下几种方式:0-------不允许继续接收数据 1-------不允许继续发送数据 2-------不允许继续发送和接收数据,均为允许则调用close () shutdown在操作成功时返回0,在出现错误时返回-1并置相应errno。

posted @ 2010-09-25 17:44 doublezxh 阅读(152) | 评论 (0)编辑 收藏
常见到的端口号的说明与建议

在上网的时候,我们经常会看到端口这个词,也会经常用到端口号,比如在FTP地址后面增加的“21”21就表示端口号。那么端口到底是什么意思呢?怎样查看端口号呢?一个端口是否成为网络恶意攻击的大门呢?,我们应该如何面对形形色色的端口呢?下面就将介绍这方面的内容,以供大家参考。

一,21端口:21端口主要用于FTP(File Transfer Protocol,文件传输协议)服务。

  端口说明:21端口主要用于FTP(File Transfer Protocol,文件传输协议)服务,FTP服务主要是为了在两台计算机之间实现文件的上传与下载,一台计算机作为FTP客户端,另一台计算机作为FTP服务器,可以采用匿名(anonymous)登录和授权用户名与密码登录两种方式登录FTP服务器。目前,通过FTP

  Windows中可以通过Internet信息服务(IIS)来提供FTP连接和管理,也可以单独安装FTP服务器软件来实现FTP功能,比如常见的FTP Serv-U

  操作建议:因为有的FTP服务器可以通过匿名登录,所以常常会被黑客利用。另外,21端口还会被一些木马利用,比如Blade RunnerFTP TrojanDoly TrojanWebEx等等。如果不架设FTP服务器,建议关闭21端口。 23端口:23端口主要用于Telnet(远程登录)服务,是Internet上普遍采用的登录和仿真程序。

  端口说明:23端口主要用于Telnet(远程登录)服务,是Internet上普遍采用的登录和仿真程序。同样需要设置客户端和服务器端,开启Telnet服务的客户端就可以登录远程Telnet服务器,采用授权用户名和密码登录。登录之后,允许用户使用命令提示符窗口进行相应的操作。在Windows中可以在命令提示符窗口中,键入“Telnet”命令来使用Telnet远程登录。

  操作建议:利用Telnet服务,黑客可以搜索远程登录Unix的服务,扫描操作系统的类型。而且在Windows 2000Telnet服务存在多个严重的漏洞,比如提升权限、拒绝服务等,可以让远程服务器崩溃。Telnet服务的23端口也是TTS(Tiny Telnet Server)木马的缺省端口。所以,建议关闭23端口。

二,25端口:25端口为SMTP(Simple Mail Transfer Protocol,简单邮件传输协议)服务器所开放,主要用于发送邮件,如今绝大多数邮件服务器都使用该协议。

  端口说明:25端口为SMTP(Simple Mail Transfer Protocol,简单邮件传输协议)服务器所开放,主要用于发送邮件,如今绝大多数邮件服务器都使用该协议。比如我们在使用电子邮件客户端程序的时候,在创建账户时会要求输入SMTP服务器地址,该服务器地址默认情况下使用的就是25端口。

  端口漏洞:

  1. 利用25端口,黑客可以寻找SMTP服务器,用来转发垃圾邮件。

  2. 25端口被很多木马程序所开放,比如AjanAntigenEmail Password SenderProMailtrojanTapirasTerminatorWinPCWinSpy等等。拿WinSpy来说,通过开放25端口,可以监视计算机正在运行的所有窗口和模块。

  操作建议:如果不是要架设SMTP邮件服务器,可以将该端口关闭。

三,53端口:53端口为DNS(Domain Name Server,域名服务器)服务器所开放,主要用于域名解析,DNS服务在NT系统中使用的最为广泛。

  端口说明:53端口为DNS(Domain Name Server,域名服务器)服务器所开放,主要用于域名解析,DNS服务在NT系统中使用的最为广泛。通过DNS服务器可以实现域名与IP地址之间的转换,只要记住域名就可以快速访问网站。

  端口漏洞:如果开放DNS服务,黑客可以通过分析DNS服务器而直接获取Web服务器等主机的IP地址,再利用53端口突破某些不稳定的防火墙,从而实施攻击。近日,美国一家公司也公布了10个最易遭黑客攻击的漏洞,其中第一位的就是DNS服务器的BIND漏洞。

  操作建议:如果当前的计算机不是用于提供域名解析服务,建议关闭该端口。

四,6768端口:6768端口分别是为Bootp服务的Bootstrap Protocol Server(引导程序协议服务端)Bootstrap Protocol Client(引导程序协议客户端)开放的端口。

  端口说明:6768端口分别是为Bootp服务的Bootstrap Protocol Server(引导程序协议服务端)Bootstrap Protocol Client(引导程序协议客户端)开放的端口。Bootp服务是一种产生于早期Unix的远程启动协议,我们现在经常用到的DHCP服务就是从Bootp服务扩展而来的。通过Bootp服务可以为局域网中的计算机动态分配IP地址,而不需要每个用户去设置静态IP地址。

  端口漏洞:如果开放Bootp服务,常常会被黑客利用分配的一个IP地址作为局部路由器通过中间人”(man-in-middle)方式进行攻击。

  操作建议:建议关闭该端口。

五,69端口:TFTPCisco公司开发的一个简单文件传输协议,类似于FTP

  端口说明:69端口是为TFTP(Trival File Tranfer Protocol,次要文件传输协议)服务开放的,TFTPCisco公司开发的一个简单文件传输协议,类似于FTP。不过与FTP相比,TFTP不具有复杂的交互存取接口和认证控制,该服务适用于不需要复杂交换环境的客户端和服务器之间进行数据传输。

  端口漏洞:很多服务器和Bootp服务一起提供TFTP服务,主要用于从系统下载启动代码。可是,因为TFTP服务可以在系统中写入文件,而且黑客还可以利用TFTP的错误配置来从系统获取任何文件。

  操作建议:建议关闭该端口

六,79端口:79端口是为Finger服务开放的,主要用于查询远程主机在线用户、操作系统类型以及是否缓冲区溢出等用户的详细信息。

  端口说明:79端口是为Finger服务开放的,主要用于查询远程主机在线用户、操作系统类型以及是否缓冲区溢出等用户的详细信息。比如要显示远程计算机www.abc.com上的user01用户的信息,可以在命令行中键入“finger user01@www.abc.com”即可。

  端口漏洞:一般黑客要攻击对方的计算机,都是通过相应的端口扫描工具来获得相关信息,比如使用流光就可以利用79端口来扫描远程计算机操作系统版本,获得用户信息,还能探测已知的缓冲区溢出错误。这样,就容易遭遇到黑客的攻击。而且,79端口还被Firehotcker木马作为默认的端口。

  操作建议:建议关闭该端口。

七,80端口:80端口是为HTTP(HyperText Transport Protocol,超文本传输协议)开放的,这是上网冲浪使用最多的协议,主要用于在WWW(World Wide Web,万维网)服务上传输信息的协议。

  端口说明:80端口是为HTTP(HyperText Transport Protocol,超文本传输协议)开放的,这是上网冲浪使用最多的协议,主要用于在WWW(World Wide Web,万维网)服务上传输信息的协议。我们可以通过HTTP地址加“:80”(即常说的网址”)来访问网站的,比如http://www.cce.com.cn:80,因为浏览网页服务默认的端口号是80,所以只要输入网址,不用输入“:80”

  端口漏洞:有些木马程序可以利用80端口来攻击计算机的,比如ExecutorRingZero等。

  操作建议:为了能正常上网冲浪,我们必须开启80端口。

八,99端口:99端口是用于一个名为“Metagram Relay”(亚对策延时)的服务,该服务比较少见,一般是用不到的。

  端口说明:99端口是用于一个名为“Metagram Relay”(亚对策延时)的服务,该服务比较少见,一般是用不到的。

  端口漏洞:虽然“Metagram Relay”服务不常用,可是Hidden PortNCx99等木马程序会利用该端口,比如在Windows 2000中,NCx99可以把cmd.exe程序绑定到99端口,这样用Telnet就可以连接到服务器,随意添加用户、更改权限。

  操作建议:建议关闭该端口。

九,109110端口:109端口是为POP2(Post Office Protocol Version 2,邮局协议2)服务开放的,110端口是为POP3(邮件协议3)服务开放的,POP2POP3都是主要用于接收邮件的。

  端口说明:109端口是为POP2(Post Office Protocol Version 2,邮局协议2)服务开放的,110端口是为POP3(邮件协议3)服务开放的,POP2POP3都是主要用于接收邮件的,目前POP3使用的比较多,许多服务器都同时支持POP2POP3。客户端可以使用POP3协议来访问服务端的邮件服务,如今ISP的绝大多数邮件服务器都是使用该协议。在使用电子邮件客户端程序的时候,会要求输入POP3服务器地址,默认情况下使用的就是110端口。

  端口漏洞:POP2POP3在提供邮件接收服务的同时,也出现了不少的漏洞。单单POP3服务在用户名和密码交换缓冲区溢出的漏洞就不少于20个,比如WebEasyMail POP3 Server合法用户名信息泄露漏洞,通过该漏洞远程攻击者可以验证用户账户的存在。另外,110端口也被ProMail trojan等木马程序所利用,通过110端口可以窃取POP账号用户名和密码。

  操作建议:如果是执行邮件服务器,可以打开该端口。

十,111端口:111端口是SUN公司的RPC(Remote Procedure Call,远程过程调用)服务所开放的端口,主要用于分布式系统中不同计算机的内部进程通信,RPC在多种网络服务中都是很重要的组件。

  端口说明:111端口是SUN公司的RPC(Remote Procedure Call,远程过程调用)服务所开放的端口,主要用于分布式系统中不同计算机的内部进程通信,RPC在多种网络服务中都是很重要的组件。常见的RPC服务有rpc.mountdNFSrpc.statdrpc.csmdrpc.ttybdamd等等。在MicrosoftWindows中,同样也有RPC服务。

  端口漏洞:SUN RPC有一个比较大漏洞,就是在多个RPC服务时xdr_array函数存在远程缓冲溢出漏洞,通过该漏洞允许攻击者传递超

十一,113端口:113端口主要用于Windows“Authentication Service”(验证服务)

  端口说明:113端口主要用于Windows“Authentication Service”(验证服务),一般与网络连接的计算机都运行该服务,主要用于验证TCP连接的用户,通过该服务可以获得连接计算机的信息。在Windows 2000/2003 Server中,还有专门的IAS组件,通过该组件可以方便远程访问中进行身份验证以及策略管理。

  端口漏洞:113端口虽然可以方便身份验证,但是也常常被作为FTPPOPSMTPIMAP以及IRC等网络服务的记录器,这样会被相应的木马程序所利用,比如基于IRC聊天室控制的木马。另外,113端口还是Invisible Identd DeamonKazimas等木马默认开放的端口。

  操作建议:建议关闭该端口。

十二,119端口:119端口是为“Network News Transfer Protocol”(网络新闻组传输协议,简称NNTP)开放的。

  端口说明:119端口是为“Network News Transfer Protocol”(网络新闻组传输协议,简称NNTP)开放的,主要用于新闻组的传输,当查找USENET服务器的时候会使用该端口。

  端口漏洞:著名的Happy99蠕虫病毒默认开放的就是119端口,如果中了该病毒会不断发送电子邮件进行传播,并造成网络的堵塞。

  操作建议:如果是经常使用USENET新闻组,就要注意不定期关闭该端口。 135端口:135端口主要用于使用RPC(Remote Procedure Call,远程过程调用)协议并提供DCOM(分布式组件对象模型)服务。

十三,135端口说明:135端口主要用于使用RPC(Remote Procedure Call,远程过程调用)协议并提供DCOM(分布式组件对象模型)服务,通过RPC可以保证在一台计算机上运行的程序可以顺利地执行远程计算机上的代码;使用DCOM可以通过网络直接进行通信,能够跨包括HTTP协议在内的多种网络传输。

  端口漏洞:相信去年很多Windows 2000Windows XP用户都中了冲击波病毒,该病毒就是利用RPC漏洞来攻击计算机的。RPC本身在处理通过TCP/IP的消息交换部分有一个漏洞,该漏洞是由于错误地处理格式不正确的消息造成的。该漏洞会影响到RPCDCOM之间的一个接口,该接口侦听的端口就是135

  操作建议:为了避免冲击波病毒的攻击,建议关闭该端口。

十四,137端口:137端口主要用于“NetBIOS Name Service”(NetBIOS名称服务)

  端口说明:137端口主要用于“NetBIOS Name Service”(NetBIOS名称服务),属于UDP端口,使用者只需要向局域网或互联网上的某台计算机的137端口发送一个请求,就可以获取该计算机的名称、注册用户名,以及是否安装主域控制器、IIS是否正在运行等信息。

  端口漏洞:因为是UDP端口,对于攻击者来说,通过发送请求很容易就获取目标计算机的相关信息,有些信息是直接可以被利用,并分析漏洞的,比如IIS服务。另外,通过捕获正在利用137端口进行通信的信息包,还可能得到目标计算机的启动和关闭的时间,这样就可以利用专门的工具来攻击。

  操作建议:建议关闭该端口。

十五,139端口:139端口是为“NetBIOS Session Service”提供的,主要用于提供Windows文件和打印机共享以及Unix中的Samba服务。

  端口说明:139端口是为“NetBIOS Session Service”提供的,主要用于提供Windows文件和打印机共享以及Unix中的Samba服务。在Windows中要在局域网中进行文件的共享,必须使用该服务。比如在Windows 98中,可以打开控制面板,双击网络图标,在配置选项卡中单击文件及打印共享按钮选中相应的设置就可以安装启用该服务;Windows 2000/XP中,可以打开控制面板,双击网络连接图标,打开本地连接属性;接着,在属性窗口的常规选项卡中选择“Internet协议(TCP/IP)”,单击属性按钮;然后在打开的窗口中,单击高级按钮;高级TCP/IP设置窗口中选择“WINS”选项卡,在“NetBIOS设置区域中启用TCP/IP上的NetBIOS

  端口漏洞:开启139端口虽然可以提供共享服务,但是常常被攻击者所利用进行攻击,比如使用流光、SuperScan等端口扫描工具,可以扫描目标计算机的139端口,如果发现有漏洞,可以试图获取用户名和密码,这是非常危险的。

  操作建议:如果不需要提供文件和打印机共享,建议关闭该端口。

十六,143端口:143端口主要是用于“Internet Message Access Protocol”v2(Internet消息访问协议,简称IMAP)

  端口说明:143端口主要是用于“Internet Message Access Protocol”v2(Internet消息访问协议,简称IMAP),和POP3一样,是用于电子邮件的接收的协议。通过IMAP协议我们可以在不接收邮件的情况下,知道信件的内容,方便管理服务器中的电子邮件。不过,相对于POP3协议要负责一些。如今,大部分主流的电子邮件客户端软件都支持该协议。

  端口漏洞:POP3协议的110端口一样,IMAP使用的143端口也存在缓冲区溢出漏洞,通过该漏洞可以获取用户名和密码。另外,还有一种名为“admv0rm”Linux蠕虫病毒会利用该端口进行繁殖。

  操作建议:如果不是使用IMAP服务器操作,应该将该端口关闭。

十七,161端口:161端口是用于“Simple Network Management Protocol”(简单网络管理协议,简称SNMP)

  端口说明:161端口是用于“Simple Network Management Protocol”(简单网络管理协议,简称SNMP),该协议主要用于管理TCP/IP网络中的网络协议,在Windows中通过SNMP服务可以提供关于TCP/IP网络上主机以及各种网络设备的状态信息。目前,几乎所有的网络设备厂商都实现对SNMP的支持。

  在Windows 2000/XP中要安装SNMP服务,我们首先可以打开“Windows组件向导,在组件中选择管理和监视工具,单击详细信息按钮就可以看到简单网络管理协议(SNMP)”,选中该组件;然后,单击下一步就可以进行安装。

  端口漏洞:因为通过SNMP可以获得网络中各种设备的状态信息,还能用于对网络设备的控制,所以黑客可以通过SNMP漏洞来完全控制网络。

  操作建议:建议关闭该端口443端口:443端口即网页浏览端口,主要是用于HTTPS服务,是提供加密和通过安全端口传输的另一种HTTP

十八,443端口说明:443端口即网页浏览端口,主要是用于HTTPS服务,是提供加密和通过安全端口传输的另一种HTTP。在一些对安全性要求较高的网站,比如银行、证券、购物等,都采用HTTPS服务,这样在这些网站上的交换信息其他人都无法看到,保证了交易的安全性。网页的地址以https://开始,而不是常见的http://

  端口漏洞:HTTPS服务一般是通过SSL(安全套接字层)来保证安全性的,但是SSL漏洞可能会受到黑客的攻击,比如可以黑掉在线银行系统,盗取信用卡账号等。

  操作建议:建议开启该端口,用于安全性网页的访问。另外,为了防止黑客的攻击,应该及时安装微软针对SSL漏洞发布的最新安全补丁。

十九,554端口:554端口默认情况下用于“Real Time Streaming Protocol”(实时流协议,简称RTSP)

  端口说明:554端口默认情况下用于“Real Time Streaming Protocol”(实时流协议,简称RTSP),该协议是由RealNetworksNetscape共同提出的,通过RTSP协议可以借助于Internet将流媒体文件传送到RealPlayer中播放,并能有效地、最大限度地利用有限的网络带宽,传输的流媒体文件一般是Real服务器发布的,包括有.rm.ram。如今,很多的下载软件都支持RTSP协议,比如FlashGet、影音传送带等等。

  端口漏洞:目前,RTSP协议所发现的漏洞主要就是RealNetworks早期发布的Helix Universal Server存在缓冲区溢出漏洞,相对来说,使用的554端口是安全的。

  操作建议:为了能欣赏并下载到RTSP协议的流媒体文件,建议开启554端口。

二十,1024端口:1024端口一般不固定分配给某个服务,在英文中的解释是“Reserved”(保留)

  端口说明:1024端口一般不固定分配给某个服务,在英文中的解释是“Reserved”(保留)。之前,我们曾经提到过动态端口的范围是从102465535,而1024正是动态端口的开始。该端口一般分配给第一个向系统发出申请的服务,在关闭服务的时候,就会释放1024端口,等待其他服务的调用。

  端口漏洞:著名的YAI木马病毒默认使用的就是1024端口,通过该木马可以远程控制目标计算机,获取计算机的屏幕图像、记录键盘事件、获取密码等,后果是比较严重的。

  操作建议:一般的杀毒软件都可以方便地进行YAI病毒的查杀,所以在确认无YAI病毒的情况下建议开启该端口。

  小帖士:在windows2000以上版本中,在命令提示符方式下用

  netstat -an

  命令可以查出自己电脑都打开什么端口了,对于有高端端口一定要注意,看看是不是中了别人的木马了,木马软件一般是自己从网上下载的或是从别人那里得来的文件运行后才种上的,所以我们在平常网上生活中一定要注意不要从不可靠的网站下载软件,或者接收别人给你的可执行文件,中了木马后可以手动删除或用一些外部软件来删除。

posted @ 2010-09-25 17:43 doublezxh 阅读(110) | 评论 (0)编辑 收藏
仅列出标题
共2页: 1 2