You are on page 1of 76

1

ACKNOWLEDGEMENT

The satisfaction and euphoria accompany the successful completion of task


and would be incomplete without the mention of the people who made it possible,
whose constant guidance and encouragement crown all the efforts with success.

I owe my gratitude to our principal, Prof. JAGADEESWARA REDDY, for


his kind attention and valuable guidance to me throughout this course.

I also express my sincere gratitude to D.PAVAN KUMAR, Head of the


Department of M.C.A, for his great encouragement and invaluable support
throughout my study.

I wish to express my deepest sense of gratitude and pay my sincere thanks to


my guide Mr. J.NAGARAJU, Assoc. Professor Department of M.C.A, who
evinced keen interest in my efforts and provider her valuable guidance throughout my
project work.

I also thankful to all staff members of department of M.C.A, for helping me


to complete this project work by giving valuable suggestions.

All of the above I great fully acknowledge and express my thanks to my


parents who have been instrumental for success of this project play a vital role.

The last but not least, I express my sincere thanks to all my friends who have
supported me in the accomplishment of this project.

SATISH KUMAR.K
2

(08AR1F0043)
TABLES OF CONTENTS

ANNEXURE TITLE PAGE NO

1. INTRODUCTION
1.1 OVERVIEW OF THE PROJECT 12
1.2 LITRATURE SYURVEY 13
1.3 PROPOSED SYSTEM 22
1.4 OBJECTIVES & SCOPES 23
1.5 ORGANIZATION OF THE PROJECT 24

2. REQUIREMENT SPECIFICATION
2.1 OVERALL DESCIPTION 25
2.2 PRODUCT PERSPECTIVE 27
2.3 USER CHARACTRSICS 28
2.4 OPERATION ENVIRONMENT 29
2.5 CONSTRIANTS 37
2.6 SPECIFIC REQUIREMENTS 40
2.7 EXTERNAL INTERFACE REQUIREMENTS 41
2.8 SYSTEM FEATURE 42
2.9 DATA FLOW AND ER DIAGRAMS 43
2.10PERFORMANACE REQUIREMENTS 45
2.11 SOFTWARE QUALITY ATTRIBUTE 46

3. SYSTEM DESIGN AND TEST PLAN


3.1 DECOMPOSTION DESCRIPTION 48
3.2 DEPENDENDENCY DESCRIPTION 49
3.3 DETAILED DESIGN 50
3.4 TEST PLAN 60

4. IMPLENTATION AND RESULTS


4.1 IMPLEMENTATION 63
4.2 RESULTS 68

5. CONCLUSION AND FUTURE WORK


5.1 FUTUTRE WORK 79
5.2 REFERENCES 80
5.3 APPENDIXES 81
3

LIST OF FIGURES
4
5

List Of Abbrevations:
1. BRuIT -Bandwidth Reservation under InTerferences influence

2. RREQ - Route Request

3. RREP - Route Reply

4. QuoS - Quality of Service

5. MANET -Mobile Adhoc Network

6. MAC - Medium Access Control


6

1. INTRODUCTION

1.1 OVERVIEW OF THE PROJECT

Since 2005, IEEE 802.11-based networks have been able to provide a certain level of quality of
service (QoS) by the means of service differentiation, due to the IEEE 802.11e amendment.
However, no mechanism or method has been standardized to accurately evaluate the amount of
resources remaining on a given channel. Such an evaluation would, however, be a good asset for
bandwidth-constrained applications. In multi hop ad hoc networks, such evaluation becomes even
more difficult. Consequently, despite the various contributions around this research topic, the
estimation of the available bandwidth still represents one of the main issues in this field. AD hoc
networks are autonomous, self-organized, wireless, and mobile networks. They do not require
setting up any fixed infrastructure such as access points, as the nodes organize themselves
automatically to transfer data packets and manage topology changes due to mobility.
7

1.2 LITERTURE SURVEY


Available bandwidth evaluation has generated several contributions in the
wired and wireless networking communities. Several classifications of these solutions may be
imagined. I chose to separate them into the following two categories:
. I designate by active approaches the techniques that rely on the emission of dedicated end-to-end
probe packets to estimate the available bandwidth along a path.
. We designate by passive approaches the techniques that use only local information on the
utilization of the bandwidth. A typical example of such approaches is a node monitoring the
channel usage by sensing the radio medium. These mechanisms are usually transparent, but they
may exchange information via one-hop broadcasts, as such information can be piggybacked in the
Hello messages used by many routing protocols to discover the local topology.

1.2.1Active Bandwidth Estimation Techniques :


A detailed survey of the different techniques to evaluate the available bandwidth in wired
networks is accessible in [1]. Most of these techniques measure the end-to-end available
bandwidth by sending packets of equal size from a source to a receiver. The source increases
gradually the probe packet emission rate. Measurements of the characteristics of this particular
flow are performed at the receiver’s side and then converted into an estimation of the end-to-end
available bandwidth. Several protocols such as SLoPS [2] or TOPP [3] fall into this category.
They mainly differ in the way they increase the packet sequence rate and in the metrics measured
on the probing packet flow. It is worth noting that, with these techniques, the probing traffic may
influence existing flows. Li et al. [4] propose to detect the presence of congestion by monitoring
probe packets’ delay. Whenever this delay gets larger than the theoretical maximum delay, the
medium suffers from congestion. They propose a method to compute the medium utilization from
such measurements and then derive the channel capacity from this channel usage ratio. Based on
the TOPP method, the authors of DietTOPP [5] evaluate the accuracy of such techniques in
wireless networks. This paper shows that both the probe packet size and the volume of cross-
traffic have a stronger impact on the measured bandwidth in this environment than in wired
networks. These techniques are, therefore, also very sensitive to the measurement parameters and
easily lead to inaccurate results in a wireless environment. The active techniques cited above
present, in addition, two major drawbacks regarding multihop ad hoc networks. First, when many
nodes need to perform such an evaluation for several destinations, the amount of probe packets
introduced in the network becomes important. It may, thus, interact with the data traffic and with
8

other probes, modifying other estimations. Second, an end-to-end evaluation technique may not be
as reactive as a local technique in a mobile context. When updating routes in response to node
mobility or to a change in the available resources, local detection and reconstruction may be more
efficient in several situations.

1.2.2 Passive Bandwidth Estimation Techniques

A dynamic bandwidth management scheme for single-hop ad hoc networks is proposed in [6]. In
this solution, one node in the network hosts the Bandwidth Manager process, which is responsible
for evaluating the available bandwidth in the cell and for allocating the bandwidth to each peer.
Each node may ask the Bandwidth Manager for an exclusive access to the channel during a
proportion of time using dedicated control messages. As the topology is reduced to a single cell,
the available proportion time-share is computed by this entity considering that the total load is the
sum of the individual loads. The available fraction of time may then be translated into an available
bandwidth by considering the capacity of the wireless link, called total bandwidth in this paper,
which is deduced from a measurement of the data packets’ throughput. This approach can be
considered as passive as very few control packets are exchanged, usually of small size. However,
this solution is adapted to network topologies where all the nodes are within communication range
but cannot be directly used in multihop ad hoc networks. Even if the election, the synchronization,
and the maintenance of several Bandwidth Managers may represent a significant cost in large
distributed networks, similar measurements may be employed. When a node desires to estimate
the bandwidth available in its vicinity, the intuitive approach consists in monitoring the channel
over a given time period and to deduce from this observation the utilization ratio of the shared
resource. The method proposed in [7] uses such technique and adds a smoothing factor to hide
transient effects. The QoS routing protocol designed in this paper is based on a simple estimation
of the available bandwidth by each node and does not consider any interfering nodes. QoS-AODV
[8] also performs such a per-node ABE. The evaluation mechanism constantly updates a value
called Bandwidth Efficiency Ratio (BWER), which is the ratio between the numbers of
transmitted and received packets. The available bandwidth is simply obtained by multiplying the
BWER value by the channel capacity. This ratio is broadcasted among the one-hop neighbors of
each node through Hello messages. The bandwidth available to a node is then inferred from these
values as the minimum of the available bandwidths over a closed single-hop neighborhood. QoS-
AODV, therefore, considers not only the possibility to send a given amount of data but also the
effect of the emissions of a node on its neighborhood. In [9], Chaudet and Lassous proposed a
bandwidth reservation protocol called Bandwidth Reservation under InTerferences influence
9

