Categories
TE Computer Engineering

4. Write a program to demonstrate subnetting and find the subnet masks.

Download The write up here

import java.io.*;
import java.net.InetAddress;
public class Subnet1 {

    public static void main(String[] args) throws IOException {

        System.out.println(“ENTER IP:”);
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String ip = br.readLine();
        String checkclass = ip.substring(0, 3);

        int cc = Integer.parseInt(checkclass);
        String mask = null;
        if(cc>0)
        {
            if(cc<=127)
            {
                mask = “255.0.0.0”;
        System.out.println(“Class A IP Address”);
        System.out.println(“SUBNET MASK:\n”+mask);
            }
            if(cc>=128 && cc<=191)
            {
                mask = “255.255.0.0”;
        System.out.println(“Class B IP Address”);
        System.out.println(“SUBNET MASK:\n”+mask);
            }
            if(cc>=192 && cc<=223)
            {
                mask = “255.255.255.0”;
        System.out.println(“Class C IP Address”);
        System.out.println(“SUBNET MASK:\n”+mask);
            }
        if(cc>=224 && cc<=239)
            {
        mask = “255.0.0.0”;
                System.out.println(“Class D IP Address Used for multicasting”);
            }
            if(cc>=240 && cc<=254)
            {
        mask = “255.0.0.0”;
                System.out.println(“Class E IP Address Experimental Use”);
            }
        }

        String networkAddr=””;
    String lastAddr=””;
        String[] ipAddrParts=ip.split(“\\.”);
        String[] maskParts=mask.split(“\\.”);

        for(int i=0;i<4;i++){
        int x=Integer.parseInt(ipAddrParts[i]);
        int y=Integer.parseInt(maskParts[i]);
        int z=x&y;
        networkAddr+=z+”.”;
    int w=z|(y^255);
    lastAddr+=w+”.”;
        }

    System.out.println(“First IP of block: “+networkAddr);
    System.out.println(“Last IP of block: “+lastAddr);
   }

}

/*OUTPUT
iotlab@iotlab-Veriton-M200-B360:~$ javac Subnet1.java
iotlab@iotlab-Veriton-M200-B360:~$ java Subnet1
ENTER IP:
226.35.65.23
Class D IP Address Used for multicasting
First IP of block: 226.0.0.0.
Last IP of block: 226.255.255.255.
iotlab@iotlab-Veriton-M200-B360:~$ java Subnet1
ENTER IP:
192.168.100.5
Class C IP Address
SUBNET MASK:
255.255.255.0
First IP of block: 192.168.100.0.
Last IP of block: 192.168.100.255.
iotlab@iotlab-Veriton-M200-B360:~$
*/

Categories
TE Computer Engineering

3. Write a program to simulate Go back N and Selective Repeat Modes of Sliding Window Protocol in peer to peer mode and demonstrate the packets captured traces using Wireshark Packet Analyzer Tool for peer to peer mode.

Download The write up here

//—–AT CLIENT SIDE——

    import java.lang.System;
    import java.net.*;
    import java.io.*;

    public class Client {
        static Socket connection;

        public static void main(String a[]) throws SocketException {
            try {
                int v[] = new int[9];
                //int g[] = new int[8];
                int n = 0;
                InetAddress addr = InetAddress.getByName(“Localhost”);
                System.out.println(addr);
                connection = new Socket(addr, 8011);
                DataOutputStream out = new DataOutputStream(
                        connection.getOutputStream());
                DataInputStream in = new DataInputStream(
                        connection.getInputStream());
                int p = in.read();
                System.out.println(“No of frame is:” + p);

                for (int i = 0; i < p; i++) {
                    v[i] = in.read();
                    System.out.println(v[i]);
                    //g[i] = v[i];
                }
                v[5] = -1;
                for (int i = 0; i < p; i++)
                 {
                    System.out.println(“Received frame is: ” + v[i]);

                    }
                for (int i = 0; i < p; i++)
                    if (v[i] == -1) {
                System.out.println(“Request to retransmit packet no “
                                + (i+1) + ” again!!”);
                        n = i;
                        out.write(n);
                        out.flush();
                    }

                System.out.println();

                    v[n] = in.read();
                System.out.println(“Received frame is: ” + v[n]);



                System.out.println(“quiting”);
            } catch (Exception e) {
                System.out.println(e);
            }

        }
    }

