1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

from collections import defaultdict

class Graph:
    def __init__(self, vertices):
        self.V = vertices
        self.graph = defaultdict(list)

    def addEdge(self, u, v):
        self.graph[u].append(v)

    def DLS(self, src, target, maxDepth, visited):
        visited.append(src)  # Add the current node to visited
        if src == target:
            return True, visited

        if maxDepth <= 0:
            return False, visited

        for i in self.graph[src]:
            found, visited = self.DLS(i, target, maxDepth - 1, visited)
            if found:
                return True, visited
        return False, visited

    def IDDFS(self, src, target, maxDepth):
        visited = []  # Initialize the visited list
        for i in range(maxDepth + 1):  # Include maxDepth level
            found, visited = self.DLS(src, target, i, visited)
            if found:
                return True, visited
        return False, visited

# Create a graph
g = Graph(7)
g.addEdge(0, 1)
g.addEdge(0, 2)
g.addEdge(1, 3)
g.addEdge(1, 4)
g.addEdge(2, 5)
g.addEdge(2, 6)

target = 6
maxDepth = 3
src = 0

found, visited = g.IDDFS(src, target, maxDepth)
if found:
    print("Target is reachable from source within max depth")
    print("Visited nodes:", visited)
else:
    print("Target is NOT reachable from source within max depth")
    print("Visited nodes:", visited)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

# Python3 Program to print BFS traversal
# from a given source vertex. BFS(int s)
# traverses vertices reachable from s.

from collections import defaultdict


# This class represents a directed graph
# using adjacency list representation
class Graph:

    # Constructor
    def __init__(self):

        # Default dictionary to store graph
        self.graph = defaultdict(list)

    # Function to add an edge to graph
    def addEdge(self, u, v):
        self.graph[u].append(v)

    # Function to print a BFS of graph
    def BFS(self, s):

        # Mark all the vertices as not visited
        visited = [False] * (max(self.graph) + 1)

        # Create a queue for BFS
        queue = []

        # Mark the source node as
        # visited and enqueue it
        queue.append(s)
        visited[s] = True

        while queue:

            # Dequeue a vertex from
            # queue and print it
            s = queue.pop(0)
            print(s, end=" ")

            # Get all adjacent vertices of the
            # dequeued vertex s.
            # If an adjacent has not been visited,
            # then mark it visited and enqueue it
            for i in self.graph[s]:
                if not visited[i]:
                    queue.append(i)
                    visited[i] = True

# Driver code
if __name__ == '__main__':

    # Create a graph given in
    # the above diagram
    g = Graph()
    g.addEdge(0, 1)
    g.addEdge(0, 2)
    g.addEdge(1, 2)
    g.addEdge(2, 0)
    g.addEdge(2, 3)
    g.addEdge(3, 3)

    print("Following is Breadth First Traversal"
        " (starting from vertex 2)")
    g.BFS(2)

# This code is contributed by Neelam Yadav

# This code is modified by Susobhan Akhuli

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

import heapq
# tw3


def astar(graph, start, goal):
    # priority queue to store nodes to be explored
    open_list = [(0, start)]
    # dictionary to store parent nodes
    parents = {}
    # dictionary to store g values (cost from start node to current node)
    g_values = {node: float('inf') for node in graph}
    g_values[start] = 0
    # dictionary to store f values (estimated total cost from start to goal)
    f_values = {node: float('inf') for node in graph}
    f_values[start] = graph[start][1]

    iteration = 0

    while open_list:
        # get node with minimum f value
        current_f, current_node = heapq.heappop(open_list)

        # check if current node is the goal
        if current_node == goal:
            path = []
            while current_node in parents:
                path.append(current_node)
                current_node = parents[current_node]
            path.append(start)
            final_cost = g_values[goal]
            print(f"\nFinal Cost: {final_cost}")
            return path[::-1]

        # explore neighbors
        for child, cost in graph[current_node][0].items():
            # calculate tentative g value
            tentative_g = g_values[current_node] + cost
            if tentative_g < g_values[child]:
                # update parent and g values
                parents[child] = current_node
                g_values[child] = tentative_g
                f_values[child] = tentative_g + graph[child][1]
                # add child to open list
                heapq.heappush(open_list, (f_values[child], child))

        iteration += 1
        print(f"\nIteration {iteration}:")
        print("Current Path:", reconstruct_path(parents, start, current_node))
        print(f"Evaluation Function Value for {current_node}: {f_values[current_node]}")