(BRuIT). This protocol’s ABE mechanism takes into account the fact that, with the IEEE 802.11
standard, the carrier sense radius is larger than the transmission range. In other words, emitters
share the bandwidth with other nodes they cannot communicate with. Experimental studies have
shown that this carrier sense radius is at least twice the communication radius. To address this
issue, each node regularly broadcasts to all its immediate neighbors information about the total
bandwidth it uses to route and emit flows (deduced from applications and routing information) and
its estimated available bandwidth. It also transmits similar information concerning all its one-hop
neighbors, propagating such information at a two-hop distance. Each node then performs
admission control based on this two-hop neighborhood knowledge. When the carrier sense radius
is equal to twice the communication radius, the authors have shown that two-hop communication
represents the best compromise between estimation accuracy and cost [10]. Making the same
observation, Yaling and Kravets [11] proposed the Contention Aware Admission Control Protocol
(CACP). In this framework, each node first computes its local proportion of idle channel time by
monitoring the radio medium. Then, the authors propose three different techniques to propagate
this information to the greatest number of nodes within the carrier sense area.

First, similarly to BRuIT, they propose to include the information in Hello messages to reach the
two-hop neighborh ood.

Second, they propose to increase the nodes’ transmission power; however, this emission power is
often limited by regulations and this technique may therefore only be applicable when power
control is used for regular transmissions.

Finally, receiving nodes can also reduce their sensitivity in order to decode information coming
from farther away, which depends on the quality of electronics and on the signal modulation.
Similarly to [12], the authors also point out the existence of intraflow contention. When a flow
takes a multihop route, successive routers contend for channel access for frames belonging to the
same flow. It is thus important to take into account at least the route length when performing
admission control. Ideally, the exact
10

interactions between nodes along a path should be identified and considered. Finally, the AAC
protocol, proposed in [13], makes each node consider the set of potential contenders as a single
node. It measures the activity period durations and considers that any such period can be seen as a
frame emission of the corresponding length. With this mechanism, collisions and distant emissions
are also considered when computing the medium occupancy. Based on this measurement, each
node is able to evaluate its available bandwidth. It exchanges this information with its neighbors to
compute the bandwidth on each link, a link being defined as a pair of nodes. This value is defined
as the minimum between the available bandwidths of both ends. AAC also takes into account the
intraflow contention problem mentioned above.
11

1.3 PROPOSED SYSTEM


Here, we present a new method to evaluate the available bandwidth in ad hoc networks
based on the IEEE 802.11 MAC layer. This method uses the nodes’ carrier sense capability
combined to other techniques such as collision prediction to perform this estimation. It provides
upper layers with an evaluation that represents an acceptable compromise between accuracy and
measurement cost. Finally, even though it is closely linked to a particular technology, it may
easily be adapted to similar random medium access protocols. In wireless ad hoc networks, a flow
could easily take over the whole capacity of the network due to the strong interdependency
between wireless links. Therefore, it is necessary to take into account the disruption that may be
introduced in the network by the addition of a new flow and to distinguish between the raw
throughput that may be transferred along a path and the maximum data rate that may be
transferred without any noticeable interference.
We define the available bandwidth between two neighbor nodes as the maximum throughput that
can be transmitted between these two peers without disrupting any already ongoing flow in the
network. We will denote by link capacity the maximum throughput a flow can achieve between
two neighbor nodes regardless of other flows present in the network.
Based on the previous literature study and considering how the IEEE 802.11 MAC protocol
operates, we can point out a few phenomena that may have an influence on the bandwidth
available from a node to one of its neighbors:
1. The carrier sense mechanism prevents two close emitters from transmitting simultaneously,
unless they draw the same backoff counter value. Therefore, an emitter shares the channel
bandwidth with all its close neighbors. The channel utilization has to be monitored to evaluate the
capacity of a node to emit a given traffic volume.
2. For a transmission to take place, the receiver needs that no interference occurs during the whole
transmission. Therefore, the value of the available bandwidth on a link depends on both peer
channel utilization ratios and also on the idle period synchronization. This synchronization needs
to be evaluated.
3. No collision detection is possible in a wireless environment. Therefore, whenever a collision
happens, both colliding frames are completely emitted, maximizing the bandwidth loss. The
collision probability needs to be estimated and integrated to the ABE.
4. Finally, when collisions happen on unicast frames, the IEEE 802.11 protocol automatically
retries to emit the same frame, drawing the backoff counter in a double-sized contention window.
The time lost in the additional overhead may also have an impact on the available bandwidth and
has to be evaluated.
12

1.4 OBJECTIVES&SCOPE

1.4.1 IMPROVING AVAILABLE BANDWIDTH ESTIMATION


ACCURACY:
Based on the previous literature study and considering how the IEEE 802.11 MAC protocol
operates, we can point out a few phenomena that may have an influence on the
bandwidth available from a node to one of its neighbors:

. The carrier sense mechanism prevents two close emitters from transmitting simultaneously,
unless they draw the same backoff counter value. Therefore, an emitter shares the channel
bandwidth with all its close neighbors. The channel utilization has to be monitored to evaluate the
capacity of a node to emit a given traffic volume.
. For a transmission to take place, the receiver needs that no interference occurs during the whole
transmission. Therefore, the value of the available bandwidth on a link depends on both peer
channel utilization ratios and also on the idle period synchronization. This synchronization needs
to be evaluated.
. No collision detection is possible in a wireless environment. Therefore, whenever a collision
happens, both colliding frames are completely emitted, maximizing the bandwidth loss. As shown
by the scenario depicted in Fig. 1, the collision probability
needs to be estimated and integrated to the ABE.

. Finally, when collisions happen on unicast frames, the IEEE 802.11 protocol automatically
retries to emit the same frame, drawing the backoff counter in a double-sized contention window.
The time lost in the additional overhead may also have an impact on the available bandwidth and
has to be evaluated.

Carrier Sense Mechanism: Estimating a Node’s Emission Capabilities

Whenever a node needs to send a frame, it first needs to contend for medium access and it cannot
emit its frame unless the medium is free. Therefore, a potential sender needs to evaluate the load
of the medium, i.e., the proportion of time the medium is idle to determine the chance it has to
successfully gain access to the shared resource. Such evaluation is also performed by the solutions
proposed in [7] or [11].
13

Let us consider a node s in the network during an observation interval of _ seconds. We use the
following notations:

is the total idle time, i.e., the total time during which node s neither emits any frame nor
senses the medium busy. Both physical and virtual carrier sense mechanisms should report an idle
state. This includes periods during which no frame is ready to be emitted as well as periods of
deferral (back off time and interframe spacing).
.Bs is the bandwidth available to node s, i.e., the maximum throughput it can emit without
degrading close flow’s rate.
. Cmax is the capacity of the medium.
1.4.2 Evaluation of literature survey
It is quite tricky, from an operational point of view, to evaluate the
performance of the sole ABE part of an existing QoS protocol. Therefore, for comparison
purposes, we have integrated the previously described bandwidth evaluation technique ABE into a
protocol and implemented it under NS-2. This simulator has been chosen because of the
availability of other protocol models. We have chosen to integrate ABE into AODV, in order to be
similar to BRuIT, QoS-AODV, or AAC. It is thus based on broadcasted route request messages,
admission control at each intermediate node, and explicit reservation by a unicast route reply
message issued by the destination. We can thus study the impact of our estimation technique on
the bandwidth management in the network by comparing the performance of the different
protocols. The protocol is called hereafter ABE-AODV. The accuracy of the bandwidth evaluation
obviously depends on the value of _, which can be considered as a sampling period. The larger _
is, the more stable the measurements will be, hiding fast variations in the medium load. However,
_ should also be small enough to allow fast reactions to long-term load variations and to node
mobility. Hello-based techniques generate additional overhead depending on the Hello emission
frequency. Ideally, the Hello packet emission frequency should be adapted to the node mobility
and/or to the flow dynamics. In order to have meaningful comparisons, we chose to fix this value
to _ ¼ 1 second in ABE-AODV. Similarly, all compared protocols are tuned accordingly to emit
one information frame each second. We have slightly modified AODV in order to transform it into
a QoS protocol based on ABE. It thus becomes a cross-layer routing protocol. The MAC layer
estimates
proactively and periodically the available bandwidth of the neighboring links, and the routing
layer is in charge of discovering QoS routes complying to the application
demands, basing its decisions on the MAC layer information.
14

