《unix环境编程》很多有用函数整理-1

1. 超时时间，可以使用clock_gettime但并不是所有平台都支持，所以可以使用gettimeofday’’’

#include <sys/time.h>
#include <stdlib.h>

void
maketimeout(struct timespec *tsp, long minutes)
{
    
    
	struct timeval now;

	/* get the current time */
	gettimeofday(&now, NULL);
	tsp->tv_sec = now.tv_sec;
	tsp->tv_nsec = now.tv_usec * 1000; /* usec to nsec */
	/* add the offset to get timeout value */
	tsp->tv_sec += minutes * 60;
}
//对于clock_gettime方法
clock_gettime(CLOCK_REALTIME, &tout);
tmp = localtime(&tout.tv_sec);
strftime(buf, sizeof(buf), "%r", tmp);
printf("current time is %s\n", buf);
tout.tv_sec += 10;	/* 10 seconds from now */

2. 关于sleep实现，采用sigsuspend函数实现

#include "apue.h"

static void
sig_alrm(int signo)
{
    
    
	/* nothing to do, just returning wakes up sigsuspend() */
    printf("cauth alarm\n");
}

unsigned int
sleep3(unsigned int seconds)
{
    
    
	struct sigaction	newact, oldact;
	sigset_t			newmask, oldmask, suspmask;
	unsigned int		unslept;

	/* set our handler, save previous information */
	newact.sa_handler = sig_alrm;
	sigemptyset(&newact.sa_mask);
	newact.sa_flags = 0;
	sigaction(SIGALRM, &newact, &oldact);

	/* block SIGALRM and save current signal mask */
	sigemptyset(&newmask);
	sigaddset(&newmask, SIGALRM);
	sigprocmask(SIG_BLOCK, &newmask, &oldmask);

	alarm(seconds);
	suspmask = oldmask;

	/* make sure SIGALRM isn't blocked */
	sigdelset(&suspmask, SIGALRM);

	/* wait for any signal to be caught */
	sigsuspend(&suspmask);

	/* some signal has been caught, SIGALRM is now blocked */

	unslept = alarm(0);

	/* reset previous action */
	sigaction(SIGALRM, &oldact, NULL);

	/* reset signal mask, which unblocks SIGALRM */
	sigprocmask(SIG_SETMASK, &oldmask, NULL);
	return(unslept);
}

3. 关于system实现，关键是调用进程忽略SIGINT, SIGQUIT信号，同时阻塞SIGCHILD信号，原因：

SIGINT 作用终止前台进程组，ctrl+c
SIGQUIT 作用终止前台进程组，并产生core文件， ctrl + \
SIGCHILD 在一个进程终止或停止时，SIGCHILD信号被送给其父进程，按照系统默认，将忽略此信号，如果父进程希望被其子进程的这种改变，则应当捕捉此信号。
为什么要忽略是由于：当system创建的子进程结束，按理应由system自己处理，如果不选择忽略，那么调用的system的进程会认为是自己的一个进程结束了，并通过wait或waitpid获取子进程的返回状态。这阻碍了system获取子进程状态并将其作为返回;system执行时，如执行一个脚本，如果发送SIGINT信号，那么system子进程（shell）,shell运行的命令进程，本身进程都会收到SIGINT信号，但system执行的可能是交互式命令，SIGINT主要是想终止shell fork的命令进程，因此本身进程应当忽略此信号；SIGQUIT也是这个道理

#include	<sys/wait.h>
#include	<errno.h>
#include	<signal.h>
#include	<unistd.h>