/* OUTPUT 
iotlab@iotlab-Veriton-M200-B360:~/sliding window$ javac Client.java
iotlab@iotlab-Veriton-M200-B360:~/sliding window$ java Client
Localhost/127.0.0.1
No of frame is:9
30
40
50
60
70
80
90
100
110
Received frame is: 30
Received frame is: 40
Received frame is: 50
Received frame is: 60
Received frame is: 70
Received frame is: -1
Received frame is: 90
Received frame is: 100
Received frame is: 110
Request to retransmit packet no 6 again!!

Received frame is: 80
quiting
iotlab@iotlab-Veriton-M200-B360:~/sliding window$
*/

//—–AT SERVER SIDE—–

    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.io.IOException;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.net.SocketException;

    public class Server {
        static ServerSocket Serversocket;
        static DataInputStream dis;
        static DataOutputStream dos;

        public static void main(String[] args) throws SocketException {

        try {
            int a[] = { 30, 40, 50, 60, 70, 80, 90, 100, 110 };
            Serversocket = new ServerSocket(8011);
            System.out.println(“waiting for connection”);
            Socket client = Serversocket.accept();
            dis = new DataInputStream(client.getInputStream());
            dos = new DataOutputStream(client.getOutputStream());
            System.out.println(“The number of packets sent is:” + a.length);
            int y = a.length;
            dos.write(y);
            dos.flush();

            for (int i = 0; i < a.length; i++) {
                dos.write(a[i]);
                dos.flush();
            }

            int k = dis.read();

            dos.write(a[k]);
            dos.flush();

            } catch (IOException e) {
                System.out.println(e);
            } finally {
                try {
                    dis.close();
                    dos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        }
    }

/*OUTPUT
iotlab@iotlab-Veriton-M200-B360:~/sliding window$ javac Server.java
iotlab@iotlab-Veriton-M200-B360:~/sliding window$ java Server
waiting for connection
The number of packets sent is:9
iotlab@iotlab-Veriton-M200-B360:~/sliding window$
*/

Categories
TE Computer Engineering

2. Write a program for error detection and correction for 7/8 bits ASCII codes using Hamming Codes or CRC. Demonstrate the packets captured traces using Wireshark Packet Analyzer Tool for peer to peer mode.( 50% students will perform Hamming Code and others will perform CRC).

Download The write up here

1. CRC

#include <iostream>
using namespace std;

int main()
{
    int i,j,k,l;

        //Get Frame
        int fs;
        cout<<“\n Enter Frame size: “;
        cin>>fs;

        int f[20];

        cout<<“\n Enter Frame:”;
        for(i=0;i<fs;i++)
        {
        cin>>f[i];
        }

        //Get Generator
        int gs;
        cout<<“\n Enter Generator size: “;
        cin>>gs;

        int g[20];

        cout<<“\n Enter Generator:”;
        for(i=0;i<gs;i++)
        {
        cin>>g[i];
        }

        cout<<“\n Sender Side:”;
        cout<<“\n Frame: “;
        for(i=0;i<fs;i++)
        {
        cout<<f[i];
        }
        cout<<“\n Generator :”;
        for(i=0;i<gs;i++)
        {
        cout<<g[i];
        }

        //Append 0’s
        int rs=gs-1;
        cout<<“\n Number of 0’s to be appended: “<<rs;
        for (i=fs;i<fs+rs;i++)
        {
        f[i]=0;
        }

        int temp[20];
        for(i=0;i<20;i++)
        {
        temp[i]=f[i];
        }

        cout<<“\n Message after appending 0’s :”;
        for(i=0; i<fs+rs;i++)
        {
        cout<<temp[i];
        }

        //Division
        for(i=0;i<fs;i++)
        {
        j=0;
        k=i;
        //check whether it is divisible or not
        if (temp[k]>=g[j])
        {
            for(j=0,k=i;j<gs;j++,k++)
            {
                if((temp[k]==1 && g[j]==1) || (temp[k]==0 && g[j]==0))
                {
                    temp[k]=0;
                }
                else
                {
                    temp[k]=1;
                }
            }
        }
        }

        //CRC
        int crc[15];
        for(i=0,j=fs;i<rs;i++,j++)
        {
        crc[i]=temp[j];
        }

        cout<<“\n CRC bits: “;
        for(i=0;i<rs;i++)
        {
        cout<<crc[i];
        }

        cout<<“\n Transmitted Frame: “;
        int tf[15];
        for(i=0;i<fs;i++)
        {
        tf[i]=f[i];
        }
        for(i=fs,j=0;i<fs+rs;i++,j++)
        {
        tf[i]=crc[j];
        }
        for(i=0;i<fs+rs;i++)
        {
        cout<<tf[i];
        }

        cout<<“\n Receiver side : “;
        cout<<“\n Received Frame: “;
        for(i=0;i<fs+rs;i++)
        {
        cout<<tf[i];
        }

        for(i=0;i<fs+rs;i++)
        {
        temp[i]=tf[i];
        }

        //Division
        for(i=0;i<fs+rs;i++)
        {
        j=0;
        k=i;
        if (temp[k]>=g[j])
        {
            for(j=0,k=i;j<gs;j++,k++)
            {
                if((temp[k]==1 && g[j]==1) || (temp[k]==0 && g[j]==0))
                {
                    temp[k]=0;
                }
                else
                {
                    temp[k]=1;
                }
            }
        }
        }

        cout<<“\n Reaminder: “;
        int rrem[15];
        for (i=fs,j=0;i<fs+rs;i++,j++)
        {
        rrem[j]= temp[i];
        }
        for(i=0;i<rs;i++)
        {
        cout<<rrem[i];
        }

        int flag=0;
        for(i=0;i<rs;i++)
        {
        if(rrem[i]!=0)
        {
            flag=1;
        }
        }

        if(flag==0)
        {
        cout<<“\n Since Remainder Is 0 Hence Message Transmitted From Sender To Receriver Is Correct”;
        }
        else
        {
        cout<<“\n Since Remainder Is Not 0 Hence Message Transmitted From Sender To Receriver Contains Error”;
        }
        return 0;
}

/* OUTPUT
iotlab@iotlab-Veriton-M200-B360:~$ g++ crc1.cpp
iotlab@iotlab-Veriton-M200-B360:~$ ./a.out

 Enter Frame size: 8

 Enter Frame:1
0
1
1
0
1
1
1

 Enter Generator size: 4

 Enter Generator:1
0
1
0

Sender Side:
Frame: 10110111
Generator :1010
Number of 0’s to be appended: 3
Message after appending 0’s :10110111000
CRC bits: 110
Transmitted Frame: 10110111110
Receiver side :
Received Frame: 10110111110
Reaminder: 000
Since Remainder Is 0 Hence Message Transmitted From Sender To Receriver Is Correct
*/

2. Hamming Code

 #include<iostream>

using namespace std;

int main()
{
    int data[10];
    int dataatrec[10],c,c1,c2,c3,i;

        cout<<“Enter 4 bits of data one by one\n”;
        cin>>data[7];
        cin>>data[6];
        cin>>data[5];
        cin>>data[3];

        //Calculation of even parity
        data[4]=data[5]^data[6]^data[7];
        data[2]=data[3]^data[6]^data[7];
        data[1]=data[3]^data[5]^data[7];

        cout<<“\nEncoded data is\n”;
        for(i=1;i<=7;i++)
            cout<<data[i];

        cout<<“\n\nEnter received data bits one by one\n”;
        for(i=1;i<=7;i++)
            cin>>dataatrec[i];

        c1=dataatrec[1]^dataatrec[3]^dataatrec[5]^dataatrec[7];
        c2=dataatrec[2]^dataatrec[3]^dataatrec[6]^dataatrec[7];
        c3=dataatrec[4]^dataatrec[5]^dataatrec[6]^dataatrec[7];
        c=c3*4+c2*2+c1;
        if(c==0)
        {
        cout<<“\ncongratulations there is no error: “;
    }
    else
    {
        cout<<“\nerror on the postion:”<<c;
        cout<<“\nCorrect message is:”;
        if(dataatrec[c]==0)
                 dataatrec[c]=1;
        else
                 dataatrec[c]=0;
        for (i=1;i<=7;i++)
        {
            cout<<dataatrec[i];
        }
    }

        return 0;
}

/*OUTPUT
iotlab@iotlab-Veriton-M200-B360:~$ g++ Ham.cpp
iotlab@iotlab-Veriton-M200-B360:~$ ./a.out
Enter 4 bits of data one by one
1
1
0
0

Encoded data is
1000011

Enter received data bits one by one
1
1
0
0
0
1
1

error on the postion:2
Correct message is:1000011

iotlab@iotlab-Veriton-M200-B360:~$*/

Categories
TE Computer Engineering

1. Part A: Setup a wired LAN using Layer 2 Switch and then IP switch of minimum four computers. It includes preparation of cable, testing of cable using line tester, configuration machine using IP addresses, testing using PING utility and demonstrate the PING packets captured traces using Wireshark Packet Analyzer Tool. Part B: Extend the same Assignment for Wireless using Access Point.

Refer Lab Manual

Download The write up here

Categories
SE Computer Engineering

NASM Package Installation Process

NASM Package Installation Process

Step 1:
Click here to
Download package from here

Step2:
Extract package at home
Unpack the archive into a directory, which creates a subdirectory nasm-X. XX.

Step 3:
cd to nasm-X. XX and type “./configure” . This shell script will find the best C compiler to use and set up Makefiles accordingly.

Step 4:
Type make to build the nasm and ndisasm binaries.

Step 5:
Type “sudo make install” to install nasm and ndisasm in /usr/local/bin and to install the man pages.

Download Book for Assembly Language Practice

Categories
SE Computer Engineering

12. Write 80387 ALP to find the roots of the quadratic equation. All the possible cas es must be considered in calculating the roots.

section .data
msg1 db 10,13,”Complex Root”
msglen1 equ $-msg1

msg2 db 10,13,” Root1: “
msglen2 equ $-msg2

msg3 db 10,13,” Root2: “
msglen3 equ $-msg3

a dd 1.00
b dd 8.00
c dd 15.00
four dd 4.00
two dd 2.00

hdec dq 100
point db “.”

section .bss

    root1 resd 1
    root2 resd 1
    resbuff rest 1
    temp resb 2
    disc resd 1

%macro write 2            ;macro for display
    mov rax,1
    mov rdi,1
    mov rsi,%1
    mov rdx,%2
    syscall
%endmacro

%macro read 2            ;macro for input
    mov rax,0
    mov rdi,0
    mov rsi,%1
    mov rdx,%2
    syscall
%endmacro

%macro exit 0            ;macro for exit
    mov rax,60
    xor rdi,rdi
    syscall
%endmacro

section .text
  global _start
  _start:

  finit                ; initialise 80387 co-processor
  fld dword[b]            ; stack: b

  fmul dword[b]             ; stack: b*b

  fld dword[a]            ; stack: a, b*b

  fmul dword[c]             ; stack: a*c, b*b

  fmul dword[four]        ; stack: 4*a*c,b*b

  fsub                 ; stack: b*b – 4*a*c

  ftst                 ; compares ST0 and 0


  fstsw ax                ;Stores the coprocessor status word ;into either a word in memory or the AX register
  sahf        ;Stores the AH register into the FLAGS register.
  jb no_real_solutions         ; if disc < 0, no real solutions
  fsqrt             ; stack: sqrt(b*b – 4*a*c)

  fst dword[disc]     ; store disc= sqrt(b*b – 4*a*c)

  fsub dword[b]                 ; stack: disc-b

  fdiv dword[a]             ; stack: disc-b/2*a or (-b+disc)/2a

  fdiv dword[two]

  write msg2,msglen2
 call disp_proc
  fldz                ;stack:0
  fsub dword[disc]        ;stack:-disc
  fsub dword[b]             ; stack: -disc – b
  fdiv dword[a]        ; stack: (-b – disc)/(2*a)
  fdiv dword[two]

  write msg3,msglen3
  call disp_proc
  jmp exi

no_real_solutions:
write msg1,msglen1
exi :

mov rax,60
mov rdi,1
syscall

disp_proc:
    FIMUL dword[hdec]
    FBSTP tword[resbuff]
    mov rsi,resbuff+9
    mov rcx,09
  next1:

      push rcx
      push rsi

      mov bl,[rsi]
      call disp

      pop rsi
      pop rcx

       dec rsi
      loop next1
    push rsi
      write point,1
    pop rsi
      mov bl,[rsi]
      call disp
    ret

disp:
        mov edi,temp                ;mov dnum address into edi
        mov ecx,02                    ;initialize ecx with 2
        dispup1:
            rol bl,4                ;rotate bl by 4 bits
            mov dl,bl                ;move bl into dl
            and dl,0fh            ;and of dl with 0fh
            add dl,30h            ;add 30h into dl
            cmp dl,39h            ;compare dl with 39h
            jbe dispskip1            ;jump if below and equal to dispskip1
            add dl,07h            ;add 7h into dl
            dispskip1:
                mov [edi],dl        ;mov dl into dnum
                inc edi            ;increament edi by a byte
            loop dispup1        ;loop dispup1 while ecx not zero
            write temp,2            ;Display dnum by calling macro
          ret                    ;return from procedure

OUTPUT:

swlab@swlab-H81-M1:~$ nasm -f elf64 square.asm
swlab@swlab-H81-M1:~$
 ld -o mean mean.o
swlab@swlab-H81-M1:~$
 ./squareRoot1: 800000000000000003.00
Root2: 800000000000000005.00
swlab@swlab-H81-M1:~$

Categories
SE Computer Engineering

11. Write 80387 ALP to obtain: i) Mean ii) Variance iii) Standard Deviation Also plot the histogram for the data set.