1.5 ORGANIZATION OF REPORT


Pensoft Solutions
Our corporate culture reflects our understanding that successful business relationships are

built on long term mutual gain, not short-term expediency. We believe that this long term mutual

gain is founded on sharing risk and responsibility with our clients. Our priority is solving

problems for you, not giving you more to worry about. We also know that forming strategic

partnerships with our clients is a key to success. We work together with both your business and

technical teams to ensure we deliver high quality solutions to meet the needs of your business.

This leaves you in control and able to build competence and knowledge within your own teams.

The closeness we develop in our working relationship with you results in reduced risk and

increased efficiencies in the projects we support.

The Service

At Pensoft Solutions, we believe that a global delivery approach must be managed by a

local relationship founded on trust and accountability. We recognize that our clients want support

that is sensitive to their priorities, focused on their business needs and always responsive to the

constant change they experience. If you have experience of working with services companies that

seem to need you to flex to the way they work, then working with Pensoft Solutions will be a

refreshing change. Pensoft Solutions staffs are able to tailor a service that exactly meets your

needs and we flex our systems to accommodate the way you work. Our services are delivered

through the Pensoft Solutions Delivery Method which has received the highest level of industry

accreditations. We do not have a fixed view of how and where we can perform services and are

keen to provide a method that meets all of your needs, taking into account other parameters such

as cost, management, skills availability and communication methods. We also recognize the need

to provide a service that can react dynamically to your business. Consequently, our management

structure is flat and our people are empowered to make decisions. If you have issues, or need to
15

escalate priorities, you are only ever one level away from the most senior management in our

organization, who are always ready to pick up the phone when you need us.
16

2. REQUIREMENTS SPECIFICATION
2.1 OVERALL DESCRIPTION

Mobile Networks

It is illusory to provide hard QoS guarantees when nodes are mobile. QoS violations appear due to the

topology changes, which result either in route breakage or in unexpected variations of the available

throughputs. In this situation, the route can either be finally broken or can be rebuilt at the source, or it

may finally be rebuilt locally. Choosing between all these strategies is not in the scope of this paper.

We present results on mobile networks only to give indication on the creativeness of the raw bandwidth

estimation approach, as protocols all exchange information at the same rate.


17

2.2 PRODUCT PERSPECTIVE


Modules Explanation
Packet Creation
In this module we split the Data in to N number of Fixed size packet with Maximum length of 48
Characters.
Apply the RREQ and get RREP
The aim of the RREQ is to find a route between the sender and the receiver that meets the constraints
specified by the application level in terms of Bandwidth.
Therefore, two flows with the same source and destination can follow different routes depending on the
network state.
When a source node has data to send, it broadcasts a route request (RREQ) to its neighbors. The RREQ
packet contains the address of the sender, and the requirements at the application level, the destination
address, and a sequence number. The Intermediate Node or Destination Node sends RREP if it is free,
otherwise, it silently discards the message.
Admission Control Mechanism
The Admission Control Mechanism is done in the receiver side. The Admission Control Mechanism
has the all status of the node so if the nodes want to send RREP or discard the message, the particular
node check the status by using the Admission Control Mechanism.
Bandwidth Utilized
After the source nodes send the total message to the Destination Node finally we calculate the end to
end delivery of the Bandwidth and Time delay.
18

2.3 USER CHARACTERSTICS


ODBC
Microsoft Open Database Connectivity (ODBC) is a standard programming interface for
application developers and database systems providers. Before ODBC became a de facto standard
for Windows programs to interface with database systems, programmers had to use proprietary
languages for each database they wanted to connect to. Now, ODBC has made the choice of the
database system almost irrelevant from a coding perspective, which is as it should be. Application
developers have much more important things to worry about than the syntax that is needed to port
their program from one database to another when business needs suddenly change.
Through the ODBC Administrator in Control Panel, you can specify the particular
database that is associated with a data source that an ODBC application program is written to use.
Think of an ODBC data source as a door with a name on it. Each door will lead you to a particular
database. For example, the data source named Sales Figures might be a SQL Server database,
whereas the Accounts Payable data source could refer to an Access database. The physical
database referred to by a data source can reside anywhere on the LAN.
The ODBC system files are not installed on your system by Windows 95. Rather, they are
installed when you setup a separate database application, such as SQL Server Client or Visual
Basic 4.0. When the ODBC icon is installed in Control Panel, it uses a file called
ODBCINST.DLL. It is also possible to administer your ODBC data sources through a stand-alone
program called ODBCADM.EXE. There is a 16-bit and a 32-bit version of this program, and each
maintains a separate list of ODBC data sources.

From a programming perspective, the beauty of ODBC is that the application can be
written to use the same set of function calls to interface with any data source, regardless of the
database vendor. The source code of the application doesn’t change whether it talks to Oracle or
SQL Server. We only mention these two as an example. There are ODBC drivers available for
several dozen popular database systems. Even Excel spreadsheets and plain text files can be turned
into data sources. The operating system uses the Registry information written by ODBC
Administrator to determine which low-level ODBC drivers are needed to talk to the data source
(such as the interface to Oracle or SQL Server). The loading of the ODBC drivers is transparent to
the ODBC application program. In a client/server environment, the ODBC API even handles
many of the network issues for the application programmer.
The advantages of this scheme are so numerous that you are probably thinking there must
be some catch. The only disadvantage of ODBC is that it isn’t as efficient as talking directly to the
native database interface. ODBC has had many detractors make the charge that it is too slow.
19

Microsoft has always claimed that the critical factor in performance is the quality of the driver
software that is used. In our humble opinion, this is true. The availability of good ODBC drivers
has improved a great deal recently. And anyway, the criticism about performance is somewhat
analogous to those who said that compilers would never match the speed of pure assembly
language. Maybe not, but the compiler (or ODBC) gives you the opportunity to write cleaner
programs, which means you finish sooner. Meanwhile, computers get faster every year.

JDBC
In an effort to set an independent database standard API for Java, Sun Microsystems
developed Java Database Connectivity, or JDBC. JDBC offers a generic SQL database access
mechanism that provides a consistent interface to a variety of RDBMSs. This consistent interface
is achieved through the use of “plug-in” database connectivity modules, or drivers. If a database
vendor wishes to have JDBC support, he or she must provide the driver for each platform that the
database and Java run on.
To gain a wider acceptance of JDBC, Sun based JDBC’s framework on ODBC. As you
discovered earlier in this chapter, ODBC has widespread support on a variety of platforms. Basing
JDBC on ODBC will allow vendors to bring JDBC drivers to market much faster than developing
a completely new connectivity solution.
JDBC was announced in March of 1996. It was released for a 90 day public review that
ended June 8, 1996. Because of user input, the final JDBC v1.0 specification was released soon
after.
The remainder of this section will cover enough information about JDBC for you to know what it
is about and how to use it effectively. This is by no means a complete overview of JDBC. That
would fill an entire book.

JDBC Goals
Few software packages are designed without goals in mind. JDBC is one that, because of
its many goals, drove the development of the API. These goals, in conjunction with early reviewer
feedback, have finalized the JDBC class library into a solid framework for building database
applications in Java.
The goals that were set for JDBC are important. They will give you some insight as to why
certain classes and functionalities behave the way they do. The eight design goals for JDBC are as
follows:
20

1.SQL Level API


