С linux system function

Если string равно NULL , то system() возвращает ненулевой результат при условии, что есть доступ к оболочке shell, и ноль, если доступа нет.

system() не отражается на дочерних процессах.

СООТВЕТСТВИЕ СТАНДАРТАМ

ЗАМЕЧАНИЯ

Крайне неудобно, что system() игнорирует SIGINT и SIGQUIT. Это может привести к тому что программы вызывающие ее из цикла станут неприрываемыми, пока сами не проверят условия выхода для своих дочерних процессов. Например,

Не используйте system() в программах с привилегиями suid или sgid, потому что некоторые значения переменных окружения могут вызвать сбои в системе. Вместо нее рекомендуется использование семейства функций exec (3), но не execlp (3) или execvp (3). system() неправильно функционирует в программах с привилегиями suid или sgid тех систем, где /bin/sh заменено на bash версии 2, так как bash 2 обнуляет права при запуске. Debian использует измененный bash, который не производит при запуске этого действия так, как это делает sh .

Проверка доступности /bin/sh не производится, так как всегда подразумевается, что доступ к нему есть. ISO C описывает процесс проверки, а POSIX.2 говорит, что возвращаемое значение никогда не равно нулю, так как shell всегда считается установленным.

Существует возможность, что команда оболочки возвратит значение 127, но это неявное доказательство неуспешного вызова execve() ; проверьте errno для того, чтобы в этом удостовериться.

Источник

3.2.1. Функция system()

Функция system() определена в стандартной библиотеке языка С и позволяет вызывать из программы системную команду, как если бы она была набрана в командной строке. По сути, эта функция запускает стандартный интерпретатор Bourne shell (/bin/sh) и передает ему команду на выполнение. Например, программа, представленная в листинге 3.2, вызывает команду ls -l /, отображающую содержимое корневого каталога.

Листинг 3.2. (system.c) Использование функции system()

return_value = system(«ls -l /»);

Функция system() возвращает код завершения указанной команды. Если интерпретатор не может быть запущен, возвращается значение 127, а в случае возникновения других ошибок — -1.

Поскольку функция system() запускает интерпретатор команд, она подвержена всем тем ограничениям безопасности, что и системный интерпретатор. Рассчитывать на наличие какой-то конкретной версии Bourne shell не приходится. В большинстве UNIX-систем программа /bin/sh представляет собой символическую ссылку на другой интерпретатор. В Linux — это bash (Bourne-Again SHell), причем в разных дистрибутивах присутствуют разные его версии. Вызов из функции system() программы с привилегиями пользователя root также может иметь неодинаковые последствия в разных системах. Таким образом, лучше создавать процессы с помощью функций fork() и exec().

Функция system()

Не работает функция system
Добрый день, я столкнулся с проблемой функции system() на C++ под Linux ОС. Эта функция.

функция system в c++
Такой вопрос, а могу ли я в качестве аргумента функции передать переменную? Например: string a.

Функция system
Здравствуйте! Такой вот вопрос: есть функция system, которая может команды cmd выполнять, но при.

функция system()
Собственно, есть такая стандартная функция system(), она определена в stdlib.h и её прототип int.

Спасибо. clear работает!

Добавлено через 1 час 18 минут
Работало нормально но что то внезапно начало писать что system не описана нигде, std подключене полностью, даже если написать std::system(«clear»); ошибка остается.

Помощь в написании контрольных, курсовых и дипломных работ здесь.

Функция system() стопорит программу
в общем есть вот такая программа #include #include using namespace std; .

Как получить то, что выводит функция system
Всем привет! Я тут сидел и думал , аж голову сломал , можно ли как то получить то, что выводит.

Получить вывод команды оболочки — функция, обратная system()
Доброго времени суток, товарищи! Расскажите, пожалуйста, существует ли в С++ функция, обратная.

Какое значение вернет функция system, если задана неверная команда
Подскажите какое значение вернет функция system, если задана неверная команда, например открытие.

Функция system(«start «) для ячейки массива
int main_Братья по С++ Я старпер новичек, вот занимаюсь немножко. Никак не могу запустить.

Источник

Exec System Call in C

In this article, I am going talk about the exec family of functions and show you how to use each one of these exec family function in C. So, let’s get started.

C System Functions in Exec Family:

The exec function families are defined in the header unistd.h. So, you must use this header on the C program where you want to use these functions.

The available exec functions along with their function parameters are given below:

int execl(const char *path, const char *arg, …, NULL);
int execlp(const char *file, const char *arg, …, NULL );
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execle(const char *path, const char *arg, …, NULL, char * const envp[] );
int execve(const char *file, char *const argv[], char *const envp[]);

Let’s see what each of these functions do and how to use them.

execl() System Function:

In execl() system function takes the path of the executable binary file (i.e. /bin/ls) as the first and second argument. Then, the arguments (i.e. -lh, /home) that you want to pass to the executable followed by NULL. Then execl() system function runs the command and prints the output. If any error occurs, then execl() returns -1. Otherwise, it returns nothing.

Syntax:

An example of the execl() system function is given below:

