OCaml语言下的Unix系统编程入门

需积分: 10 147 浏览量更新于2024-07-22 收藏 857KB PDF 举报

"《基于OCaml的Unix系统编程》是一份由Xavier Leroy和Didier Rémy编写的教程，首次发布于2014年12月。这本教程旨在引导读者进入Unix系统编程的世界，特别关注进程间的通信。它的独特之处在于它使用了OCaml语言，这是一种与传统系统编程常用的C语言不同的编程范式。OCaml，作为ML语言的一个方言，为系统编程提供了新颖的视角，使得学习者可以探索不同于C语言的编程理念和技术。该教程的主要目标是教授如何利用OCaml进行高效的、模块化的系统级编程，包括但不限于文件操作、网络编程、进程间通信（IPC）以及操作系统接口。作者通过实例展示如何在OCaml中实现常见的系统功能，同时也深入讨论了语言特性如何影响系统的性能和安全性。书中涵盖了以下几个核心主题： 1. OCaml基础：介绍OCaml语言的语法、类型系统、函数式编程思想和异常处理，为后续的系统编程打下坚实的基础。 2. Unix系统接口：讲解如何在OCaml中操作文件系统、目录结构、以及使用标准输入/输出和错误处理。 3. 进程管理：探讨fork()、exec()、信号处理等进程控制机制，以及如何利用它们进行线程池和守护进程的设计。 4. 网络编程：涉及套接字编程，包括TCP/IP协议栈的使用，以及异步I/O模型的实现。 5. 并发与同步：讲解如何在OCaml中实现并发控制，如线程池、锁和条件变量，以及互斥和同步原语。 6. 高级主题：探讨模块化设计、元编程、以及OCaml在实际系统项目中的应用案例。由于本书翻译自法文版，并由多位译者和校对者协作完成，因此读者不仅能够获取到系统编程的知识，还能了解到多语言合作翻译的过程。课程最后还提供了法律条款链接，明确了版权和分享许可。《Unix系统编程 in OCaml》是一本独特且富有深度的学习资料，对于希望用现代语言探索系统编程领域的程序员，特别是对函数式编程感兴趣的读者来说，具有很高的价值。通过学习这本书，读者将有机会领略OCaml在系统编程中的优势，并掌握一种全新的编程思维方式。"

Files

val stat : string -> stats

val lstat : string -> stats

val fstat : file

descr -> stats

The system calls stat and lstat take a ﬁle name as an argument while fstat

takes a previously opened descriptor and returns information about the ﬁle it

points to. stat and lstat diﬀer on symbolic links : lstat returns information

about the symbolic link itself, while stat returns information about the ﬁle that

the link points to. The result of these three calls is a record of type stats whose

ﬁelds are described in table 1.

Identiﬁcation

A ﬁle is uniquely identiﬁed by the pair made of its device number (typically the

disk partition where it is located) st

dev and its inode number st

ino.

Owners

A ﬁle has one user owner st

uid and one group owner st

gid. All the users and

groups on the machine are usually described in the /etc/passwd and /etc/groups

ﬁles. We can look up them by name in a portable manner with the functions

getpwnam and getgrnam or by id with getpwuid and getgrgid.

val getpwnam : string -> passwd

entry

val getgrnam : string -> group

entry

val getpwuid : int -> passwd

entry

val getgrgid : int -> group

entry

The name of the user of a running process and all the groups to which it

belongs can be retrieved with the commands getlogin and getgroups.

val getlogin : unit -> string

val getgroups : unit -> int array

The call chown changes the owner (second argument) and the group (third

argument) of a ﬁle (ﬁrst argument). If we have a ﬁle descriptor, fchown can be

used instead. Only the super user can change this information arbitrarily.

val chown : string -> int -> int -> unit

val fchown : file

descr -> int -> int -> unit

Access rights

Access rights are encoded as bits in an integer, and the type file

perm is just

an abbreviation for the type int. They specify special bits and read, write and

execution rights for the user owner, the group owner and the other users as vector

of bits:

Special