section .data

msg1 db 10,13,’mean is:  ‘
msg1len equ $- msg1

msg2 db 10,13, ‘std deviation is:’
msg2len equ $- msg2

msg3 db 10,13, ‘variance is:’
msg3len equ $- msg3

data dd 9.0,1.0
datacnt dw 02
hdec dq 100

decpt db ‘.’

section .bss

res rest 01
mean resd 01
var resd 01
dispbuff resb 01

%macro disp 2
    mov eax,04
    mov ebx,01
    mov ecx,%1
    mov edx,%2
    int 80h
%endmacro
%macro accept 2
    mov eax,03
    mov ebx,00
    mov ecx,%1
    mov edx,%2
    int 80h
%endmacro

section .text
global _start
_start:

disp msg1,msg1len

       finit
    fldz
    mov rbx,data
    mov rsi,00
    xor rcx,rcx
    mov cx,[datacnt]

bk:    fadd dword [rbx+rsi*4]
    inc rsi
    loop bk

    fidiv word[datacnt]
    fst dword[mean]

    call dispres

    MOV RCX,00
    MOV CX,[datacnt]
    MOV RBX,data
    MOV RSI,00
    FLDZ
up1:    FLDZ
    FLD DWORD[RBX+RSI*4]
    FSUB DWORD[mean]
    FST ST1
    FMUL
    FADD
    INC RSI
    LOOP up1
    FIDIV word[datacnt]
    FST dWORD[var]
    FSQRT

    disp msg2,msg2len
    CALL dispres

    FLD dWORD[var]
    disp msg3,msg3len
    CALL dispres


