SS

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)

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.

27

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.

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:

28

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.

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:

29

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,

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

30

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

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

31

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.

2.6 SPECIFIC REQUIREMENTS

2.6.1 Hardware Specification

Pentium Processor, 1GB RAM

32

2.6.2 Software Specification

JDK 5.0, Java Swings, MS Access

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

33

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.

2.8 SYSTEM FEATURES

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

34

Scenario illustrating link synchronization phenomenon

Fig 3.8.1

2.9 DATA FLOW DIAGRAM

Context Level DFD

35

Level 1 DFD

Sender

Bandwidth Estimation for IEEE 802.11

Based Ad Hoc Networks

Receiver

Node1

Node2

Node4

Node3

RREP

+

RREQ

RREQ

RREQRREP+

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

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:

37

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:

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.

38

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.

3.3 DETAILED DESIGN

UML DIGRAMS

41

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.

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.

42

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

node

SourceSourcer

Apply RREQ

Get the RREP

DestinationSourcer

Send the data

View the details

43

Class Diagram

44

Node1

i,m,value

initialize component()Action performed()

Node 2

length,cond

Node2 ser ()Initialize Component()

Node 3

message,time,d

Node3()Server()

Node 4

i,m,n,k,cond

Node4()Action Performed()

State Diagram

45

Sender

Packet Creation

Apply RREQ

Get RREP

Destination

Activity Diagram

46

Off Conzone node

Destination

ON Conzone Node

select the off conzone node and transmit the data

Select the Node

Input Data

Sequence Diagram

47

Source : (Source)

Network Formation

Message Tranformation

RREQ

RREP

Message transfer to the RREP node

Collaboration Diagram

48

Source 1: RREQ

2: RREP

Network Formation

3: Message transfer to the RREP node

Message Transformation

49

Component Diagram

Network formation

Conzone Discovery

Message transformation

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.

6.1 Unit Testing:

52

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

SAMPLING CODING

53

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();this.setVisible(true);

54

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);jTabbedPane1.setFont(new Font("Arial",Font.BOLD,13));

55

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){this.dispose();

58

}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());if(out!=null)

59

{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));}else

60

{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();jTextArea1.append("Destination Address "+s+"\n");

61

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();int c=length;

62

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

}}

RESULTSNode 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.

76

5.3 Appendixes