#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
 
/*
 * This program is intended to help you test your shell.
 * You can use it to test that you are correctly starting and waiting
 * for multiple processes.
 * 
 * Recommended Usage: 
 * Run multiple copies of this program simultaneously
 *
 * You should see the output from each intermingled 
 * (you can tell which process is which because each prints its "pid").
 *
 * You might only see the output intermingled when one of the processes 
 * goes to sleep; this is okay.  However, it is not okay if you see the
 * output of one process completely before the output of the other.
 *
 */
int main(int argc, char *argv[])
{
 
  int pid;
  int i;
  int j;
  int outer = 5;
  int inner = 10;
  int count = 0;
  long max_usleep = 1000000; // 1 second
  int seed;
  long usec;
  int c;
 
  pid = getpid();
  while ((c = getopt(argc, argv, "o:i:s:r:")) != -1) {
    switch (c) {
    case 'o':
      outer = atoi(optarg);
      break;
 
    case 'i':
      inner = atoi(optarg);
      break;
 
    case 's':
      max_usleep = (long)atoi(optarg);
      break;
 
    case 'r':
      seed = atoi(optarg);
      srand(seed);
      break;
 
    default:
      fprintf(stderr, "Usage: %s [-o <outerloops>] [-i <innerloops>] [-s <maxusecsleep>] [-r <random seed>]\n", argv[0]);
      exit(1);
    }
  }
 
  for (i = 0; i < outer; i++) {
 
    for (j = 0; j < inner; j++) {
 
      printf("%d: %d\n", pid, count);
      count++;
    }
 
    usec = max_usleep * ((float)rand() / (float)RAND_MAX);
    printf("%d sleeping for  %ld usec\n", pid, usec);
    usleep(usec);
  }
 
  printf("Job completed\n");
}
 
 
//this is the given program and i have to place my code in this program which i'm unable to do
 
 
// my code v
//              v 
 
// using fork  
 
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
 
 
int main(void)
{
    pid_t child;
 
 
    if((child = fork()) == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    } else if(child == 0) {
        puts("in child");
        printf("\tchild pid = %d\n", getpid());
        printf("\tchild ppid = %d\n", getppid());
        exit(EXIT_SUCCESS);
    } else {  
 
 
fputs("in parent");
        printf("\tparent pid = %d\n", getpid());
        printf("\tparent ppid = %d\n", getppid());
    }
    exit(EXIT_SUCCESS);
}
 
 
// uses the kill function to send two signals to a sleeping child process, 
// one that will be ignored, and one that will kill the process  
 
#include <sys/types.h>
#include <wait.h>
#include <unistd.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
 
 
int main(void)
{
    pid_t child;
    int errret;
 
 
    if((child = fork()) < 0) {
        perror("fork");
        exit(EXIT_FAILURE);
    } else if(child == 0) { /* in the child process */
        sleep(30);
    } else { /* in the parent */
        /* send a signal that gets ignored */
        printf("sending SIGCHLD to %d\n", child);
        errret = kill(child, SIGCHLD);
        if(errret < 0)
            perror("kill:SIGCHLD");
        else
            printf("%d still alive\n", child);
 
 
        /* now murder the child */
        printf("killing %d\n", child);
        if((kill(child, SIGTERM)) < 0)
            perror("kill:SIGTERM");
        /* have to wait to reap the status */
        waitpid(child, NULL, 0 ); 
}
     exit(EXIT_SUCCESS);
}