exit:     mov eax,01
    mov ebx,00
    int 80h

disp8_proc:
    mov rdi,dispbuff
    mov rcx,02
back:    rol bl,04
    mov dl,bl
    and dl,0FH
    cmp dl,09
    jbe next1
    add dl,07H
next1:  add dl,30H
    mov [rdi],dl
    inc rdi
    loop back
    ret

dispres:
    fimul dword[hdec]
    fbstp tword[res]
    xor rcx,rcx
    mov rcx,09H
    mov rsi,res+9
up2:    push rcx
    push rsi
    mov bl,[rsi]
    call disp8_proc
    disp dispbuff,2 
    pop rsi
    dec rsi
    pop rcx
    loop up2
    disp decpt,1

    mov bl,[res]
    call disp8_proc
    disp dispbuff,2 
    ret

OUTPUT:
swlab@swlab-H81-M1:~$ nasm -f elf64 mean.asm
swlab@swlab-H81-M1:~$ ld -o mean mean.o
swlab@swlab-H81-M1:~$ ./mean

mean is:  000000000000000005.00
std deviation is:000000000000000004.00
variance is:000000000000000016.00

swlab@swlab-H81-M1:~$

Categories
SE Computer Engineering

10. Write x86 ALP to find the factorial of a given integer number on a command line by using recursion. Explicit stack manipulation is expected in the code.