The designers felt that their main goal was to define a SQL interface for Java. Although
not the lowest database interface level possible, it is at a low enough level for higher-level
tools and APIs to be created. Conversely, it is at a high enough level for application
programmers to use it confidently. Attaining this goal allows for future tool vendors to
“generate” JDBC code and to hide many of JDBC’s complexities from the end user.
2.SQL Conformance
SQL syntax varies as you move from database vendor to database vendor. In an effort to
support a wide variety of vendors, JDBC will allow any query statement to be passed through
it to the underlying database driver. This allows the connectivity module to handle non-
standard functionality in a manner that is suitable for its users.
3. JDBC must be implemental on top of common database interfaces
The JDBC SQL API must “sit” on top of other common SQL level APIs. This goal
allows JDBC to use existing ODBC level drivers by the use of a software interface. This
interface would translate JDBC calls to ODBC and vice versa.
4. Provide a Java interface that is consistent with the rest of the Java system
Because of Java’s acceptance in the user community thus far, the designers feel that they
should not stray from the current design of the core Java system.
5. Keep it simple
This goal probably appears in all software design goal listings. JDBC is no exception. Sun
felt that the design of JDBC should be very simple, allowing for only one method of
completing a task per mechanism. Allowing duplicate functionality only serves to confuse the
users of the API.
6. Use strong, static typing wherever possible
Strong typing allows for more error checking to be done at compile time; also, less errors
appear at runtime.
7. Keep the common cases simple
Because more often than not, the usual SQL calls used by the programmer are simple
SELECT’s, INSERT’s, DELETE’s and UPDATE’s, these queries should be simple to
perform with JDBC. However, more complex SQL statements should also be possible.

Finally we decided to proceed the implementation using Java Networking.

And for dynamically updating the cache table we go for MS Access database .
21

Java ha two things: a programming language and a platform.


Java is a high-level programming language that is all of the following

Simple Architecture-neutral
Object-oriented Portable
Distributed High-performance
Interpreted multithreaded
Robust Dynamic
Secure

Java is also unusual in that each Java program is both compiled and interpreted.
With a compile you translate a Java program into an intermediate language called Java
byte codes the platform-independent code instruction is passed and run on the
computer.

Compilation happens just once; interpretation occurs each time the program is
executed. The figure illustrates how this works.

You can think of Java byte codes as the machine code instructions for the Java
Virtual Machine (Java VM). Every Java interpreter, whether it’s a Java development
tool or a Web browser that can run Java applets, is an implementation of the Java VM.
The Java VM can also be implemented in hardware.

Java byte codes help make “write once, run anywhere” possible. You can compile
your Java program into byte codes on my platform that has a Java compiler. The byte
codes can then be run any implementation of the Java VM. For example, the same
Java program can run Windows NT, Solaris, and Macintosh.

Networking

TCP/IP stack

The TCP/IP stack is shorter than the OSI one:


22

TCP is a connection-oriented protocol; UDP (User Datagram Protocol) is a


connectionless protocol.

IP datagram’s

The IP layer provides a connectionless and unreliable delivery system. It considers each
datagram independently of the others. Any association between datagram must be supplied
by the higher layers. The IP layer supplies a checksum that includes its own header. The
header includes the source and destination addresses. The IP layer handles routing through
an Internet. It is also responsible for breaking up large datagram into smaller ones for
transmission and reassembling them at the other end.

UDP

UDP is also connectionless and unreliable. What it adds to IP is a checksum for the
contents of the datagram and port numbers. These are used to give a client/server model -
see later.
23

TCP

TCP supplies logic to give a reliable connection-oriented protocol above IP. It provides
a virtual circuit that two processes can use to communicate.

Internet addresses

In order to use a service, you must be able to find it. The Internet uses an address
scheme for machines so that they can be located. The address is a 32 bit integer which gives
the IP address. This encodes a network ID and more addressing. The network ID falls into
various classes according to the size of the network address.

Network address

Class A uses 8 bits for the network address with 24 bits left over for other addressing.
Class B uses 16 bit network addressing. Class C uses 24 bit network addressing and class D
uses all 32.

Subnet address

Internally, the UNIX network is divided into sub networks. Building 11 is currently on
one sub network and uses 10-bit addressing, allowing 1024 different hosts.

Host address

8 bits are finally used for host addresses within our subnet. This places a limit of 256
machines that can be on the subnet.

Total address

The 32 bit address is usually written as 4 integers separated by dots.


24

Port addresses

A service exists on a host, and is identified by its port. This is a 16 bit number. To send
a message to a server, you send it to the port for that service of the host that it is running on.
This is not location transparency! Certain of these ports are "well known".

Sockets

A socket is a data structure maintained by the system to handle network


connections. A socket is created using the call socket. It returns an integer that is
like a file descriptor. In fact, under Windows, this handle can be used with Read
File and Write File functions.

#include <sys/types.h>
#include <sys/socket.h>
int socket(int family, int type, int protocol);

Here "family" will be AF_INET for IP communications, protocol will be zero, and type
will depend on whether TCP or UDP is used. Two processes wishing to communicate over
a network create a socket each. These are similar to two ends of a pipe - but the actual pipe
does not yet exist.
25

2.4 OPERATIONAL ENVIRONMENT

Java Technology

Java technology is both a programming language and a platform.

The Java Programming Language

The Java programming language is a high-level language that can be


characterized by all of the following buzzwords:

 Simple
 Architecture neutral
 Object oriented
 Portable
 Distributed
 High performance
 Interpreted
 Multithreaded
 Robust
 Dynamic
 Secure

With most programming languages, you either compile or interpret a program so that you can
run it on your computer. The Java programming language is unusual in that a program is both compiled
and interpreted. With the compiler, first you translate a program into an intermediate language called
Java byte codes —the platform-independent codes interpreted by the interpreter on the Java platform.
The interpreter parses and runs each Java byte code instruction on the computer. Compilation happens
just once; interpretation occurs each time the program is executed. The following figure illustrates how
this works.
26

You can think of Java bytecodes as the machine code instructions for the Java Virtual
Machine (Java VM). Every Java interpreter, whether it’s a development tool or a Web browser that can
run applets, is an implementation of the Java VM. Java bytecodes help make “write once, run
anywhere” possible. You can compile your program into bytecodes on any platform that has a Java
compiler. The bytecodes can then be run on any implementation of the Java VM. That means that as
long as a computer has a Java VM, the same program written in the Java programming language can
run on Windows 2000, a Solaris workstation, or on an iMac.

The Java Platform


A platform is the hardware or software environment in which a program runs. We’ve
already mentioned some of the most popular platforms like Windows 2000, Linux, Solaris,
and MacOS. Most platforms can be described as a combination of the operating system and
hardware. The Java platform differs from most other platforms in that it’s a software-only
platform that runs on top of other hardware-based platforms.
The Java platform has two components:

• The Java Virtual Machine (Java VM)

• The Java Application Programming Interface (Java API)


27

You’ve already been introduced to the Java VM. It’s the base for the Java platform and is
ported onto various hardware-based platforms.
The Java API is a large collection of ready-made software components that provide many
useful capabilities, such as graphical user interface (GUI) widgets. The Java API is grouped
into libraries of related classes and interfaces; these libraries are known as packages. The next
section, What Can Java Technology Do?, highlights what functionality some of the packages
in the Java API provide.
The following figure depicts a program that’s running on the Java platform. As the figure
shows, the Java API and the virtual machine insulate the program from the hardware.

Native code is code that after you compile it, the compiled code runs on a specific
hardware platform. As a platform-independent environment, the Java platform can be a bit
slower than native code. However, smart compilers, well-tuned interpreters, and just-in-time
bytecode compilers can bring performance close to that of native code without threatening
portability.

What Can Java Technology Do?


The most common types of programs written in the Java programming language are applets
and applications. If you’ve surfed the Web, you’re probably already familiar with applets. An
applet is a program that adheres to certain conventions that allow it to run within a Java-
enabled browser.
However, the Java programming language is not just for writing cute, entertaining applets for
the Web. The general-purpose, high-level Java programming language is also a powerful
software platform. Using the generous API, you can write many types of programs.
An application is a standalone program that runs directly on the Java platform. A special kind
of application known as a server serves and supports clients on a network. Examples of
servers are Web servers, proxy servers, mail servers, and print servers. Another specialized
program is a servlet. A servlet can almost be thought of as an applet that runs on the server
side. Java Servlets are a popular choice for building interactive web applications, replacing the
use of CGI scripts. Servlets are similar to applets in that they are runtime extensions of
applications. Instead of working in browsers, though, servlets run within Java Web servers,
configuring or tailoring the server.
28

