signal updated

Author: behnamasadi

CMakeLists.txt

@@ -78,21 +78,7 @@ add_executable(arrays src/arrays.cpp)
 add_executable(dynamic_memory_allocation src/dynamic_memory_allocation.cpp)
 
 # ADD_LIBRARY(add MODULE src/add.cpp)
-if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    add_library(add SHARED src/add.cpp)
-    add_executable(loadeding_libraries src/loadeding_libraries.cpp)
-    target_link_libraries(loadeding_libraries dl)
 
-    add_executable(align src/align.cpp)
-    
-    add_executable(signals src/signals.cpp)
-    add_executable(system_call src/system_call.cpp)
-
-    # add_executable(date_time src/date_time.cpp)
-
-    add_executable(fork src/fork.cpp)
-    
-endif()
 
 add_executable(template src/template.cpp)
 
@@ -406,3 +392,21 @@ if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/main.cpp")
     add_executable(main src/main.cpp)
 endif()
 
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    add_library(add SHARED src/add.cpp)
+    add_executable(loadeding_libraries src/loadeding_libraries.cpp)
+    target_link_libraries(loadeding_libraries dl)
+
+    add_executable(align src/align.cpp)
+    
+
+    set(CMAKE_CXX_FLAGS "-fsanitize=address ${CMAKE_CXX_FLAGS}")
+    set(CMAKE_CXX_FLAGS "-fno-omit-frame-pointer ${CMAKE_CXX_FLAGS}")
+    add_executable(signals src/signals.cpp)
+    add_executable(system_call src/system_call.cpp)
+
+    # add_executable(date_time src/date_time.cpp)
+
+    add_executable(fork src/fork.cpp)
+    
+endif()

docs/signals.md