int main ( void ) <
char * binaryPath = «/bin/ls» ;
char * arg1 = «-lh» ;
char * arg2 = «/home» ;

execl ( binaryPath , binaryPath , arg1 , arg2 , NULL ) ;

I ran the ls -lh /home command using execl() system function. As you can see, the correct result is displayed.

execlp() System Function:

execl() does not use the PATH environment variable. So, the full path of the executable file is required to run it with execl(). execlp() uses the PATH environment variable. So, if an executable file or command is available in the PATH, then the command or the filename is enough to run it, the full path is not needed.

Syntax:

We can rewrite the execl() example using the execlp() system function as follows:

int main ( void ) <
char * programName = «ls» ;
char * arg1 = «-lh» ;
char * arg2 = «/home» ;

execlp ( programName , programName , arg1 , arg2 , NULL ) ;

I only passed the command name ls, not the full path /bin/ls. As you can see, I got the same output as before.

execv() System Function:

In execl() function, the parameters of the executable file is passed to the function as different arguments. With execv(), you can pass all the parameters in a NULL terminated array argv. The first element of the array should be the path of the executable file. Otherwise, execv() function works just as execl() function.

Syntax:

We can rewrite the execl() example as follows:

int main ( void ) <
char * binaryPath = «/bin/ls» ;
char * args [ ] = < binaryPath , "-lh" , "/home" , NULL >;

execv ( binaryPath , args ) ;

As you can see, I am getting the correct output.

execvp() System Function:

Works the same way as execv() system function. But, the PATH environment variable is used. So, the full path of the executable file is not required just as in execlp().

Syntax:

We can rewrite the execv() example as follows:

int main ( void ) <
char * programName = «ls» ;
char * args [ ] = < programName , "-lh" , "/home" , NULL >;

execvp ( programName , args ) ;

As you can see, the correct output is displayed.

execle() System Function:

Works just like execl() but you can provide your own environment variables along with it. The environment variables are passed as an array envp. The last element of the envp array should be NULL. All the other elements contain the key-value pairs as string.

Syntax:

An example of the execle() system function is given below:

int main ( void ) <
char * binaryPath = «/bin/bash» ;
char * arg1 = «-c» ;
char * arg2 = «echo » Visit $HOSTNAME : $PORT from your browser. «» ;
char * const env [ ] = < "HOSTNAME=www.linuxhint.com" , "PORT=8080" , NULL >;

execle ( binaryPath , binaryPath , arg1 , arg2 , NULL , env ) ;

I passed two environment variables HOSTNAME and PORT to the execle() function. As you can see, I can access them from the executable /bin/bash.

execve() System Function:

Just like execle() you can provide your own environment variables along with execve(). You can also pass arguments as arrays as you did in execv().

Syntax:

The execle() example can be rewritten as follows:

execve ( binaryPath , args , env ) ;

As you can see, we get the same output as in the execle() example.

So, that’s how you use the exec function family in C for system programming in Linux. Thanks for reading this article.

Источник

Linux System Call Tutorial with C

In this article, we’re going to use actual system calls to do real work in our C program. First, we’ll review if you need to use a system call, then provide an example using the sendfile() call that can dramatically improve file copy performance. Finally, we’ll go over some points to remember while using Linux system calls.

Do You Need a System Call?

While it’s inevitable you’ll use a system call at some point in your C development career, unless you are targeting high performance or a particular type functionality, the glibc library and other basic libraries included in major Linux distributions will take care of the majority of your needs.

The glibc standard library provides a cross-platform, well-tested framework to execute functions that would otherwise require system-specific system calls. For example, you can read a file with fscanf(), fread(), getc(), etc., or you can use the read() Linux system call. The glibc functions provide more features (i.e. better error handling, formatted IO, etc.) and will work on any system glibc supports.

On the other hand, there are times where uncompromising performance and exact execution are critical. The wrapper that fread() provides is going to add overhead, and although minor, isn’t entirely transparent. Additionally, you may not want or need the extra features the wrapper provides. In that case, you’re best served with a system call.

You can also use system calls to perform functions not yet supported by glibc. If your copy of glibc is up to date, this will hardly be an issue, but developing on older distributions with newer kernels might require this technique.

Now that you’ve read the disclaimers, warnings, and potential detours, now let’s dig into some practical examples.

What CPU Are We On?

A question that most programs probably don’t think to ask, but a valid one nonetheless. This is an example of a system call that cannot be duplicated with glibc and isn’t covered with a glibc wrapper. In this code, we’ll call the getcpu() call directly via the syscall() function. The syscall function works as follows:

The first argument, SYS_call, is a definition that represents the number of the system call. When you include sys/syscall.h, these are included. The first part is SYS_ and the second part is the name of the system call.

Arguments for the call go into arg1, arg2 above. Some calls require more arguments, and they’ll continue in order from their man page. Remember that most arguments, especially for returns, will require pointers to char arrays or memory allocated via the malloc function.

example1.c

#include
#include
#include
#include

unsigned cpu , node ;

// Get current CPU core and NUMA node via system call
// Note this has no glibc wrapper so we must call it directly
syscall ( SYS_getcpu , & cpu , & node , NULL ) ;

