├── CN
    ├── ServerClient
    │   ├── AnotherWayOfDoingIt
    │   │   ├── clientNew.py
    │   │   └── serverNew.py
    │   └── OneWayOfDoingIt
    │   │   ├── client.py
    │   │   └── server.py
    ├── SlidingWindow
    │   ├── Usliding.c
    │   ├── goback.c
    │   ├── siding_selective.c
    │   └── slidingWindow.c
    ├── bellman
    │   ├── bellAlgo.c
    │   ├── bellman.c
    │   ├── bellman.cpp
    │   └── bellmanFord.py
    ├── hamming.c
    ├── hammingCode
    │   ├── ham.c
    │   └── hammingCode.py
    ├── ipValidation.c
    └── ipv4_modified.c
├── CNS
    ├── Hill_Cipher_Encrypt_and_Decrypt.py
    ├── aes.cpp
    ├── hillCipherEncryption.py
    ├── rsa.py
    └── transposition.py
├── README.md
└── WT
    ├── XML_CSS
        ├── PROG5.css
        └── usnChecker.xml
    ├── XML_XSL
        ├── 4b.xml
        └── 4b.xsl
    ├── html
        ├── fib.html
        ├── reverse.html
        ├── square.html
        ├── usnValidation.html
        └── vowel.html
    └── php
        ├── cookie.php
        ├── counter.php
        ├── greet.php
        ├── largest.php
        ├── library
            ├── DBConnection.php
            ├── DisplayBooks.php
            ├── EnterBooks.php
            ├── InsertBooks.php
            └── SearchBooks.php
        ├── serverInfo.php
        └── session.php


/CN/ServerClient/AnotherWayOfDoingIt/clientNew.py:
--------------------------------------------------------------------------------
 1 | import socket
 2 | 
 3 | ip = "127.0.0.1"
 4 | port = 4444
 5 | 
 6 | server=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 7 | server.connect((ip, port))
 8 | 
 9 | string = input ("Enter string: ")
10 | server.send(bytes(string, "utf-8"))
11 | buffer = server.recv(1024)
12 | buffer = buffer.decode("utf-8")
13 | print(f"Server: {buffer} ")
14 | 


--------------------------------------------------------------------------------
/CN/ServerClient/AnotherWayOfDoingIt/serverNew.py:
--------------------------------------------------------------------------------
 1 | import socket
 2 | 
 3 | ip = "127.0.0.1"
 4 | port = 4444
 5 | 
 6 | server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 7 | print("Socket Succesfully Created")
 8 | server.bind((ip, port))
 9 | print("Socket Succesfully Binded")
10 | server.listen(5)
11 | print("Socket is Listening..")
12 | 
13 | 
14 | while True:
15 |     client, address = server.accept ()
16 |     print (f"Connection Estabished {address}")
17 |     string = client.recv(1024)
18 |     string = string.decode("utf-8")
19 |     string = string.upper()
20 |     client.send(bytes (string, "utf-8"))
21 |     client.close ()
22 |     break
23 | 


--------------------------------------------------------------------------------
/CN/ServerClient/OneWayOfDoingIt/client.py:
--------------------------------------------------------------------------------
 1 | import socket
 2 | 
 3 | s=socket.socket()
 4 | port = 6000
 5 | s.connect(('127.0.0.1',port))
 6 | print(s.recv(1024).decode())
 7 | 
 8 | msg=input("Enter the text to be Conveted : ")
 9 | s.send(msg.encode())
10 | print(s.recv(1024).decode())
11 | s.close()
12 | 
13 | 
14 | 
15 | #for python 2 use the below code (literally the same with raw_input)
16 | 
17 | import socket
18 | 
19 | s=socket.socket()
20 | 
21 | port = 6000
22 | 
23 | s.connect(('127.0.0.1',port))
24 | print(s.recv(1024).decode())
25 | 
26 | msg  =raw_input("Enter the text to be Conveted : ")
27 | s.send(msg)
28 | print(s.recv(1024).decode())
29 | 
30 | s.close()
31 | 


--------------------------------------------------------------------------------
/CN/ServerClient/OneWayOfDoingIt/server.py:
--------------------------------------------------------------------------------
 1 | import socket
 2 | 
 3 | s = socket.socket()
 4 | print("Socket successfully created\n")
 5 | 
 6 | port = 6000
 7 | s.bind(('',port))
 8 | print("Socket binded to %s"%(port))
 9 | 
10 | s.listen(5)
11 | print("Socket is Listening")
12 | 
13 | while 1:
14 |         c,addr = s.accept()
15 |         print("Got Connection from",addr)
16 |         c.send("Succesfully Connected".encode())
17 |         msg = c.recv(1024).decode().upper()
18 |         c.send(msg.encode())
19 |         c.close()
20 |         break
21 | 