;Problem Statement: Write x86 ALP to find the factorial of a given integer ;number on a command line by using
;recursion. Explicit stack manipulation is expected in the code.

%macro scall 4   ;common macro for input/output
 mov rax,%1
 mov rdi,%2
 mov rsi,%3
 mov rdx,%4
 syscall
%endmacro

section .data
 num db 00h
 msg db “Factorial is : “
 msglen equ $-msg
 msg1 db “*****Program to find Factorial of a number***** “,0Ah
   db “Enter the number : “,
 msg1len equ $-msg1

 zerofact db ” 00000001 “
 zerofactlen equ $-zerofact

section .bss
 dispnum resb 16
 result resb 4
 temp resb 3

section .text
global _start
_start:

 scall 1,1,msg1,msg1len
 scall 0,0,temp,3   ;accept number from user
 call convert       ;convert number from ascii to hex
 mov [num],dl

 scall 1,1,msg,msglen

 mov rdx,0        ;RMD
 mov rax,0        ;RMD
 mov al,[num]   ;store number in accumulator
 cmp al,01h 
 jbe endfact
 mov rbx,0        ;RMD
 mov bl,01h
 call factr    ;call factorial procedure
 call display

 call exit
endfact:
 scall 1,1,zerofact,zerofactlen
 call exit

 factr:    ;recursive procedure

   cmp rax,01h
   je retcon1
   push rax 
   dec rax

   call factr

  retcon:
   pop rbx
   mul ebx
   jmp endpr

  retcon1:   ;if rax=1 return
   pop rbx
   jmp retcon
  endpr:

 ret

 display:   ; procedure to convert hex to ascii

   mov rsi,dispnum+15
   mov rcx,0        ;RMD
   mov cl,16

  cont:
   mov rdx,0        ;RMD
   mov rbx,0        ;RMD
   mov bl,10h
   div ebx
   cmp dl,09h
   jbe skip
   add dl,07h
  skip:
   add dl,30h
   mov [rsi],dl
   dec rsi
   loop cont

   scall 1,1,dispnum,16

 ret

 convert:   ;procedure to convert ascii to hex
   mov rsi,temp
   mov cl,02h
   MOV rax,0        ;RMD
   mov rdx,0        ;RMD
  contc:
   rol dl,04h
   mov al,[rsi]
   cmp al,39h
   jbe skipc
   sub al,07h
  skipc:
   sub al,30h
   add dl,al
   inc rsi
   dec cl
   jnz contc

 ret

 exit:    ;exit system call

   mov rax,60
   mov rdi,0
   syscall

