#define _MULTI_THREADED
#include <pthread.h>
#include <stdio.h>
#include <signal.h>
#include "check.h"

#define NUMTHREADS 3
void sighand(int signo);

void *threadfunc(void *parm)
{
 pthread_t       self = pthread_self();
 pthread_id_np_t    tid;
 int          rc;

 pthread_getunique_np(&self, &tid);
 printf("Thread 0x%.8x %.8x entered\n", tid);
 errno = 0;
 rc = sleep(30);
 if (rc != 0 && errno == EINTR) {
  printf("Thread 0x%.8x %.8x got a signal delivered to it\n",
      tid);
  return NULL;
 }
 printf("Thread 0x%.8x %.8x did not get expected results! rc=%d, errno=%d\n",
     tid, rc, errno);
 return NULL;
}

int main(int argc, char **argv)
{
 int           rc;
 int           i;
 struct sigaction    actions;
 pthread_t        threads[NUMTHREADS];

 printf("Enter Testcase - %s\n", argv[0]);
 
 printf("Set up the alarm handler for the process\n");
 memset(&actions, 0, sizeof(actions));
 sigemptyset(&actions.sa_mask);
 actions.sa_flags = 0;
 actions.sa_handler = sighand;

 rc = sigaction(SIGALRM,&actions,NULL);
 checkResults("sigaction\n", rc);

 for(i=0; i<NUMTHREADS; ++i) {
  rc = pthread_create(&threads[i], NULL, threadfunc, NULL);
  checkResults("pthread_create()\n", rc);
 }

 sleep(3);
 for(i=0; i<NUMTHREADS; ++i) {
  rc = pthread_kill(threads[i], SIGALRM);
  checkResults("pthread_kill()\n", rc);
 }

 for(i=0; i<NUMTHREADS; ++i) {
  rc = pthread_join(threads[i], NULL);
  checkResults("pthread_join()\n", rc);
 }
 printf("Main completed\n");
 return 0;
}

void sighand(int signo)
{
 pthread_t       self = pthread_self();
 pthread_id_np_t    tid;
 
 pthread_getunique_np(&self, &tid);
 printf("Thread 0x%.8x %.8x in signal handler\n",
     tid);
 return;
}

#include <pthread.h>
#include <stdio.h>
#include<stdlib.h>
#include <unistd.h>
void *threadfunc(void *parm)
{
 printf("Entered secondary thread\n");
 while (1) {
  printf("Secondary thread is looping\n");
  pthread_testcancel();
  sleep(1);
 }
 return NULL;
}

int main(int argc, char **argv)
{
 pthread_t       thread;
 int          rc=0;

 printf("Entering testcase\n");

 /* Create a thread using default attributes */
 printf("Create thread using the NULL attributes\n");
 rc = pthread_create(&thread, NULL, threadfunc, NULL);
 checkResults("pthread_create(NULL)\n", rc);

 /* sleep() is not a very robust way to wait for the thread */
 sleep(1);

 printf("Cancel the thread\n");
 rc = pthread_cancel(thread);
 checkResults("pthread_cancel()\n", rc);

 /* sleep() is not a very robust way to wait for the thread */
 sleep(10);
 printf("Main completed\n");
 return 0;
}

#include <pthread.h>                              
#include <stdio.h>                               
#include <stdlib.h>                               
#include <unistd.h>                               
#include <errno.h>                                        
int footprint=0;
char *storage; 
void freerc(void *s)
{
  free(s);
  puts("the free called");  
}                                

static void checkResults(char *string, int rc) {
 if (rc) {
  printf("Error on : %s, rc=%d",
      string, rc);
  exit(EXIT_FAILURE);
 }
 return;
}
                                        
void *thread(void *arg) {                                                          
 int      rc=0, oldState=0; 
 rc = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldState);  //close the cancel switch  
 checkResults("pthread_setcancelstate()\n", rc);                                    
 if ((storage = (char*) malloc(80)) == NULL) {                 
  perror("malloc() failed");                         
  exit(6);                                  
 }                                       
  rc = pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,&oldState);  //open the cancel switch                                    
  checkResults("pthread_setcancelstate(2)\n", rc); 
/* Plan to release storage even if thread doesn't exit normally */      
                                        
 pthread_cleanup_push(freerc, storage);  /*the free is method here  you can use your own method here*/                    
                                        
 puts("thread has obtained storage and is waiting to be cancelled");      
 footprint++;                                 
 while (1)
  {   
     pthread_testcancel();  //make a break point here   
      //pthread_exit(NULL);  //test exit to exam whether the freerc method called                           
      sleep(1); 
  }                                 
                                        
 pthread_cleanup_pop(1);                            
}                                        
                                        
main() {                                    
 pthread_t thid; 
 void         *status=NULL;                               
                                        
 if (pthread_create(&thid, NULL, thread, NULL) != 0) {             
  perror("pthread_create() error");                      
  exit(1);                                  
 }                                       
                                        
 while (footprint == 0)                            
  sleep(1);                                  
                                        
 puts("IPT is cancelling thread");                       
                                        
 if (pthread_cancel(thid) != 0) {                       
  perror("pthread_cancel() error");  
  sleep(2);                    
  exit(3);                                  
 }                                       
                                        
 if (pthread_join(thid, &status) != 0) { 
  if(status != PTHREAD_CANCELED){                   
    perror("pthread_join() error");                       
    exit(4);
  }                                  
 }
 if(status == PTHREAD_CANCELED)
  puts("PTHREAD_CANCELED");
   
 puts("main exit");                                    
}