Advanced Programming in UNIX Environment Episode 31
exec FunctionsWhen a process calls one of the exec functions,that process is completely replaced by the new program,and the new program starts executing at its main function. The process ID does not change across an exec,because a new process is not created; exec merely replaces the current process — its text,data,heap,and stack segments — with a brand-new program from disk. There are seven different exec functions,but we’ll often simply refer to ‘‘the exec function,’’ which means that we could use any of the seven functions. These seven functions round out the UNIX System process control primitives. With fork,we can create new processes; and with the exec functions,we can initiate new programs. The exit function and the wait functions handle termination and waiting for termination. #include <unistd.h>
int execl(const char *pathname,const char *arg0,...);
int execv(const char *pathname,char *const argv[]);
int execle(const char *pathname,...
/* (char *)0,char *const envp[] */ );
int execve(const char *pathname,char *const argv[],char *const envp[]);
int execlp(const char *filename,... /* (char *)0 */ );
int execvp(const char *filename,char *const argv[]);
int fexecve(int fd,char *const envp[]);
The first difference in these functions is that the first four take a pathname argument,the next two take a filename argument,and the last one takes a file descriptor argument. When a filename argument is specified,
The PATH variable contains a list of directories,called path prefixes,that are separated by colons.
We’ve mentioned that the process ID does not change after an exec,but the new
POSIX.1 specifically requires that open directory streams (recall the opendir function from Section 4.22) be closed across an exec. This is normally done by the opendir function calling fcntl to set the close-on-exec flag for the descriptor corresponding to the open directory stream. In many UNIX system implementations,only one of these seven functions,execve,is a system call within the kernel. The other six are just library functions that eventually invoke this system call. The fexecve library function uses /proc to convert the file descriptor argument into a pathname that can be used by execve to execute the program.
#include "apue.h"
#include <sys/wait.h>
char *env_init[]={"USER=unknown","PATH=/tmp",NULL};
int main(void)
{
pid_t pid;
TELL_WAIT();
if((pid=fork())<0)
{
err_sys("fork error");
}
else if(pid==0)
{
if(execle("/home/sar/bin/echoall","echoall","myarg1","MY ARG2",(char*)0,env_init)<0)
err_sys("execle error");
}
if(waitpid(pid,NULL,0)<0)
err_sys("wait error");
if((pid==fork())<0)
{
err_sys("fork error");
}
else if(pid==0)
{
if(execlp("echoall","only 1 arg",(char *)0)<0)
err_sys("execlp error");
}
if(waitpid(pid,0)<0)
{
err_sys("wait error");
}
if((pid=fork())<0)
{
err_sys("fork_error");
}
else if(pid==0)
{
if(execlp("echoall",(char *)0)<0)
err_sys("execlp error");
}
return 0;
}
Example of exec functions #include "apue.h"
int main(int argc,char *argv[])
{
int i;
char **ptr;
extern char **environ;
for(i=0;i<argc;i++)
printf("argv[%d]: %dn",i,argv[i]);
for(ptr=environ;*ptr!=0;ptr++)
printf("%dn",*ptr);
return 0;
}
Echo all command-line arguments and all environment strings Changing User IDs and Group IDsIn the UNIX System,privileges,such as being able to change the system’s notion of the current date,and access control,such as being able to read or write a particular file,are based on user and group IDs. When our programs need additional privileges or need to gain access to resources that they currently aren’t allowed to access,they need to change their user or group ID to an ID that has the appropriate privilege or access. #include <unistd.h>
int setuid(uid_t uid);
int setgid(gid_t gid);
There are rules for who can change the IDs. Let’s consider only the user ID for now. (Everything we describe for the user ID also applies to the group ID.) 1.If the process has superuser privileges,the setuid function sets the real user ID,effective user ID,and saved set-user-ID to uid. Here,we are assuming that _POSIX_SAVED_IDS is true. If this feature isn’t provided,then delete all preceding references to the saved set-user-ID. We can make a few statements about the three user IDs that the kernel maintains. 1.Only a superuser process can change the real user ID. Normally,the real user ID is set by the login(1) program when we log in and never changes. Because login is a superuser process,it sets all three user IDs when it calls setuid.
#include <unistd.h>
int setreuid(uid_t ruid,uid_t euid);
int setregid(gid_t rgid,gid_t egid);
#include <unistd.h>
int seteuid(uid_t uid);
int setegid(gid_t gid);
An unprivileged user can set its effective user ID to either its real user ID or its saved set-user-ID. For a privileged user,only the effective user ID is set to uid. (This behavior differs from that of the setuid function,which changes all three user IDs.)
The following steps take place. 1.Assuming that the at program file is owned by root and has its set-user-ID bit real user ID = our user ID (unchanged)
effective user ID = root
saved set-user-ID = root
2.The first thing the at command does is reduce its privileges so that it runs with real user ID. After this,we have
real user ID = our user ID (unchanged)
effective user ID = our user ID
saved set-user-ID = root (unchanged)
3.The at program runs with our privileges until it needs to access the configuration files that control which commands are to be run and the time at which they need to run. These files are owned by the daemon that will run the commands for us. The at command calls seteuid to set the effective user ID to root. This call is allowed because the argument to seteuid equals the saved set-user-ID. (This is why we need the saved set-user-ID.) After this,we have real user ID = our user ID (unchanged)
effective user ID = root
saved set-user-ID = root (unchanged)
Because the effective user ID is root,file access is allowed. 4.After the files are modified to record the commands to be run and the time at which they are to be run,the at command lowers its privileges by calling seteuid to set its effective user ID to our user ID. This prevents any accidental misuse of privilege. At this point,we have real user ID = our user ID (unchanged)
effective user ID = our user ID
saved set-user-ID = root (unchanged)
5.The daemon starts out running with root privileges. To run commands on our real user ID = our user ID
effective user ID = our user ID
saved set-user-ID = our user ID
Now the daemon can safely execute commands on our behalf,because it can access only the files to which we normally have access. We have no additional permissions. （编辑：李大同） 【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容! |