ret

OUTPUT:
swlab@swlab-Veriton-M200-H81:~/Desktop/dhokane$ nasm -f elf64 fact.asm
swlab@swlab-Veriton-M200-H81:~/Desktop/dhokane$ ld -o fact fact.o
swlab@swlab-Veriton-M200-H81:~/Desktop/dhokane$ ./fact
*****Program to find Factorial of a number*****
Enter the number : 03
Factorial is : 0000000000000006
swlab@swlab-Veriton-M200-H81:~/Desktop/dhokane$

Categories
SE Computer Engineering

9. Write a TSR to gene rate the pattern of the frequency tones by reading the Real Time Clock (RTC). The duration of the each tone is solely decided by the programmer.

code segment
assume cs:code
org 100h                ;prog seg prefix addrss
jmp initze              ;hex no of 256
savint dd ?             ;for saving address of es:bx
count dw 0000h          ;count of tics

hours db ?
mins db ?
sec db ?

testnum:
        push ax    ;store all the contents of register
        push bx    ;(not to change original values of register)
        push cx
        push dx
        push cs
        push es
        push si
        push di

        mov ax,0b800h   ;starting address of display
        mov es,ax
        mov cx,count
        inc cx
        mov count,cx
        cmp cx,011h

      jne exit

        mov cx,0000h
        mov count,cx
        call time
exit:
        pop di
        pop si
        pop es
        pop ds
        pop dx
        pop cx
        pop bx
        pop ax
        jmp cs:savint   ;jump to normal isr

;——————convert procedure——————–
convert proc
        and al,0f0h
        ror al,4
        add al,30h
        call disp
        mov al,dh
        and al,0fh
        add al,30h
        call disp
        ret
endp

;————————time procedure—————-
time proc
        mov ah,02h      ;getting current time system clk
        int 1ah
        mov hours,ch    ;HH->ch, MM->cl, SS->dh
        mov mins,cl
        mov sec,dh

       ; mov bx,0E00h    ;location for displaying clk

       mov bx,3984
        mov al,hours       ;Display Hours
        mov dh,hours
        call convert
        mov al,’:’
        call disp

        mov al,mins       ;Display Mins
        mov dh,mins
        call convert
        mov al,’:’
        call disp

        mov al,sec       ;Display Seconds
        mov dh,sec
        call convert

       call tone

       ret
         endp

;———————–display procedue—————-
disp proc
        mov ah,9Ch      ;for setting attribute
                 ;ATTRIBUTE BYTE  BL  R  G  B  I  R  G  B 
                                         ;BACKGROUND FOREGROUND
       mov es:bx,ax    ;write into vedio buffer
        inc bx
        inc bx
        ret
endp

;————— frequency tone procedure——————-