# Function to reconstruct the path from start to goal using parent nodes
def reconstruct_path(parents, start, goal):
    path = [goal]
    while goal != start:
        goal = parents[goal]
        path.append(goal)
    return path[::-1]


# Example usage:
start_node = 'A'
goal_node = 'G'
graph = {
    'A': [{'B': 5, 'C': 10}, 10],
    'B': [{'D': 5, 'E': 5}, 7],
    'C': [{'F': 5}, 7],
    'D': [{'G': 10}, 3],
    'E': [{'G': 7}, 2],
    'F': [{'G': 8}, 1],
    'G': [{}, 0]
}

print("\nA* Search Path:")
path = astar(graph, start_node, goal_node)
print("Final Path:", path)

1
2
3

gedit <filename.c>
cc filename.c
./a.out

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#include <stdio.h>
int main()
{
    #if __STDC__ == 0
    printf("CC is not ANSI C compliant");
    #else
    printf("%s compiled at %s %s this statement at line %d", __FILE__, __TIME__, __DATE__, __LINE__);
    #endif
    return 0;
}

1
2

cc <filename.c> -o <filename.out>
./filename.out

1

cc <filename.c> -o <filename.out> && ./filename.out

1

gedit <filename.cpp>

1
2

g++ <filename.cpp> -o <filename.out>
./filename.out

1

g++ <filename.cpp> -o <filename.out> && ./filename.out

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#define _POSIX_SOURCE
#define _POSIX_C_SOURCE 199309L
#include <stdio.h>
#include <unistd.h>
#include <iostream.h>

using namespace std;