How does the API support all these kinds of programs? It does so with packages of software
components that provide a wide range of functionality. Every full implementation of the Java
platform gives you the following features:

• The essentials: Objects, strings, threads, numbers, input and output, data
structures, system properties, date and time, and so on.

• Applets: The set of conventions used by applets.

• Networking: URLs, TCP (Transmission Control Protocol), UDP (User Data


gram Protocol) sockets, and IP (Internet Protocol) addresses.

• Internationalization: Help for writing programs that can be localized for


users worldwide. Programs can automatically adapt to specific locales and be
displayed in the appropriate language.

• Security: Both low level and high level, including electronic signatures,
public and private key management, access control, and certificates.

• Software components: Known as JavaBeansTM, can plug into existing


component architectures.

• Object serialization: Allows lightweight persistence and communication


via Remote Method Invocation (RMI).

• Java Database Connectivity (JDBCTM): Provides uniform access to a wide


range of relational databases.
The Java platform also has APIs for 2D and 3D graphics, accessibility, servers, collaboration,
telephony, speech, animation, and more. The following figure depicts what is included in the
Java 2 SDK.
29

How Will Java Technology Change My Life?

We can’t promise you fame, fortune, or even a job if you learn the Java programming
language. Still, it is likely to make your programs better and requires less effort than other
languages. We believe that Java technology will help you do the following:

• Get started quickly: Although the Java programming language is a


powerful object-oriented language, it’s easy to learn, especially for programmers
already familiar with C or C++.

• Write less code: Comparisons of program metrics (class counts, method


counts, and so on) suggest that a program written in the Java programming language
can be four times smaller than the same program in C++.

• Write better code: The Java programming language encourages good


coding practices, and its garbage collection helps you avoid memory leaks. Its object
orientation, its JavaBeans component architecture, and its wide-ranging, easily
extendible API let you reuse other people’s tested code and introduce fewer bugs.

• Develop programs more quickly: Your development time may be as much


as twice as fast versus writing the same program in C++. Why? You write fewer lines
of code and it is a simpler programming language than C++.

• Avoid platform dependencies with 100% Pure Java: You can keep your
program portable by avoiding the use of libraries written in other languages. The
100% Pure JavaTM Product Certification Program has a repository of historical
process manuals, white papers, brochures, and similar materials online.

• Write once, run anywhere: Because 100% Pure Java programs are
compiled into machine-independent bytecodes, they run consistently on any Java
platform.

2.5 CONSTRAINTS

Route Discovery

The aim of the route discovery procedure is to find a route between the sender and the

receiver that meets the constraints specified by the application level in terms of bandwidth. Therefore,
30

two flows with the same source and destination can follow different routes depending on the network

state.

When a source node has data to send, it broadcasts a route request (RREQ) to its neighbors. The RREQ

packet contains the address of the sender, the channel use, the requirements at the application level, the

destination address, and a sequence number. Each mobile node that receives such an RREQ performs

an admission control by simply comparing the bandwidth requirement carried in the RREQ packet to

the estimated available bandwidth on the link it received the RREQ on. If this check is positive, the

node adds its own address to the route and forwards the RREQ; otherwise, it silently discards the

message. This step is different from the other tested protocols as the admission control is done at the

receiver side and not at the sender side. This is explained by the fact that, in ABE, each node stores the

available bandwidths of its ingoing links. Finally, if the destination receives a first RREQ, it sends a

unicast route reply (RREP) to the initiator of the request along the reverse path. The resources are then

reserved and the new QoS flow can be sent.

Intraflow Contention Problem

Simply comparing the bandwidth application requirement and a link available bandwidth is not

sufficient to decide about the network ability to convey a flow. Indeed, the intraflow contention

problem has to be considered when performing multihop admission control. In [12], the authors

compute a value called contention count (CC) of a node along a given path. This value is equal to the

number of nodes on the multihop path that are located within the carrier sensing range of the

considered node. To calculate the CC of each node, the authors analyze the distribution of the signal

power.As in [17], for simplicity reasons, in ABE, we rather use a direct relationship between the end-

to-end throughput and the number of hops. Hence, after consideration of the intraflow contention on an

intermediate node j, which is located at H hops from the source and has received the RREQ from a

node i, the available bandwidth considered

for admission control, denoted by is equal to


31

Where is the available bandwidth of link as computed by ABE (3).We performed

several simulations with different parameters such as network load, flow maximum throughput, number

of nodes, and network diameter. A few general results apply to all simulated protocols. For instance,

when the network load is low, all protocols yield similar results, even the non-QoS-enabled ones. Flow

QoS degradation and false admission control phenomena begin to appear when congestion rises above

a certain level. On the opposite, when the network load is too high or when the flows’ individual

throughputs are too important, very few flows are admitted. In this case, the problem falls ack to the

sole intraflow contention problem for which all solutions have similar answers.
32

2.6 SPECIFIC REQUIREMENTS

2.6.1 Hardware Specification

Pentium Processor, 1GB RAM

2.6.2 Software Specification

JDK 5.0, Java Swings, MS Access


33

2.7 EXTERNAL INTERFACE REQUIREMENTS

The feasibility of the project is analyzed in this phase and business proposal is put forth
with a very general plan for the project and some cost estimates. During system analysis the feasibility
study of the proposed system is to be carried out. This is to ensure that the proposed system is not a
burden to the company. For feasibility analysis, some understanding of the major requirements for the
system is essential.
Three key considerations involved in the feasibility analysis are
♦ ECONOMICAL FEASIBILITY
♦ TECHNICAL FEASIBILITY
♦ SOCIAL FEASIBILITY

ECONOMICAL FEASIBILITY
This study is carried out to check the economic impact that the system will have on the
organization. The amount of fund that the company can pour into the research and development of the
system is limited. The expenditures must be justified. Thus the developed system as well within the
budget and this was achieved because most of the technologies used are freely available. Only the
customized products had to be purchased.

TECHNICAL FEASIBILITY
This study is carried out to check the technical feasibility, that is, the technical
requirements of the system. Any system developed must not have a high demand on the available
technical resources. This will lead to high demands on the available technical resources. This will lead
to high demands being placed on the client. The developed system must have a modest requirement, as
only minimal or null changes are required for implementing this system.

SOCIAL FEASIBILITY
The aspect of study is to check the level of acceptance of the system by the user. This
includes the process of training the user to use the system efficiently. The user must not feel threatened
by the system, instead must accept it as a necessity. The level of acceptance by the users solely depends
on the methods that are employed to educate the user about the system and to make him familiar with
it. His level of confidence must be raised so that he is also able to make some constructive criticism,
which is welcomed, as he is the final user of the system.
34

2.8 SYSTEM FEATURES

A typical unfair scenario in which asymmetric conditions degrade sender-based


evaluations:

Scenario illustrating link synchronization phenomenon

Fig 3.8.1
35

2.9 DATA FLOW DIAGRAM

Context Level DFD

Sender
Receiver

Bandwidth
Estimation for
IEEE 802.11
Based Ad
Hoc
Networks

Level 1 DFD

Node2
RR
EQ
EQ RR
RR EP
EP +
Node1 RR Node4
RR
EQ+
Node3
36

3.2 E-R Diagram

2.10 Performance Requirements

Processor : Pentium Celeron

Processor Speed : 850 MHZ

Memory Size : 128MB

Hard Disk Drive : 40GB

2.10 Performance Requirements


37

By using recommendation algorithm we can group errors by category based on type of error the system
provide recommendation in the form of feedback. So it gives good performance, feedback flexible,
reliable, secure and maintainable

Performance is characterized by the amount of useful work accomplished by a


computersystem compared to the time and resources used. Depending on the context, good computer
performance may involve one or more of the following:

 Short response time for a given piece of work


 High throughput (rate of processing work)
 Low utilization of computing resource(s)
 High availability of the computing system or application
 Fast (or highly compact) data compression and decompression
 High bandwidth / short data transmission time

Price in economics and business is the result of an exchange and from that trade we assign a
numerical monetary value to a good, service or asset