tone proc

       mov     al, 182         ; Prepare the speaker for the
        out     43h, al         ;  note.
        mov     ax, 4560        ; Frequency number (in decimal)                             
        out     42h, al         ; Output low byte.
        mov     al, ah          ; Output high byte.
        out     42h, al
        in      al, 61h         ; Turn on note (get value from
                                ;  port 61h).
        or      al, 00000011b   ; Set bits 1 and 0.
        out     61h, al         ; Send new value.
        mov     bx, 25          ; Pause for duration of note.
.pause1:
        mov     cx, 65535
.pause2:
        dec     cx
        jne     .pause2
        dec     bx
        jne     .pause1
        in      al, 61h         ; Turn off note (get value from
                                ;  port 61h).
        and     al, 11111100b   ; Reset bits 1 and 0.
        out     61h, al         ; Send new value. 
       ret
endp
;——————initialization————————
initze:
        push cs
        pop ds
        cli             ;clear int flag

        mov ah,35h      ;35 for get orignal add
        mov al,08h      ;intrrupt no
        int 21h
        mov word ptr savint,bx
        mov word ptr savint+2,es

        mov ah,25h              ;25 for set int add
        mov al,08h
        mov dx,offset testnum   ;new add for intrrupt
        int 21h

        mov ah,31h              ;make prog resident(request tsr)
        mov dx,offset initze    ;size of program

        sti                    ;set intrrupt flag
        int 21h               
code ends
end
OUTPUT:

Categories
SE Computer Engineering

8. Write X86 menu driven Assembly Language Program (ALP) to implement OS (DOS) commands TYPE, COPY and DELETE using file operations. User is supposed to provide command line arguments in all cases.

;***Guidelines for running program***
;create two file with name file1.txt and file2.txt
;first you have to enter your choice i.e. 1 or 2 or 3….
;then enter commands
;for type: command is type file1.txt
;for copy: command is copy file1.txt file2.txt
;for delete: command is delete file1.txt
;give first file name as file1.txt and second file name as file2.txt

%macro print 2
mov rax,1
mov rdi,1
mov rsi,%1
mov rdx,%2
syscall
%endmacro

%macro accept 2
mov rax,0
mov rdi,0
mov rsi,%1
mov rdx,%2
syscall

%endmacro

%macro iomodule 4
mov rax,%1
mov rdi,%2
mov rsi,%3
mov rdx,%4
syscall
%endmacro

%macro exit 0
mov rax,60
syscall
%endmacro

section .data
    cmd db 10,13, “command menu”
        db 10,13,”1.TYPE”
        db 10,13,”2.COPY”
        db 10,13,”3.DELETE”
        db 10,13,”4.EXIT”
        db 10,13,”Enter choice:”      
    len equ $ – cmd
    entercmd db 10,13,”Enter command:——: “
    cmdlen equ $ – entercmd
    msg0 db 10,13,”Failed to open the file!!!”
    len0 equ $ – msg0
    msg1 db 10,13,”File opened successfully!!!”
    len1 equ $ – msg1
    msg2 db 10,13,”Failed to open the file!!!”
    len2 equ $ – msg2
    msg3 db 10,13, “Command not found!!!!”
    len3 equ $ – msg3

section .bss
    buffer resb 200
    bufferlen resb 8
    choice resb 50
    chlen equ $ – choice
    fdis1 resb 200
    fdis2 resb 200
    cnt1 resb 2
    ch1 resb 2
    name1 resb 20
    name2 resb 20
    size resb 200
section .text
global _start
_start:
    print cmd, len
    accept ch1, 2
    mov rsi, ch1
    cmp byte[rsi], ‘1’
    je TYPE
    cmp byte[rsi], ‘2’
    je COPY
    cmp byte[rsi], ‘3’
    je DELETE
    cmp byte[rsi], ‘4’
    exit
    jmp error

TYPE:
    print entercmd, cmdlen
    accept choice, chlen
    mov rsi, choice
    mov byte[size], al
    dec byte[size]
    mov al, byte[rsi]
nd:

    cmp al, ‘t’
    jne error
    inc rsi
    dec byte[size]
    mov al, byte[rsi]
    cmp al, ‘y’
    jne error
    inc rsi
    dec byte[size]
    mov al, byte[rsi]
    cmp al, ‘p’
    jne error
    inc rsi
    dec byte[size]
    mov al, byte[rsi]
    cmp al, ‘e’
    jne error
    inc rsi
    dec byte[size]

    jmp success
error:
    print msg3, len3
    jmp _start