int
system(const char *cmdstring)	/* with appropriate signal handling */
{
    
    
	pid_t				pid;
	int					status;
	struct sigaction	ignore, saveintr, savequit;
	sigset_t			chldmask, savemask;

	if (cmdstring == NULL)
		return(1);		/* always a command processor with UNIX */

	ignore.sa_handler = SIG_IGN;	/* ignore SIGINT and SIGQUIT */
	sigemptyset(&ignore.sa_mask);
	ignore.sa_flags = 0;
	if (sigaction(SIGINT, &ignore, &saveintr) < 0)
		return(-1);
	if (sigaction(SIGQUIT, &ignore, &savequit) < 0)
		return(-1);
	sigemptyset(&chldmask);			/* now block SIGCHLD */
	sigaddset(&chldmask, SIGCHLD);
	if (sigprocmask(SIG_BLOCK, &chldmask, &savemask) < 0)
		return(-1);

	if ((pid = fork()) < 0) {
    
    
		status = -1;	/* probably out of processes */
	} else if (pid == 0) {
    
    			/* child */
		/* restore previous signal actions & reset signal mask */
		sigaction(SIGINT, &saveintr, NULL);
		sigaction(SIGQUIT, &savequit, NULL);
		sigprocmask(SIG_SETMASK, &savemask, NULL);

		execl("/bin/sh", "sh", "-c", cmdstring, (char *)0);
		_exit(127);		/* exec error */
	} else {
    
    						/* parent */
		while (waitpid(pid, &status, 0) < 0)
			if (errno != EINTR) {
    
    
				status = -1; /* error other than EINTR from waitpid() */
				break;
			}
	}

	/* restore previous signal actions & reset signal mask */
	if (sigaction(SIGINT, &saveintr, NULL) < 0)
		return(-1);
	if (sigaction(SIGQUIT, &savequit, NULL) < 0)
		return(-1);
	if (sigprocmask(SIG_SETMASK, &savemask, NULL) < 0)
		return(-1);

	return(status);
}

4. err_sys打印错误退出逻辑

static void
err_doit(int errnoflag, int error, const char *fmt, va_list ap)
{
    
    
	char	buf[MAXLINE];

	vsnprintf(buf, MAXLINE-1, fmt, ap);
	if (errnoflag)
		snprintf(buf+strlen(buf), MAXLINE-strlen(buf)-1, ": %s",
		  strerror(error));
	strcat(buf, "\n");
	fflush(stdout);		/* in case stdout and stderr are the same */
	fputs(buf, stderr);
	fflush(NULL);		/* flushes all stdio output streams */
}
/*
 * Fatal error related to a system call.
 * Print a message and terminate.
 */
void
err_sys(const char *fmt, ...)
{
    
    
	va_list		ap;

	va_start(ap, fmt);
	err_doit(1, errno, fmt, ap);
	va_end(ap);
	exit(1);
}

5. 互斥量和条件变量的使用的使用

#include <pthread.h>

struct msg {
    
    
	struct msg *m_next;
	/* ... more stuff here ... */
};

struct msg *workq;

pthread_cond_t qready = PTHREAD_COND_INITIALIZER;

pthread_mutex_t qlock = PTHREAD_MUTEX_INITIALIZER;

void
process_msg(void)
{
    
    
	struct msg *mp;

	for (;;) {
    
    
		pthread_mutex_lock(&qlock);
		//一般都要加while， 担心因中断等异常返回；
		while (workq == NULL)
			pthread_cond_wait(&qready, &qlock);
		mp = workq;
		workq = mp->m_next;
		pthread_mutex_unlock(&qlock);
		/* now process the message mp */
	}
}

void
enqueue_msg(struct msg *mp)
{
    
    
	pthread_mutex_lock(&qlock);
	mp->m_next = workq;
	workq = mp;
	pthread_mutex_unlock(&qlock);
	pthread_cond_signal(&qready);
}

6. 以分离的方式创建线程

#include "apue.h"
#include <pthread.h>

int
makethread(void *(*fn)(void *), void *arg)
{
    
    
	int				err;
	pthread_t		tid;
	pthread_attr_t	attr;

	err = pthread_attr_init(&attr);
	if (err != 0)
		return(err);
	err = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
	if (err == 0)
		err = pthread_create(&tid, &attr, fn, arg);
	pthread_attr_destroy(&attr);
	return(err);
}