--------------------------------------------------------------------------------
/CN/SlidingWindow/Usliding.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | 
 4 | int main()
 5 | {
 6 |     int n,m,ack=-1;
 7 | 
 8 |     printf("Enter the number of frames:\n");
 9 |     scanf("%d",&n);                             // total number of frames
10 | 
11 |     printf("Enter the window size :\n");
12 |     scanf("%d",&m);                             // window size
13 | 
14 |     int x=1,y=m,temp=0;
15 |     printf("Sending frame from %d to %d\n",x,y);
16 | 
17 |     while(x<=n)
18 |     {
19 |         printf("Enter the ack received\n");
20 |         scanf("%d",&ack);
21 | 
22 |         if(y<n)
23 |         {
24 |             if(ack==x)
25 |             {
26 |                 printf("The frame received is %d\n",ack);
27 |                 x++;
28 |                 y++;
29 |                 printf("window moved from frame %d to %d\n",x,y);
30 |             }
31 |             else
32 |             {
33 |                 printf("wrong ack received it must be %d\n\n",x);
34 |                 printf("re-transmitting window %d to %d\n",x,y);
35 |             }
36 |             temp=x;
37 |         }
38 |         else{
39 |             if(ack==x)
40 |             {
41 |                 printf("the frame received id %d\n",ack);
42 |                 x++;
43 |             }
44 |             else{
45 |                 printf("wrong ack received it must be %d\n",x);
46 |                 printf("retransmitting window %d to %d\n",temp,y);
47 |             }
48 |         }
49 |     }
50 |     printf("Process complete\n");
51 |     return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/CN/SlidingWindow/goback.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | int main()
 4 | {
 5 |     int n, w, i = 1, j = 0;
 6 |     int total = 0;
 7 |     printf("Enter the number of frames : \n");
 8 |     scanf("%d", &n);
 9 |     printf("Enter the Window Size : \n");
10 |     scanf("%d", &w);
11 |     while (i <= n)
12 |     {
13 |         int x = 0;
14 |         for (j = i; j < i + w && j <= n; j++)
15 |         {
16 |             printf("Sent Frame %d\n ", j);
17 |             total++;
18 |         }
19 |         for (j = i; j < i + w && j <= n; j++)
20 |         {
21 |             int flag = rand() % 2;
22 |             if (!flag)
23 |             {
24 |                 printf("Acknowledgment for Frame %d\n", j);
25 |                 x++;
26 |             }
27 |             else
28 |             {
29 |                 printf("Frame %d Not Received\n", j);
30 |                 printf("Retransmitting Window");
31 |                 break;
32 |             }
33 |         }
34 |         printf("\n");
35 |         i += x;
36 |     }
37 |     printf("Total number of transmissions : %d", total);
38 |     return 0;
39 | }
40 | 


--------------------------------------------------------------------------------
/CN/SlidingWindow/siding_selective.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | void main()
 4 | {
 5 |     int i=1,p,a,w,nac,ack;
 6 |     printf("Enter the window size\n");
 7 |     scanf("%d",&w);
 8 |     printf("Enter the packet size\n");
 9 |     scanf("%d",&a);
10 |     printf("Transmission begins.Packet size is %d\n",a);
11 |     while(i<=a)
12 |     {
13 |         printf("Sending packets fromm %d to %d\n",i,w+i-1);
14 |         for(p=i;p<w+i;p++)
15 |         {
16 |           printf("Transmitting packet %d\n",p);
17 |         }
18 |         nac=i+rand()%w;
19 |     if(nac==i)
20 |     {
21 |         printf("Ack=%d\n",w+i);
22 |         i=i+w;
23 |         continue;
24 |     }
25 |     printf("Nac=%d\n",nac);
26 |     printf("Sending packet %d\n",nac);
27 |     printf("Ack=%d\n",nac+1);
28 |     printf("Ack=%d\n",i+w);
29 |     i=i+w;
30 |     }
31 |     printf("End of packets so ack %d is discarded\n",i);
32 | }
33 | 


--------------------------------------------------------------------------------
/CN/SlidingWindow/slidingWindow.c:
--------------------------------------------------------------------------------
 1 | // will work even without the delay function 
 2 | 
 3 | #include <stdio.h>
 4 | #include <time.h>
 5 | 
 6 | void delay (int number_of_seconds)
 7 | {
 8 |   int milli_seconds = 1000 * number_of_seconds;
 9 |   clock_t start_time = clock ();
10 |   while (clock () < start_time + milli_seconds);
11 |   // printf("Hello");
12 | }
13 | 
14 | int main ()
15 | {
16 |   int n, m, i, frames[1000], window[1000], frameStart = 0, frameEnd =0, preFrameAck = -1, ackNumber = -1;
17 |   printf ("Enter the number of frames to be sent: ");
18 |   scanf ("%d", &n);
19 |   printf ("Enter the window size: ");
20 |   scanf ("%d", &m);
21 |   frameEnd = frameStart + m;
22 | 
23 |   for (i = 0; i < n; i++)
24 |     {
25 |       frames[i] = i;
26 |     }
27 | 
28 |   printf ("Data Transmitting::: Be Patient...\n");
29 |   delay (2);
30 | 
31 |   printf ("Frames sent from frame number %d to %d\n", frameStart, frameEnd - 1);
32 | 
33 |   while (frameStart != n)
34 |     {
35 |           printf ("Enter the ack Number: ");
36 |           scanf ("%d", &ackNumber);
37 |          
38 |           if(frameEnd <= n-1){
39 |    
40 |           if (ackNumber - 1 == preFrameAck)
41 |     {
42 |      // moveWindow
43 |      frameStart += 1;
44 |      frameEnd += 1;
45 |      preFrameAck = ackNumber;
46 |      printf ("Sliding Window is moving\nContents in the Sliding Window is %d to %d\n", frameStart, frameEnd - 1);
47 |                     
48 |         }
49 |                
50 |         else
51 |         {
52 |             // resendTheWindowContent
53 |             frameStart = frameStart; frameEnd = frameEnd;
54 |             printf("Frame Lost %d\nFrames resent from frame number %d to %d\n",preFrameAck+1,frameStart,frameEnd-1);
55 |             
56 |         }
57 |             
58 |             printf("\n\n");
59 |            
60 |           }
61 |          
62 |          else{
63 |       if (ackNumber - 1 != preFrameAck)
64 |       {
65 |          
66 |              printf("Frames sent from frame number %d to %d\n",frameStart,frameEnd-1);
67 |       }
68 |       else
69 |       {
70 |           frameStart++;
71 |           preFrameAck = ackNumber;
72 |       }
73 |          }
74 |          
75 |     delay (2);
76 |     }
77 |    
78 |    
79 |     printf("Data Sent Successfully\n");
80 |    
81 |     return 0;
82 | }
83 | 


--------------------------------------------------------------------------------
/CN/bellman/bellAlgo.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | struct
 3 | {
 4 |     int dist[20];
 5 |     int from[20];
 6 | } a[20];
 7 | 
 8 | int main()
 9 | {
10 |     int nodes;
11 |     int cost[20][20];
12 |     printf("Enter number of nodes: ");
13 |     scanf("%d", &nodes);
14 |     printf("\nEnter Cost Matrix:\n");
15 |     for (int i = 0; i < nodes; i++)
16 |     {
17 |         for (int j = 0; j < nodes; j++)
18 |         {
19 |             scanf("%d", &cost[i][j]);
20 |             cost[i][i] = 0;
21 |             a[i].dist[j] = cost[i][j];
22 |             a[i].from[j] = j;
23 |         }
24 |     }
25 |     int count = 0;
26 |     do
27 |     {
28 |         count = 0;
29 |         for (int i = 0; i < nodes; i++)
30 |         {
31 |             for (int j = 0; j < nodes; j++)
32 |             {
33 |                 for (int k = 0; k < nodes; k++)
34 |                 {
35 |                     if (a[i].dist[j] > cost[i][k] + a[k].dist[j])
36 |                     {
37 |                         a[i].dist[j] = a[i].dist[k] + a[k].dist[j];
38 |                         a[i].from[j] = k;
39 |                         count++;
40 |                     }
41 |                 }
42 |             }
43 |         }
44 | 
45 |     } while (count != 0);
46 | 
47 |     for (int i = 0; i < nodes; i++)
48 |     {
49 |         printf("\n\nFor Router - %d ", i + 1);
50 |         for (int j = 0; j < nodes; j++)
51 |         {
52 |             printf("\t\nNode--> %d Via--> %d Distance--> %d ", j + 1, a[i].from[j] + 1, a[i].dist[j]);
53 |         }
54 |     }
55 | 
56 |     printf("\n\nExecution Complete\n\n");
57 |     return 0;
58 | }
59 | 


--------------------------------------------------------------------------------
/CN/bellman/bellman.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | int maxi=999;
 4 | void bellman(int g[10][3],int v,int e,int s){
 5 |     int dis[10];
 6 |     int i;
 7 |     for(i=0;i<v;i++){
 8 |         dis[i]=maxi;
 9 |     }
10 |     dis[s]=0;
11 |     int j;
12 |     for(i=0;i<v-1;i++){
13 |         for(j=0;j<e;j++){
14 |             if(dis[g[j][0]]!=maxi && dis[g[j][0]] + g[j][2]<dis[g[j][1]]){
15 |                 dis[g[j][1]]=dis[g[j][0]] + g[j][2];
16 |             }
17 |         }
18 |     }
19 |     //checking negative cycle optional
20 |     for(i=0;i<e;i++){
21 |         int x=g[i][0];
22 |         int y=g[i][1];
23 |         int wt=g[i][2];
24 |         if(dis[x]!=maxi && dis[x]+wt<dis[y]){
25 |             printf("graph contain negative cycle\n");
26 |         }
27 |     }
28 |     printf("Vertex distance    source\n");
29 |     for(i=0;i<v;i++){
30 |         printf("%d             %d\n",i,dis[i]);
31 |     }  
32 | 
33 | }
34 | int main(){
35 |     int v;
36 |     int e;
37 |     printf("Enter the number of edges\n");
38 |     scanf("%d",&e);
39 |     printf("Enter the number of vertex\n");
40 |     scanf("%d",&v);
41 |     int g[10][3];
42 |     int i,j;
43 |     printf("Enter the graph(u,v,weight)\n");
44 |     for(i=0;i<e;i++){
45 |         for(j=0;j<3;j++){
46 |             scanf("%d",&g[i][j]);
47 |         }
48 |     }
49 |     int s=0;
50 |     printf("Enter the source\n");
51 |     scanf("%d",&s);
52 |     
53 |     bellman(g,v,e,s);
54 |     return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/CN/bellman/bellman.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | const int INF = 100000;
 4 | int main()
 5 | {
 6 |   int n,m;
 7 |   cout<<"Enter number of vertex and edges";
 8 | cin>>n>>m;
 9 | vector<vector<int>>edges;
10 | for(int i=0;i<m;i++)
11 | {
12 |   int u,v,w;
13 |   cout<<"Enter the value of vertex edges and weights of graph";
14 | cin>>u>>v>>w;
15 | edges.push_back({u,v,w});
16 | }
17 | cout<<"Enter source vertex";
18 | int src;cin>>src; 
19 | vector<int>dist(n,INF);
20 | dist[src]=0;
21 | for(int i=0;i<n-1;i++)
22 | {
23 | for(auto e:edges)
24 | {
25 |    int u=e[0];
26 |    int v =e[1];
27 |    int w =e[2];
28 |    dist[v]=min(dist[v],w + dist[u]);
29 | }  
30 | }
31 | for(auto i :dist)
32 |     cout<<i<<" ";
33 |     cout<<"\n";
34 | }  
35 | 


--------------------------------------------------------------------------------
/CN/bellman/bellmanFord.py:
--------------------------------------------------------------------------------
 1 | class Graph:
 2 | 
 3 |     def __init__(self, vertices):
 4 |         self.V = vertices   
 5 |         self.graph = []     
 6 | 
 7 |     def addEdge(self, s, d, w):
 8 |         self.graph.append([s, d, w])
 9 | 
10 |     def print_solution(self, dist):
11 |         print("Vertex Distance from Source")
12 |         for i in range(self.V):
13 |             print(i,"\t\t\t\t",dist[i])
14 | 
15 |     def bellman_ford(self, src):
16 | 
17 |         dist = [float("Inf")] * self.V
18 |         dist[src] = 0
19 |         #print(dist)
20 |         for i in range(self.V - 1):
21 |             for s, d, w in self.graph:
22 |                 if dist[s] != float("Inf") and dist[s] + w < dist[d]:
23 |                     dist[d] = dist[s] + w
24 |                     #print(dist)
25 |                     
26 |         for s, d, w in self.graph:
27 |             if dist[s] != float("Inf") and dist[s] + w < dist[d]:
28 |                 print("Graph contains negative weight cycle")
29 |                 return
30 | 
31 |    
32 |         self.print_solution(dist)
33 | 
34 | 
35 | g = Graph(7)
36 | 
37 | g.addEdge(0, 1, 6)
38 | g.addEdge(0, 2, 5)
39 | g.addEdge(0, 3, 5)
40 | g.addEdge(1,4,-1)
41 | g.addEdge(3,5,-1)
42 | g.addEdge(5,6,3)
43 | g.addEdge(4,6,3)
44 | g.addEdge(2, 1, -2)
45 | g.addEdge(2, 4, 1)
46 | g.addEdge(3, 2, -2)
47 | 
48 | g.bellman_ford(0)
49 | 


--------------------------------------------------------------------------------
/CN/hamming.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | void main()
 4 | {
 5 |     int data[10];
 6 |     int dataatrec[10], c, c1, c2, c3, i;
 7 | 
 8 |     printf("Enter 4 bits of data one by one\n");
 9 |     scanf("%d", &data[0]);
10 |     scanf("%d", &data[1]);
11 |     scanf("%d", &data[2]);
12 |     scanf("%d", &data[4]);
13 | 
14 |     // Calculation of even parity
15 |     data[6] = data[0] ^ data[2] ^ data[4];
16 |     data[5] = data[0] ^ data[1] ^ data[4];
17 |     data[3] = data[0] ^ data[1] ^ data[2];
18 | 
19 |     printf("\nEncoded data is\n");
20 |     for (i = 0; i < 7; i++)
21 |         printf("%d", data[i]);
22 | 
23 |     printf("\n\nEnter received data bits one by one\n");
24 |     for (i = 0; i < 7; i++)
25 |         scanf("%d", &dataatrec[i]);
26 | 
27 |     c1 = dataatrec[6] ^ dataatrec[4] ^ dataatrec[2] ^ dataatrec[0];
28 |     c2 = dataatrec[5] ^ dataatrec[4] ^ dataatrec[1] ^ dataatrec[0];
29 |     c3 = dataatrec[3] ^ dataatrec[2] ^ dataatrec[1] ^ dataatrec[0];
30 |     c = c3 * 4 + c2 * 2 + c1;
31 | 
32 |     if (c == 0)
33 |     {
34 |         printf("\nNo error while transmission of data\n");
35 |     }
36 |     else
37 |     {
38 |         printf("\nError on position %d", c);
39 | 
40 |         printf("\nData sent : ");
41 |         for (i = 0; i < 7; i++)
42 |             printf("%d", data[i]);
43 | 
44 |         printf("\nData received : ");
45 |         for (i = 0; i < 7; i++)
46 |             printf("%d", dataatrec[i]);
47 |         printf("\nCorrect message is\n");
48 | 
49 |         // if errorneous bit is 0 we complement it else vice versa
50 |         if (dataatrec[7 - c] == 0)
51 |             dataatrec[7 - c] = 1;
52 |         else
53 |             dataatrec[7 - c] = 0;
54 |         for (i = 0; i < 7; i++)
55 |         {
56 |             printf("%d", dataatrec[i]);
57 |         }
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/CN/hammingCode/ham.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 |     int data[10], count = 0;
 5 |     int recd[10], p, p1, p2, p3, i;
 6 | 
 7 |     printf("Enter 4 bits of data one by one\n");
 8 |     scanf("%d", &data[0]);
 9 |     scanf("%d", &data[1]);
10 |     scanf("%d", &data[2]);
11 |     scanf("%d", &data[4]);
12 | 
13 |     data[6] = data[0] ^ data[2] ^ data[4];
14 |     data[5] = data[0] ^ data[1] ^ data[4];
15 |     data[3] = data[0] ^ data[1] ^ data[2];
16 | 
17 |     printf("\nEncoded data is\n");
18 |     for (i = 0; i < 7; i++)
19 |         printf("%d", data[i]);
20 | 
21 |     printf("\n\nDetection and Correction of Error for the received data\nEnter the data received data one by one \n");
22 | 
23 |     for (int i = 0; i < 7; i++)
24 |     {
25 |         scanf("%d", &recd[i]);
26 |     }
27 | 
28 |     p1 = recd[6] ^ recd[4] ^ recd[2] ^ recd[0];
29 |     p2 = recd[5] ^ recd[4] ^ recd[1] ^ recd[0];
30 |     p3 = recd[3] ^ recd[2] ^ recd[1] ^ recd[0];
31 | 
32 |     if (p1 == 1 || p2 == 1 || p3 == 1)
33 |     {
34 |         printf("\nERROR DETECTED!");
35 |         p = p3 * 4 + p2 * 2 + p1;
36 |         printf("\nError bit %d", (8 - p));
37 | 
38 |         printf("\n\nReceived data before correction\n");
39 |         for (int i = 0; i < 7; i++)
40 |         {
41 |             printf("%d", recd[i]);
42 |         }
43 | 
44 |         if (recd[7 - p] == 0)
45 |             recd[7 - p] = 1;
46 |         else
47 |             recd[7 - p] = 0;
48 | 
49 |         printf("\n\nReceived data after correction\n");
50 | 
51 |         for (int i = 0; i < 7; i++)
52 |         {
53 |             printf("%d", recd[i]);
54 |         }
55 |     }
56 |     else
57 |     {
58 | 
59 |         printf("\n\nEncoded data and Received data both matches\n");
60 |         for (int i = 0; i < 7; i++)
61 |         {
62 |             printf("%d", recd[i]);
63 |         }
64 |         printf("\n\nNO ERROR FOUND!\n\n");
65 |     }
66 | 
67 |     return 0;
68 | }
69 | 


--------------------------------------------------------------------------------
/CN/hammingCode/hammingCode.py:
--------------------------------------------------------------------------------
 1 | def redun(x,y,z):
 2 |     res = 0;
 3 |     if(x==y):
 4 |         res = 0;
 5 |         if(str(res) == z):
 6 |             res = 0;
 7 |         else: res = 1;
 8 |        
 9 |     else:
10 |         res = 1;
11 |         if(str(res) == z):
12 |             res = 0;
13 |         else: res = 1;
14 |        
15 |     return res;
16 |    
17 | def syn(a,b,c,d):
18 |     res = redun(a,b,c)
19 |     if(str(res) == str(d)):
20 |         res = 0;
21 |     else: res = 1
22 |    
23 |     return str(res);
24 |    
25 | dataWord = list(raw_input("Enter the DataWord: "));
26 | codeWord = dataWord[:]
27 | 
28 | dataWord.reverse();
29 | codeWord.append(str(redun(dataWord[1], dataWord[0], dataWord[3])))
30 | codeWord.append(str(redun(dataWord[3], dataWord[2], dataWord[1])))
31 | codeWord.append(str(redun(dataWord[2], dataWord[1], dataWord[0])))
32 | print("Redundant Bits are: ", redun(dataWord[1], dataWord[0], dataWord[3]), redun(dataWord[3], dataWord[2], dataWord[1]), redun(dataWord[2], dataWord[1], dataWord[0]))
33 | print("Code Word is ", codeWord)
34 | 
35 | 
36 | recCodeWord = list(raw_input("Enter the recieved Keyword: "));
37 | s0 = syn(recCodeWord[1], recCodeWord[2], recCodeWord[3], recCodeWord[6])
38 | s1 = syn(recCodeWord[0], recCodeWord[1], recCodeWord[2], recCodeWord[5])
39 | s2 = syn(recCodeWord[2], recCodeWord[3], recCodeWord[0], recCodeWord[4])
40 | 
41 | synd = []
42 | synd.append(s2); synd.append(s1); synd.append(s0);
43 | actuSyn = "".join(synd)
44 | print("The syndrome is", (actuSyn))
45 | 
46 | msg = "".join(codeWord)
47 | 
48 | if int(actuSyn) == 0:
49 |     print("No Error In The Code")
50 | elif int(actuSyn) == 1:
51 |     print("Error in Q0\nThe corrected message is",msg);
52 | elif int(actuSyn) == 10:
53 |     print("Error in Q1\nThe corrected message is",msg);
54 | elif int(actuSyn) == 11:
55 |     print("Error in B2\nThe corrected message is",msg);
56 | elif int(actuSyn) == 100:
57 |     print("Error in Q2\nThe corrected message is",msg);
58 | elif int(actuSyn) == 101:
59 |     print("Error in B0\nThe corrected message is",msg);
60 | elif int(actuSyn) == 110:
61 |     print("Error in B3\nThe corrected message is",msg);
62 | elif int(actuSyn) == 111:
63 |     print("Error in Q0\nThe corrected message is",msg);
64 | 


--------------------------------------------------------------------------------
/CN/ipValidation.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | 
 4 | int main()
 5 | {
 6 |         int a[4],i;
 7 |         char dot;
 8 | 
 9 |         printf("Enter your IP address: ");
10 |         for(i=0;i<4;i++)
11 |         {
12 |                 scanf("%d",&a[i]);
13 |                 if(i==4){
14 |                         break;
15 |                 }
16 |                 scanf("%c",&dot);
17 |         }
18 | 
19 |         for(i=0;i<4;i++)
20 |         {
21 |                 if(a[i] < 0 || a[i] > 255)
22 |                 {
23 |                         printf("1. Programm Terminating: Invalid IP address\n");
24 |                         return 0;
25 |                 }
26 | 
27 |         }
28 |         if(a[0] >= 0 && a[0] < 128){
29 |                 printf("Given IP is a Class A IP\n");
30 |                 printf("Network ID is: ");
31 |                 printf("%d\n",a[0]);
32 | 
33 |                 printf("Host ID is: %d.%d.%d\n",a[1],a[2],a[3]);
34 |         }
35 |         else if(a[0] >= 128 && a[0] < 192){
36 |                 printf("Given IP is a Class B IP\n");
37 |                 printf("Network ID is: ");
38 |                 printf("%d.%d\n",a[0],a[1]);
39 | 
40 |                 printf("Host ID is: %d.%d\n",a[2],a[3]);
41 | 
42 |         }
43 |         else if(a[0] >= 192 && a[0] < 224) {
44 |                 printf("Given IP is a Class C IP\n");
45 |                 printf("Network ID is: ");
46 |                 printf("%d.%d.%d\n",a[0],a[1],a[2]);
47 | 
48 |                 printf("Host ID is: %d\n",a[3]);
49 | 
50 |         }
51 |         else if(a[0] >= 224 && a[0] < 240) printf("Given IP is a Class D IP\n");
52 |         else if(a[0] >= 240 && a[0] < 256) printf("Given IP is a Class E IP\n");
53 |         else printf("Invalid IP Address\n");
54 | 
55 |         return 0;
56 | 
57 | }
58 | 


--------------------------------------------------------------------------------
/CN/ipv4_modified.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | int main()
 4 | {
 5 | 	int a[10],i,flag=0;
 6 | 	char rem;
 7 | 	char dot;
 8 | 	printf("Enter the IP Adress\n");
 9 | 	for(i=0;i<4;i++)
10 | 	{
11 | 		scanf("%d",&a[i]);
12 | 		if(i == 3)
13 | 		{
14 | 			break;
15 | 		}
16 | 		scanf("%c",&dot);
17 | 		if(dot != '.')
18 | 		{
19 | 			flag = 1;
20 | 		}
21 | 	}
22 | 	scanf("%c",&rem);
23 | 	if(rem != '\n')
24 | 	{
25 | 		flag = 1;
26 | 	}
27 | 	for(i=0;i<4;i++)
28 | 	{
29 | 		if(!(a[i]>=0 && a[i]<256))
30 | 			flag = 1;
31 | 	}
32 | 	if(flag == 1)
33 | 	{
34 | 		printf("Entered IP is Invalid\n");
35 | 	}
36 | 	else{
37 | 	if(a[0]>=0 && a[0]<128)
38 | 	{
39 | 		printf("IP BELONGS TO CLASS - A\n ");
40 | 		printf("NETWORK ID = %d\n",a[0]);
41 | 		printf("HOST ID = %d.%d.%d\n",a[1],a[2],a[3]);
42 | 	}
43 | 	else if(a[0]>=128 && a[0]<192)
44 | 	{
45 | 		printf("IP BELONGS TO CLASS - B\n ");
46 | 		printf("NETWORK ID = %d.%d\n",a[0],a[1]);
47 | 		printf("HOST ID = %d.%d\n",a[2],a[3]);
48 | 	}
49 | 	else if(a[0]>=192 && a[0]<224)
50 | 	{
51 | 		printf("IP BELONGS TO CLASS - C\n ");
52 | 		printf("NETWORK ID = %d.%d.%d\n",a[0],a[1],a[2]);
53 | 		printf("HOST ID = %d\n",a[3]);
54 | 	}
55 | 	else if(a[0]>=224 && a[0]<240)
56 | 	{
57 | 		printf("IP BELONGS TO CLASS - D\n ");
58 | 		printf("IP ADRESS = %d.%d.%d.%d\n",a[0],a[1],a[2],a[3]);
59 | 	}
60 | 	else{
61 | 		printf("IP BELONGS TO CLASS - E\n ");
62 | 		printf("IP ADRESS = %d.%d.%d.%d\n",a[0],a[1],a[2],a[3]);
63 | 	}
64 | 	}
65 | 	return 0;
66 | }
67 | 
68 | 


--------------------------------------------------------------------------------
/CNS/Hill_Cipher_Encrypt_and_Decrypt.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | def encrypt(msg):
 3 |     msg = msg.replace(" ", "")
 4 |     C = make_key()
 5 |     len_check = len(msg) % 2 == 0
 6 |     if not len_check:
 7 |         msg += "0"
 8 |     P = create_matrix_of_integers_from_string(msg)
 9 |     msg_len = int(len(msg)/2)
10 |     encrypted_msg = ""
11 |     for i in range(msg_len):
12 |         row_0 = P[0][i] * C[0][0] + P[1][i] * C[0][1]
13 |         integer = int(row_0 % 26 + 65)
14 |         encrypted_msg += chr(integer)
15 |         row_1 = P[0][i] * C[1][0] + P[1][i] * C[1][1]
16 |         integer = int(row_1 % 26 + 65)
17 |         encrypted_msg += chr(integer)
18 |     return encrypted_msg
19 | 
20 | def decrypt(encrypted_msg):
21 |     C = make_key()
22 |     determinant = C[0][0] * C[1][1] - C[0][1] * C[1][0]
23 |     determinant = determinant % 26
24 |     multiplicative_inverse = find_multiplicative_inverse(determinant)
25 |     C_inverse = C
26 |     C_inverse[0][0], C_inverse[1][1] = C_inverse[1, 1], C_inverse[0, 0]
27 |     C[0][1] *= -1
28 |     C[1][0] *= -1
29 |     for row in range(2):
30 |         for column in range(2):
31 |             C_inverse[row][column] *= multiplicative_inverse
32 |             C_inverse[row][column] = C_inverse[row][column] % 26
33 | 
34 |     P = create_matrix_of_integers_from_string(encrypted_msg)
35 |     msg_len = int(len(encrypted_msg) / 2)
36 |     decrypted_msg = ""
37 |     for i in range(msg_len):
38 |         column_0 = P[0][i] * C_inverse[0][0] + P[1][i] * C_inverse[0][1]
39 |         integer = int(column_0 % 26 + 65)
40 |         decrypted_msg += chr(integer)
41 |         column_1 = P[0][i] * C_inverse[1][0] + P[1][i] * C_inverse[1][1]
42 |         integer = int(column_1 % 26 + 65)
43 |         decrypted_msg += chr(integer)
44 |     if decrypted_msg[-1] == "0":
45 |         decrypted_msg = decrypted_msg[:-1]
46 |     return decrypted_msg
47 | def find_multiplicative_inverse(determinant):
48 |     multiplicative_inverse = -1
49 |     for i in range(26):
50 |         inverse = determinant * i
51 |         if inverse % 26 == 1:
52 |             multiplicative_inverse = i
53 |             break
54 |     return multiplicative_inverse
55 | 
56 | 
57 | def make_key():
58 |     determinant = 0
59 |     C = None
60 |     while True:
61 |         cipher = raw_input("Input 4 letter cipher: ")
62 |         C = create_matrix_of_integers_from_string(cipher)
63 |         determinant = C[0][0] * C[1][1] - C[0][1] * C[1][0]
64 |         determinant = determinant % 26
65 |         inverse_element = find_multiplicative_inverse(determinant)
66 |         if inverse_element == -1:
67 |             print("Determinant is not relatively prime to 26, uninvertible key")
68 |         elif np.amax(C) > 26 and np.amin(C) < 0:
69 |             print("Only a-z characters are accepted")
70 |             print(np.amax(C), np.amin(C))
71 |         else:
72 |             break
73 |     return C
74 | 
75 | def create_matrix_of_integers_from_string(string):
76 |     integers = [chr_to_int(c) for c in string]
77 |     length = len(integers)
78 |     M = np.zeros((2, int(length / 2)), dtype=np.int32)
79 |     iterator = 0
80 |     for column in range(int(length / 2)):
81 |         for row in range(2):
82 |             M[row][column] = integers[iterator]
83 |             iterator += 1
84 |     return M
85 | 
86 | def chr_to_int(char):
87 |     char = char.upper()
88 |     integer = ord(char) - 65
89 |     return integer
90 | def main():
91 |     msg = raw_input("Message: ")
92 |     encrypted_msg = encrypt(msg)
93 |     print("Encrypting:")
94 |     print(encrypted_msg)
95 |     print("Decrypting")
96 |     decrypted_msg = decrypt(encrypted_msg)
97 |     print(decrypted_msg)
98 | main()
99 | 


--------------------------------------------------------------------------------
/CNS/aes.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>  
  2 | #include <bitset>  
  3 | using namespace std;   
  4 | typedef bitset<8> byte;  
  5 | typedef bitset<32> word;  
  6 |   
  7 | const int Nr = 10;  //AES-128 requires 10 rounds of encryption  
  8 | const int Nk = 4;   //Nk Represents the number of word s that are input keys  
  9 |   
 10 | byte S_Box[16][16] = {  
 11 |     {0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76},  
 12 |     {0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0},  
 13 |     {0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15},  
 14 |     {0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75},  
 15 |     {0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84},  
 16 |     {0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF},  
 17 |     {0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8},  
 18 |     {0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2},  
 19 |     {0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73},  
 20 |     {0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB},  
 21 |     {0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79},  
 22 |     {0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08},  
 23 |     {0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A},  
 24 |     {0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E},  
 25 |     {0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF},  
 26 |     {0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16}  
 27 | };  
 28 |   
 29 | //Round constant, used in key expansion. (AES-128 only takes 10 rounds)  
 30 | word Rcon[10] = {0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000,   
 31 |                  0x20000000, 0x40000000, 0x80000000, 0x1b000000, 0x36000000};  
 32 |   
 33 | /** 
 34 |  * Convert four byte s to one word. 
 35 |  */  
 36 | word Word(byte& k1, byte& k2, byte& k3, byte& k4)  
 37 | {  
 38 |     word result(0x00000000);  
 39 |     word temp;  
 40 |     temp = k1.to_ulong();  // K1  
 41 |     temp <<= 24;  
 42 |     result |= temp;  
 43 |     temp = k2.to_ulong();  // K2  
 44 |     temp <<= 16;  
 45 |     result |= temp;  
 46 |     temp = k3.to_ulong();  // K3  
 47 |     temp <<= 8;  
 48 |     result |= temp;  
 49 |     temp = k4.to_ulong();  // K4  
 50 |     result |= temp;  
 51 |     return result;  
 52 | }  
 53 |   
 54 | /** 
 55 |  *  Cyclic left shift by byte 
 56 |  *  That is to say, [a0, a1, a2, a3] becomes [a1, a2, a3, a0] 
 57 |  */  
 58 | word RotWord(word& rw)  
 59 | {  
 60 |     word high = rw << 8;  
 61 |     word low = rw >> 24;  
 62 |     return high | low;  
 63 | }  
 64 |   
 65 | /** 
 66 |  *  S-box transformation for each byte in input word 
 67 |  */  
 68 | word SubWord(word& sw)  
 69 | {  
 70 |     word temp;  
 71 |     for(int i=0; i<32; i+=8)  
 72 |     {  
 73 |         int row = sw[i+7]*8 + sw[i+6]*4 + sw[i+5]*2 + sw[i+4];  
 74 |         int col = sw[i+3]*8 + sw[i+2]*4 + sw[i+1]*2 + sw[i];  
 75 |         byte val = S_Box[row][col];  
 76 |         for(int j=0; j<8; ++j)  
 77 |             temp[i+j] = val[j];  
 78 |     }  
 79 |     return temp;  
 80 | }  
 81 |   
 82 | /** 
 83 |  *  Key Extension Function - Extended 128-bit key to w[4*(Nr+1)] 
 84 |  */   
 85 | void KeyExpansion(byte key[4*Nk], word w[4*(Nr+1)])  
 86 | {  
 87 |     word temp;  
 88 |     int i = 0;  
 89 |     //The first four of w [] are input key s  
 90 |     while(i < Nk)   
 91 |     {  
 92 |         w[i] = Word(key[4*i], key[4*i+1], key[4*i+2], key[4*i+3]);  
 93 |         ++i;  
 94 |     }  
 95 |   
 96 |     i = Nk;  
 97 |   
 98 |     while(i < 4*(Nr+1))  
 99 |     {  
100 |         temp = w[i-1]; //Record the previous word  
101 |         if(i % Nk == 0)   {
102 |             word rot = RotWord(temp);
103 |             w[i] = w[i-Nk] ^ SubWord(rot) ^ Rcon[i/Nk-1];  
104 |         }
105 |             
106 |         else   
107 |             w[i] = w[i-Nk] ^ temp;  
108 |         ++i;  
109 |     }  
110 | }  
111 |   
112 | int main()  
113 | {  
114 |     byte key[16] = {0x24, 0x75, 0xa2, 0xb3,   
115 |                     0x34, 0x75, 0x56, 0x88,   
116 |                     0x31, 0xe2, 0x12, 0x00,   
117 |                     0x13, 0xaa, 0x54, 0x87};  
118 |   
119 |     word w[4*(Nr+1)];  
120 |   
121 |     cout << "KEY IS: ";  
122 |     for(int i=0; i<16; ++i)  
123 |         cout << hex << key[i].to_ulong() << " ";  
124 |     cout << endl;  
125 |   
126 |     KeyExpansion(key, w);  
127 |     //Testing  
128 |     for(int i=0; i<4*(Nr+1); ++i)  
129 |         cout << "w[" << dec << i << "] = " << hex << w[i].to_ulong() << endl;  
130 |   
131 |     return 0;  
132 | } 
133 | 


--------------------------------------------------------------------------------
/CNS/hillCipherEncryption.py:
--------------------------------------------------------------------------------
 1 | # Python3 code to implement Hill Cipher  --- This is only encryption and not decryption
 2 | #Code is messy, if anyone wants to modify, feel free
 3 | 
 4 | keyMatrix = [[0] * 3 for i in range(3)]
 5 | 
 6 | # Generate vector for the message
 7 | messageVector = [[0] for i in range(3)]
 8 | 
 9 | # Generate vector for the cipher
10 | cipherMatrix = [[0] for i in range(3)]
11 | 
12 | # Following function generates the
13 | # key matrix for the key string
14 | def getKeyMatrix(key):
15 | 	k = 0
16 | 	for i in range(3):
17 | 		for j in range(3):
18 | 			keyMatrix[i][j] = ord(key[k]) % 65
19 | 			k += 1
20 | 
21 | # Following function encrypts the message
22 | def encrypt(messageVector):
23 | 	for i in range(3):
24 | 		for j in range(1):
25 | 			cipherMatrix[i][j] = 0
26 | 			for x in range(3):
27 | 				cipherMatrix[i][j] += (keyMatrix[i][x] *
28 | 									messageVector[x][j])
29 | 			cipherMatrix[i][j] = cipherMatrix[i][j] % 26
30 | 
31 | def HillCipher(message, key):
32 | 
33 | 	# Get key matrix from the key string
34 | 	getKeyMatrix(key)
35 | 
36 | 	# Generate vector for the message
37 | 	for i in range(3):
38 | 		messageVector[i][0] = ord(message[i]) % 65
39 | 
40 | 	# Following function generates
41 | 	# the encrypted vector
42 | 	encrypt(messageVector)
43 | 
44 | 	# Generate the encrypted text
45 | 	# from the encrypted vector
46 | 	CipherText = []
47 | 	for i in range(3):
48 | 		CipherText.append(chr(cipherMatrix[i][0] + 65))
49 | 
50 | 	# Finally print the ciphertext
51 | 	print("Ciphertext: ", "".join(CipherText))
52 | 
53 | def main():
54 | 
55 | 	msg1="YAT"					#Use your own name with each string divided into strings of length 3
56 | 	msg2="HIN"					#will make the code better with for loop (but lazy rn)
57 | 	msg3="RAO"
58 | 
59 | 	key = "GYBNQKURP"                     #Any key is fine
60 | 
61 | 	HillCipher(msg1, key)
62 | 	HillCipher(msg2, key)
63 | 	HillCipher(msg3, key)
64 | 
65 | if __name__ == "__main__":
66 | 	main()
67 | 


--------------------------------------------------------------------------------
/CNS/rsa.py:
--------------------------------------------------------------------------------
  1 | '''
  2 | WELCOME TO THE RSA ENCRYPTOR. THIS IS AN INTERACTIVE TOOL USED TO ENCRYPT OR DECRYPT A MESSAGE USING THE FAMOUS RSA ALGORITHM.
  3 |  
  4 | PROGRAMMER: ANIRUDH GOTTIPARTHY
  5 | '''
  6 |  
  7 | import math
  8 |  
  9 | print("RSA ENCRYPTOR/DECRYPTOR")
 10 | print("*****************************************************")
 11 |  
 12 | #Input Prime Numbers
 13 | print("PLEASE ENTER THE 'p' AND 'q' VALUES BELOW:")
 14 | p = int(input("Enter a prime number for p: "))
 15 | q = int(input("Enter a prime number for q: "))
 16 | print("*****************************************************")
 17 |  
 18 | #Check if Input's are Prime
 19 | '''THIS FUNCTION AND THE CODE IMMEDIATELY BELOW THE FUNCTION CHECKS WHETHER THE INPUTS ARE PRIME OR NOT.'''
 20 | def prime_check(a):
 21 |     if(a==2):
 22 |         return True
 23 |     elif((a<2) or ((a%2)==0)):
 24 |         return False
 25 |     elif(a>2):
 26 |         for i in range(2,a):
 27 |             if not(a%i):
 28 |                 return false
 29 |     return True
 30 |  
 31 | check_p = prime_check(p)
 32 | check_q = prime_check(q)
 33 | while(((check_p==False)or(check_q==False))):
 34 |     p = int(input("Enter a prime number for p: "))   #73
 35 |     q = int(input("Enter a prime number for q: "))   #151
 36 |     check_p = prime_check(p)
 37 |     check_q = prime_check(q)
 38 |  
 39 | #RSA Modulus
 40 | '''CALCULATION OF RSA MODULUS 'n'.'''
 41 | n = p * q
 42 | print("RSA Modulus(n) is:",n)
 43 |  
 44 | #Eulers Toitent
 45 | '''CALCULATION OF EULERS TOITENT 'r'.'''
 46 | r= (p-1)*(q-1)
 47 | print("Eulers Toitent(r) is:",r)
 48 | print("*****************************************************")
 49 |  
 50 | #GCD
 51 | '''CALCULATION OF GCD FOR 'e' CALCULATION.'''
 52 | def egcd(e,r):
 53 |     while(r!=0):
 54 |         e,r=r,e%r
 55 |     return e
 56 |  
 57 | #Euclid's Algorithm
 58 | def eugcd(e,r):
 59 |     for i in range(1,r):
 60 |         while(e!=0):
 61 |             a,b=r//e,r%e
 62 |             if(b!=0):
 63 |                 print("%d = %d*(%d) + %d"%(r,a,e,b))
 64 |             r=e
 65 |             e=b
 66 |  
 67 | #Extended Euclidean Algorithm
 68 | def eea(a,b):
 69 |     if(a%b==0):
 70 |         return(b,0,1)
 71 |     else:
 72 |         gcd,s,t = eea(b,a%b)
 73 |         s = s-((a//b) * t)
 74 |         print("%d = %d*(%d) + (%d)*(%d)"%(gcd,a,t,s,b))
 75 |         return(gcd,t,s)
 76 |  
 77 | #Multiplicative Inverse
 78 | def mult_inv(e,r):
 79 |     gcd,s,_=eea(e,r)
 80 |     if(gcd!=1):
 81 |         return None
 82 |     else:
 83 |         if(s<0):
 84 |             print("s=%d. Since %d is less than 0, s = s(modr), i.e., s=%d."%(s,s,s%r))
 85 |         elif(s>0):
 86 |             print("s=%d."%(s))
 87 |         return s%r
 88 |  
 89 | #e Value Calculation
 90 | '''FINDS THE HIGHEST POSSIBLE VALUE OF 'e' BETWEEN 1 and 1000 THAT MAKES (e,r) COPRIME.'''
 91 | for i in range(1,1000):
 92 |     if(egcd(i,r)==1):
 93 |         e=i
 94 | print("The value of e is:",e)
 95 | print("*****************************************************")
 96 |  
 97 | #d, Private and Public Keys
 98 | '''CALCULATION OF 'd', PRIVATE KEY, AND PUBLIC KEY.'''
 99 | print("EUCLID'S ALGORITHM:")
100 | eugcd(e,r)
101 | print("END OF THE STEPS USED TO ACHIEVE EUCLID'S ALGORITHM.")
102 | print("*****************************************************")
103 | print("EUCLID'S EXTENDED ALGORITHM:")
104 | d = mult_inv(e,r)
105 | print("END OF THE STEPS USED TO ACHIEVE THE VALUE OF 'd'.")
106 | print("The value of d is:",d)
107 | print("*****************************************************")
108 | public = (e,n)
109 | private = (d,n)
110 | print("Private Key is:",private)
111 | print("Public Key is:",public)
112 | print("*****************************************************")
113 |  
114 | #Encryption
115 | '''ENCRYPTION ALGORITHM.'''
116 | def encrypt(pub_key,n_text):
117 |     e,n=pub_key
118 |     x=[]
119 |     m=0
120 |     for i in n_text:
121 |         if(i.isupper()):
122 |             m = ord(i)-65
123 |             c=(m**e)%n
124 |             x.append(c)
125 |         elif(i.islower()):               
126 |             m= ord(i)-97
127 |             c=(m**e)%n
128 |             x.append(c)
129 |         elif(i.isspace()):
130 |             spc=400
131 |             x.append(400)
132 |     return x
133 |      
134 |  
135 | #Decryption
136 | '''DECRYPTION ALGORITHM'''
137 | def decrypt(priv_key,c_text):
138 |     d,n=priv_key
139 |     txt=c_text.split(',')
140 |     x=''
141 |     m=0
142 |     for i in txt:
143 |         if(i=='400'):
144 |             x+=' '
145 |         else:
146 |             m=(int(i)**d)%n
147 |             m+=65
148 |             c=chr(m)
149 |             x+=c
150 |     return x
151 |  
152 | #Message
153 | message = input("What would you like encrypted or decrypted?(Separate numbers with ',' for decryption):")
154 | print("Your message is:",message)
155 |  
156 | #Choose Encrypt or Decrypt and Print
157 | choose = input("Type '1' for encryption and '2' for decrytion.")
158 | if(choose=='1'):
159 |     enc_msg=encrypt(public,message)
160 |     print("Your encrypted message is:",enc_msg)
161 |     print("Thank you for using the RSA Encryptor. Goodbye!")
162 | elif(choose=='2'):
163 |     print("Your decrypted message is:",decrypt(private,message))
164 |     print("Thank you for using the RSA Encryptor. Goodbye!")
165 | else:
166 |     print("You entered the wrong option.")
167 |     print("Thank you for using the RSA Encryptor. Goodbye!")
168 | 


--------------------------------------------------------------------------------
/CNS/transposition.py:
--------------------------------------------------------------------------------
 1 | import math
 2 | 
 3 | key = input()
 4 | 
 5 | 
 6 | def encryptMessage(msg):
 7 | 	cipher = ""
 8 | 
 9 | 	k_indx = 0
10 | 
11 | 	msg_len = float(len(msg))
12 | 	msg_lst = list(msg)
13 | 	key_lst = sorted(list(key))
14 | 
15 | 	col = len(key)
16 | 
17 | 	row = int(math.ceil(msg_len / col))
18 | 
19 | 	fill_null = int((row * col) - msg_len)
20 | 	msg_lst.extend('_' * fill_null)
21 | 
22 | 	matrix = [msg_lst[i: i + col]
23 | 			for i in range(0, len(msg_lst), col)]
24 | 
25 | 	for _ in range(col):
26 | 		curr_idx = key.index(key_lst[k_indx])
27 | 		cipher += ''.join([row[curr_idx]
28 | 						for row in matrix])
29 | 		k_indx += 1
30 | 
31 | 	return cipher
32 | 
33 | def decryptMessage(cipher):
34 | 	msg = ""
35 | 
36 | 	k_indx = 0
37 | 
38 | 	msg_indx = 0
39 | 	msg_len = float(len(cipher))
40 | 	msg_lst = list(cipher)
41 | 
42 | 	col = len(key)
43 | 
44 | 	row = int(math.ceil(msg_len / col))
45 | 
46 | 	key_lst = sorted(list(key))
47 | 
48 | 	dec_cipher = []
49 | 	for _ in range(row):
50 | 		dec_cipher += [[None] * col]
51 | 
52 | 	for _ in range(col):
53 | 		curr_idx = key.index(key_lst[k_indx])
54 | 
55 | 		for j in range(row):
56 | 			dec_cipher[j][curr_idx] = msg_lst[msg_indx]
57 | 			msg_indx += 1
58 | 		k_indx += 1
59 | 
60 | 	try:
61 | 		msg = ''.join(sum(dec_cipher, []))
62 | 	except TypeError:
63 | 		raise TypeError("This program cannot",
64 | 						"handle repeating words.")
65 | 
66 | 	null_count = msg.count('_')
67 | 
68 | 	if null_count > 0:
69 | 		return msg[: -null_count]
70 | 
71 | 	return msg
72 | 
73 | msg = input()
74 | 
75 | cipher = encryptMessage(msg)
76 | l=[]
77 | for i in range(len(cipher)):
78 |     l.append(cipher[i])
79 |     
80 |     
81 |     
82 | print("the encrypted message is: {}".format(l))
83 | 
84 | print("Decryped Message: {}".
85 | 	format(decryptMessage(cipher)))
86 | 
87 | 
88 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # 6thSemLabPrograms
 2 | CNS, CN and WT lab programs
 3 | 
 4 | Feel free to add/modify/document programs
 5 | 
 6 | Also, the WT text book link -> https://drive.google.com/file/d/15Nj3W9YihJwiE4DKX8dffHbctgkREAKg/view?usp=sharing <br />
 7 | CN book -> https://drive.google.com/file/d/12rphUZy1f3wNAT9_zuPrwxoR_ARJkjEX/view?usp=sharing
 8 | 
 9 | 
10 | GGWP to everyone who used/contributed to-this repo to learn for lab :) 
11 | 


--------------------------------------------------------------------------------
/WT/XML_CSS/PROG5.css:
--------------------------------------------------------------------------------
1 | *{
2 |     display: block; font-size: 20px;
3 | }
4 | USN {
5 |     color: blue;
6 |     font-size: 30px;
7 |     margin-top: 20px;
8 | }
9 | 


--------------------------------------------------------------------------------
/WT/XML_CSS/usnChecker.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <?xml-stylesheet type="text/css" href="PROG5.css"?>
 3 | 
 4 | <STUDENTDATA>
 5 | 
 6 |  <STUDENT>
 7 |   <USN>USN   : 4ni19is116 </USN>
 8 |   <NAME>NAME : Yathin S Rao</NAME>
 9 |   <COLLEGE>COLLEGE : NIE, Mysore</COLLEGE>
10 |   <BRANCH>BRANCH :ISE</BRANCH>
11 |   <YEAR>YEAR : 2019-2023</YEAR>
12 |   <EMAIL>E-MAIL : 4ni19is116_b@nie.ac.in</EMAIL>
13 |  </STUDENT>
14 |  
15 |  <STUDENT>
16 |   <USN>USN   : 4ni19is113 </USN>
17 |   <NAME>NAME : Vishal Rai</NAME>
18 |   <COLLEGE>COLLEGE : NIE, Mysore</COLLEGE>
19 |   <BRANCH>BRANCH :ISE</BRANCH>
20 |   <YEAR>YEAR : 2019-2023</YEAR>
21 |   <EMAIL>E-MAIL : 4ni19is113_b@nie.ac.in</EMAIL>
22 |  </STUDENT>
23 |  
24 |  <STUDENT>
25 |   <USN>USN   : 4ni19is119 </USN>
26 |   <NAME>NAME : Aman Narayan Singh</NAME>
27 |   <COLLEGE>COLLEGE : NIE, Mysore</COLLEGE>
28 |   <BRANCH>BRANCH :ISE</BRANCH>
29 |   <YEAR>YEAR : 2019-2023</YEAR>
30 |   <EMAIL>E-MAIL : 4ni19ec010_b@nie.ac.in</EMAIL>
31 |  </STUDENT>
32 | 
33 | </STUDENTDATA>
34 | 


--------------------------------------------------------------------------------
/WT/XML_XSL/4b.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <?xml-stylesheet type="text/xsl" href="4b.xsl" ?>
 3 | <students>
 4 |   <title>Student Information</title>
 5 |   <student>
 6 |     <usn>4ni19is116</usn>
 7 |     <name>Some_Name</name>
 8 |     <college>Some_College</college>
 9 |     <branch>Some_Branch</branch>
10 |     <yoj>Year_Of_Joining</yoj>
11 |     <email>Some_Email</email>
12 |   </student>
13 |   <student>
14 |     <usn>1AT10CS002</usn>
15 |     <name>Y</name>
16 |     <college>AIT</college>
17 |     <branch>Computer Science and Engineering</branch>
18 |     <yoj>2010</yoj>
19 |     <email>y@me.com</email>
20 |   </student>
21 |   <student>
22 |     <usn>1AT10CS003</usn>
23 |     <name>Z</name>
24 |     <college>AIT</college>
25 |     <branch>Computer Science and Engineering</branch>
26 |     <yoj>2010</yoj>
27 |     <email>z@gmail.com</email>
28 |   </student>
29 | </students>
30 | 


--------------------------------------------------------------------------------
/WT/XML_XSL/4b.xsl:
--------------------------------------------------------------------------------
 1 | <?xml version = "1.0"?>
 2 | <xsl:stylesheet
 3 |     version = "1.0"
 4 |     xmlns:xsl = "http://www.w3.org/1999/XSL/Transform"
 5 |     xmlns = "http://www.w3.org/1999/xhtml">
 6 | 
 7 |   <xsl:template match="/">
 8 |     <html>
 9 |       <body bgcolor="red">
10 |         <xsl:apply-templates/>
11 |       </body>
12 |     </html>
13 |   </xsl:template>
14 | 
15 |   <xsl:template match="student">
16 |     
17 |       <h2>STUDENT</h2>
18 |       USN:<xsl:value-of select="usn"/><br/>
19 |       Name:<xsl:value-of select="name"/><br/>
20 |       College:<xsl:value-of select="college"/><br/>
21 |       Branch:<xsl:value-of select="branch" /><br/>
22 |       Year of Join:<xsl:value-of select="yoj"/><br/>
23 |       E-Mail:<xsl:value-of select="email"/><br/>
24 |   
25 |   </xsl:template>
26 | 
27 |   <xsl:template match="text()"/>
28 | 
29 | </xsl:stylesheet>
30 | 


--------------------------------------------------------------------------------
/WT/html/fib.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | <head>
 3 | <title>Program 2a</title>
 4 | </head>
 5 | <script type="text/javascript">
 6 | function fib() {
 7 | var n = prompt("Enter N: ","");
 8 | fib1=0;
 9 | fib2=1;
10 | fib=0;
11 | document.write("<h2>" +fib1 +"\n</h2>");
12 | document.write("<h2>" +fib2 +"\n</h2>");
13 | for(i=0;i<n;i++) {
14 | fib = fib1+fib2;
15 | fib1=fib2;
16 | fib2=fib;
17 | document.write("<h2>" +fib +"\n</h2>");
18 | }}
19 | </script>
20 | <body onload="fib()">
21 | 
22 | </body>
23 | </html>
24 | 


--------------------------------------------------------------------------------
/WT/html/reverse.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | <head>
 3 | <title>Program 3b</title>
 4 | </head>
 5 | <script type="text/javascript">
 6 | function rev()
 7 | {
 8 | var n = prompt("Enter a number: ","");
 9 | var str=0;
10 | for(i=n.length-1;i>=0;i--)
11 | str = str*10 + Number(n[i]);
12 | alert(str);
13 | }
14 | </script>
15 | <body onload="rev()">
16 | </body>
17 | </html>
18 | 
19 | 
20 | 
21 | //Another method using string and array methods lol
22 | 
23 | <html>
24 |   <head>
25 |     <title>
26 |       prog
27 |     </title>
28 |   </head>
29 |   <script>
30 |     function rev(){
31 |     var x = prompt("Enter the number");
32 |     var y = x.toString();
33 |      document.write("<h2>"+y.split('').reverse().join('')+"</h2>");
34 |     }
35 |   </script>
36 |   <body onload="rev()">
37 |   </body>
38 | </html>
39 | 


--------------------------------------------------------------------------------
/WT/html/square.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | <head>
 3 | <title>Program 2b</title>
 4 | </head>
 5 | <body>
 6 | <script type="text/javascript">
 7 | var n=prompt("enter a number");
 8 | if(n!=null && n>0)
 9 | {
10 | var i=0;
11 | document.write("<h2>The first " + n + " numbers and their squares are: </h2>");
12 | document.write("<table border=1><tr><th><b>Number</b></th><th><b>Square</b></th></tr><br>");
13 | for(i=1;i<=n;i++)
14 | document.write("<tr><td>" + i + "</td><td>" + i*i + "</td></tr><br>");
15 | document.write("</table>");
16 | }
17 | else
18 | alert("No input");
19 | </script>
20 | </body>
21 | </html>
22 | 


--------------------------------------------------------------------------------
/WT/html/usnValidation.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | <head>
 3 | <title>Program 4</title>
 4 | </head>
 5 | <body>
 6 |   <script type="text/javascript">
 7 |     function validate()
 8 |     {
 9 |        var pattern=/[1-4][A-Z][A-Z][0-9][0-9][A-Z][A-Z][0-9][0-9][0-9]$/;
10 |        usn = document.getElementById('usn');
11 |        if( !usn.value.match(pattern))
12 |        alert("Invalid USN");
13 |        else
14 |        alert("Valid USN");
15 |     }
16 |     </script>
17 |     
18 | <form>
19 |        Enter USN: 
20 |        <input type="text" name="usn" id="usn"><br> 
21 |        <input type="submit" name="submit" onclick=validate()><br>
22 | </form>
23 | </body>
24 | </html>
25 | 


--------------------------------------------------------------------------------
/WT/html/vowel.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | <head>
 3 | <title>Program 3a</title>
 4 | </head>
 5 | <script type="text/javascript">
 6 | function vowel()
 7 | {
 8 | var n = prompt("Enter a string: ","");
 9 | flag=0;
10 | for(i=0;i<n.length && flag!=1 ;i++)
11 | {
12 | switch(n[i])
13 | {
14 | case 'a':
15 | case 'e':
16 | case 'i':
17 | case 'o':
18 | case 'u': alert("The left most vowel is present in the position: " +(i+1));
19 |  flag = 1;
20 |  break;
21 | default : break;
22 | }
23 | }
24 | if(!flag)
25 | alert("No Vowels found.");
26 | }
27 | </script>
28 | <body onload="vowel()">
29 | </body>
30 | </html>
31 | 


--------------------------------------------------------------------------------
/WT/php/cookie.php:
--------------------------------------------------------------------------------
 1 | <html>
 2 | <body bgcolor="87ceeb">
 3 | <center><h2> Last visited time on the web page</h2></center>
 4 | <br>
 5 | <?php
 6 | //date_default_timezone_set('Asia/Calcutta');-You can choose any timezone
 7 |  
 8 | //Calculate 60 days in the future
 9 | //seconds * minutes * hours * days + current time
10 |  
11 | $inTwoMonths = 60 * 60 * 24 * 60 + time();
12 | setcookie('lastVisit', date("G:i - m/d/y"), $inTwoMonths);
13 | if(isset($_COOKIE['lastVisit']))
14 |  
15 | {
16 | $visit = $_COOKIE['lastVisit'];
17 | echo "Your last visit was - ". $visit;
18 | }
19 | else
20 | echo "You've got some stale cookies!";
21 | ?>
22 | </body>
23 | </html>
24 | 


--------------------------------------------------------------------------------
/WT/php/counter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $name = "counter.txt";
 4 | $file = fopen($name, "r");
 5 | 
 6 | $hits = fscanf($file, "%d");
 7 | fclose($file);
 8 | 
 9 | $file = fopen($name, "w");
10 | $hits[0]++;
11 | fwrite($file, $hits[0]);
12 | 
13 | echo "Total number of views: ".$hits[0];
14 | ?>
15 | 
16 | 
17 | another code if the above one doesnt work in putty SSH
18 | 
19 | <?php
20 |  
21 | $count_page = ("counter.txt");
22 | $hits = file($count_page);
23 | $hits[0] ++;
24 |  
25 | $fp = fopen($count_page , "w");
26 | fputs($fp , "$hits[0]");
27 | fclose($fp);
28 | echo $hits[0];
29 |  
30 | ?>
31 | 


--------------------------------------------------------------------------------
/WT/php/greet.php:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |    <title></title>
 5 |    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 6 |    </head>
 7 |    <body>
 8 |    <form method='POST'>
 9 |    <h2>Please input your name:</h2>
10 |  <input type="text" name="name">
11 |  <input type="submit" value="Submit Name">
12 |  </form>
13 | <?php
14 | 
15 | $name = $_POST['name'];
16 | $greetings =array("Hello","Welcome","Hi","Good morning");
17 | $random_keys=array_rand($greetings);
18 | $greeting = $greetings[$random_keys];
19 | echo "<h3> $greeting $name </h3>";
20 | ?>
21 | 
22 | </body>
23 | </html>
24 | 


--------------------------------------------------------------------------------
/WT/php/largest.php:
--------------------------------------------------------------------------------
1 | <?php
2 | $a=(int)readline('Enter the first number: ');
3 | $b=(int)readline('Enter the first number: ');
4 | $c=(int)readline('Enter the first number: ');
5 | $large = max($a,$b,$c);
6 | echo $large;
7 | ?>
8 | 


--------------------------------------------------------------------------------
/WT/php/library/DBConnection.php:
--------------------------------------------------------------------------------
1 | <?php
2 | //Establishing connection with the database
3 | define('DB_SERVER', 'localhost:3306');
4 | define('DB_USERNAME', 'root');   // username:- viis{number}
5 | define('DB_PASSWORD', 'root123'); // password:-^^^
6 | define('DB_DATABASE', 'test'); //where test is the database name  ---> make this the db of your choice 
7 | $db = mysqli_connect(DB_SERVER,DB_USERNAME,DB_PASSWORD,DB_DATABASE);
8 | ?>
9 | 


--------------------------------------------------------------------------------
/WT/php/library/DisplayBooks.php:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE HTML>
 2 | <html>
 3 |     <body bgcolor="87ceeb">
 4 |     <center><h2>Simple Library Management System</h2></center>
 5 |     <br>
 6 |  
 7 |     <?php
 8 |     include("DBConnection.php");
 9 |  
10 |     $search = $_REQUEST["search"];
11 |  
12 |     $query = "select ISBN,Title,Author,Edition,Publication from book_info where title like '%$search%'"; //search with a book name in the table book_info
13 |     $result = mysqli_query($db,$query);
14 |  
15 |     if(mysqli_num_rows($result)>0)if(mysqli_num_rows($result)>0)
16 |  
17 |     {
18 |     ?>
19 |  
20 |     <table border="2" align="center" cellpadding="5" cellspacing="5">
21 |         <tr>
22 |             <th> ISBN </th>
23 |             <th> Title </th>
24 |             <th> Author </th>
25 |             <th> Edition </th>
26 |             <th> Publication </th>
27 |         </tr>
28 |  
29 |         <?php while($row = mysqli_fetch_assoc($result))
30 |         {
31 |         ?>
32 |         <tr>
33 |             <td><?php echo $row["ISBN"];?> </td>
34 |             <td><?php echo $row["Title"];?> </td>
35 |             <td><?php echo $row["Author"];?> </td>
36 |             <td><?php echo $row["Edition"];?> </td>
37 |             <td><?php echo $row["Publication"];?> </td>
38 |         </tr>
39 |         <?php
40 |         }
41 |         }
42 |         else
43 |         echo "<center>No books found in the library by the name $search </center>" ;
44 |         ?>   
45 |     </table>
46 |     </body>
47 | </html>
48 | 


--------------------------------------------------------------------------------
/WT/php/library/EnterBooks.php:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE HTML>
 2 | <html>
 3 | <body bgcolor="87ceeb">
 4 |     <center><h2>Simple Library Management System</h2></center>
 5 |     <!--Once the form is submitted, all the form data is forwarded to InsertBooks.php -->
 6 |     <form action="InsertBooks.php" method="post">
 7 |  
 8 |         <table border="2" align="center" cellpadding="5" cellspacing="5">
 9 |             <tr>
10 |             <td> Enter ISBN :</td>
11 |             <td> <input type="text" name="isbn" size="48"> </td>
12 |             </tr>
13 |             <tr>
14 |             <td> Enter Title :</td>
15 |             <td> <input type="text" name="title" size="48"> </td>
16 |             </tr>
17 |             <tr>
18 |             <td> Enter Author :</td>
19 |             <td> <input type="text" name="author" size="48"> </td>
20 |             </tr>
21 |             <tr>
22 |             <td> Enter Edition :</td>
23 |             <td> <input type="text" name="edition" size="48"> </td>
24 |             </tr>
25 |             <tr>
26 |             <td> Enter Publication: </td>
27 |             <td> <input type="text" name="publication" size="48"> </td>
28 |             </tr>
29 |             <tr>
30 |             <td></td>
31 |             <td>
32 |             <input type="submit" value="submit">
33 |             <input type="reset" value="Reset">
34 |             </td>
35 |             </tr>
36 |         </table>
37 |     </form>
38 | </body>
39 | </html>
40 | 


--------------------------------------------------------------------------------
/WT/php/library/InsertBooks.php:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE HTML>
 2 | <html>
 3 | <body bgcolor="87ceeb">
 4 |     <center><h2>Simple Library Management System</h2></center>
 5 |     <br>
 6 |  
 7 |     <?php
 8 |         include("DBConnection.php");
 9 |  
10 |         $isbn=$_POST["isbn"];
11 |         $title=$_POST["title"];
12 |         $author=$_POST["author"];
13 |         $edition=$_POST["edition"];
14 |         $publication=$_POST["publication"];
15 |  
16 |         $query = "insert into book_info(isbn,title,author,edition,publication) values('$isbn','$title','$author','$edition','$publication')"; //Insert query to add book details into the book_info table
17 |         $result = mysqli_query($db,$query);
18 |     ?>
19 |     <h3> Book information is inserted successfully </h3>
20 |  
21 |     <a href="SearchBooks.php"> To search for the Book information click here </a>
22 |  
23 | </body>
24 | </html>
25 | 


--------------------------------------------------------------------------------
/WT/php/library/SearchBooks.php:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE HTML>
 2 | <html>
 3 |     <body bgcolor="87ceeb">
 4 |     <center><h2>Simple Library Management System</h2></center>
 5 |     <form action = "DisplayBooks.php" method="get">
 6 |         <center>Enter the title of the book to be searched :
 7 |         <input type="text" name="search" size="48">
 8 |         <br></br>
 9 |         <input type="submit" value="submit">
10 |         <input type="reset" value="Reset">
11 |         </center>
12 |         <br>
13 |         </form>
14 |     </body>
15 | </html>
16 | 


--------------------------------------------------------------------------------
/WT/php/serverInfo.php:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <body>
 4 | 
 5 | <?php
 6 | echo $_SERVER['SERVER_NAME'];
 7 | echo "<br>";
 8 | echo $_SERVER['SERVER_SOFTWARE'];
 9 | echo "<br>";
10 | echo $_SERVER['SERVER_PROTOCOL'];
11 | echo "<br>";
12 | echo $_SERVER['SERVER_ADDR'];
13 | echo "<br>";
14 | echo $_SERVER['GATEWAY_INTERFACE'];
15 | echo "<br>";
16 | echo $_SERVER['REQUEST_METHOD'];
17 | echo "<br>";
18 | echo $_SERVER['SERVER_PORT'];
19 | ?>
20 | 
21 | </body>
22 | </html>
23 | 


--------------------------------------------------------------------------------
/WT/php/session.php:
--------------------------------------------------------------------------------
 1 | <?php 
 2 |   
 3 | session_start();
 4 |    
 5 | if(isset($_SESSION['views']))
 6 |     $_SESSION['views'] = $_SESSION['views']+1;
 7 | else
 8 |     $_SESSION['views']=1;
 9 |       
10 | echo"views = ".$_SESSION['views'];
11 |   
12 | ?>
13 | 


--------------------------------------------------------------------------------