http://blog.csdn.net/clx1314/archive/2006/03/30/643829.aspx
linux操作系統下c語言編程入門
1)Linux程序設計入門--基礎知識
2)Linux程序設計入門--進程介紹
3)Linux程序設計入門--文件操作
4)Linux程序設計入門--時間概念
5)Linux程序設計入門--信號處理
6)Linux程序設計入門--消息管理
7)Linux程序設計入門--線程操作
8)Linux程序設計入門--網絡編程
9)Linux下C開發工具介紹
1)Linux程序設計入門--基礎知識
Linux下C語言編程基礎知識
前言:
這篇文章介紹在LINUX下進行C語言編程所需要的基礎知識.在這篇文章當中,我們將
會學到以下內容:
源程序編譯
Makefile的編寫
程序庫的鏈接
程序的調試
頭文件和系統求助
----------------------------------------------------------------------------
----
1.源程序的編譯
在Linux下面,如果要編譯一個C語言源程序,我們要使用GNU的gcc編譯器. 下面我們
以一個實例來說明如何使用gcc編譯器.
假設我們有下面一個非常簡單的源程序(hello.c):
int main(int argc,char **argv)
{
printf("Hello Linux/n");
}
要編譯這個程序,我們只要在命令行下執行:
gcc -o hello hello.c
gcc 編譯器就會爲我們生成一個hello的可執行文件.執行./hello就可以看到程序的輸出
結果了.命令行中 gcc表示我們是用gcc來編譯我們的源程序,-o 選項表示我們要求編譯
器給我們輸出的可執行文件名爲hello 而hello.c是我們的源程序文件.
gcc編譯器有許多選項,一般來說我們只要知道其中的幾個就夠了. -o選項我們已經知道
了,表示我們要求輸出的可執行文件名. -c選項表示我們只要求編譯器輸出目標代碼,而
不必要輸出可執行文件. -g選項表示我們要求編譯器在編譯的時候提供我們以後對程序
進行調試的信息.
知道了這三個選項,我們就可以編譯我們自己所寫的簡單的源程序了,如果你想要知道更
多的選項,可以查看gcc的幫助文檔,那裏有着許多對其它選項的詳細說明.
2.Makefile的編寫
假設我們有下面這樣的一個程序,源代碼如下:
/* main.c */
#include "mytool1.h"
#include "mytool2.h"
int main(int argc,char **argv)
{
mytool1_print("hello");
mytool2_print("hello");
}
/* mytool1.h */
#ifndef _MYTOOL_1_H
#define _MYTOOL_1_H
void mytool1_print(char *print_str);
#endif
/* mytool1.c */
#include "mytool1.h"
void mytool1_print(char *print_str)
{
printf("This is mytool1 print %s/n",print_str);
}
/* mytool2.h */
#ifndef _MYTOOL_2_H
#define _MYTOOL_2_H
void mytool2_print(char *print_str);
#endif
/* mytool2.c */
#include "mytool2.h"
void mytool2_print(char *print_str)
{
printf("This is mytool2 print %s/n",print_str);
}
當然由於這個程序是很短的我們可以這樣來編譯
gcc -c main.c
gcc -c mytool1.c
gcc -c mytool2.c
gcc -o main main.o mytool1.o mytool2.o
這樣的話我們也可以產生main程序,而且也不時很麻煩.但是如果我們考慮一下如果有一
天我們修改了其中的一個文件(比如說mytool1.c)那麼我們難道還要重新輸入上面的命令
?也許你會說,這個很容易解決啊,我寫一個SHELL腳本,讓她幫我去完成不就可以了.是的
對於這個程序來說,是可以起到作用的.但是當我們把事情想的更復雜一點,如果我們的程
序有幾百個源程序的時候,難道也要編譯器重新一個一個的去編譯?
爲此,聰明的程序員們想出了一個很好的工具來做這件事情,這就是make.我們只要執行以
下make,就可以把上面的問題解決掉.在我們執行make之前,我們要先編寫一個非常重要的
文件.--Makefile.對於上面的那個程序來說,可能的一個Makefile的文件是:
# 這是上面那個程序的Makefile文件
main:main.o mytool1.o mytool2.o
gcc -o main main.o mytool1.o mytool2.o
main.o:main.c mytool1.h mytool2.h
gcc -c main.c
mytool1.o:mytool1.c mytool1.h
gcc -c mytool1.c
mytool2.o:mytool2.c mytool2.h
gcc -c mytool2.c
有了這個Makefile文件,不過我們什麼時候修改了源程序當中的什麼文件,我們只要執行
make命令,我們的編譯器都只會去編譯和我們修改的文件有關的文件,其它的文件她連理
都不想去理的.
下面我們學習Makefile是如何編寫的.
在Makefile中也#開始的行都是註釋行.Makefile中最重要的是描述文件的依賴關係的說
明.一般的格式是:
target: components
TAB rule
第一行表示的是依賴關係.第二行是規則.
比如說我們上面的那個Makefile文件的第二行
main:main.o mytool1.o mytool2.o
表示我們的目標(target)main的依賴對象(components)是main.o mytool1.o mytool2.o
當倚賴的對象在目標修改後修改的話,就要去執行規則一行所指定的命令.就象我們的上
面那個Makefile第三行所說的一樣要執行 gcc -o main main.o mytool1.o mytool2.o
注意規則一行中的TAB表示那裏是一個TAB鍵
Makefile有三個非常有用的變量.分別是$@,$^,$<代表的意義分別是:
$@--目標文件,$^--所有的依賴文件,$<--第一個依賴文件.
如果我們使用上面三個變量,那麼我們可以簡化我們的Makefile文件爲:
# 這是簡化後的Makefile
main:main.o mytool1.o mytool2.o
gcc -o $@ $^
main.o:main.c mytool1.h mytool2.h
gcc -c $<
mytool1.o:mytool1.c mytool1.h
gcc -c $<
mytool2.o:mytool2.c mytool2.h
gcc -c $<
經過簡化後我們的Makefile是簡單了一點,不過人們有時候還想簡單一點.這裏我們學習
一個Makefile的缺省規則
..c.o:
gcc -c $<
這個規則表示所有的 .o文件都是依賴與相應的.c文件的.例如mytool.o依賴於mytool.c
這樣Makefile還可以變爲:
# 這是再一次簡化後的Makefile
main:main.o mytool1.o mytool2.o
gcc -o $@ $^
..c.o:
gcc -c $<
好了,我們的Makefile 也差不多了,如果想知道更多的關於Makefile規則可以查看相應的
文檔.
3.程序庫的鏈接
試着編譯下面這個程序
/* temp.c */
#include <math.h>
int main(int argc,char **argv)
{
double value;
printf("Value:%f/n",value);
}
這個程序相當簡單,但是當我們用 gcc -o temp temp.c 編譯時會出現下面所示的錯誤.
/tmp/cc33Kydu.o: In function `main':
/tmp/cc33Kydu.o(.text+0xe): undefined reference to `log'
collect2: ld returned 1 exit status
出現這個錯誤是因爲編譯器找不到log的具體實現.雖然我們包括了正確的頭文件,但是我
們在編譯的時候還是要連接確定的庫.在Linux下,爲了使用數學函數,我們必須和數學庫
連接,爲此我們要加入 -lm 選項. gcc -o temp temp.c -lm這樣才能夠正確的編譯.也許
有人要問,前面我們用printf函數的時候怎麼沒有連接庫呢?是這樣的,對於一些常用的函
數的實現,gcc編譯器會自動去連接一些常用庫,這樣我們就沒有必要自己去指定了. 有時
候我們在編譯程序的時候還要指定庫的路徑,這個時候我們要用到編譯器的 -L選項指定
路徑.比如說我們有一個庫在 /home/hoyt/mylib下,這樣我們編譯的時候還要加上 -L/h
ome/hoyt/mylib.對於一些標準庫來說,我們沒有必要指出路徑.只要它們在起缺省庫的路
徑下就可以了.系統的缺省庫的路徑/lib /usr/lib /usr/local/lib 在這三個路徑下面
的庫,我們可以不指定路徑.
還有一個問題,有時候我們使用了某個函數,但是我們不知道庫的名字,這個時候怎麼辦呢
?很抱歉,對於這個問題我也不知道答案,我只有一個傻辦法.首先,我到標準庫路徑下面去
找看看有沒有和我用的函數相關的庫,我就這樣找到了線程(thread)函數的庫文件(libp
thread.a). 當然,如果找不到,只有一個笨方法.比如我要找sin這個函數所在的庫. 就只
好用 nm -o /lib/*.so|grep sin>~/sin 命令,然後看~/sin文件,到那裏面去找了. 在s
in文件當中,我會找到這樣的一行libm-2.1.2.so:00009fa0 W sin 這樣我就知道了sin在
libm-2.1.2.so庫裏面,我用 -lm選項就可以了(去掉前面的lib和後面的版本標誌,就剩
下m了所以是 -lm). 如果你知道怎麼找,請趕快告訴我,我回非常感激的.謝謝!
4.程序的調試
我們編寫的程序不太可能一次性就會成功的,在我們的程序當中,會出現許許多多我
們想不到的錯誤,這個時候我們就要對我們的程序進行調試了.
最常用的調試軟件是gdb.如果你想在圖形界面下調試程序,那麼你現在可以選擇xxgdb.記
得要在編譯的時候加入 -g選項.關於gdb的使用可以看gdb的幫助文件.由於我沒有用過這
個軟件,所以我也不能夠說出如何使用. 不過我不喜歡用gdb.跟蹤一個程序是很煩的事情
,我一般用在程序當中輸出中間變量的值來調試程序的.當然你可以選擇自己的辦法,沒有
必要去學別人的.現在有了許多IDE環境,裏面已經自己帶了調試器了.你可以選擇幾個試
一試找出自己喜歡的一個用.
5.頭文件和系統求助
有時候我們只知道一個函數的大概形式,不記得確切的表達式,或者是不記得着函數
在那個頭文件進行了說明.這個時候我們可以求助系統.
比如說我們想知道fread這個函數的確切形式,我們只要執行 man fread 系統就會輸出着
函數的詳細解釋的.和這個函數所在的頭文件<stdio.h>說明了. 如果我們要write這個函
數的說明,當我們執行man write時,輸出的結果卻不是我們所需要的. 因爲我們要的是w
rite這個函數的說明,可是出來的卻是write這個命令的說明.爲了得到write的函數說明
我們要用 man 2 write. 2表示我們用的write這個函數是系統調用函數,還有一個我們常
用的是3表示函數是C的庫函數.
記住不管什麼時候,man都是我們的最好助手.
------------------------------------------------------------------------
好了,這一章就講這麼多了,有了這些知識我們就可以進入激動人心的Linux下的C程序探
險活動.
2)Linux程序設計入門--進程介紹
Linux下進程的創建
前言:
這篇文章是用來介紹在Linux下和進程相關的各個概念.我們將會學到:
進程的概念
進程的身份
進程的創建
守護進程的創建
----------------------------------------------------------------------------
----
1。進程的概念
Linux操作系統是面向多用戶的.在同一時間可以有許多用戶向操作系統發出各種命
令.那麼操作系統是怎麼實現多用戶的環境呢? 在現代的操作系統裏面,都有程序和進程
的概念.那麼什麼是程序,什麼是進程呢? 通俗的講程序是一個包含可以執行代碼的文件
,是一個靜態的文件.而進程是一個開始執行但是還沒有結束的程序的實例.就是可執行文
件的具體實現. 一個程序可能有許多進程,而每一個進程又可以有許多子進程.依次循環
下去,而產生子孫進程. 當程序被系統調用到內存以後,系統會給程序分配一定的資源(內
存,設備等等)然後進行一系列的複雜操作,使程序變成進程以供系統調用.在系統裏面只
有進程沒有程序,爲了區分各個不同的進程,系統給每一個進程分配了一個ID(就象我們的
身份證)以便識別. 爲了充分的利用資源,系統還對進程區分了不同的狀態.將進程分爲新
建,運行,阻塞,就緒和完成五個狀態. 新建表示進程正在被創建,運行是進程正在運行,阻
塞是進程正在等待某一個事件發生,就緒是表示系統正在等待CPU來執行命令,而完成表示
進程已經結束了系統正在回收資源. 關於進程五個狀態的詳細解說我們可以看《操作系
統》上面有詳細的解說。
2。進程的標誌
上面我們知道了進程都有一個ID,那麼我們怎麼得到進程的ID呢?系統調用getpid可
以得到進程的ID,而getppid可以得到父進程(創建調用該函數進程的進程)的ID.
#include <unistd>
pid_t getpid(void);
pid_t getppid(void);
進程是爲程序服務的,而程序是爲了用戶服務的.系統爲了找到進程的用戶名,還爲進程和
用戶建立聯繫.這個用戶稱爲進程的所有者.相應的每一個用戶也有一個用戶ID.通過系統
調用getuid可以得到進程的所有者的ID.由於進程要用到一些資源,而Linux對系統資源是
進行保護的,爲了獲取一定資源進程還有一個有效用戶ID.這個ID和系統的資源使用有關
,涉及到進程的權限. 通過系統調用geteuid我們可以得到進程的有效用戶ID. 和用戶ID
相對應進程還有一個組ID和有效組ID系統調用getgid和getegid可以分別得到組ID和有效
組ID
#include <unistd>
#include <sys/types.h>
uid_t getuid(void);
uid_t geteuid(void);
gid_t getgid(void);
git_t getegid(void);
有時候我們還會對用戶的其他信息感興趣(登錄名等等),這個時候我們可以調用getpwui
d來得到.
struct passwd {
char *pw_name; /* 登錄名稱 */
char *pw_passwd; /* 登錄口令 */
uid_t pw_uid; /* 用戶ID */
gid_t pw_gid; /* 用戶組ID */
char *pw_gecos; /* 用戶的真名 */
char *pw_dir; /* 用戶的目錄 */
char *pw_shell; /* 用戶的SHELL */
};
#include <pwd.h>
#include <sys/types.h>
struct passwd *getpwuid(uid_t uid);
下面我們學習一個實例來實踐一下上面我們所學習的幾個函數:
#include <unistd.h>
#include <pwd.h>
#include <sys/types.h>
#include <stdio.h>
int main(int argc,char **argv)
{
pid_t my_pid,parent_pid;
uid_t my_uid,my_euid;
gid_t my_gid,my_egid;
struct passwd *my_info;
my_pid=getpid();
parent_pid=getppid();
my_uid=getuid();
my_euid=geteuid();
my_gid=getgid();
my_egid=getegid();
my_info=getpwuid(my_uid);
printf("Process ID:%ld/n",my_pid);
printf("Parent ID:%ld/n",parent_pid);
printf("User ID:%ld/n",my_uid);
printf("Effective User ID:%ld/n",my_euid);
printf("Group ID:%ld/n",my_gid);
printf("Effective Group ID:%ld/n",my_egid):
if(my_info)
{
printf("My Login Name:%s/n" ,my_info->pw_name);
printf("My Password :%s/n" ,my_info->pw_passwd);
printf("My User ID :%ld/n",my_info->pw_uid);
printf("My Group ID :%ld/n",my_info->pw_gid);
printf("My Real Name:%s/n" ,my_info->pw_gecos);
printf("My Home Dir :%s/n", my_info->pw_dir);
printf("My Work Shell:%s/n", my_info->pw_shell);
}
}
3。進程的創建
創建一個進程的系統調用很簡單.我們只要調用fork函數就可以了.
#include <unistd.h>
pid_t fork();
當一個進程調用了fork以後,系統會創建一個子進程.這個子進程和父進程不同的地方只
有他的進程ID和父進程ID,其他的都是一樣.就象符進程克隆(clone)自己一樣.當然創建
兩個一模一樣的進程是沒有意義的.爲了區分父進程和子進程,我們必須跟蹤fork的返回
值. 當fork掉用失敗的時候(內存不足或者是用戶的最大進程數已到)fork返回-1,否則f
ork的返回值有重要的作用.對於父進程fork返回子進程的ID,而對於fork子進程返回0.我
們就是根據這個返回值來區分父子進程的. 父進程爲什麼要創建子進程呢?前面我們已經
說過了Linux是一個多用戶操作系統,在同一時間會有許多的用戶在爭奪系統的資源.有時
進程爲了早一點完成任務就創建子進程來爭奪資源. 一旦子進程被創建,父子進程一起從
fork處繼續執行,相互競爭系統的資源.有時候我們希望子進程繼續執行,而父進程阻塞直
到子進程完成任務.這個時候我們可以調用wait或者waitpid系統調用.
#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *stat_loc);
pid_t waitpid(pid_t pid,int *stat_loc,int options);
wait系統調用會使父進程阻塞直到一個子進程結束或者是父進程接受到了一個信號.如果
沒有父進程沒有子進程或者他的子進程已經結束了wait回立即返回.成功時(因一個子進
程結束)wait將返回子進程的ID,否則返回-1,並設置全局變量errno.stat_loc是子進程的
退出狀態.子進程調用exit,_exit 或者是return來設置這個值. 爲了得到這個值Linux定
義了幾個宏來測試這個返回值.
WIFEXITED:判斷子進程退出值是非0
WEXITSTATUS:判斷子進程的退出值(當子進程退出時非0).
WIFSIGNALED:子進程由於有沒有獲得的信號而退出.
WTERMSIG:子進程沒有獲得的信號號(在WIFSIGNALED爲真時纔有意義).
waitpid等待指定的子進程直到子進程返回.如果pid爲正值則等待指定的進程(pid).如果
爲0則等待任何一個組ID和調用者的組ID相同的進程.爲-1時等同於wait調用.小於-1時等
待任何一個組ID等於pid絕對值的進程. stat_loc和wait的意義一樣. options可以決定
父進程的狀態.可以取兩個值 WNOHANG:父進程立即返回當沒有子進程存在時. WUNTACHE
D:當子進程結束時waitpid返回,但是子進程的退出狀態不可得到.
父進程創建子進程後,子進程一般要執行不同的程序.爲了調用系統程序,我們可以使用系
統調用exec族調用.exec族調用有着5個函數.
#include <unistd.h>
int execl(const char *path,const char *arg,...);
int execlp(const char *file,const char *arg,...);
int execle(const char *path,const char *arg,...);
int execv(const char *path,char *const argv[]);
int execvp(const char *file,char *const argv[]):
exec族調用可以執行給定程序.關於exec族調用的詳細解說可以參考系統手冊(man exec
l). 下面我們來學習一個實例.注意編譯的時候要加 -lm以便連接數學函數庫.
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <errno.h>
#include <math.h>
void main(void)
{
pid_t child;
int status;
printf("This will demostrate how to get child status/n");
if((child=fork())==-1)
{
printf("Fork Error :%s/n",strerror(errno));
exit(1);
}
else if(child==0)
{
int i;
printf("I am the child:%ld/n",getpid());
for(i=0;i<1000000;i++) sin(i);
i=5;
printf("I exit with %d/n",i);
exit(i);
}
while(((child=wait(&status))==-1)&(errno==EINTR));
if(child==-1)
printf("Wait Error:%s/n",strerror(errno));
else if(!status)
printf("Child %ld terminated normally return status is zero/n",
child);
else if(WIFEXITED(status))
printf("Child %ld terminated normally return status is %d/n",
child,WEXITSTATUS(status));
else if(WIFSIGNALED(status))
printf("Child %ld terminated due to signal %d znot caught/n",
child,WTERMSIG(status));
}
strerror函數會返回一個指定的錯誤號的錯誤信息的字符串.
4。守護進程的創建
如果你在DOS時代編寫過程序,那麼你也許知道在DOS下爲了編寫一個常駐內存的程序
我們要編寫多少代碼了.相反如果在Linux下編寫一個"常駐內存"的程序卻是很容易的.我
們只要幾行代碼就可以做到. 實際上由於Linux是多任務操作系統,我們就是不編寫代碼
也可以把一個程序放到後臺去執行的.我們只要在命令後面加上&符號SHELL就會把我們的
程序放到後臺去運行的. 這裏我們"開發"一個後臺檢查郵件的程序.這個程序每個一個指
定的時間回去檢查我們的郵箱,如果發現我們有郵件了,會不斷的報警(通過機箱上的小喇
叭來發出聲音). 後面有這個函數的加強版本加強版本
後臺進程的創建思想: 首先父進程創建一個子進程.然後子進程殺死父進程(是不是很無
情?). 信號處理所有的工作由子進程來處理.
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
/* Linux 的默任個人的郵箱地址是 /var/spool/mail/用戶的登錄名 */
#define MAIL "/var/spool/mail/hoyt"
/* 睡眠10秒鐘 */
#define SLEEP_TIME 10
main(void)
{
pid_t child;
if((child=fork())==-1)
{
printf("Fork Error:%s/n",strerror(errno));
exit(1);
}
else if(child>0)
while(1);
if(kill(getppid(),SIGTERM)==-1)
{
printf("Kill Parent Error:%s/n",strerror(errno));
exit(1);
}
{
int mailfd;
while(1)
{
if((mailfd=open(MAIL,O_RDONLY))!=-1)
{
fprintf(stderr,"%s","7");
close(mailfd);
}
sleep(SLEEP_TIME);
}
}
}
你可以在默認的路徑下創建你的郵箱文件,然後測試一下這個程序.當然這個程序還有很
多地方要改善的.我們後面會對這個小程序改善的,再看我的改善之前你可以嘗試自己改
善一下.比如讓用戶指定郵相的路徑和睡眠時間等等.相信自己可以做到的.動手吧,勇敢
的探險者.
好了進程一節的內容我們就先學到這裏了.進程是一個非常重要的概念,許多的程序都會
用子進程.創建一個子進程是每一個程序員的基本要求!
3)Linux程序設計入門--文件操作
Linux下文件的操作
前言:
我們在這一節將要討論linux下文件操作的各個函數.
文件的創建和讀寫
文件的各個屬性
目錄文件的操作
管道文件
----------------------------------------------------------------------------
----
1。文件的創建和讀寫
我假設你已經知道了標準級的文件操作的各個函數(fopen,fread,fwrite等等).當然
如果你不清楚的話也不要着急.我們討論的系統級的文件操作實際上是爲標準級文件操作
服務的.
當我們需要打開一個文件進行讀寫操作的時候,我們可以使用系統調用函數open.使用完
成以後我們調用另外一個close函數進行關閉操作.
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
int open(const char *pathname,int flags);
int open(const char *pathname,int flags,mode_t mode);
int close(int fd);
open函數有兩個形式.其中pathname是我們要打開的文件名(包含路徑名稱,缺省是認爲在
當前路徑下面).flags可以去下面的一個值或者是幾個值的組合.
O_RDONLY:以只讀的方式打開文件.
O_WRONLY:以只寫的方式打開文件.
O_RDWR:以讀寫的方式打開文件.
O_APPEND:以追加的方式打開文件.
O_CREAT:創建一個文件.
O_EXEC:如果使用了O_CREAT而且文件已經存在,就會發生一個錯誤.
O_NOBLOCK:以非阻塞的方式打開一個文件.
O_TRUNC:如果文件已經存在,則刪除文件的內容.
前面三個標誌只能使用任意的一個.如果使用了O_CREATE標誌,那麼我們要使用open的第
二種形式.還要指定mode標誌,用來表示文件的訪問權限.mode可以是以下情況的組合.
-----------------------------------------------------------------
S_IRUSR 用戶可以讀 S_IWUSR 用戶可以寫
S_IXUSR 用戶可以執行 S_IRWXU 用戶可以讀寫執行
-----------------------------------------------------------------
S_IRGRP 組可以讀 S_IWGRP 組可以寫
S_IXGRP 組可以執行 S_IRWXG 組可以讀寫執行
-----------------------------------------------------------------
S_IROTH 其他人可以讀 S_IWOTH 其他人可以寫
S_IXOTH 其他人可以執行 S_IRWXO 其他人可以讀寫執行
-----------------------------------------------------------------
S_ISUID 設置用戶執行ID S_ISGID 設置組的執行ID
-----------------------------------------------------------------
我們也可以用數字來代表各個位的標誌.Linux總共用5個數字來表示文件的各種權限.
00000.第一位表示設置用戶ID.第二位表示設置組ID,第三位表示用戶自己的權限位,第四
位表示組的權限,最後一位表示其他人的權限.
每個數字可以取1(執行權限),2(寫權限),4(讀權限),0(什麼也沒有)或者是這幾個值的和
..
比如我們要創建一個用戶讀寫執行,組沒有權限,其他人讀執行的文件.設置用戶ID位那麼
我們可以使用的模式是--1(設置用戶ID)0(組沒有設置)7(1+2+4)0(沒有權限,使用缺省)
5(1+4)即10705:
open("temp",O_CREAT,10705);
如果我們打開文件成功,open會返回一個文件描述符.我們以後對文件的所有操作就可以
對這個文件描述符進行操作了.
當我們操作完成以後,我們要關閉文件了,只要調用close就可以了,其中fd是我們要關閉
的文件描述符.
文件打開了以後,我們就要對文件進行讀寫了.我們可以調用函數read和write進行文件的
讀寫.
#include <unistd.h>
ssize_t read(int fd, void *buffer,size_t count);
ssize_t write(int fd, const void *buffer,size_t count);
fd是我們要進行讀寫操作的文件描述符,buffer是我們要寫入文件內容或讀出文件內容的
內存地址.count是我們要讀寫的字節數.
對於普通的文件read從指定的文件(fd)中讀取count字節到buffer緩衝區中(記住我們必
須提供一個足夠大的緩衝區),同時返回count.
如果read讀到了文件的結尾或者被一個信號所中斷,返回值會小於count.如果是由信號中
斷引起返回,而且沒有返回數據,read會返回-1,且設置errno爲EINTR.當程序讀到了文件
結尾的時候,read會返回0.
write從buffer中寫count字節到文件fd中,成功時返回實際所寫的字節數.
下面我們學習一個實例,這個實例用來拷貝文件.
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>
#define BUFFER_SIZE 1024
int main(int argc,char **argv)
{
int from_fd,to_fd;
int bytes_read,bytes_write;
char buffer[BUFFER_SIZE];
char *ptr;
if(argc!=3)
{
fprintf(stderr,"Usage:%s fromfile tofile/n/a",argv[0]);
exit(1);
}
/* 打開源文件 */
if((from_fd=open(argv[1],O_RDONLY))==-1)
{
fprintf(stderr,"Open %s Error:%s/n",argv[1],strerror(errno));
exit(1);
}
/* 創建目的文件 */
if((to_fd=open(argv[2],O_WRONLY|O_CREAT,S_IRUSR|S_IWUSR))==-1)
{
fprintf(stderr,"Open %s Error:%s/n",argv[2],strerror(errno));
exit(1);
}
/* 以下代碼是一個經典的拷貝文件的代碼 */
while(bytes_read=read(from_fd,buffer,BUFFER_SIZE))
{
/* 一個致命的錯誤發生了 */
if((bytes_read==-1)&&(errno!=EINTR)) break;
else if(bytes_read>0)
{
ptr=buffer;
while(bytes_write=write(to_fd,ptr,bytes_read))
{
/* 一個致命錯誤發生了 */
if((bytes_write==-1)&&(errno!=EINTR))break;
/* 寫完了所有讀的字節 */
else if(bytes_write==bytes_read) break;
/* 只寫了一部分,繼續寫 */
else if(bytes_write>0)
{
ptr+=bytes_write;
bytes_read-=bytes_write;
}
}
/* 寫的時候發生的致命錯誤 */
if(bytes_write==-1)break;
}
}
close(from_fd);
close(to_fd);
exit(0);
}
2。文件的各個屬性
文件具有各種各樣的屬性,除了我們上面所知道的文件權限以外,文件還有創建時間
,大小等等屬性.
有時侯我們要判斷文件是否可以進行某種操作(讀,寫等等).這個時候我們可以使用acce
ss函數.
#include <unistd.h>
int access(const char *pathname,int mode);
pathname:是文件名稱,mode是我們要判斷的屬性.可以取以下值或者是他們的組合.
R_OK文件可以讀,W_OK文件可以寫,X_OK文件可以執行,F_OK文件存在.當我們測試成功時
,函數返回0,否則如果有一個條件不符時,返回-1.
如果我們要獲得文件的其他屬性,我們可以使用函數stat或者fstat.
#include <sys/stat.h>
#include <unistd.h>
int stat(const char *file_name,struct stat *buf);
int fstat(int filedes,struct stat *buf);
struct stat {
dev_t st_dev; /* 設備 */
ino_t st_ino; /* 節點 */
mode_t st_mode; /* 模式 */
nlink_t st_nlink; /* 硬連接 */
uid_t st_uid; /* 用戶ID */
gid_t st_gid; /* 組ID */
dev_t st_rdev; /* 設備類型 */
off_t st_off; /* 文件字節數 */
unsigned long st_blksize; /* 塊大小 */
unsigned long st_blocks; /* 塊數 */
time_t st_atime; /* 最後一次訪問時間 */
time_t st_mtime; /* 最後一次修改時間 */
time_t st_ctime; /* 最後一次改變時間(指屬性) */
};
stat用來判斷沒有打開的文件,而fstat用來判斷打開的文件.我們使用最多的屬性是st_
mode.通過着屬性我們可以判斷給定的文件是一個普通文件還是一個目錄,連接等等.可以
使用下面幾個宏來判斷.
S_ISLNK(st_mode):是否是一個連接.S_ISREG是否是一個常規文件.S_ISDIR是否是一個目
錄S_ISCHR是否是一個字符設備.S_ISBLK是否是一個塊設備S_ISFIFO是否 是一個FIFO文
件.S_ISSOCK是否是一個SOCKET文件. 我們會在下面說明如何使用這幾個宏的.
3。目錄文件的操作
在我們編寫程序的時候，有時候會要得到我們當前的工作路徑。C庫函數提供了get
cwd來解決這個問題。
#include <unistd.h>
char *getcwd(char *buffer,size_t size);
我們提供一個size大小的buffer,getcwd會把我們當前的路徑考到buffer中.如果buffer
太小,函數會返回-1和一個錯誤號.
Linux提供了大量的目錄操作函數,我們學習幾個比較簡單和常用的函數.
#include <dirent.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
int mkdir(const char *path,mode_t mode);
DIR *opendir(const char *path);
struct dirent *readdir(DIR *dir);
void rewinddir(DIR *dir);
off_t telldir(DIR *dir);
void seekdir(DIR *dir,off_t off);
int closedir(DIR *dir);
struct dirent {
long d_ino;
off_t d_off;
unsigned short d_reclen;
char d_name[NAME_MAX+1]; /* 文件名稱 */
mkdir很容易就是我們創建一個目錄,opendir打開一個目錄爲以後讀做準備.readdir讀一
個打開的目錄.rewinddir是用來重讀目錄的和我們學的rewind函數一樣.closedir是關閉
一個目錄.telldir和seekdir類似與ftee和fseek函數.
下面我們開發一個小程序,這個程序有一個參數.如果這個參數是一個文件名,我們輸出這
個文件的大小和最後修改的時間,如果是一個目錄我們輸出這個目錄下所有文件的大小和
修改時間.
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <time.h>
static int get_file_size_time(const char *filename)
{
struct stat statbuf;
if(stat(filename,&statbuf)==-1)
{
printf("Get stat on %s Error:%s/n",
filename,strerror(errno));
return(-1);
}
if(S_ISDIR(statbuf.st_mode))return(1);
if(S_ISREG(statbuf.st_mode))
printf("%s size:%ld bytes/tmodified at %s",
filename,statbuf.st_size,ctime(&statbuf.st_mtime));
return(0);
}
int main(int argc,char **argv)
{
DIR *dirp;
struct dirent *direntp;
int stats;
if(argc!=2)
{
printf("Usage:%s filename/n/a",argv[0]);
exit(1);
}
if(((stats=get_file_size_time(argv[1]))==0)||(stats==-1))exit(1);
if((dirp=opendir(argv[1]))==NULL)
{
printf("Open Directory %s Error:%s/n",
argv[1],strerror(errno));
exit(1);
}
while((direntp=readdir(dirp))!=NULL)
if(get_file_size_time(direntp-<d_name)==-1)break;
closedir(dirp);
exit(1);
}
4。管道文件
Linux提供了許多的過濾和重定向程序,比如more cat
等等.還提供了< > | <<等等重定向操作符.在這些過濾和重 定向程序當中,都用到了管
道這種特殊的文件.系統調用pipe可以創建一個管道.
#include<unistd.h>
int pipe(int fildes[2]);
pipe調用可以創建一個管道(通信緩衝區).當調用成功時,我們可以訪問文件描述符fild
es[0],fildes[1].其中fildes[0]是用來讀的文件描述符,而fildes[1]是用來寫的文件描
述符.
在實際使用中我們是通過創建一個子進程,然後一個進程寫,一個進程讀來使用的.
關於進程通信的詳細情況請查看進程通信
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>
#define BUFFER 255
int main(int argc,char **argv)
{
char buffer[BUFFER+1];
int fd[2];
if(argc!=2)
{
fprintf(stderr,"Usage:%s string/n/a",argv[0]);
exit(1);
}
if(pipe(fd)!=0)
{
fprintf(stderr,"Pipe Error:%s/n/a",strerror(errno));
exit(1);
}
if(fork()==0)
{
close(fd[0]);
printf("Child[%d] Write to pipe/n/a",getpid());
snprintf(buffer,BUFFER,"%s",argv[1]);
write(fd[1],buffer,strlen(buffer));
printf("Child[%d] Quit/n/a",getpid());
exit(0);
}
else
{
close(fd[1]);
printf("Parent[%d] Read from pipe/n/a",getpid());
memset(buffer,'',BUFFER+1);
read(fd[0],buffer,BUFFER);
printf("Parent[%d] Read:%s/n",getpid(),buffer);
exit(1);
}
}
爲了實現重定向操作,我們需要調用另外一個函數dup2.
#include <unistd.h>
int dup2(int oldfd,int newfd);
dup2將用oldfd文件描述符來代替newfd文件描述符,同時關閉newfd文件描述符.也就是說
,
所有向newfd操作都轉到oldfd上面.下面我們學習一個例子,這個例子將標準輸出重定向
到一個文件.
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#define BUFFER_SIZE 1024
int main(int argc,char **argv)
{
int fd;
char buffer[BUFFER_SIZE];
if(argc!=2)
{
fprintf(stderr,"Usage:%s outfilename/n/a",argv[0]);
exit(1);
}
if((fd=open(argv[1],O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR))==-1)
{
fprintf(stderr,"Open %s Error:%s/n/a",argv[1],strerror(errno));
exit(1);
}
if(dup2(fd,STDOUT_FILENO)==-1)
{
fprintf(stderr,"Redirect Standard Out Error:%s/n/a",strerror(errno));
exit(1);
}
fprintf(stderr,"Now,please input string");
fprintf(stderr,"(To quit use CTRL+D)/n");
while(1)
{
fgets(buffer,BUFFER_SIZE,stdin);
if(feof(stdin))break;
write(STDOUT_FILENO,buffer,strlen(buffer));
}
exit(0);
}
好了,文件一章我們就暫時先討論到這裏,學習好了文件的操作我們其實已經可以寫出一
些比較有用的程序了.我們可以編寫一個實現例如dir,mkdir,cp,mv等等常用的文件操作
命令了.
想不想自己寫幾個試一試呢?
4)程序設計入門--時間概念
前言:Linux下的時間概念
這一章我們學習Linux的時間表示和計算函數
時間的表示
時間的測量
計時器的使用
1。時間表示 在程序當中,我們經常要輸出系統當前的時間,比如我們使用date命令
的輸出結果.這個時候我們可以使用下面兩個函數
#include <time.h>
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 <sys/time.h>
int gettimeofday(struct timeval *tv,struct timezone *tz);
strut timeval {
long tv_sec; /* 秒數 */
long tv_usec; /* 微秒數 */
};
gettimeofday將時間保存在結構tv之中.tz一般我們使用NULL來代替.
#include <sys/time.h<
#include <stdio.h<
#include <math.h<
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 <sys/time.h>
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 <sys/time.h>
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#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 <sys/types.h>
#include <signal.h>
#include <unistd.h>
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 <unistd.h>
main()
{
unsigned int i;
alarm(1);
for(i=0;1;i++)
printf("I=%d",i);
}
SIGALRM的缺省操作是結束進程,所以程序在1秒之後結束,你可以看看你的最後I值爲多少
,來比較一下大家的系統性能差異(我的是2232).
2。信號操作 有時候我們希望進程正確的執行,而不想進程受到信號的影響,比如我
們希望上面那個程序在1秒鐘之後不結束.這個時候我們就要進行信號的操作了.
信號操作最常用的方法是信號屏蔽.信號屏蔽要用到下面的幾個函數.
#include <signal.h>
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 <signal.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
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<repeat_factor;i++)y=sin((double)i);
fprintf(stderr,"Blocked calculation is finished/n");
/* 取消阻塞 */
sigprocmask(SIG_UNBLOCK,&intmask,NULL);
fprintf(stderr,"SIGINT signal unblocked/n");
for(i=0;i<repeat_factor;i++)y=sin((double)i);
fprintf(stderr,"Unblocked calculation is finished/n");
}
exit(0);
}
程序在運行的時候我們要使用Ctrl+C來結束.如果我們在第一計算的時候發出SIGINT信號
,由於信號已經屏蔽了,所以程序沒有反映.只有到信號被取消阻塞的時候程序纔會結束.
注意我們只要發出一次SIGINT信號就可以了,因爲信號屏蔽只是將信號加入到信號阻塞
集合之中,並沒有丟棄這個信號.一旦信號屏蔽取消了,這個信號就會發生作用.
有時候我們希望對信號作出及時的反映的,比如當擁護按下Ctrl+C時,我們不想什麼事情
也不做,我們想告訴用戶你的這個操作不好,請不要重試,而不是什麼反映也沒有的. 這個
時候我們要用到sigaction函數.
#include <signal.h>
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 <signal.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#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 <unistd.h>
#include <signal.h>
int pause(void);
int sigsuspend(const sigset_t *sigmask);
pause函數很簡單,就是掛起進程直到一個信號發生了.而sigsuspend也是掛起進程只是在
調用的時候用sigmask取代當前的信號阻塞集合.
#include <sigsetjmp>
int sigsetjmp(sigjmp_buf env,int val);
void siglongjmp(sigjmp_buf env,int val);
還記得goto函數或者是setjmp和longjmp函數嗎.這兩個信號跳轉函數也可以實現程序的
跳轉讓我們可以從函數之中跳轉到我們需要的地方.
由於上面幾個函數,我們很少遇到,所以只是說明了一下,詳細情況請查看聯機幫助.
4。一個實例 還記得我們在守護進程創建的哪個程序嗎?守護進程在這裏我們把那個
程序加強一下. 下面這個程序會在也可以檢查用戶的郵件.不過提供了一個開關,如果用
戶不想程序提示有新的郵件到來,可以向程序發送SIGUSR2信號,如果想程序提供提示可以
發送SIGUSR1信號.
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <string.h>
#include <pwd.h>
#include <sys/types.h>
#include <sys/stat.h>
/* 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 arrived7/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 <semaphore.h>
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 <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
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 <stdio.h>
#include <unistd.h>
#include <limits.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#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<n;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!='')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 <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
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 <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/stat.h>
#include <sys/msg.h>
#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 <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/stat.h>
#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,'',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 <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
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 <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#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,'',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 <pthread.h>
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 <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include <dirent.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#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)
Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=643829