for(i=0;i<2;i++)
if(fork()==0)
printf("Hi");
I am expecting 3 hi and getting 4 hi
SO i edited the printf as printf("Hi %d %d %d ",i,getpid(),getppid());
The first child created prints two hi with same value of I i.e 0 and its pid and parent's pid are also same. Why?
It's quite interesting and looks like the answer is output buffering. For example we have:
#include <unistd.h>
#include <stdio.h>
int main() {
for(int i=0;i<2;i++) {
if(fork()==0) {
printf("Hi %d %d %d\n",i,getpid(),getppid());
}
}
}
If run this code in terminal there will be 3 lines, but if I will redirect the output to less there will be four!
If we will flush the buffer after printf() the problem will disappear:
// ...
printf("Hi %d %d %d\n",i,getpid(),getppid());
fflush(stdout);
// ...
That's happening because stdout is buffered, so when process forked the buffer still not flushed.
From man stdout:
The stream stderr is unbuffered. The stream stdout is
line-buffered when it points to a terminal. Partial lines will not
appear until fflush(3) or exit(3) is called, or a newline is printed.
This can produce unexpected results, especially with debugging
output.
Related
My Code
#include<stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
int main()
{
char * arg_list[3];
arg_list[0] = "ls";
arg_list[1] = "-l";
arg_list[2] = 0;
char *arg_list2[3];
arg_list2[0] = " ps";
arg_list2[1] = "-ef";
arg_list2[2] = 0;
for(int i=0;i<5;i++){ // loop will run n times (n=5)
if(fork() == 0) {
if (i == 0){
execvp("ls", arg_list);
}else if(i==1){
execvp("ps" , arg_list2);
}else if(i>1){
printf("[son] pid %d from [parent] pid %d\n",getpid(),getppid());
exit(0);
}
}
}
for(int i=0;i<5;i++) // loop will run n times (n=5)
wait(NULL);
}
ME trying to modify it
#include<stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
int main()
{
for(int i=0;i<5;i++){ // loop will run n times (n=5)
if(fork() == 0) {
printf("[son] pid %d from [parent] pid %d\n",getpid(),getppid());
execlp(argv[i],argv[i],argv[i+1],(char*)NULL);
exit(0);
}
}
for(int i=0;i<5;i++) // loop will run n times (n=5)
wait(NULL);
}
-- NEED GUIDANCE AND UNDERSTANDING
I am trying to make my own tiny little shell program. When I run my first code works fine, runs all commands on the command line. But I cannot know and define all commands the user might enter. So i am trying to get a base code which could run any commands single or multiple entered by user. I tried using execlp where it does not compile saying argv is not defined which is true as i don't want to specifically define it.
I am trying to make my own tiny little shell program. When I run my first code works fine, runs all commands on the command line. But I cannot know and define all commands the user might enter.
For sure.... A shell program purpose is basically:
Read user input
Execute user input
Return result of execution.
There's nothing in your code that read user input....
So i am trying to get a base code which could run any commands single or multiple entered by user.
So read user input ;-)
I tried using execlp where it does not compile saying argv is not defined which is true as i don't want to specifically define it.
For sure ... but how would GCC guessed that `argv[]̀ must be automaticallty filled with user input ?
There's nothing automatic when coding in C language. You have to manage this manually.
Also, note that argc, argv et envp are usually reserved for main() function:
main(int argc, char **argv, char **envp)
So you may use something else to build your command array.
In pseudo code, what you must implement is:
quit=0
while (quit = 0) {
command_to_run = read_user_input();
if (command_to_run == "exit") {
quit = 1;
} else {
execute(command_to_run);
}
}
Some advices:
Try to use more functions. For example, implement a fork_and_run(char **cmd) function to fork and then execute command provided by the user. Il will make your code more readable and easy to maintain.
Read carefully manpages: everything you should know (like, for example, the fact that array provided to execvp() must be NULL-terminated) is written in it.
Your debugging messages should be printed to stderr. The result of the command run must be printed to stdin, so use fprintf() instead of printf() to write to the correct stream.
I would use a #define debug(x) fprintf(stderr, x) or something similar for debugging output so that you can easily disable later ;-)
I have written a CMakeFile that simply creates a test:
cmake_minimum_required (VERSION 3.1)
project (hello_test)
enable_testing ()
set (all_tests "")
list (APPEND all_tests hello_test)
add_executable (hello_test hello_test.c)
add_test (NAME hello_test COMMAND hello_test)
The test is as follow :
#include <stdio.h>
#include <unistd.h>
int main()
{
printf ("This message should appear when the test is launched \n"); //1st message
sleep(5); //sleep for 5s
printf ("This message should appear after 5 s \n"); //2nd message
}
I run the generated test using ./hello_test.exe.
What I expected is that the 1st message appear and then the program sleep for 5s and then the 2nd message appears.
However what I see is that the messages are only shown in the end of execution of the program
So if I want to debug a concurrent test(see which instruction is executed before the other using printf) it want help me a lot.
Is there a way to change the behaviour of the program as I expected ?
The printf buffer has not been flushed you could either flush to stdout or do fprintf(stdout, "...");
#include <stdio.h>
#include <unistd.h>
int main()
{
printf ("This message should appear when the test is launched \n"); //1st message
fflush(stdout); // add this
sleep(5); //sleep for 5s
printf ("This message should appear after 5 s \n"); //2nd message
}
Another thing could be
#include <stdio.h>
#include <unistd.h>
int main()
{
fprintf (stdout, "This message should appear when the test is launched \n"); //Notice the fprintf
sleep(5); //sleep for 5s
fprintf (stdout, "This message should appear after 5 s \n"); //Notice the fprintf
}
I've written a libcurses-based ascii ui that writes text to stdout when the program exits.
If I execute the program alone, like so...
> ./test
...the ui displays.
However, if I try to capture the program output to a Bash variable, like so...
> foo=$(./test)
...the ui does not display, however the Bash variable captures the expected output.
Does anyone know why this behavior is as such? Is there a way to get the ui to show up when trying to capture its stdout to a Bash variable?
The Code
#include <iostream>
#include <curses.h>
#include <unistd.h>
int main(int argc, char* argv[])
{
WINDOW* pWindow = initscr();
keypad(pWindow, TRUE);
curs_set(0);
nodelay(pWindow, FALSE);
mvwprintw(pWindow, 5, 5, "hello, world!");
mvwprintw(pWindow, 6, 5, "hello, fold!");
mvwprintw(pWindow, 7, 5, "hello, toad!");
for (int i = 0; i < 5; ++i)
{
mvwprintw(pWindow, 5 + i, 1, "==>");
refresh();
usleep(500000);
mvwprintw(pWindow, 5 + i, 1, " ");
refresh();
}
endwin();
std::cout << "bar" << std::endl;
}
Simply because redirecting the std output (>, a=$(…)) just redirects the standard output – ncurses, on the other hand, directly talks to the terminal and displays characters, that never are part of stdout.
Short: it doesn't capture the output because there is none. Instead, ncurses programs directly talk to the underlying terminal.
Is there a way to get the ui to show up when trying to capture its stdout to a Bash variable?
I don't recommend that. Because you're mixing non-interactive usage (getting std output) and interactive, and that can't really go well in the end, but:
you can end your ncurses session and just use printf like any other C programmer. Then you'd actually be producing std output.
I'd much rather just add an option to my program that takes a file to which I write my output. Then the bash script could open that file after my program has run.
When you initialize curses using initscr, it will use the standard output for display. (You could use newterm to specify another output). So when you redirect the output of the program you will not see the user-interface.
Adapting your example,
#!/bin/bash
g++ -o test foo.c $(ncursesw6-config --cflags --libs)
foo=$(./test)
set >foo.log
and looking at what bash puts in $foo, I see the expected control characters which are written in the user interface, e.g.,
foo=$'\E[?1049h\E[1;40r\E(B\E[m\E[4l\E[?7h\E[?1h\E=\E[?25l\E[H\E[2J\E[6d ==> hello, world!\n\E[6Ghello, fold!\n\E[6Ghello, toad!\E[6;5H\r \r\n ==>\r \r\n ==>\r \r\n ==>\r\E[J \r\n ==>\r\E[J \E[40;1H\E[?12l\E[?25h\E[?1049l\r\E[?1l\E>bar'
I tried to write simple fork-and-exec application with the following code
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/wait.h>
int
spawn(char *program, char *arg_list[])
{
pid_t child_pid;
child_pid = fork();
if (child_pid != 0)
return child_pid;
else {
execvp(program, arg_list);
fprintf(stderr, "an error occured\n");
exit(EXIT_FAILURE);
}
}
int
main()
{
int child_stat;
char *arg_list[] = {
"ls",
"-l",
"/",
NULL
};
spawn("ls", arg_list);
printf("return to parent\n");
return 0;
}
Every goes fine, but child after becoming ls does not terminate.
Shell looks like
./main
return to parent
-- ls output here --
But command prompt does not appear, so I assume that one process hangs and the reason is not obvious for me. Can you, please, point to my mistake.
Thanks in advance.
I believe that it works correctly. However, the order of execution of the child and parent are not what you expect, so you see output you don't understand. On my Arch linux box (kernel 4.xx), it works fine, but the parent process returns first, leaving ls to overwrite and otherwise garble the command prompt. Do a wait() on the child process to get execution to happen in a specific order. Add a couple of lines of code after the spawn() call:
spawn("ls", arg_list);
printf("return to parent\n");
wait(&child_stat);
printf("Waited on child\n");
return 0;
After the fork() call, the parent process will call wait(), which won't return until a child process (if there is at least one) exits. Since there's only one child process, the output of ls occurs before the command prompt gets written out, and thus you will see what you believe you should see.
I'm trying to simulate a pipe behavior on Ubuntu's Terminal, for example the command:
"echo hello | wc".
Please assume I got the tokens from stdin, handled everything correctly and now These are the commands I "received" from the user who typed them in the shell for me to handle.
I'm trying to create two processes. Using a pipe, in the first process, I point the file descriptor of the writing edge of the pipe to stdout. The second process should read into stdin with the reading edge of the pipe what execvp(..) returned.?
Here is the code I wrote:
#include <stdio.h>
#include <stdlib.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
int main()
{
char* fcmd[] = {"echo", "hello", NULL};
char* scmd[] = {"wc", NULL};
pid_t pid;
int pipe_des[2];
int i;
pipe(pipe_des);
for(i = 0; i < 2; i++)
{
pid = fork();
if (pid ==0)
{
switch (i)
{
case 0: // FIRST CHILD
{
dup2(pipe_des[1], STDOUT_FILENO);
close(pipe_des[0]);
execvp(fcmd[0], fcmd);
exit(0);
}
case 1: //SECOND CHILD
{
dup2(pipe_des[0], STDIN_FILENO);
close(pipe_des[1]);
execvp(scmd[0], scmd);
exit(0);
}
}
}
else if (pid < 0)
exit(EXIT_FAILURE);
return EXIT_SUCCESS;
}
I get: " amirla#ubuntu:~/Desktop/os/class/ex4$ 1 1 6 "
Like it should, but why he's printing the bash cwd first? The pipe seems to work because I get what I should, according to the length of the word I'm sending with the echo command(in the main()). After that the cursor just waits on the line below for another command without showing me the bash pwd. (maybe stdin is waiting?)
I've looked in many posts on here as well as on other websites and I still can't seem to find a solution to my problem. Any help would be appreciated. Thanks in advance.
Note: Please Ignore checking for errors, I've delete them to make the code shorter so assume they exist.
Why do I get a prompt before the output?
Your main process doesn't wait for the children to finish. What you see is:
Main starts
Main creates children
Main exits
BASH prints prompt
Children start their work
To prevent this, you need to wait for the children. See How to wait until all child processes called by fork() complete?
In your case, it's enough to add
waitpid(-1, NULL, 0);
after the loop.