6. 后台单例程序运行，通过文件和记录锁进行设置

#include <syslog.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <sys/stat.h>

#define LOCKFILE "/var/run/daemon.pid"
#define LOCKMODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)

extern int lockfile(int);

int
already_running(void)
{
    
    
	int		fd;
	char	buf[16];

	fd = open(LOCKFILE, O_RDWR|O_CREAT, LOCKMODE);
	if (fd < 0) {
    
    
		syslog(LOG_ERR, "can't open %s: %s", LOCKFILE, strerror(errno));
		exit(1);
	}
	if (lockfile(fd) < 0) {
    
    
		if (errno == EACCES || errno == EAGAIN) {
    
    
			close(fd);
			return(1);
		}
		syslog(LOG_ERR, "can't lock %s: %s", LOCKFILE, strerror(errno));
		exit(1);
	}
	ftruncate(fd, 0);
	sprintf(buf, "%ld", (long)getpid());
	write(fd, buf, strlen(buf)+1);
	return(0);
}

7. 守护进程的特征：

首先要做的是调用umask将文件模式创建屏蔽字设置为一个已知值。
调用fork, 然后使父进程exit.(1.守护进程作为一条简单的shell命令启动的，那么父进程终止会让shell认为这条命令已经执行完毕；2.子进程继承了父进程的进程组ID值，获得了一个新的进程ID，这就保证了子进程不是一个进程的组长进程。）
调用setsid创建一个新的会话，然后setsid会执行3个步骤：1）成为新会话的首进程；2）成为一个新进程的组长进程；3）没有控制终端
将当前工作目录改为根目录。因为守护进程通常在系统再引导之前是已知存在，如果守护进程当前工作目录挂载在一个文件系统中，那么该系统就不能被卸载；也可以改为其他工作目录
关闭不再需要的文件描述符；通过使用open_max函数或者getrlimit函数来判断最高文件描述符；
某些守护进程打开/dev/null时期文件描述符0,1，2不会产生效果

#include "apue.h"
#include <syslog.h>
#include <fcntl.h>
#include <sys/resource.h>

void
daemonize(const char *cmd)
{
    
    
   int					i, fd0, fd1, fd2;
   pid_t				pid;
   struct rlimit		rl;
   struct sigaction	sa;

   /*
    * Clear file creation mask.
    */
   umask(0);

   /*
    * Get maximum number of file descriptors.
    */
   if (getrlimit(RLIMIT_NOFILE, &rl) < 0)
   	err_quit("%s: can't get file limit", cmd);

   /*
    * Become a session leader to lose controlling TTY.
    */
   if ((pid = fork()) < 0)
   	err_quit("%s: can't fork", cmd);
   else if (pid != 0) /* parent */
   	exit(0);
   setsid();

   /*
    * Ensure future opens won't allocate controlling TTYs.
    */
   sa.sa_handler = SIG_IGN;
   sigemptyset(&sa.sa_mask);
   sa.sa_flags = 0;
   if (sigaction(SIGHUP, &sa, NULL) < 0)
   	err_quit("%s: can't ignore SIGHUP", cmd);
   if ((pid = fork()) < 0)
   	err_quit("%s: can't fork", cmd);
   else if (pid != 0) /* parent */
   	exit(0);

   /*
    * Change the current working directory to the root so
    * we won't prevent file systems from being unmounted.
    */
   if (chdir("/") < 0)
   	err_quit("%s: can't change directory to /", cmd);

   /*
    * Close all open file descriptors.
    */
   if (rl.rlim_max == RLIM_INFINITY)
   	rl.rlim_max = 1024;
   for (i = 0; i < rl.rlim_max; i++)
   	close(i);

   /*
    * Attach file descriptors 0, 1, and 2 to /dev/null.
    */
   fd0 = open("/dev/null", O_RDWR);
   fd1 = dup(0);
   fd2 = dup(0);

   /*
    * Initialize the log file.
    */
   openlog(cmd, LOG_CONS, LOG_DAEMON);
   if (fd0 != 0 || fd1 != 1 || fd2 != 2) {
    
    
   	syslog(LOG_ERR, "unexpected file descriptors %d %d %d",
   	  fd0, fd1, fd2);
   	exit(1);
   }
}

8. 一个基本的后台模板

#include "apue.h"
#include <syslog.h>
#include <errno.h>

extern int lockfile(int);
extern int already_running(void);

void
reread(void)
{
    
    
	/* ... */
	syslog(LOG_INFO, "re read config file\n");
}

void
sigterm(int signo)
{
    
    
	syslog(LOG_INFO, "got SIGTERM; exiting");
	exit(0);
}

void
sighup(int signo)
{
    
    
	syslog(LOG_INFO, "Re-reading configuration file");
	reread();
}

int
main(int argc, char *argv[])
{
    
    
	char				*cmd;
	struct sigaction	sa;
	int 				i;

	if ((cmd = strrchr(argv[0], '/')) == NULL)
		cmd = argv[0];
	else
		cmd++;

	/*
	 * Become a daemon.
	 */
	daemonize(cmd);

	/*
	 * Make sure only one copy of the daemon is running.
	 */
	if (already_running()) {
    
    
		syslog(LOG_ERR, "daemon already running");
		exit(1);
	}

	/*
	 * Handle signals of interest.
	 */
	sa.sa_handler = sigterm;
	sigemptyset(&sa.sa_mask);
	sigaddset(&sa.sa_mask, SIGHUP);
	sa.sa_flags = 0;
	if (sigaction(SIGTERM, &sa, NULL) < 0) {
    
    
		syslog(LOG_ERR, "can't catch SIGTERM: %s", strerror(errno));
		exit(1);
	}
	sa.sa_handler = sighup;
	sigemptyset(&sa.sa_mask);
	sigaddset(&sa.sa_mask, SIGTERM);
	sa.sa_flags = 0;
	if (sigaction(SIGHUP, &sa, NULL) < 0) {
    
    
		syslog(LOG_ERR, "can't catch SIGHUP: %s", strerror(errno));
		exit(1);
	}

	/*
	 * Proceed with the rest of the daemon.
	 */
	for (i = 0; i < 10; ++i) {
    
    
		syslog(LOG_INFO, "sleep %d\n", i);
		sleep(20);
	}
	exit(0);
}

8. fnctl设置或清空文件描述的状态

#include "apue.h"
#include <fcntl.h>

void
set_fl(int fd, int flags) /* flags are file status flags to turn on */
{
    
    
	int		val;

	if ((val = fcntl(fd, F_GETFL, 0)) < 0)
		err_sys("fcntl F_GETFL error");

	val |= flags;		/* turn on flags */

	if (fcntl(fd, F_SETFL, val) < 0)
		err_sys("fcntl F_SETFL error");
}

#include "apue.h"
#include <fcntl.h>

void
clr_fl(int fd, int flags)
				/* flags are the file status flags to turn off */
{
    
    
	int		val;

	if ((val = fcntl(fd, F_GETFL, 0)) < 0)
		err_sys("fcntl F_GETFL error");

	val &= ~flags;		/* turn flags off */

	if (fcntl(fd, F_SETFL, val) < 0)
		err_sys("fcntl F_SETFL error");
}

9. 加锁或解锁一个文件区域的函数

int
lock_reg(int fd, int cmd, int type, off_t offset, int whence, off_t len)
{
    
    
	struct flock	lock;

	lock.l_type = type;		/* F_RDLCK, F_WRLCK, F_UNLCK */
	lock.l_start = offset;	/* byte offset, relative to l_whence */
	lock.l_whence = whence;	/* SEEK_SET, SEEK_CUR, SEEK_END */
	lock.l_len = len;		/* #bytes (0 means to EOF) */

	return(fcntl(fd, cmd, &lock));
}


#define	read_lock(fd, offset, whence, len) \
			lock_reg((fd), F_SETLK, F_RDLCK, (offset), (whence), (len))
#define	readw_lock(fd, offset, whence, len) \
			lock_reg((fd), F_SETLKW, F_RDLCK, (offset), (whence), (len))
#define	write_lock(fd, offset, whence, len) \
			lock_reg((fd), F_SETLK, F_WRLCK, (offset), (whence), (len))
#define	writew_lock(fd, offset, whence, len) \
			lock_reg((fd), F_SETLKW, F_WRLCK, (offset), (whence), (len))
#define	un_lock(fd, offset, whence, len) \
			lock_reg((fd), F_SETLK, F_UNLCK, (offset), (whence), (len))

10. 进程间通过SIGUSR1和SIGUSR2进行同步

#include "apue.h"

static volatile sig_atomic_t sigflag; /* set nonzero by sig handler */
static sigset_t newmask, oldmask, zeromask;

static void
sig_usr(int signo)	/* one signal handler for SIGUSR1 and SIGUSR2 */
{
    
    
	sigflag = 1;
}

void
TELL_WAIT(void)
{
    
    
	if (signal(SIGUSR1, sig_usr) == SIG_ERR)
		err_sys("signal(SIGUSR1) error");
	if (signal(SIGUSR2, sig_usr) == SIG_ERR)
		err_sys("signal(SIGUSR2) error");
	sigemptyset(&zeromask);
	sigemptyset(&newmask);
	sigaddset(&newmask, SIGUSR1);
	sigaddset(&newmask, SIGUSR2);

	/* Block SIGUSR1 and SIGUSR2, and save current signal mask */
	if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0)
		err_sys("SIG_BLOCK error");
}