// Display information
printf ( «This program is running on CPU core %u and NUMA node %u. \n \n » , cpu , node ) ;

To compile and run :

gcc example1. c — o example1
. / example1

For more interesting results, you could spin threads via the pthreads library and then call this function to see on which processor your thread is running.

Sendfile: Superior Performance

Sendfile provides an excellent example of enhancing performance through system calls. The sendfile() function copies data from one file descriptor to another. Rather than using multiple fread() and fwrite() functions, sendfile performs the transfer in kernel space, reducing overhead and thereby increasing performance.

In this example, we’re going to copy 64 MB of data from one file to another. In one test, we’re going to use the standard read/write methods in the standard library. In the other, we’ll use system calls and the sendfile() call to blast this data from one location to another.

test1.c (glibc)

#include
#include
#include
#include

#define BUFFER_SIZE 67108864
#define BUFFER_1 «buffer1»
#define BUFFER_2 «buffer2»

FILE * fOut , * fIn ;

printf ( » \n I/O test with traditional glibc functions. \n \n » ) ;

// Grab a BUFFER_SIZE buffer.
// The buffer will have random data in it but we don’t care about that.
printf ( «Allocating 64 MB buffer: » ) ;
char * buffer = ( char * ) malloc ( BUFFER_SIZE ) ;
printf ( «DONE \n » ) ;

// Write the buffer to fOut
printf ( «Writing data to first buffer: » ) ;
fOut = fopen ( BUFFER_1 , «wb» ) ;
fwrite ( buffer , sizeof ( char ) , BUFFER_SIZE , fOut ) ;
fclose ( fOut ) ;
printf ( «DONE \n » ) ;

printf ( «Copying data from first file to second: » ) ;
fIn = fopen ( BUFFER_1 , «rb» ) ;
fOut = fopen ( BUFFER_2 , «wb» ) ;
fread ( buffer , sizeof ( char ) , BUFFER_SIZE , fIn ) ;
fwrite ( buffer , sizeof ( char ) , BUFFER_SIZE , fOut ) ;
fclose ( fIn ) ;
fclose ( fOut ) ;
printf ( «DONE \n » ) ;

printf ( «Freeing buffer: » ) ;
free ( buffer ) ;
printf ( «DONE \n » ) ;

printf ( «Deleting files: » ) ;
remove ( BUFFER_1 ) ;
remove ( BUFFER_2 ) ;
printf ( «DONE \n » ) ;

test2.c (system calls)

#include
#include
#include
#include
#include
#include
#include
#include
#include

#define BUFFER_SIZE 67108864

printf ( » \n I/O test with sendfile() and related system calls. \n \n » ) ;

// Write the buffer to fOut
printf ( «Writing data to first buffer: » ) ;
fOut = open ( «buffer1» , O_RDONLY ) ;
write ( fOut , & buffer , BUFFER_SIZE ) ;
close ( fOut ) ;
printf ( «DONE \n » ) ;

printf ( «Copying data from first file to second: » ) ;
fIn = open ( «buffer1» , O_RDONLY ) ;
fOut = open ( «buffer2» , O_RDONLY ) ;
sendfile ( fOut , fIn , 0 , BUFFER_SIZE ) ;
close ( fIn ) ;
close ( fOut ) ;
printf ( «DONE \n » ) ;

printf ( «Freeing buffer: » ) ;
free ( buffer ) ;
printf ( «DONE \n » ) ;

printf ( «Deleting files: » ) ;
unlink ( «buffer1» ) ;
unlink ( «buffer2» ) ;
printf ( «DONE \n » ) ;

Compiling and Running Tests 1 & 2

To build these examples, you will need the development tools installed on your distribution. On Debian and Ubuntu, you can install this with:

Then compile with:

To run both and test the performance, run:

You should get results like this:

I/O test with traditional glibc functions.

As you can see, the code that uses the system calls runs much faster than the glibc equivalent.

Things to Remember

System calls can increase performance and provide additional functionality, but they are not without their disadvantages. You’ll have to weigh the benefits system calls provide against the lack of platform portability and sometimes reduced functionality compared to library functions.

When using some system calls, you must take care to use resources returned from system calls rather than library functions. For example, the FILE structure used for glibc’s fopen(), fread(), fwrite(), and fclose() functions are not the same as the file descriptor number from the open() system call (returned as an integer). Mixing these can lead to issues.

In general, Linux system calls have fewer bumper lanes than glibc functions. While it’s true that system calls have some error handling and reporting, you’ll get more detailed functionality from a glibc function.

And finally, a word on security. System calls directly interface with the kernel. The Linux kernel does have extensive protections against shenanigans from user land, but undiscovered bugs exist. Don’t trust that a system call will validate your input or isolate you from security issues. It is wise to ensure the data you hand to a system call is sanitized. Naturally, this is good advice for any API call, but you cannot be to careful when working with the kernel.

I hope you enjoyed this deeper dive into the land of Linux system calls. For a full list of Linux System Calls, see our master list.

Источник

С linux system function