Accessibility is a general term used to describe the degree to which a product, device, service,
or environment is accessible by as many people as possible. Accessibility can be viewed as the "ability
to access" and possible benefit of some system or entity. Accessibility is often used to focus on people
with disabilities and their right of access to the system.
Availability is the degree to which a system, subsystem, or equipment is operable and in
acommittable state at the start of a mission, when the mission is called for at an unknown, i.e., a
random, time. Simply put, availability is the proportion of time a system is in a functioning condition.

Maintenance is the ease with which a software product can be modified in order to:
 correct defects
 meet new requirements
 make future maintenance easier, or
 cope with a changed environment

Reliability may be defined in several ways:


38

 The idea that something is fit for purpose with respect to time;
 The capacity of a device or system to perform as designed;
 The resistance to failure of a device or system;
 The ability of a device or system to perform a required function under stated
conditions for a specified period of time;
 The probability that a functional unit will perform its required function for a specified
interval under stated conditions.

Scalability applies to technology and business settings. Regardless of the setting, the base concept is
consistent - The ability for a business or technology to accept increased volume without impacting the
system.In telecommunications and software engineering, scalability is a desirable property of a system,
a network, or a process, which indicates its ability to either handle growing amounts of work in a
graceful manner or to be readily enlarged.

Security is the degree of protection against danger, loss, and criminals. Security has to be compared
and contrasted with other related concepts: Safety, continuity, reliability. The key difference between
security and reliability is that security must take into account the actions of people attempting to cause
destruction. Security as a state or condition is resistance to harm. From an objective perspective, it is a
structure's actual (conceptual and never fully knowable) degree of resistance to harm.
39

3.SYSTEM DESIGN AND TEST PLAN

3.1 Decomposition Description:


1. The carrier sense mechanism prevents two close emitters from transmitting simultaneously,

unless they draw the same backoff counter value. Therefore, an emitter shares the channel bandwidth

with all its close neighbors. The channel utilization has to be monitored to evaluate the capacity of a

node to emit a given traffic volume.

2. For a transmission to take place, the receiver needs that no interference occurs during the whole

transmission. Therefore, the value of the available bandwidth on a link depends on both peer channel

utilization ratios and also on the idle period synchronization. This synchronization needs to be

evaluated.

3. No collision detection is possible in a wireless environment. Therefore, whenever a collision

happens, both colliding frames are completely emitted, maximizing the bandwidth loss. The collision

probability needs to be estimated and integrated to the ABE.

4. Finally, when collisions happen on unicast frames, the IEEE 802.11 protocol automatically retries to

emit the same frame, drawing the backoff counter in a double-sized contention window. The time lost

in the additional overhead may also have an impact on the available bandwidth and has to be evaluated.
40

3.2 Dependency Description:


1.Packet Creation
In this module we split the Data in to N number of Fixed size packet with Maximum length
of 48 Characters.
2.Apply the RREQ and get RREP
The aim of the RREQ is to find a route between the sender and the receiver that meets the
constraints specified by the application level in terms of Bandwidth.
Therefore, two flows with the same source and destination can follow different routes depending on the
network state.
When a source node has data to send, it broadcasts a route request (RREQ) to its neighbors. The RREQ
packet contains the address of the sender, and the requirements at the application level, the destination
address, and a sequence number. The Intermediate Node or Destination Node sends RREP if it is free,
otherwise, it silently discards the message.

3.Admission Control Mechanism


The Admission Control Mechanism is done in the receiver side. The Admission Control
Mechanism has the all status of the node so if the nodes want to send RREP or discard the message, the
particular node check the status by using the Admission Control Mechanism.
4.Bandwidth Utilized
After the source nodes send the total message to the Destination Node finally we
calculate the end to end delivery of the Bandwidth and Time delay.
41

3.3 DETAILED DESIGN


UML DIGRAMS

Unified Modeling Language

The Unified Modeling Language allows the software engineer to express an analysis model using the
modeling notation that is governed by a set of syntactic semantic and pragmatic rules.

A UML system is represented using five different views that describe the system from distinctly
different perspective. Each view is defined by a set of diagram, which is as follows.
• User Model View
i. This view represents the system from the users perspective.
ii. The analysis representation describes a usage scenario from the end-users
perspective.

• Structural model view


i. In this model the data and functionality are arrived from inside the system.
ii. This model view models the static structures.

• Behavioral Model View


It represents the dynamic of behavioral as parts of the system, depicting the
interactions of collection between various structural elements described in the user
model and structural model view.

• Implementation Model View


In this the structural and behavioral as parts of the system are represented as they are
to be built.

• Environmental Model View


In this the structural and behavioral aspects of the environment in which the system is
to be implemented are represented.
42

UML is specifically constructed through two different domains they are:


 UML Analysis modeling, this focuses on the user model and structural model views of the
system.
 UML design modeling, which focuses on the behavioral modeling, implementation modeling
and environmental model views.

Use case Diagrams represent the functionality of the system from a user’s point of view. Use cases are
used during requirements elicitation and analysis to represent the functionality of the system. Use cases
focus on the behavior of the system from external point of view.

Actors are external entities that interact with the system. Examples of actors include users like
administrator, bank customer …etc., or another system like central database.

Use case Diagram

Select the Get the

node

Apply
Source RREQ
Sourcer
RREP
43

Send
the
data

View the
details

Destination
Sourcer

Class Diagram
44

Node 2
length,cond

Node2 ser ()
Initialize Component()

Node1
Node 3
i,m,value
message,time,d
initi al ize component()
Action performed() Node3()
Server()

Node 4
i,m,n,k,cond

Node4()
Action P erformed()

State Diagram
45

Sender

Packet
Creation

Apply
RREQ

Get RREP

Destination

Activity Diagram
46

Input Data

select the off


conzone node and Select the
transmit the data Node

ON Conzone Off Conzone


Node node

Desti nation

Sequence Diagram
47

S ource : Network M es s age


(Source) F ormation Tranform ati on
RR E Q

RRE P

M ess age trans fer to the RR E P node

Collaboration Diagram
48

1: RREQ Network
Sourc e
Form ation

2: R REP

3: M es s age trans fer to the R REP node

M es s age
Transform ation
49

Component Diagram

Ne t work Co nz one M ess a ge


form at io n Dis c o ve ry t rans fo rm ation
50

3.4 TEST PLAN

The purpose of testing is to discover errors. Testing is the process of trying to discover every
conceivable fault or weakness in a work product. It provides a way to check the functionality of
components, sub assemblies, assemblies and/or a finished product It is the process of exercising
software with the intent of ensuring that the Software system meets its requirements and user
expectations and does not fail in an unacceptable manner. There are various types of test. Each test type
addresses a specific testing requirement.

TYPES OF TESTS

Unit testing
Unit testing involves the design of test cases that validate that the internal program logic is
functioning properly, and that program input produce valid outputs. All decision branches and internal
code flow should be validated. It is the testing of individual software units of the application .it is done
after the completion of an individual unit before integration. This is a structural testing, that relies on
knowledge of its construction and is invasive. Unit tests perform basic tests at component level and test
a specific business process, application, and/or system configuration. Unit tests ensure that each unique
path of a business process performs accurately to the documented specifications and contains clearly
defined inputs and expected results.

Integration testing
Integration tests are designed to test integrated software components to determine if they
actually run as one program. Testing is event driven and is more concerned with the basic outcome of
screens or fields. Integration tests demonstrate that although the components were individually
satisfaction, as shown by successfully unit testing, the combination of components is correct and
consistent. Integration testing is specifically aimed at exposing the problems that arise from the
combination of component

Functional test
51

Functional tests provide a systematic demonstrations that functions tested are available as
specified by the business and technical requirements, system documentation , and user manuals.
Functional testing is centered on the following items:
Valid Input : identified classes of valid input must be accepted.
Invalid Input : identified classes of invalid input must be rejected.
Functions : identified functions must be exercised.
Output : identified classes of application outputs must be exercised.
Systems/Procedures : interfacing systems or procedures must be invoked.

Organization and preparation of functional tests is focused on requirements, key functions, or


special test cases. In addition, systematic coverage pertaining to identify
Business process flows; data fields, predefined processes, and successive processes must be considered
for testing. Before functional testing is complete, additional tests are identified and the effective value
of current tests is determined.