success:
    inc rsi
    dec byte[size]
    mov rdi, name1
top:
    mov al, byte[rsi]
    mov [rdi], al
    inc rdi
    inc rsi
    dec byte[size]
    jnz top

    iomodule 2, name1, 2, 777
    mov qword[fdis1], rax
    bt rax, 63
    jc error

    iomodule 0, [fdis1], buffer, 200
    mov qword[cnt1], rax

    iomodule 1, 1, buffer, qword[cnt1]

    mov rax, 3
    mov rdi, name1
    syscall
    jmp _start

DELETE:
    print entercmd, cmdlen
    accept choice, chlen
    mov byte[size], al
    dec byte[size]
    mov al, byte[rsi]
nd1:
    cmp al, ‘d’
    jne error
    inc rsi
    dec byte[size]
    mov al, byte[rsi]
    cmp al, ‘e’
    jne error
    inc rsi
    dec byte[size]
    mov al, byte[rsi]
    cmp al, ‘l’
    jne error
    inc rsi
    dec byte[size]
    mov al, byte[rsi]
    cmp al, ‘e’
    jne error
    inc rsi
    dec byte[size]
    mov al, byte[rsi]
    cmp al, ‘t’
    jne error
    inc rsi
    dec byte[size]
    mov al, byte[rsi]
    cmp al, ‘e’
    jne error
    inc rsi
    dec byte[size]
    jmp success1
success1:
    inc rsi
    dec byte[size]
    mov rdi, name2
top1:
    mov al, byte[rsi]
    mov [rdi], al
    inc rdi
    inc rsi
    dec byte[size]
    jnz top1

    mov rax, 87
    mov rdi, name2
    syscall
    jmp _start

COPY:
    print entercmd, cmdlen
    accept choice, chlen
    mov byte[size], al
    dec byte[size]
    mov al, byte[rsi]
nd2:
    cmp al, ‘c’
    jne error
    inc rsi
    dec byte[size]
    mov al, byte[rsi]
    cmp al, ‘o’
    jne error
    inc rsi
    dec byte[size]
    mov al, byte[rsi]
    cmp al, ‘p’
    jne error
    inc rsi
    dec byte[size]
    mov al, byte[rsi]
    cmp al, ‘y’
    jne error
    inc rsi
    dec byte[size]

    jmp success2
success2:
        inc rsi
    dec byte[size]
    mov rdi, name1
    mov rcx, 9
nsp:
    mov al, [rsi]
    mov [rdi], al
    inc edi
    inc rsi
    dec byte[size]
    loop nsp

    inc rsi
    dec byte[size]
        xor rdi, rdi
    mov rdi, name2
nnl:
    mov al, [rsi]
    mov [rdi], al
    inc rdi
    inc rsi
    dec byte[size]
    jnz nnl

    iomodule 2, name1, 2, 777
    mov qword[fdis1], rax


    iomodule 0, [fdis1], buffer, 200
    mov qword[cnt1], rax
    iomodule 2, name2, 2, 777
    mov qword[fdis2], rax

    iomodule 1, [fdis2], buffer, qword[cnt1]

    mov rax, 3
    mov rdi, name1
    syscall
    mov rax, 3
    mov rdi, name2
    syscall

jmp _start
    exit

file1.txt
I am Prof. Dhokane R.M

file2.txt
I am Prof. Butkar U.D.

OUTPUT
swlab@swlab-H81-M1:~$ cd Desktop/
swlab@swlab-H81-M1:~/Desktop$ cd cmd/
swlab@swlab-H81-M1:~/Desktop/cmd$ nasm -f elf64 cmd.asm
swlab@swlab-H81-M1:~/Desktop/cmd$ ld -o cmd cmd.o
swlab@swlab-H81-M1:~/Desktop/cmd$ ./cmd

command menu
1.TYPE
2.COPY
3.DELETE
4.EXIT
1

Enter command:——: type file1.txt
I am prof Butkar U.D.

command menu
1.TYPE
2.COPY
3.DELETE
4.EXIT
1

Enter command:——: type file2.txt
I am prof Dhokane R.M.

command menu
1.TYPE
2.COPY
3.DELETE
4.EXIT
2

Enter command:——: copy file1.txt file2.txt

command menu
1.TYPE
2.COPY
3.DELETE
4.EXIT
3

Enter command:——: delete file1.txt

command menu
1.TYPE
2.COPY
3.DELETE
4.EXIT
4
swlab@swlab-H81-M1:~/Desktop/cmd$