@@ -1,4 +1,5 @@
 - [Signals](#signals)
+  * [Types of Signals](#types-of-signals)
   * [SIGILL](#sigill)
   * [SIGSEGV](#sigsegv)
     + [Segmentation fault](#segmentation-fault)
@@ -8,46 +9,66 @@
   * [SIGSYS](#sigsys)
   * [SIGTRAP](#sigtrap)
   * [SIGTERM](#sigterm)
-- [Raising a Signal](#raising-a-signal)
 - [Setting Signal Handler](#setting-signal-handler)
+- [Examples](#examples)
+  * [SIGINT_Handler](#sigint-handler)
+  * [SIGSEGV_Handler](#sigsegv-handler)
+- [Raising a Signal](#raising-a-signal)
+
 
 
 # Signals
-Signals in computers are a way of communication between the process and the OS.
-When a running program undergoes some serious error then the OS sends a signal to
-the process and the process further may not execute.
-Some processes may have a signal handler which does some important tasks before the
+Signals are a communication mechanism between a process and the operating system. When a running program encounters a significant error, the OS sends a signal to that process. Some processes may have a signal handler which does some important tasks before the
 process leaves the CPU.
-Signal and interrupt are basically same but a small distinction exists i.e interrupts
-are generated by the processor and handled by the kernel but signals are generated by
-the kernel and handled by the process.
-Error signals generally causes termination of the program and a core dump file is
-created named core, which stores the state of the process at the moment of termination.
-This file can be investigated using debugger to know the cause of program termination.
+
+
+Signals and interrupts serve similar purposes, but they differ in their origin and handling mechanisms. Interrupts originate from the processor and are managed by the operating system's kernel. In contrast, signals are generated by the kernel and are managed by the individual process to which they are sent. 
+
+
+## Types of Signals
+There are various types of signals, each corresponding to different events.
 ## SIGILL
-This signal denotes illegal instruction. When a garbage instruction or instruction
-which a program has no privilege to execute, is executed then this signal is
-generated.
-C does not produce illegal instruction so there is no chance of facing such error
-signal, as the probable cause may be that the object file may be corrupted.
-This signal is also generated when stack overflow occurs.
+This signal in Unix-like operating systems is sent to a process when it attempts to execute an illegal, malformed, unknown, or privileged instruction. 
 ## SIGSEGV
-The signal is generated when process tries to access memory location not
-allocated to it, like de-referencing a wild pointer which leads to
-“segmentation fault”.
+The signal is generated when process tries to access memory location which is not allocated to it.
 
 ###  Segmentation fault  
 The following are some typical causes of a segmentation fault:
 1. Attempting to access a nonexistent memory address (outside process's address space)
 2. Attempting to access memory the program does not have rights to (such as kernel structures in process context)
 3. Attempting to write read-only memory (such as code segment)
 
-The above incidents will happens while dereferencing or assigning null pointer/ wild pointer/ dangling pointer, heap overflow, stack overflow.
+
 When you access an array index, C and C++ don't do bound checking. Segmentation faults only happen when you try to
 read or write to a page that was not allocated (or try to do something on a page which isn't permitted,
 e.g. trying to write to a read-only page), but since pages are usually pretty big
 (multiples of a few kilobytes), it often leaves you with lots of room to overflow.
+
+
+```
+int main() {
+  // Define an array with a small size
+  int array[5] = {0, 1, 2, 3, 4};
+
+  std::cout << "Original array values:\n";
+  for (int i = 0; i < 5; i++) {
+    std::cout << "array[" << i << "] = " << array[i] << "\n";
+  }
+
+  // Overflowing the array
+  // Writing beyond the bounds of the array
+  std::cout << "\nWriting beyond the bounds of the array...\n";
+  for (int i = 0; i < 100;
+       i++) { // This loop intentionally goes well beyond the array's bounds
+    array[i] = i;
+  }
+  return 0;
+}
+```
+
 By setting the followings flag you can find the issue:
+
+
 ```
 set(CMAKE_CXX_FLAGS "-fsanitize=address ${CMAKE_CXX_FLAGS}")
 set(CMAKE_CXX_FLAGS "-fno-omit-frame-pointer ${CMAKE_CXX_FLAGS}")
@@ -77,38 +98,99 @@ Unlike `SIGKILL`, this signal can be blocked, handled, and ignored. It is
 the normal way to politely ask a program to terminate. The shell command
 kill generates `SIGTERM` by default.
 
-# raising a Signal
-The `<csignal>` header file declared the function `raise()` to handle a particular signal. Signal learns some unusual behavior in a program, and calls the signal handler. It is implemented to check if the default handler will get called or it will be ignored.
-Syntax: 
-```cpp
-int raise ( int signal_ )
-```
+
 # Setting Signal Handler
-Sets the handler for signal sig
-```cpp
-signal(int sig, /*signal-handler*/* handler);
-```
+create the signal handler function:
 
-defining a signal handler:
 ```cpp
-sig_atomic_t s_value = 0;
-void handle(int signum)
-{
-    s_value = signum;
+void signalHandler(int signum) {
+    std::cout << "signal (" << signum << ") received.\n";
+    // Cleanup and close up logic
+    exit(signum);
 }
 ```
+
 setting the handler for a specific signal: 
 ```cpp
-//SIGILL,SIGINT,SIGSEGV,SIGTERM,SIGABRT,SIGFPE
-signal(SIGTERM, handle);
+
+int main() {
+    // Register signal SIGINT ( or any of SIGILL,SIGINT,SIGSEGV,SIGTERM,SIGABRT,SIGFPE) and signal handler  
+    signal(SIGINT, signalHandler);
+}
+```
+
+
+
+# Examples
+## SIGINT_Handler
+In the following example signal that is being handled is `SIGINT`. This signal is typically sent when the user presses `Ctrl+C` in the terminal. The SIGINT_Handler function in the example is specifically set up to catch and handle the SIGINT signal.
+```
+#include <csignal>
+#include <iostream>
+
+
+// Signal handler function
+void SIGINT_Handler(int signum) {
+    std::cout << "Interrupt signal (" << signum << ") received.\n";
+    // Cleanup and close up logic
+    exit(signum);
+}
+
+int main() {
+    // Register signal SIGINT and signal handler  
+    signal(SIGINT, SIGINT_Handler);
+
+    while(1) {
+       std::cout << "Waiting for signal..." << std::endl;
+       sleep(1);
+    }
+
+    return 0;
+}
+```
+
+## SIGSEGV_Handler
+
+```
+#include <csignal>
+#include <cstdlib> // for  exit()
+#include <iostream>
+#include <unistd.h> // getpid()
+
+void SIGSEGV_Handler(int signum) {
+  std::cout << "oh my god! segmenation fault happened" << std::endl;
+  printf("Process %d got signal %d\n", getpid(), signum);
+  // kill(getpid(), signum);
+  exit(signum);
+}
+
+int main() {
+  signal(SIGSEGV, SIGSEGV_Handler);
+  int *p;
+  *p = 10;
+}
 ```
-raising the signal:
+
+ 
+# Raising a Signal
+The `<csignal>` header file declared the function `raise()` to handle a particular signal.
+Syntax: 
 ```cpp
-std::cout << "Before called Signal = " << s_value << std::endl;
-raise(SIGTERM);
-std::cout << "After called Signal = " << s_value << std::endl;
+int raise ( int signal_ )
+```
+
+complete example:
+
+```
+sig_atomic_t s_value = 0;
+void SIGTERM_Handler(int signum) { s_value = signum; }
+
+int main() {
+  signal(SIGTERM, SIGTERM_Handler);
+  std::cout << "Before called Signal = " << s_value << std::endl;
+  raise(SIGTERM);
+  std::cout << "After called Signal = " << s_value << std::endl;
+}
+
 ```
-  
-  
-  
  [code](../src/signals.cpp)  

src/main.cpp

@@ -1,14 +1,52 @@
-#include <algorithm>
 #include <cmath>
 #include <exception>
 #include <iomanip>
 #include <iostream>
-#include <list>
-#include <map>
 #include <memory>
-#include <set>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
 
-int main() {}
+struct Foo {
+  std::string id;
+  Foo(std::string id) : id(id) {
+
+    std::cout << id << " constructor" << std::endl;
+  }
+  ~Foo() { std::cout << id << " destructor" << std::endl; }
+};
+
+Foo globalFoo("global object");
+static Foo staticFoo("static object");
+
+void runBeforeTermination() {
+  std::cout << "cleaning up temp dir before termination..." << std::endl;
+}
+void abortExample() {
+  Foo fooObject("abortExample");
+  std::shared_ptr<Foo> fooObject_ptr(new Foo("abortExample_ptr"));
+  atexit(runBeforeTermination);
+  abort();
+}
+
+int main() {
+  int array[5] = {0, 1, 2, 3, 4};
+
+  std::cout << "Original array values:\n";
+  for (int i = 0; i < 5; i++) {
+    std::cout << "array[" << i << "] = " << array[i] << "\n";
+  }
+
+  // Overflowing the array
+  // Writing beyond the bounds of the array
+  std::cout << "\nWriting beyond the bounds of the array...\n";
+  for (int i = 0; i < 10;
+       i++) { // This loop intentionally goes well beyond the array's bounds
+    array[i] = i;
+  }
+
+  // std::cout << "\nReading values after overflow:\n";
+  // // Reading values after overflow
+  // for (int i = 0; i < int(100);
+  //      i++) { // Again, intentionally reading beyond the array's bounds
+  //   std::cout << "array[" << i << "] = " << array[i] << "\n";
+  //   std::cout << "i = " << i << "\n";
+  // }
+}

src/signals.cpp

@@ -3,32 +3,32 @@
 #include <iostream>
 #include <unistd.h> // getpid()
 
-sig_atomic_t s_value = 0;
-void handle(int signum) { s_value = signum; }
-
-void SIGSEGVhandle(int signum) {
+void SIGSEGV_Handler(int signum) {
   std::cout << "oh my god! segmenation fault happened" << std::endl;
   printf("Process %d got signal %d\n", getpid(), signum);
-
   // kill(getpid(), signum);
   exit(signum);
 }
 
-void SIGExample() {
-  // SIGILL,SIGINT,SIGSEGV,SIGTERM,SIGABRT,SIGFPE
-  signal(SIGTERM, handle);
-  std::cout << "Before called Signal = " << s_value << std::endl;
-  raise(SIGTERM);
-  std::cout << "After called Signal = " << s_value << std::endl;
+void SIGINT_Handler(int signum) {
+  std::cout << "Interrupt signal (" << signum << ") received.\n";
+  // Cleanup and close up logic
+  exit(signum);
 }
 
+sig_atomic_t s_value = 0;
+void SIGTERM_Handler(int signum) { s_value = signum; }
+
 int main() {
-  // first example
-  // SIGExample();
+  // signal(SIGSEGV, SIGSEGV_Handler);
+  // int *p;
+  // *p = 10;
+
+  // //  Register signal SIGINT and signal handler
+  // signal(SIGINT, SIGINT_Handler);
 
-  // second example
-  signal(SIGSEGV, SIGSEGVhandle);
-  // signal(SIGSEGV, SIG_DFL);  // restore default behavior
-  int *p;
-  *p = 10;
+  signal(SIGTERM, SIGTERM_Handler);
+  std::cout << "Before called Signal = " << s_value << std::endl;
+  raise(SIGTERM);
+  std::cout << "After called Signal = " << s_value << std::endl;
 }