int main() {
    #ifdef _POSIX_VERSION
        cout << "POSIX compliant" << _POSIX_VERSION << endl;
    #else
        cout << "POSIX version is not defined" << endl;
    #endif
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

#define _POSIX_SOURCE
#define _POSIX_C_SOURCE 1993309L
#include <iostream>
#include <limits.h>
#include <unistd.h>

using namespace std;

void compileTime() {
    cout << "\n\nMANIFEST CONSTANTS\n\n";
    #ifdef _SC_CLK_TCK
        cout << "SYSTEM SUPPORTS CLK_TCK which is " << _SC_CLK_TCK << endl;
    #else
        cout << "SYSTEM DOES NOT SUPPORT CLK_TCK" << endl;
    #endif

    #ifdef _POSIX_CHILD_MAX
        cout << "Man number of child processes is " << _POSIX_CHILD_MAX << endl;
    #else
        cout << "CHILD_MAX is not defined" << endl;
    #endif

    #ifdef _POSIX_PATH_MAX
        cout << "Maximum path length is " << _POSIX_PATH_MAX << endl;
    #else
        cout << "PATH_MAX is not defined" << endl;
    #endif
    #ifdef _POSIX_OPEN_MAX
        cout << "Maximum number of open files per process is " << _POSIX_OPEN_MAX << endl; 
    #else
        cout << "OPEN_MAX is not defined" << endl;
    #endif
    #ifdef _POSIX_NAME_MAX
        cout << "Maximum number of characters in a filename is " << _POSIX_NAME_MAX << endl;
    #else
        cout << "SYSTEM DOES NOT SUPPORT _POSIX_NAME_MAX" << endl;
    #endif
}

void runTime() {
    cout << "\n\nRUNTIME CONSTANTS\n\n";
    long arg_max = sysconf(_SC_ARG_MAX);
    cout << "Maximum length of arguments to exec is " << arg_max << endl;
    long child_max = sysconf(_SC_CHILD_MAX);
    cout << "Maximum number of child processes is " << child_max << endl;
    long clk_tck = sysconf(_SC_CLK_TCK);
    cout << "Number of clock ticks per second is " << clk_tck << endl;
    long open_max = sysconf(_SC_OPEN_MAX);
    cout << "Maximum number of open files per process is " << open_max << endl;
    long name_max = sysconf(_PC_NAME_MAX);
    cout << "Maximum number of characters in a filename is " << name_max << endl;
    long path_max = pathconf("/", _PC_PATH_MAX);
    cout << "Maximum path length is " << path_max << endl;
}

int main() {
    compileTime();
    runTime();
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

MANIFEST CONSTANTS

SYSTEM SUPPORTS CLK_TCK which is 2
Man number of child processes is 25
Maximum path length is 256
Maximum number of open files per process is 20
Maximum number of characters in a filename is 14


RUNTIME CONSTANTS

Maximum length of arguments to exec is 2097152
Maximum number of child processes is 30544
Number of clock ticks per second is 100
Maximum number of open files per process is 1048576
Maximum number of characters in a filename is 65536
Maximum path length is 4096

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#define _POSIX_SOURCE
#define _POSIX_C_SOURCE 199309L
#include <iostream>
#include <unistd.h>

using namespace std;

int main() {
    #ifdef _POSIX_JOB_CONTROL
        cout << "System supports POSIX Job Control." << endl;
    #else
        cout << "System doesn't support POSIX Job Control." << endl;
    #endif

    #ifdef _POSIX_SAVED_IDS
        cout << "System supports saved set-UID and saved set-GID." << endl;
    #else
        cout << "System doesn't support POSIX saved IDs." << endl;
    #endif

    #ifdef _POSIX_CHOWN_RESTRICTED
        cout << "Chown restricted option is: " << _POSIX_CHOWN_RESTRICTED << endl;
    #else
        cout << "System doesn't support chown restricted option." << endl;
    #endif

    #ifdef _POSIX_NO_TRUNC
        cout << "Truncation option is: " << _POSIX_NO_TRUNC << endl;
    #else
        cout << "System doesn't support POSIX truncation." << endl;
    #endif

    #ifdef _POSIX_VDISABLE
        cout << "Disable char for terminal files: " << _POSIX_VDISABLE << endl;
    #else
        cout << "System doesn't support POSIX disability." << endl;
    #endif

    return 0;
}

1
2
3
4
5
6

lts@POWERHOUSE:~/Documents/blog/test$ g++ test.cpp && ./a.out
System supports POSIX Job Control.
System supports saved set-UID and saved set-GID.
Chown restricted option is: 0
Truncation option is: 1
Disable char for terminal files: 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include<iostream>
#include<sys/types.h>
#include<unistd.h>
#include<string.h>
using namespace std;
int main( int argc , char* argv[] )
 {
   if( ((argc<3) || (argc>4)) || (argc==4 && strcmp(argv[1],"-s")) )
    { 
      cerr<<"Usage : "<< argv[0]<<" [-s] <orig_file> <new_file> \n";
      return 1;
    }
   if( argc == 4 )   // programName -s <source_file> <destination_file>
    {
      if( symlink( argv[2] ,argv[3] ) == -1 )
        {
	  	perror("link");   		return 1;
	   }
           cout<<"Symbolic | Soft link of File created successfully\n";
    }


if( argc == 3 )  // programName <source_file> <destination_file>
    {
	   if( link(argv[1],argv[2]) == -1 )
	    {
	      perror("link"); 
	      return 1;
	    }
	   cout<<"Hard link of File created successfully\n";
    }
   return 0; 
 }

1
2
3
4
5
6
7
8

lts@POWERHOUSE:~/Documents/blog/test$ g++ test.cpp -o link_creator
lts@POWERHOUSE:~/Documents/blog/test$ ./link_creator -s example.txt example_link.txt
Symbolic | Soft link of File created successfully

lts@POWERHOUSE:~/Documents/blog/test$ g++ test.cpp 
lts@POWERHOUSE:~/Documents/blog/test$ touch soft.txt
lts@POWERHOUSE:~/Documents/blog/test$ ./a.out soft.txt  file.txt
Hard link of File created successfully

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#include <stdio.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main(int argc, char *argv[])
{
    char temp[1000];
    struct flock fvar;
    int fdesc;
    char buf;
    int rc;
    off_t offset;

    if (argc != 2) {
        printf("Usage: %s <filename>\n", argv[0]);
        return 1;
    }

    fdesc = open(argv[1], O_RDWR);
    if (fdesc == -1) {
        perror("Error opening file");
        return 1;
    }

    offset = lseek(fdesc, -100, SEEK_END);
    
    fvar.l_type = F_WRLCK;
    fvar.l_whence = SEEK_CUR;
    fvar.l_start = 0;
    fvar.l_len = 100;

    if (fcntl(fdesc, F_SETLK, &fvar) == -1)
    {
        printf("\n---- File has been locked by: \n");
        while (fcntl(fdesc, F_GETLK, &fvar) != -1 && fvar.l_type != F_UNLCK)
        {
            printf("\nFile: %s is locked by process with pid: %d\n", argv[1], fvar.l_pid);
        }
    }
    else
    {
        printf("\n---- \n");
        printf("\nFile: %s was not locked and acquiring of exclusive lock was:", argv[1]);
        printf(" Successful By Process Id: %d\n", getpid());

        offset = lseek(fdesc, -50, SEEK_END);
        printf("\nLast 50 bytes of file %s = \n", argv[1]);
        while ((rc = read(fdesc, &buf, 1)) > 0) printf("%c", buf);
        
        offset = lseek(fdesc, -100, SEEK_END);
        fvar.l_type = F_UNLCK;
        fvar.l_whence = SEEK_CUR;
        fvar.l_start = 0;
        fvar.l_len = 100;

        fcntl(fdesc, F_SETLKW, &fvar);
        printf("\nFile unlocked successfully\n");
    }

    close(fdesc);
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

lts@POWERHOUSE:~/Documents/blog/test$ echo "lando gets pole position" > file.txt
lts@POWERHOUSE:~/Documents/blog/test$ g++ test.cpp -o file_locking
lts@POWERHOUSE:~/Documents/blog/test$ ./file_locking file.txt 

---- 

File: file.txt was not locked and acquiring of exclusive lock was: Successful By Process Id: 13895

Last 50 bytes of file file.txt = 
lando gets pole position

File unlocked successfully
lts@POWERHOUSE:~/Documents/blog/test$ 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
    pid_t child_pid;

    // Create a child process
    child_pid = fork();

    if (child_pid == 0) {
        // Child process
        printf("Child process with PID %d exiting...\n", getpid());
        exit(0);
    } else if (child_pid > 0) {
        // Parent process
        printf("Parent process with PID %d waiting...\n", getpid());

        // Don't wait for the child process to terminate (create zombie)
        sleep(5);  // Sleep for a few seconds to allow child to exit

        // Execute ps command to verify child process state
        system("ps -e -o pid,ppid,stat,cmd");
    } else {
        // Fork failed
        perror("fork");
        exit(1);
    }

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

lts@POWERHOUSE:~/Documents/blog/test$ gcc test.cpp 
lts@POWERHOUSE:~/Documents/blog/test$ ./a.out 
Parent process with PID 19180 waiting...
Child process with PID 19181 exiting...
    PID    PPID STAT CMD
      1       0 Ss   /sbin/init
      2       1 Sl   /init
      6       2 Sl   plan9 --control-socket 6 --log-level 4 --server-fd 7 --pipe-fd 9 --log-truncate
     38       1 S<s  /lib/systemd/systemd-journald
     57       1 Ss   /lib/systemd/systemd-udevd
     69       1 Ssl  snapfuse /var/lib/snapd/snaps/bare_5.snap /snap/bare/5 -o ro,nodev,allow_other,suid
     70       1 Ssl  snapfuse /var/lib/snapd/snaps/core_16928.snap /snap/core/16928 -o ro,nodev,allow_other,suid
     80       1 Ssl  snapfuse /var/lib/snapd/snaps/core20_2264.snap /snap/core20/2264 -o ro,nodev,allow_other,suid
     87       1 Ssl  snapfuse /var/lib/snapd/snaps/core20_2318.snap /snap/core20/2318 -o ro,nodev,allow_other,suid
     94       1 Ssl  snapfuse /var/lib/snapd/snaps/core22_1122.snap /snap/core22/1122 -o ro,nodev,allow_other,suid
     97       1 Ssl  snapfuse /var/lib/snapd/snaps/core22_1380.snap /snap/core22/1380 -o ro,nodev,allow_other,suid
    105       1 Ssl  snapfuse /var/lib/snapd/snaps/gtk-common-themes_1535.snap /snap/gtk-common-themes/1535 -o ro,nodev,allow_other,suid
    110       1 Ssl  snapfuse /var/lib/snapd/snaps/hugo_19714.snap /snap/hugo/19714 -o ro,nodev,allow_other,suid
    115       1 Ssl  snapfuse /var/lib/snapd/snaps/hugo_19814.snap /snap/hugo/19814 -o ro,nodev,allow_other,suid
    123       1 Ssl  snapfuse /var/lib/snapd/snaps/snapd_21465.snap /snap/snapd/21465 -o ro,nodev,allow_other,suid
    130       1 Ssl  snapfuse /var/lib/snapd/snaps/snapd_21759.snap /snap/snapd/21759 -o ro,nodev,allow_other,suid
    134       1 Ssl  snapfuse /var/lib/snapd/snaps/ubuntu-desktop-installer_1284.snap /snap/ubuntu-desktop-installer/1284 -o ro,nodev,allow_
    138       1 Ssl  snapfuse /var/lib/snapd/snaps/ubuntu-desktop-installer_1286.snap /snap/ubuntu-desktop-installer/1286 -o ro,nodev,allow_
    203       1 Ss   /lib/systemd/systemd-resolved
    222       1 Ss   /usr/sbin/cron -f -P
    224       1 Ss   @dbus-daemon --system --address=systemd: --nofork --nopidfile --systemd-activation --syslog-only
    228       1 Ss   /usr/bin/python3 /usr/bin/networkd-dispatcher --run-startup-triggers
    229       1 Ssl  /usr/sbin/rsyslogd -n -iNONE
    231       1 Ssl  /usr/lib/snapd/snapd
    232       1 Ss   /lib/systemd/systemd-logind
    278       1 Ss   /bin/bash /snap/ubuntu-desktop-installer/1286/bin/subiquity-server
    280       1 Ssl  /usr/bin/python3 /usr/share/unattended-upgrades/unattended-upgrade-shutdown --wait-for-signal
    288       1 Ss+  /sbin/agetty -o -p -- \u --noclear --keep-baud console 115200,38400,9600 vt220
    303       1 Ss+  /sbin/agetty -o -p -- \u --noclear tty1 linux
    326     278 Sl   /snap/ubuntu-desktop-installer/1286/usr/bin/python3.10 -m subiquity.cmd.server --use-os-prober --storage-version=2 --po
    371       2 Ss   /init
    372     371 S    /init
    373     372 Ss+  sh -c "$VSCODE_WSL_EXT_LOCATION/scripts/wslServer.sh" 5437499feb04f7a586f677b155b039bc2b3669eb stable code-server .vsco
    374       2 Ss   /bin/login -f
    376     373 S+   sh /mnt/c/Users/aumpa/.vscode/extensions/ms-vscode-remote.remote-wsl-0.88.2/scripts/wslServer.sh 5437499feb04f7a586f677
    407       1 Ss   /lib/systemd/systemd --user
    408     407 S    (sd-pam)
    413     374 S+   -bash
    449     376 S+   sh /home/lts/.vscode-server/bin/5437499feb04f7a586f677b155b039bc2b3669eb/bin/code-server --host=127.0.0.1 --port=0 --co
    453     449 Sl+  /home/lts/.vscode-server/bin/5437499feb04f7a586f677b155b039bc2b3669eb/node /home/lts/.vscode-server/bin/5437499feb04f7a
    465       2 Ss   /init
    466     326 S    python3 /snap/ubuntu-desktop-installer/1286/usr/bin/cloud-init status --wait
    467     465 S    /init
    469     467 Ssl+ /home/lts/.vscode-server/bin/5437499feb04f7a586f677b155b039bc2b3669eb/node -e const net = require('net'); process.stdin
    478       2 Ss   /init
    479     478 S    /init
    480     479 Ssl+ /home/lts/.vscode-server/bin/5437499feb04f7a586f677b155b039bc2b3669eb/node -e const net = require('net'); process.stdin
    501     453 Sl+  /home/lts/.vscode-server/bin/5437499feb04f7a586f677b155b039bc2b3669eb/node /home/lts/.vscode-server/bin/5437499feb04f7a
    515     453 Sl+  /home/lts/.vscode-server/bin/5437499feb04f7a586f677b155b039bc2b3669eb/node --dns-result-order=ipv4first /home/lts/.vsco
    542     515 Sl+  /home/lts/.vscode-server/bin/5437499feb04f7a586f677b155b039bc2b3669eb/node /home/lts/.vscode-server/bin/5437499feb04f7a
    557     453 Rl+  /home/lts/.vscode-server/bin/5437499feb04f7a586f677b155b039bc2b3669eb/node /home/lts/.vscode-server/bin/5437499feb04f7a
    678     557 Ss   /bin/bash --init-file /home/lts/.vscode-server/bin/5437499feb04f7a586f677b155b039bc2b3669eb/out/vs/workbench/contrib/te
  19180     678 S+   ./a.out
  19181   19180 Z+   [a.out] <defunct>
  19232   19180 S+   sh -c ps -e -o pid,ppid,stat,cmd
  19233   19232 R+   ps -e -o pid,ppid,stat,cmd
lts@POWERHOUSE:~/Documents/blog/test$ 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

static void charactertime(const char *); // Change to const char*

int main() {
    int pid;
    if ((pid = fork()) < 0) {
        printf("fork error\n");
    } else if (pid == 0) {
        charactertime("Output of the Child\n");
    } else {
        charactertime("Output of the Parent\n");
    }
    _exit(0);
}

static void charactertime(const char *str) { // Change to const char*
    const char *ptr; // Change to const char*
    int c;
    setbuf(stdout, NULL); // Disable buffering for stdout
    for (ptr = str; (c = *ptr++) != 0; ) {
        putc(c, stdout); // Output each character one at a time
    }
}

1
2
3
4

lts@POWERHOUSE:~/Documents/blog/test$ ./a.out 
Output ofO utthpeu tP aorfe ntth
e Child
lts@POWERHOUSE:~/Documents/blog/test$ 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <string.h>
#define PORT 4444
int main() {
 int listenfd, connfd;
 struct sockaddr_in servAddr, cliAddr;
 socklen_t clilen;
 char buffer[1024];
 
 listenfd = socket(AF_INET, SOCK_STREAM, 0);
 printf("[+] Server socket created successfully\n");
 bzero(&servAddr, sizeof(servAddr));
 servAddr.sin_family = AF_INET;
 servAddr.sin_port = htons(PORT);
 servAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
 
 bind(listenfd, (struct sockaddr *) &servAddr, sizeof(servAddr));
 printf("[+] Bind to PORT %d successful\n", PORT);
 
 listen(listenfd, 5);
 printf("[+] Listening...\n");
 
 connfd = accept(listenfd, (struct sockaddr *) &cliAddr, 
&clilen);
 
 strcpy(buffer, "Hello World!");
 send(connfd, buffer, strlen(buffer), 0);
 printf("[+] Data sent to client: %s\n", buffer);
 
 printf("[+] Closing the connection\n");
 return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define PORT 4444
int main() {
 int sockfd;
 struct sockaddr_in servAddr;
 char buffer[1024];
 
 sockfd = socket(AF_INET, SOCK_STREAM, 0);
 printf("[+] Client socket created successfully\n");
 
 bzero(&servAddr, sizeof(servAddr));
 servAddr.sin_family = AF_INET;
 servAddr.sin_port = htons(PORT);
 servAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
 
 connect(sockfd, (struct sockaddr *) &servAddr, 
sizeof(servAddr));
 printf("[+] Connected to server\n");
 
 recv(sockfd, buffer, 1024, 0);
 printf("[+] Data received from server: %s\n", buffer);
 printf("[+] Closing the connection\n");
 return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// server output
lts@POWERHOUSE:~/Documents/blog/test$ ./server 
[+] Server socket created successfully
[+] Bind to PORT 4444 successful
[+] Listening...
[+] Data sent to client: Hello World!
[+] Closing the connection
lts@POWERHOUSE:~/Documents/blog/test$ 

// client output
lts@POWERHOUSE:~/Documents/blog/test$ ./client 
[+] Client socket created successfully
[+] Connected to server
[+] Data received from server: Hello World!�
[+] Closing the connection
lts@POWERHOUSE:~/Documents/blog/test$ 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/internet-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/applications-module.h"
#include "ns3/netanim-module.h"

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("FirstScriptExample");

int
main (int argc, char *argv[])
{
  CommandLine cmd;
  cmd.Parse (argc, argv);
  
  Time::SetResolution (Time::NS);
  LogComponentEnable ("UdpEchoClientApplication", LOG_LEVEL_INFO);
  LogComponentEnable ("UdpEchoServerApplication", LOG_LEVEL_INFO);

  NodeContainer nodes;
  nodes.Create (2);

  PointToPointHelper pointToPoint;
  pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
  pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));

  NetDeviceContainer devices;
  devices = pointToPoint.Install (nodes);

  InternetStackHelper stack;
  stack.Install (nodes);

  Ipv4AddressHelper address;
  address.SetBase ("10.1.1.0", "255.255.255.0");

  Ipv4InterfaceContainer interfaces = address.Assign (devices);

  UdpEchoServerHelper echoServer (9);

  ApplicationContainer serverApps = echoServer.Install (nodes.Get (1));
  serverApps.Start (Seconds (1.0));
  serverApps.Stop (Seconds (10.0));

  UdpEchoClientHelper echoClient (interfaces.GetAddress (1), 9);
  echoClient.SetAttribute ("MaxPackets", UintegerValue (1));
  echoClient.SetAttribute ("Interval", TimeValue (Seconds (1.0)));
  echoClient.SetAttribute ("PacketSize", UintegerValue (1024));

  ApplicationContainer clientApps = echoClient.Install (nodes.Get (0));
  clientApps.Start (Seconds (2.0));
  clientApps.Stop (Seconds (10.0));

  AnimationInterface anim("first, xml");
  AsciiTraceHelper ascii;
  point.EnableAsciiAll(ascii.CreateFileStream("first.tr"));
  pointToPoint.EnablePcapAll("first");

  Simulator::Run ();
  Simulator::Destroy ();
  return 0;
}