z }| {

− − −

User

z }| {

− − −

Group

z }| {

− − −

Other

z }| {

− − −

| {z }

0oSUGO

where in each of the user, group and other ﬁelds, the order of bits indicates read

(r), write (w) and execute (x) rights. The permissions on a ﬁle are the union of

all these individual rights, as shown in table 2.

Files

Bit (octal) Notation ls -l Access right

0o100 --x------ executable by the user owner

0o200 -w------- writable by the user owner

0o400 r-------- readable by the user owner

0o10 -----x--- executable by members of the group owner

0o20 ----w---- writable by members of the group owner

0o40 ---r---- readable by members of the group owner

0o1 --------x executable by other users

0o2 -------w- writable by other users

0o4 ------r-- readable by other users

0o1000 --------t the bit t on the group (sticky bit)

0o2000 -----s--- the bit s on the group (set-gid)

0o4000 --s------ the bit s on the user (set-uid)

Table 2 — Permission bits

For ﬁles, the meaning of read, write and execute permissions is obvious. For

a directory, the execute permission means the right to enter it (to chdir to it)

and read permission the right to list its contents. Read permission on a directory

is however not needed to read its ﬁles or sub-directories (but we then need to

know their names).

The special bits do not have meaning unless the x bit is set (if present without

x set, they do not give additional rights). This is why their representation is

superimposed on the bit x and the letters S and T are used instead of s and t

whenever x is not set. The bit t allows sub-directories to inherit the permissions

of the parent directory. On a directory, the bit s allows the use of the directory’s

uid or gid rather than the user’s to create directories. For an executable ﬁle,

the bit s allows the changing at execution time of the user’s eﬀective identity or

group with the system calls setuid and setgid.

val setuid : int -> unit

val setgid : int -> unit

The process also preserves its original identities unless it has super user privi-

leges, in which case setuid and setgid change both its eﬀective and original user

and group identities. The original identity is preserved to allow the process to

subsequently recover it as its eﬀective identity without needing further privileges.

The system calls getuid and getgid return the original identities and geteuid

and getegid return the eﬀective identities.

val getuid : unit -> int

val geteuid : unit -> int

val getgid : unit -> int

val getegid : unit -> int

Operations on directories

A process also has a ﬁle creation mask encoded the same way ﬁle permissions

are. As its name suggests, the mask speciﬁes prohibitions (rights to remove):

during ﬁle creation a bit set to 1 in the mask is set to 0 in the permissions of the

created ﬁle. The mask can be consulted and changed with the system call umask:

val umask : int -> int

Like many system calls that modify system variables, the modifying function

returns the old value of the variable. Thus, to just look up the value we need

to call the function twice. Once with an arbitrary value to get the mask and a

second time to put it back. For example:

let m = umask 0 in ignore (umask m); m

File access permissions can be modiﬁed with the system calls chmod and

fchmod:

val chmod : string -> file

perm -> unit

val fchmod : file

descr -> file

perm -> unit

and they can be tested “dynamically” with the system call access:

type access

permission = R

OK | W

OK | X

OK | F

val access : string -> access

permission list -> unit

where requested access rights to the ﬁle are speciﬁed by a list of values of type

access

permission whose meaning is obvious except for F

OK which just checks

for the ﬁle’s existence (without checking for the other rights). The function raises

an error if the access rights are not granted.

Note that the information inferred by access may be more restrictive than

the information returned by lstat because a ﬁle system may be mounted with

restricted rights — for example in read-only mode. In that case access will deny

a write permission on a ﬁle whose meta-attributes would allow it. This is why

we distinguish between “dynamic” (what a process can actually do) and “static”

(what the ﬁle system speciﬁes) information.

2.4 Operations on directories

Only the kernel can write in directories (when ﬁles are created). Thus opening a

directory in write mode is prohibited. In certain versions of Unix a directory may

be opened in read only mode and read with read, but other versions prohibit it.

However, even if this is possible, it is preferable not to do so because the format of

directory entries vary between Unix versions and is often complex. The following

functions allow reading a directory sequentially in a portable manner:

val opendir : string -> dir

handle

val readdir : dir

handle -> string

val rewinddir : dir

handle -> unit

val closedir : dir

handle -> unit

The system call opendir returns a directory descriptor for a directory. readdir

reads the next entry of a descriptor, and returns a ﬁle name relative to the di-

rectory or raises the exception End

file if the end of the directory is reached.

rewinddir repositions the descriptor at the beginning of the directory and closedir

closes the directory descriptor.

Files

Example The following library function, in Misc, iterates a function f over the

entries of the directory dirname.

let iter

dir f dirname =

let d = opendir dirname in

try while true do f (readdir d) done

with End

file -> closedir d

* * *

To create a directory or remove an empty directory, we have mkdir and rmdir:

val mkdir : string -> file

perm -> unit

val rmdir : string -> unit

The second argument of mkdir determines the access rights of the new directory.

Note that we can only remove a directory that is already empty. To remove

a directory and its contents, it is thus necessary to ﬁrst recursively empty the

contents of the directory and then remove the directory.

2.5 Complete example: search in a ﬁle hierarchy

The Unix command find lists the ﬁles of a hierarchy matching certain criteria

(ﬁle name, type and permissions etc.). In this section we develop a library

function Findlib.find which implements these searches and a command find

that provides a version of the Unix command find that supports the options

-follow and -maxdepth.

We specify the following interface for Findlib.find:

val find :

(Unix.error

string

string -> unit) ->

(string -> Unix.stats -> bool) -> bool -> int -> string list ->

unit

The function call

find handler action follow depth roots

traverses the ﬁle hierarchy starting from the roots speciﬁed in the list roots

(absolute or relative to the current directory of the process when the call is

made) up to a maximum depth depth and following symbolic links if the ﬂag

follow is set. The paths found under the root r include r as a preﬁx. Each

found path p is given to the function action along with the data returned by

Unix.lstat p (or Unix.stat p if follow is true). The function action returns

a boolean indicating, for directories, whether the search should continue for its

contents (true) or not (false).

The handler function reports traversal errors of type Unix

error. Whenever

an error occurs the arguments of the exception are given to the handler function

and the traversal continues. However when an exception is raised by the func-

tions action or handler themselves, we immediately stop the traversal and let it

propagate to the caller. To propagate an Unix

error exception without catching

it like a traversal error, we wrap these exceptions in the Hidden exception (see

hide

exn and reveal

exn).

剩余142页未读，继续阅读

zxgngl

粉丝: 0
资源: 3

OCaml语言下的Unix系统编程入门

UNIX Systems Programming

UNIX系统编程 中文版 pdf

用OCaml开发的国际象棋程序

parallel-programming-in-multicore-ocaml:使用domainslib进行多核OCaml并行编程的教程

OCaml Game System-开源

ocaml

OCaml

Caml和OCaml（目标Caml）编程Caml and OCaml (Objective Caml) Programming

真实世界的OCaml：面向大众的函数式编程Real World OCaml: Functional Programming for the Masses

OCaml功能

最新资源

UNIX系统编程中文版 pdf