void
TELL_PARENT(pid_t pid)
{
    
    
	kill(pid, SIGUSR2);		/* tell parent we're done */
}

void
WAIT_PARENT(void)
{
    
    
	while (sigflag == 0)
		sigsuspend(&zeromask);	/* and wait for parent */
	sigflag = 0;

	/* Reset signal mask to original value */
	if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)
		err_sys("SIG_SETMASK error");
}

void
TELL_CHILD(pid_t pid)
{
    
    
	kill(pid, SIGUSR1);			/* tell child we're done */
}

void
WAIT_CHILD(void)
{
    
    
	while (sigflag == 0)
		sigsuspend(&zeromask);	/* and wait for child */
	sigflag = 0;

	/* Reset signal mask to original value */
	if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)
		err_sys("SIG_SETMASK error");
}

《unix环境编程》很多有用函数整理-1

1. 超时时间， 可以使用clock_gettime但并不是所有平台都支持，所以可以使用gettimeofday’’’

2. 关于sleep实现，采用sigsuspend函数实现

3. 关于system实现，关键是调用进程忽略SIGINT, SIGQUIT信号，同时阻塞SIGCHILD信号， 原因：

4. err_sys打印错误退出逻辑

5. 互斥量和条件变量的使用的使用

6. 以分离的方式创建线程

6. 后台单例程序运行，通过文件和记录锁进行设置

7. 守护进程的特征：

8. 一个基本的后台模板

8. fnctl设置或清空文件描述的状态

9. 加锁或解锁一个文件区域的函数

10. 进程间通过SIGUSR1和SIGUSR2进行同步

猜你喜欢

1. 超时时间，可以使用clock_gettime但并不是所有平台都支持，所以可以使用gettimeofday’’’

3. 关于system实现，关键是调用进程忽略SIGINT, SIGQUIT信号，同时阻塞SIGCHILD信号，原因：