System Test
System testing ensures that the entire integrated software system meets requirements. It tests a
configuration to ensure known and predictable results. An example of system testing is the
configuration oriented system integration test. System testing is based on process descriptions and
flows, emphasizing pre-driven process links and integration points.

White Box Testing


White Box Testing is a testing in which in which the software tester has knowledge of the inner
workings, structure and language of the software, or at least its purpose. It is purpose. It is used to test
areas that cannot be reached from a black box level .

Black Box Testing


Black Box Testing is testing the software without any knowledge of the inner workings, structure
or language of the module being tested . Black box tests, as most other kinds of tests, must be written
from a definitive source document, such as specification or requirements document, such as
specification or requirements document. It is a testing in which the software under test is treated, as a
black box .you cannot “see” into it. The test provides inputs and responds to outputs without
considering how the software works.
52

6.1 Unit Testing:

Unit testing is usually conducted as part of a combined code and unit test phase of the
software lifecycle, although it is not uncommon for coding and unit testing to be conducted as two
distinct phases.

Test strategy and approach


Field testing will be performed manually and functional tests will be written in detail.

Test objectives
• All field entries must work properly.
• Pages must be activated from the identified link.
• The entry screen, messages and responses must not be delayed.

Features to be tested
• Verify that the entries are of the correct format
• No duplicate entries should be allowed
• All links should take the user to the correct page.

4. IMPLEMENTATION AND RESULTS

IMPLEMENTATION
53

SAMPLING CODING
Source Coding
/****************************************************************/
/* Node1 */
/* */
/****************************************************************/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import java.io.*;
import java.net.*;
import java.sql.*;
import java.rmi.*;
import java.rmi.server.*;
public class Node1 extends JFrame implements ActionListener
{
private JTabbedPane jTabbedPane1;
private JPanel contentPane;
private JTextField jTextField2;
private JLabel jLabel1;
private JTextArea jTextArea1;
private JScrollPane jScrollPane2;
private JTextArea jTextArea2;
private JScrollPane jScrollPane3;
private JButton jButton1;
private JButton jButton2;
private JButton jButton3;
private JButton jButton4;
private JButton jButton5;
private JButton jButton6;
private JPanel jPanel1;
private JComboBox jComboBox1;
private JPanel jPanel2;
private int i,m,n,k=0,length1,value,cond=0;
long time,d;
String pac[];
String s;
String message;
Socket client1;
Socket S1;
ServerSocket server1;
public Node1()
{
super();
initializeComponent();
54

this.setVisible(true);
try
{
server1=new ServerSocket(11);}

catch (Exception exp)


{
exp.printStackTrace();
}
}
private void initializeComponent()
{
jTabbedPane1 = new JTabbedPane();
contentPane = (JPanel)this.getContentPane();
jTextField2 = new JTextField();
jTextArea1 = new JTextArea();
jScrollPane2 = new JScrollPane();
jTextArea2 = new JTextArea();
jScrollPane3 = new JScrollPane();
jTextArea1.setFont(new Font("Arial",Font.BOLD,12));
jTextArea2.setFont(new Font("Arial",Font.BOLD,12));
jButton1 = new JButton();
jButton1.setFont(new Font("Arial",Font.BOLD,12));
jButton2 = new JButton();
jButton2.setFont(new Font("Arial",Font.BOLD,12));
jButton3 = new JButton();
jButton3.setFont(new Font("Arial",Font.BOLD,12));
jButton4 = new JButton();
jButton4.setFont(new Font("Arial",Font.BOLD,12));
jButton5 = new JButton();
jButton5.setFont(new Font("Arial",Font.BOLD,12));
jButton6 = new JButton();
jButton6.setFont(new Font("Arial",Font.BOLD,12));
jPanel1 = new JPanel();
jComboBox1 = new JComboBox();
jComboBox1.addActionListener(this);
jComboBox1.addItem("");
jComboBox1.addItem("Node2");
jComboBox1.addItem("Node3");
jComboBox1.addItem("Node4");
//jComboBox1.addItem("Node5");
jLabel1 = new JLabel();
jLabel1.setFont(new Font("Arial",Font.BOLD,12));
jPanel2 = new JPanel();
jTabbedPane1.addTab(" Node1 ", jPanel1);
jTabbedPane1.setFont(new Font("Arial",Font.BOLD,13));
jTabbedPane1.addTab("Received Message", jPanel2);
55

jTabbedPane1.setFont(new Font("Arial",Font.BOLD,13));
jTabbedPane1.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent e)
{
jTabbedPane1_stateChanged(e);
}
});
jLabel1.setText("Destination Node :");
contentPane.setLayout(null);
addComponent(contentPane, jTabbedPane1, 55,49,523,433);
jTextField2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
jTextField2_actionPerformed(e);
}
});
jTextArea1.setText("");
jScrollPane2.setViewportView(jTextArea1);
jScrollPane3.setViewportView(jTextArea2);
jButton1.setText("Browse");
jButton1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
jButton1_actionPerformed(e);
}
});
jButton2.setText("RREQ");
jButton2.addActionListener(this);
jButton3.setText("Exit");
jButton3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
jButton3_actionPerformed(e);
}
});
jButton5.setText("SEND");
jButton5.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
jButton5_actionPerformed(e);
}
});
jButton6.setText("CLEAR");
jButton6.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
jButton6_actionPerformed(e);
56

}
});
jButton4.setText("Exit");
jButton4.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
jButton4_actionPerformed(e);
}
});
jPanel1.setLayout(null);
addComponent(jPanel1, jTextField2, 19,144,223,22);
addComponent(jPanel1, jScrollPane2, 21,195,220,193);
addComponent(jPanel1, jButton1, 266,140,78,28);
addComponent(jPanel1, jButton2, 267,200,71,28);
addComponent(jPanel1, jComboBox1, 130,52,100,22);
addComponent(jPanel1, jLabel1, 22,52,112,18);
addComponent(jPanel1,jButton5,267,250,71,28);
addComponent(jPanel1,jButton6,267,300,72,28);
addComponent(jPanel1, jButton3, 267,360,71,28);
jPanel2.setLayout(null);
addComponent(jPanel2, jScrollPane3, 80,50,343,295);
addComponent(jPanel2,jButton4,208,360,83,28);
this.setTitle("Node1 - extends JFrame");
this.setLocation(new Point(0, 0));
this.setSize(new Dimension(600, 534));
}
private void addComponent(Container container,Component c,int x,int y,int width,int
height)
{
c.setBounds(x,y,width,height);
container.add(c);
}
private void jComboBox1_actionPerformed(ActionEvent e)
{
System.out.println("\njComboBox1_actionPerformed(ActionEvent e) called.");
Object o = jComboBox1.getSelectedItem();
System.out.println(">>" + ((o==null)? "null" : o.toString()) + " is selected.");
}
private void jTabbedPane1_stateChanged(ChangeEvent e)
{
System.out.println("\njTabbedPane1_stateChanged(ChangeEvent e) called.");
}
private void jTextField2_actionPerformed(ActionEvent e)
{
System.out.println("\njTextField2_actionPerformed(ActionEvent e) called.");
}
private void jButton1_actionPerformed(ActionEvent e)
57

