Remote Desktop Administration Using Wanet ": Bachelor of Technology in Computer Science & Engineering
Remote Desktop Administration Using Wanet ": Bachelor of Technology in Computer Science & Engineering
DESKTOP ADMINISTRATION
USING WANET (Wireless Ad Hoc Network)
BACHELOR OF TECHNOLOGY
In
COMPUTER SCIENCE & ENGINEERING
Submitted By:
SuryanshRastogi (1248610046)
Nitesh Kumar Singh(1248610036)
Himanshu Sharma (1248610014)
CERTIFICATE
Certified that SuryanshRastogi(1248610046)
award
presented
in
this
ofBACHELOR
OF
TECHNOLOGY
from
Dr
APJ
Abdul
Miss GeetaGangwar
Assistant Professor
Department of Computer Science
& Engineering
ABSTRACT
Today computers have become an integral part of everyones life. Use of computers is not only
restricted for corporate use but also for personal use and intercommunication purpose. For all
these different purposes networking or network has become the magic word. Today, lots of
information and resources are shared all over the world through the network. The buzzword or
the revolutionary term originated from this is global network i.e. Internet. But along with all the
advancements and developments, the danger of misusing the network has also increased. The
main objective behind development of Remote Desktop Administrator to build a server
application that allows to view or even control the desktop session on another machine that is
running a compatible client application, with the efficiency to provide the real time information
about the remote machine.
The current existing systems are potentially good systems, which do allow us to remotely
connect to the remote machines and access their respective desktops. But most of the existing
systems are quite difficult to use and implement for a layman.
The Remote desktop Administrator will allow the system administrator to use or to remotely
control the other systems through a simple application. This software intends to leverage existing
technologies and to utilize them in a new way. The proposed Remote desktop will exist in a
distributed computer environment such as the Internet but will also be accessible from with
in an intranet such as an office or in the home itself.
Remote desktop Administrator is a potentially huge growth area and several companies are
currently developing software that enables users to access remote systems from the office or
other remote locations by using even embedded system. By using platform independent
languages like JAVA, for development, gives freedom to use same application in heterogeneous
system.
Content
1. Introduction
2. System study
3. Software requirement specification
4. Techniques used
5. System design
6. Coding
7. Snapshots
8. Conclusion
9. Future enhancement
10.Reference
ACKNOWLEDGEMENT
It gives us a great sense of pleasure to present the report of the B. Tech Project undertaken during
B. Tech. Final Year.We owe special debt of gratitude to assistant professor Ms.GeetaGangwar,
Department of Computer Science & Engineering, ANA College of Engineering &
Management Studies, Bareilly for her constant support and guidance throughout the course of
our work. Her sincerity, thoroughness and perseverance have been a constant source of
inspiration for us. It is only her cognizant efforts that our endeavors have seen light of the day.
We also take the opportunity to acknowledge the contribution of MrNarendra Pal Singh, Head
of Department of Computer Science & Engineering, ANA College of Engineering &
Management Studies, Bareilly for his full support and assistance during the development of the
project.
We also do not like to miss the opportunity to acknowledge the contribution of all faculty
members of the department for their kind assistance and cooperation during the development of
our project. Last but not the least, we acknowledge our friends for their contribution in the
completion of the project.
SuryanshRastogi
(1248610046)
Nitesh Kumar Singh
(1248610036)
Himanshu Sharma
(1248610014)
Chapter
1:INTRODUCTION
SYSTEM STUDY
1.1 Existing System
In the present generation systems, there is a need for the administrator has to go all
around the network in order to terminate any system that is left non-terminated.
The administrator has to take all the trouble of going to a particular system to access a
file that is needed by him.
In order to get the system configuration details of any particular system, the administrator
has to take the trouble of going to that system for obtaining the information.
The processes that are running in a particular system can be viewed only in that system
itself by using the present generation softwares.
The administrator can get the configuration of the remote system from the server system
itself using this software.
In order to terminate the operations on the remote systems, the administrator can obtain
the current process details of the remote systems from the server itself. Running rmi
registry in the client systems performs all the above operations.
All projects are feasible, given unlimited resources and infinite time. But the
development of software is plagued by the scarcity of resources and difficult delivery
rates. It is prudent to evaluate the feasibility of the project at the earliest possible time.
Three key considerations are involved in feasibility analysis as:-
Technical Feasibility
The REMOTE VIRTUAL DESKTOP software is developed using the java environment.
The reason for using java, as the development platform is that, java is an Object Oriented
Language which handles most of the networking concepts. Since java is a platform
independent language, the class files can be executed on any operating system easily.
Economic Feasibility
This is the most frequently used method for evaluating the effectiveness of a system. It is
also called as a cost analysis. The Remote Virtual Desktop project, which is used to
control all the remote systems in a network, requires resources such as the software and
hardware components that support the Remote Control through java project effectively.
Since all the clients are usually connected to the server in any organization, it reduces the
cost factor. Hence there is no need of further physical connection to be established
between the server and the client.
Operational Feasibility
The Remote Virtual Desktop project is a user-friendly tool developed in order to make
the operations of the administrator much better. It will be easy for the administrator to
handle all the systems in the network from the server itself which helps in increasing the
operational efficiency of the administrator.
FUNCTIONS REQUIRED
The REMOTE DESKTOP ADMINISTRATOR software is divided in to five modules based
on their functionalities. These modules are as follows.
Remote Desktop
Retrieve
Control
Remote desktop
Using this module we can access the desktop of any remote system by giving the desired
systems IP address and port number we can get the desktop of that system. It is useful for the
administrator to monitor the activities of the employees of that organization.
The administrator can be able to get the desktop of that particular system and can warn the
employees if they are doing any illegal activities.
Retrieve
The purpose of the Retrieve using this module can determine the processes that are currently
running in a particular client system, present in a network. The administrator can know the
details of the processes by specifying the IP address of the remote system. This module has two
options like system information and process information. By using system information we can
determine the system name, RAM free space, OS, etc. By using the process information we
can determine the processes running at the client system at that time. By knowing these
information the server can know requirements for installing software remotely. This module is
similar to that of a task manager present in the windows operating system.
Control
The Control module handles the terminal operations such as shutdown, restart and logoff, by
specifying the IP address of the remote system. For this purpose we are using RMI (Remote
Method Invocation) and Java Runtime class.
This module asks the administrator to enter the system address on which he wants to perform the
terminal operations. It also asks the administrator to mention one of the above three terminal
operations to be performed on the remote system. Once the administrator has confirmed the
action, an echo message is sent to the remote system in order to ensure whether the user is using
the system or not. In case of the system being accessed by the user a response is sent to the
administrator. The administrator can either suspend or continue with his actions after receiving
the response. If the administrator knows that no one is using the system or no processes running
at that time then he can use these options like shutdown, restart or logoff.
File Transfer
Using this module we can transfer files between the client and the server based on the IP address.
Chapter
2:SOFTWARE
REQUIREMENT
SPECIFICATION
through which the client and user needs are accurately specified. It forms the basis of software
development. A good SRS should satisfy all the parties involved in the system.
Problem/Requirement Analysis: The process is order and more nebulous of the two,
deals with understand the problem, the goal and constraints.
Requirement Specification: Here, the focus is on specifying what has been found giving
analysis such as representation, specification languages and tools, and checking the
specifications are addressed during this activity. The requirement phase terminates with
the production of the validate SRS document. Producing the SRS document is the basic
goal of this phase.
FRONT END
at least 256 MB
HARD DISK
at least 20 GB
VDU
KEY BOARD
104 Standards
NETWORK
Chapter
3:TECHNOLOGIES
USED
In the early days of the web, a server could dynamically construct a page by creating a separate
process to handle each client request. The process would open connection to one or more
databases in order to obtain the necessary information. It communicated with the web server via
an interface known as the Common Gateway Interface (CGI) .CGI allowed the separate process
to read data from HTTP request and write data to the HTTP response. A variety of different
languages were used to build CGI programs including C, C++ and Perl.
The key that allows java to solve both the security and the portability problems just described is
that, the output of the java compiler is not an executable code. Rather, it is Byte Code. Byte Code
is a highly optimized set of instructions designed to be executed by virtual machine that the java
Run-time system emulates. However, the fact that a java program is interpreted helps solve the
major problems associated with downloading the program over the Internet.
Here is why java was designed to be interpreted language. Because java programs are
interpreted rather than compiled .It is easier to run them in wide variety of environments. Only
the java runtime system needs to be implemented for each platform. Once the runtime package
exists for a given system any java program can run on it. If java were a compiled language then
different versions of the same program will have to exist for each type of CPU connected to the
Internet. Thus interpretation is the easiest way to create truly portable programs. Although java
was designed to be interpreted, there is technically nothing about java that prevents on the fly
compilation of Byte Code into native code. However, even if dynamic compilation were applied
to Byte Code, the portability and safety would still apply, because the run time system would still
be in charge of the execution environment.
The reasons for this failure of procedural languages are mainly because of the role played
by data.
Why Java?
Although the fundamentals that necessitated the invention of java are portability and security,
there are other factors that played an important role on molding the final form of the language.
The java in the following list of buzzwords summed up the key considerations:
Simple
Portable
Object-oriented
Robust
Multithreaded
Architectural-neutral
High performance
Distributed
Dynamic
Procedural Languages
The procedural languages include Pascal, C, Basic, FORTRAN, and some other similar
languages. Each statement in these languages tells the computer to perform some operation. A
program in a procedural language is a list of instructions.
For very small programs no other organizing principle (often called a paradigm) is needed. The
programmer creates the list of instructions, and the computer carries them out.
Few
programmers can comprehend a program of more than a few hundred statements unless it is
broken down into smaller units. For this reason the function was adopted as a way to make
programs more comprehensible to their human creators. (The term function is used in C++ and
C. In other languages the same concept may be referred to as a subroutine, a subprogram, or a
procedure.) A program is divided into functions, and (ideally, at least) each function has a
clearly defined purpose and a clearly defined interface to the other functions in the program.
The idea of breaking a program into functions can be further extended by grouping a number of
functions together into a larger entity called a module, but the principle is similar: grouping a
number of components that carry out specific tasks.
Dividing a program into functions and modules is one of the cornerstones of structured
programming, the somewhat loosely defined discipline that has influenced programming
organization for more than a decade.
components--functions and data structures--don't model the real world very well. For example,
suppose you are writing a program to create the elements of a graphics user interface: menus,
windows, and so on. Quick now, what functions will you need? What data structures? The
answers are not obvious, to say the least. It would be better if windows and menus corresponded
more closely to actual program elements.
extensibility; you can extend the capabilities of the language. Traditional languages are not
usually extensible. Without unnatural convolutions, you cant bundle together both X and Y
coordinates into a single variable called Point, and then add and subtract values of this type. The
result is that traditional programs are more complex to write and maintain.
Humans manage
complexity through abstraction. For example, people do not think of a car as a set of tens of
thousands of individual parts. They think of it as a well-defined object with its own unique
behavior. This abstraction allows people to use a car to drive to the grocery store without being
overwhelmed by the complexity of the parts that form the car. They can ignore the details of
how the engine, transmission, and braking systems work. Instead they are free to utilize the
object as a whole.
Encapsulation
Encapsulation is the process of binding the code and the data, thus providing security from the
outside interface. The other way of defining encapsulation is by providing the code and data
with a protective wrapper, thus preventing them from being accessed by the code present outside
the wrapper. Access to the code and data inside the wrapper is tightly controlled through a well
defined interface. In Java the basis of encapsulation is the class. A class defines the structure
and behavior (data and code) that will be shared by a set of objects. Each object of a given class
contains the structure and behavior defined by the class. For this reason, objects are sometimes
referred to as instances of a class. Thus, a class is a logical construct; an object has physical
reality.
Inheritance
Inheritance is the process by which one object acquires the properties of another object. This is
important because it supports the concept of hierarchical classification. As mentioned earlier,
most knowledge is made manageable by hierarchical (that is, top-down) classifications. For
example, a Golden Retriever is part of the classification dog, which in turn is part of the mammal
class, which is under the larger class animal. Without the use of hierarchies, each object would
need to define all of its characteristics explicitly. However, by use of inheritance, an object need
only define those qualities that make it unique within its class. It can inherit its general attributes
from its parent. Thus, it is the inheritance mechanism that makes it possible for one object to be
a specific instance of a more general case.
Polymorphism
Polymorphism (from the Greek, meaning many forms) is a feature that allows one interface to
be used for a general class of actions. The specific action is determined by the exact nature of
the situation. Consider a stack (which is a last-in, first-out list). You might have a program that
requires three types of stack. One stack is used for integer values, one for floating-point values,
and one for characters. The algorithm that implements each stack is the same, even though the
data being stored differs. In a non-object-oriented language, you would be required to create
three difference sets of stack routines, with each set using different names. However, because of
polymorphism, in Java you can specify a general set of stack routines that all share the same
names.
The first file is an interface that declares the methods, which are accessed remotely. The purpose
of making an interface is to enable the client to access the methods of an interface with the help
of its reference. The second file creates a class and the binds that object in RMI registry. An RMI
registry is the naming server, which allows the remote request to be redirected to an object,
which is bind inside it.
On a client side, a file is created that creates a class access that remote object through RMI
registry and invokes the remote methods.
The first side to create an RMI application is to create server side application. For server side
application, the first thing to create is an interface that defines the methods, which are accessed
by the remote clients. The code for defining an interface is given below which is the first step
towards creating server application.
To call the methods of an object remotely, you have to create a remote interface that should
extend the java.rmi.Remote interface. This is the first steps in creating an RMI application,
which extends the Remote interface. All the method declares in this interface can be called
remotely. Each and every methods declares in the remote interface must have the
java.rmi.RemoteException in the throws clause as they throw this exception whenever there is
an error in sending or receiving information.
Remote Interface
importjava.rmi.*;
importjava.rmi.server.*;
Public interface int extends remote
{
publicint add(inta,int b)throws RemoteException;
publicint sub(int a1,int b1) throws RemoteException;
}
In this step the interface created in step 1 is implemented. The class, which implements the
interface, must extend java.rmi.server.unicastRemoteObject. The purpose of an extending the
UnicasRemoteObject class is to provide the functionality to import an object from a remote
machines. The code for implementation of an interface is given below
importjava.rmi.*;
importjava.rmi.server.*;
This step contains the main program for the server machine by registering the object of the class,
which implements the interface. This is done through bind() and rebind() method found in
java.rmi.Naming class Bind() and rebind() are static methods found in the naming class In the
code given code given below the method rebind() has been used
importjava.rmi.*;
importjava.rmi.server.*;
public class server
{
public static void main (String s[]) THROWS Exception
{
serverimplimpl=new serverIMPL()
System.out.printl(initializing server.);
Naming.rebind(ram, impl);
System.out.println(registered);
}
}
Step1:
Compileall the four source file i.e intf.java, serversimple.java, sever.java and client.java
Step 2:
The next step is to create the stub and skeleton of the serveIMPL for the creation of the RMOI
server. For this purpose you have to use the rmic compiler rmicserverIMPL
The rmic command will create the following 2 files:1. ServerIMPL_Skel.class
2. SeverIMPL_stub.class
Step 3:
Start the rmiregistry by typing command rmiregistry in the command prompt of the server
machine:c:\rmiexample>rmiregistry
Chapter 4:
SYSTEM DESIGN
SYSTEM DESIGN
4.1 Design Methodology
In the system design the focus on the deciding which functions are needed for the system, the
specification of these modules and how these modules should be interconnected.
Verifiability
Completeness
Consistency
Traceability
Simplicity / Understandability
Class Diagram:
Class is nothing but a structure that contains both variables and methods. The Class
Diagram shows a set of classes, interfaces, and collaborations and their relating ships.
There is most common diagram in modeling the object oriented systems and are used to
give the static view of a system.
shutdown
<<extend>>
<<extend>>
Administrator
IP address
restart
<<extend>>
system configuration
configuration details
<<extend>>
logoff
Administrator
IP address
<<extend>>
process management
process details
Interaction Diagrams
Sequence Diagram
A sequence diagram is an interaction diagram that emphasizes the time ordering of the messages.
Graphically, a sequence diagram is a table that shows objects arranged along the X-axis and
messages, ordered in increasing time, along the Y-axis.
Sequence diagrams have two interesting features:
1. There is the object lifeline. An object lifeline is the vertical dashed line that represents the
existence of an object over a period of time. Most objects that appear in the interaction
diagrams will be in existence for the duration of the interaction, so these objects are all
aligned at the top of the diagram, with their lifelines drawn from the top of the diagram
to the bottom.
2. There is a focus of the control. The focus of control is tall, thin rectangle that shows the
period of time during which an object is performing an action, either directly or through
the subordinate procedure. The top of the rectangle is aligns with the action; the bottom is
aligned with its completion.
Sequence diagram for REMOTE DESKTOP ADMINISTRATOR is shown as below:-
Collaboration Diagram
Activity Diagram
An activity diagram shows the flow from an activity to activity. An activity is an ongoing
nonatomic execution with in a state machine. Activities ultimately result in some action which is
made up of executable atomic computation that result in a change in state of the system or the
return of a value. Action encompasses calling another operation, sending a signal, creating or
destroying an object or some pure computation, such as evaluating an expression.Graphicallyan
activity diagram is a collection of vertices and arcs.
In Remote Desktop Administrator system, an activity Diagram shows the flow of control during
access of client system by the server system. Administrator i.e. remote server can perform
various tasks such as multimedia access, file retrieve, file transfer and many more functions
using the interface network which is Wireless Ad Hoc Network (WANET) in proposed system.
Deployment Diagram
Deployment Diagrams are one of the two kinds of diagrams used in modeling the aspects of an
Object Oriented System. A Deployment Diagram shows the configuration of Runtime Processing
Nodes and the Components that live on them.
Chapter 5:
CODING
REMOTE SERVER
ServerInitiator.java
packageremoteserver;
importjava.awt.BorderLayout;
importjava.io.IOException;
importjava.net.ServerSocket;
importjava.net.Socket;
importjavax.swing.JDesktopPane;
importjavax.swing.JFrame;
importjavax.swing.JOptionPane;
/**
* This is the entry class of the server
*/
public class ServerInitiator {
//Main server frame
ClientHandler.java
packageremoteserver;
importjava.awt.BorderLayout;
importjava.awt.Rectangle;
importjava.beans.PropertyVetoException;
importjava.io.IOException;
importjava.io.ObjectInputStream;
importjava.net.Socket;
importjavax.swing.JDesktopPane;
importjavax.swing.JInternalFrame;
importjavax.swing.JPanel;
classClientHandler extends Thread {
privateJDesktopPane desktop = null;
private Socket cSocket = null;
privateJInternalFrameinterFrame = new JInternalFrame("Client Screen",true, true, true);
privateJPanelcPanel = new JPanel();
publicClientHandler(Socket cSocket, JDesktopPane desktop) {
this.cSocket = cSocket;
this.desktop = desktop;
start();
}
/* Draw GUI per each connected client
*/
public void drawGUI(){
interFrame.setLayout(new BorderLayout());
interFrame.getContentPane().add(cPanel,BorderLayout.CENTER);
interFrame.setSize(100,100);
desktop.add(interFrame);
try {
//Initially show the internal frame maximized
interFrame.setMaximum(true);
} catch (PropertyVetoException ex) {
ex.printStackTrace();
}
//this allows to handle KeyListener events
cPanel.setFocusable(true);
interFrame.setVisible(true);
}
public void run(){
ClientScreenReciever.java
packageremoteserver;
importjava.awt.Graphics;
importjava.awt.Image;
importjava.io.IOException;
importjava.io.ObjectInputStream;
importjavax.swing.ImageIcon;
importjavax.swing.JPanel;
classClientScreenReciever extends Thread {
privateObjectInputStreamcObjectInputStream = null;
privateJPanelcPanel = null;
privatebooleancontinueLoop = true;
publicClientScreenReciever(ObjectInputStreamois, JPanel p) {
cObjectInputStream = ois;
cPanel = p;
REMOTE CLIENT
RemoteInitiator.java
packageremoteclient;
importjava.awt.AWTException;
importjava.awt.Dimension;
importjava.awt.GraphicsDevice;
importjava.awt.GraphicsEnvironment;
importjava.awt.Rectangle;
importjava.awt.Robot;
importjava.awt.Toolkit;
importjava.awt.event.ActionEvent;
importjava.awt.event.ActionListener;
importjava.io.IOException;
importjava.net.Socket;
importjava.net.UnknownHostException;
importjavax.swing.JButton;
importjavax.swing.JFrame;
importjavax.swing.JOptionPane;
/**
*
* This class is responsible for connecting to the server
* and starting ScreenSpyer and ServerDelegate classes
*/
public class ClientInitiator {
Socket socket = null;
public static void main(String[] args){
String ip = JOptionPane.showInputDialog("Please enter server IP");
String port = JOptionPane.showInputDialog("Please enter server port");
newClientInitiator().initialize(ip, Integer.parseInt(port));
}
public void initialize(String ip, int port ){
Robot robot = null; //Used to capture the screen
Rectangle rectangle = null; //Used to represent screen dimensions
try {
System.out.println("Connecting to server ..........");
socket = new Socket(ip, port);
System.out.println("Connection Established.");
//Get default screen device
GraphicsEnvironmentgEnv=GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevicegDev=gEnv.getDefaultScreenDevice();
//Get screen dimensions
Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
ServerDelegate.java
packageremoteclient;
importjava.awt.Robot;
importjava.io.IOException;
importjava.net.Socket;
importjava.util.Scanner;
/*
* Used to recieve server commands then execute them at the client side
*/
classServerDelegate extends Thread {
Socket socket = null;
Robot robot = null;
booleancontinueLoop = true;
publicServerDelegate(Socket socket, Robot robot) {
this.socket = socket;
this.robot = robot;
start(); //Start the thread and hence calling run method
}
public void run(){
Scanner scanner = null;
try {
//prepare Scanner object
System.out.println("Preparing InputStream");
scanner = new Scanner(socket.getInputStream());
while(continueLoop){
//recieve commands and respond accordingly
System.out.println("Waiting for command");
int command = scanner.nextInt();
System.out.println("New command: " + command);
switch(command){
case -1:
robot.mousePress(scanner.nextInt());
break;
case -2:
robot.mouseRelease(scanner.nextInt());
break;
case -3:
robot.keyPress(scanner.nextInt());
break;
case -4:
robot.keyRelease(scanner.nextInt());
break;
case -5:
robot.mouseMove(scanner.nextInt(), scanner.nextInt());
break;
}
}
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
ScreenSpyer.java
packageremoteclient;
importjava.awt.Rectangle;
importjava.awt.Robot;
importjava.awt.image.BufferedImage;
importjava.io.IOException;
importjava.io.ObjectOutputStream;
importjava.net.Socket;
importjavax.swing.ImageIcon;
/**
* This class is responisble for sending sreenshot every predefined duration
*/
classScreenSpyer extends Thread {
Socket socket = null;
Robot robot = null; // Used to capture screen
Rectangle rectangle = null; //Used to represent screen dimensions
booleancontinueLoop = true; //Used to exit the program
try{
//Prepare ObjectOutputStream
oos = new ObjectOutputStream(socket.getOutputStream());
/*
* Send screen size to the server in order to calculate correct mouse
* location on the server's panel
*/
oos.writeObject(rectangle);
}catch(IOException ex){
ex.printStackTrace();
}
while(continueLoop){
//Capture screen
BufferedImage image = robot.createScreenCapture(rectangle);
/* I have to wrap BufferedImage with ImageIcon because BufferedImage class
* does not implement Serializable interface
*/
ImageIconimageIcon = new ImageIcon(image);
//Send captured screen to the server
try {
System.out.println("before sending image");
oos.writeObject(imageIcon);
oos.reset(); //Clear ObjectOutputStream cache
System.out.println("New screenshot sent");
} catch (IOException ex) {
ex.printStackTrace();
}
Chapter 6:
SCREENSHOTS
Chapter 7:
TESTING
6.1 Testing
Plan
Software testing is a critical element of software quality assurance and represents the ultimate
review of specification, design and coding. Testing presents an interesting anomaly for the
software engineer.
6.1.1 Testing Objective includes
Testing is a process of executing a program with the intent of finding an error. A good test case is
one that has a probability of finding an as yet undiscovered error. A successful test is one that
uncovers an undiscovered error.
6.1.2 Testing Principles
6.2 Testing
Strategies
Bottom-up testing
Top-down testing
Sandwich testing
The bottom-up testing strategy first individually tests each component of the bottom layer and
then integrates them with components of the next layer up. The advantage of bottom-up testing is
that interface faults can be more easily found. The disadvantage faults found on top layer may
often leads to changes in the subsystemdecomposition.
The top-down testing strategy unit tests the components of the top layer first and then integrates
the components of the next layer down. The advantage of top-down testing is that it starts with
user interface components.
The same set of tests, derived from the requirements, can be used in testing the increasingly more
complex set of subsystems.
The sandwich testing strategy combines the top-down and bottom-up strategies, attempting to
make use of the best of both strategies.
Chapter 8:
CONCLUSION
In the present generation systems, there is a need for the administrator has to go all around the
network in order to terminate any system that is left non-terminated. The administrator has to
take all the trouble of going to a particular system to access a file that is needed by him. In order
to get the system configuration details of any particular system, the administrator has to take the
trouble of going to that system for obtaining the information. The processes that are running in a
particular system can be viewed only in that system itself by using the present generation
softwares.
So, by using this project we can avoid all the above problems. This project is very useful in the
corporate field for monitoring the employees activities.
The current existing systems are potentially good systems, which do allow us to remotely
connect to the remote machines and access their respective desktops. But most of the existing
systems are quite difficult to use and implement for a layman.
The Remote desktop Administrator will allow the system administrator to use or to remotely
control the other systems through a simple application. This software intends to leverage existing
technologies and to utilize them in a new way. The proposed Remote desktop will exist in a
distributed computer environment such as the Internet but will also be accessible from with
in an intranet such as an office or in the home itself.
By using platform independent languages like JAVA, for development, gives freedom to use
same application in heterogeneous system.
Thus this system may be proved very helpful in removing the existence of difficulties arising due
to the changing of location of server and client within the organizations to improve geographical
situation of the architecture.
If this system will be used in a large organization by using an ADSL router the working by
establishing the communication between employees of the organization will be more effective
and more convenient. Transfer of the information from one employee to another will not require
the actual movement of the employee within the organization.
The administrator can get the configuration of the remote system from the server system itself
using this software.
In order to terminate the operations on the remote systems, the administrator can obtain the
current process details of the remote systems from the server itself. Running rmi registry in the
client systems performs all the above operations
Chapter 9:
FUTURE
ENHANCEMENTS
In this project it is unable to scan any malware and virus in client system and notify it to the
server system. Further we want to implement this concept that if any malware or virus found in
client systems then a message will be sent to the server system as a notification along with brief
details.
Also we want to introduce a concept that, if any pen drive is inserted into client system illegally
then automatically it should be formatted and system should shutdown.
Future enhancement for this project may be that a big source of bandwidth such as an ADSL
router is introduced between server and client so that the transfer of response of client to server
will be faster and the working on server will be easier and more effective and the administrator
will take more interest in working with this system.
A new concept may be that an antivirus system is installed on server and as soon as the client
handover the control to the server, the server will scan the client system before accessing the
client and if there is a malware is found then it will remove the suspected ones and then will
access the client system. In this way the client system will behave as the removable device such
as pen drive or any other type of removable device.
As this system is developed in JAVA so the system may be used on any of device supporting
JAVA. Due to the platform independency of the language, server and client may be changed if
the ip address of both the systems is known. It will reduce the dependency of single location of
the server or difficulties faced in changing the location of the server will be overcome.
If this system will be used in a large organization by using an ADSL router, the working by
establishing the communication between employees of the organization will be more effective
and more convenient. Transfer of the information from one employee to another will not require
the actual movement of the employee within the organization.
Thus it is clear that it may be the best option for creating LAN within the organizations as it
doesnt require the internet connection as the compulsory one and it is platform independent so it
will not require the fixed position of server and client like internet connection.
Chapter 10:
REFERENCES
[1] Sun Yu, Context aware applications for a Pocket PC. Master of Science thesis,
School of Microelectronics and Information Technology, Royal Institute of
Technology (KTH), Stockholm, Sweden, COS/CCS 2007-28, 17 December