{
System.out.println("\njButton1_actionPerformed(ActionEvent e) called.");
try
{
s="";
int b;
FileDialog fd=new FileDialog(this,"Open",FileDialog.LOAD);
fd.show();
FileInputStream fis=new FileInputStream(fd.getDirectory()+fd.getFile());
jTextField2.setText(fd.getDirectory()+fd.getFile());
while((b=fis.read())!=-1)
{
message+=(char)b;
}
jTextArea1.setText(message);
}
catch(Exception r)
{
r.printStackTrace();
}
}
public void actionPerformed(ActionEvent e)
{
String valu="";
String check=""+jComboBox1.getSelectedItem();
if((e.getSource())==jButton2)
{
cond=1;
try
{
// Interface
is=(Interface)Naming.lookup("//192.168.1.2/Server");
Interface is=(Interface)Naming.lookup("//localhost/Server");
value=is.retrieve1(check);
}
catch (Exception ew)
{
ew.printStackTrace();
}
}
}
private void jButton3_actionPerformed(ActionEvent e)
{
this.dispose();
}
private void jButton4_actionPerformed(ActionEvent e)
{
58

this.dispose();
}
private void jButton6_actionPerformed(ActionEvent e)
{
jTextArea1.setText("");
}
private void jButton5_actionPerformed(ActionEvent e)
{
int chk=0;
try
{
if(cond==1)
{
if(jComboBox1.getSelectedItem().equals("Node2"))
{
JOptionPane.showMessageDialog(this,"Message send to Node2");
m=22;
n=22;
}
else if(jComboBox1.getSelectedItem().equals("Node3"))
{
JOptionPane.showMessageDialog(this,"Message send to Node3");
m=33;
n=33;
}
else if(jComboBox1.getSelectedItem().equals("Node4"))
{
if(value==0)
{
m=22;
n=44;
JOptionPane.showMessageDialog(this,"Message send to Node2");
}
else
{
m=33;
n=44;
JOptionPane.showMessageDialog(this,"Message send to Node3");
}
}
else if(jComboBox1.getSelectedItem().equals("Node5"))
{
JOptionPane.showMessageDialog(this,"Message send to Node5");
m=55;
}
client1=new Socket("localhost",m);
DataOutputStream out=new DataOutputStream(client1.getOutputStream());
59

if(out!=null)
{
out.flush();
}
time=System.currentTimeMillis();
int b=11;
out.writeInt(b);
out.writeInt(n);
out.writeLong(time);
int outgoing=0;
byte buffer[]=message.getBytes();
int len=buffer.length;
int tlength=buffer.length/48;
int length11=buffer.length%48;
int len1=len;
if(length11!=0)
{
tlength++;
}
out.writeInt(tlength);
int st=0;
int end=48;
System.out.println("Message Length: "+len);
String prefinal="tytyt";
String finalst="";
if (len<=48)
{
finalst=prefinal+message+"\n"+"null";
System.out.println("Message: "+message);
System.out.println("Out going Packets: "+(++outgoing));
out.writeUTF(message);
}
else
{
System.out.println("Message: "+message.substring(st,end));
System.out.println("Out going Packets: "+(++outgoing));
out.writeUTF(message.substring(st,end));
Thread.sleep(1000);
while(len1>48)
{
len1-=48;
if(len1<=48)
{
System.out.println("Message: "+message.substring(end,len));
System.out.println("Out going Packets: "+(++outgoing));
out.writeUTF(message.substring(end,len));
}
60

else
{
int sp=end+48;
System.out.println("Message: "+message.substring(end,sp));
System.out.println("Out going Packets: "+(++outgoing));
out.writeUTF(message.substring(end,sp));
end=sp;
}
}
}
String del="Data Transmission is completed";
JOptionPane.showMessageDialog(this,del);
// Interface
i=(Interface)Naming.lookup("//192.168.1.2/Server");
Interface i=(Interface)Naming.lookup("//localhost/Server");
chk=i.delete();
Thread.sleep(1500);
if(chk==0)
{
System.out.println("database items are deleted");
}
long flen=message.length();
out.writeLong(flen);
--cond;
}
else
{
String check="confirm the RREQ";
JOptionPane.showMessageDialog(this,check);
}
}
catch (Exception exp)
{
exp.printStackTrace();
}
}
public void Server()
{
try
{
int count=0;
String rr[];
S1=server1.accept();
DataInputStream dis=new DataInputStream(S1.getInputStream());
int source=dis.readInt();
jTextArea1.append("Source Address "+source+"\n");
int s=dis.readInt();
61

jTextArea1.append("Destination Address "+s+"\n");


if(s==11)
{
long sender_time=dis.readLong();
int length=dis.readInt();
rr=new String[length];
while(length>0)
{
rr[count]=dis.readUTF();
System.out.println("the received output is"+rr[count]);
jTextArea2.append("\n\nPacket " + "-->\n***********\n"+rr[count]);
length--;
count++;
}
long d=dis.readLong();
double flen=(double)d/1024;
long receiver_time=System.currentTimeMillis();
double delay=((double)(receiver_time-sender_time)/1000);
jTextArea1.append("delay " +delay+ "\n");
String sd=""+flen;
jTextArea1.append(("file length"+" "+sd.substring(0,4)+" KB \n"));
double Bandwidth=(double)flen/delay;
String as=""+Bandwidth;
jTextArea1.append("Bandwidth"+" "+as.substring(0,5)+"kbps \n");
}
else
{
if(s==33)
{
jTextArea1.append("MESSAGE SEND TO NODE3 \n");
String pro="RREQ to NODE3";
JOptionPane.showMessageDialog(this,pro);
Thread.sleep(500);
String pro1="RREP From NODE3";
JOptionPane.showMessageDialog(this,pro1);
}
else
{
jTextArea1.append("MESSAGE SEND TO NODE2 \n");
String pro="RREQ to NODE2";
JOptionPane.showMessageDialog(this,pro);
Thread.sleep(500);
String pro1="RREP From NODE2";
JOptionPane.showMessageDialog(this,pro1);
}
long sender_time=dis.readLong();
int length=dis.readInt();
62

int c=length;
pac=new String[length];
System.out.println("length===="+length);
while(length>0)
{
pac[count]=dis.readUTF();
jTextArea2.append("\n\nPacket " + "-->\n***********\n"+pac[count]);
length--;
count++;
}
d=dis.readLong();
Socket client4=new Socket("localhost",s);
DataOutputStream dout=new DataOutputStream(client4.getOutputStream());
dout.writeInt(source);
dout.writeInt(s);
dout.writeLong(sender_time);
System.out.println(""+sender_time);
dout.writeInt(c);
for(int q=0;q<count;q++)
{
dout.writeUTF(pac[q]);
}
dout.writeLong(d);

}
}
catch (Exception exp)
{
exp.printStackTrace();
}

}
//============================= Testing
================================//
//= =//
//= The following main method is just for testing this class you built.=//
//= After testing,you may simply delete it. =//
//============================================================
==========//
public static void main(String[] args)
{
Node1 node =new Node1();
while(true)
{
node.Server();
}
//= End of Testing =
63

}
}

RESULTS
Node 1
64

Node 2
65

Node 3
66

Node 4
67

Click on browse button and select the file


68

Click on RREQ button and select the destination node from the drop down list
69

Click on send button


70
71
72
73
74

5. CONCLUSION AND FUTER WORK


5.1 CONCLUSION

This method combines channel monitoring to estimate each node’s medium

occupancy including distant emissions, probabilistic combination of these values to

account for synchronization between nodes, estimation of the collision probability

between each couple of nodes, and variable overhead’s impact estimation.

These results show that single-hop flows and multihop flows are admitted more

accurately, resulting in a better stability and overall performance.

Results are encouraging in fixed networks as well as in mobile networks.

5.2 FUTURE WORKS

As future works, we plan to focus on two issues. First, in our current evaluation, we make no difference

between the bandwidth consumed by QoS flows and the bandwidth consumed by best effort flows.

Therefore, it may be possible that a node considers its available bandwidth on a link as almost null

whereas the whole bandwidth is consumed by best effort flows. Decreasing the rate of these flows may

lead to a higher acceptance rate of QoS flows.

Differentiating flow types may also result in a better utilization of the network resources. In

parallel, we are investigating the delay metric, as preliminary studies indicate that some parts of the

approach described in this paper may be used or converted to this other important parameter
75

5.3 REFERENCE

BIBLIOGRAPHY

[1] R. Prasad, M. Murray, C. Dovrolis, and K. Claffy, “Bandwidth Estimation:


Metrics, Measurement Techniques, and Tools,” IEEE Network, vol. 17, no. 6, pp. 27-
35, Nov. 2003.

[2] M. Jain and C. Dovrolis, “End-to-End Available Bandwidth: Measurement


Methodology, Dynamics, and Relation with TCP Throughput,” IEEE/ACM Trans.
Networking (TON ’03), vol. 11, no. 4, pp. 537-549, Aug. 2003.

[3] B. Melander, M. Bjorkman, and P. Gunningberg, “A New Endto- End Probing


Analysis Method for Estimating Bandwidth Bottlenecks,” Proc. Fifth Global Internet
Symp. (Global Internet) held in conjunction with Global Comm. Conf. (GLOBECOM
’00), Nov. 2000.

5.3 Appendixes
76