CHAPTER 1
INTRODUCTION

1. INTRODUCTION There is an increasing need of network storage system in today’s world. Also, nowadays the files are stored over the network. This system provides an easy way to retrieve any file which is stored over the network. The IP address of any system which is connected to the network can be found out just by selecting the name of the system. Therefore the range of IP address where the search has to be done can be found by that. The required file can be searched easily when this IP address range is known. The name of the file to be searched is given as input. If possible the file format is also given along with it. The IP address range where the search has to be performed is also selected. If there is any particular system outside that particular range they also can be selected for search operation to be performed. The search is done in each working and connected system in the shared drive and the search results are displayed in the grid view which is the output. The file can be accessed just by clicking the result that appears. Thus this provides a easy way to search a file over a number of systems connected to a network simultaneously. Thus it is very effective since the search is done in a number of systems simultaneously.

CHAPTER 2
LITERATURE REVIEW

2. LITERATURE REVIEW 2.1 Existing System:
When a particular file has to be searched which is stored in another system connected over network, the IP address of the system should be given in the run after clicking start in the taskbar. After that the particular system will open and the file name and the format which has to be chosen should be given. After that the search operation is performed in that particular system and the relevant search results are obtained. In this case the user needs to remember the IP address of the system where search is to be performed. This is quite difficult and the search operation is done in only one system at a time.

2.2 Proposed System
In the proposed system, the IP address of any system connected over the network can be found easily just by a click and the user need not remember the IP addresses of the system. By giving the name of the file which is to be chosen and by giving the range of IP address where the search operation is to be performed the file, the user is looking for, can be obtained easily. This system is effective since the search operation is performed in a number of systems at the same time while the existing system can do it only in a single system. The keyword to be searched is given as input and it is nothing but the file name. The keyword given can be any part of the file name. The system will give all the related files as the search result. Thus it is very effective and has lot of advantages than existing.

CHAPTER 3 REQUIREMENT SPECIFICATION

3. REQUIREMENT SPECIFICATION

3.1 HARDWARE SPECIFICATION

Processor : 1GHz
RAM : 512 MB
Available Hard Disk Space : 10GB
Video : 1024 x 768 High colors (16-bit)
Mouse : Compatible pointing device

3.2 SOFTWARE SPECIFICATION

Operating System : Windows XP Service Pack 2,
Programming Language : C#
IDE : Visual studio 2005/2008

CHAPTER 4
SOFTWARE OVERVIEW

4. SOFTWARE REVIEW 4. TECHNOLOGY USED
4.1 HISTORY OF DOT NET
What is .NET?
When .NET was announced in late 1999, Microsoft positioned the technology as a platform for building and consuming Extensible Markup Language (XML) Web services. XML Web services allow any type of application, be it a Windows- or browser-based application running on any type of computer system, to consume data from any type of server over the Internet. The reason this idea is so great is the way in which the XML messages are transferred: over established standard protocols that exist today.
Figure 1.1 presents a high-level overview of the .NET Framework and how XML Web services are positioned.

Figure 4.1. Stateless XML Web services model.
Since the initial announcement of the .NET Framework, it's taken on many new and different meanings to different people. To a developer, .NET means a great environment for creating robust distributed applications. To an IT manager, .NET means simpler deployment of applications to end users, tighter security, and simpler management. To a CTO or CIO, .NET means happier developers using state-of-the-art development technologies and a smaller bottom line. To understand why all these statements are true, you need to get a grip on what the .NET Framework consists of, and how it's truly a revolutionary step forward for application architecture, development, and deployment.
4.2 .NET Framework
Now that you are familiar with the major goals of the .NET Framework, let's briefly examine its architecture. As you can see in Figure 1-2, the .NET Framework sits on top of the operating system, which can be a few different flavors of Windows and consists of a number of components .NET is essentially a system application that runs on Windows.
Conceptually, the CLR and the JVM are similar in that they are both runtime infrastructures that abstract the underlying platform differences. However, while the JVM officially supports only the Java language, the CLR supports any language that can be represented in its Common Intermediate Language (CIL). The JVM executes bytecode, so it can, in principle, support many languages, too. Unlike Java's bytecode, though, CIL is never interpreted. Another conceptual difference between the two infrastructures is that Java code runs on any platform with a JVM, whereas .NET code runs only on platforms that support the CLR. In April, 2003, the International Organization for Standardization and the International Electrotechnical Committee (ISO/IEC) recognized a functional subset of the CLR, known as the Common Language Interface (CLI), as an international standard. This development, initiated by Microsoft and developed by ECMA International, a European standards organization, opens the way for third parties to implement their own versions of the CLR on other platforms, such as Linux or Mac OS X. For information on third-party and open source projects working to implement the ISO/IEC CLI and C# specifications

Figure 4.2. The .NET Framework
The layer on top of the CLR is a set of framework base classes. This set of classes is similar to the set of classes found in STL, MFC, ATL, or Java. These classes support rudimentary input and output functionality, string manipulation, security management, network communications, thread management, text management, reflection functionality, collections functionality, as well as other functions.
On top of the framework base classes is a set of classes that extend the base classes to support data management and XML manipulation. These classes, called ADO.NET, support persistent data management—data that is stored on backend databases. Alongside the data classes, the .NET Framework supports a number of classes to let you manipulate XML data and perform XML searching and XML translations.
The Common Language Runtime
At the heart of the .NET Framework is the common language runtime. The common language runtime is responsible for providing the execution environment that code written in a .NET language runs under. The common language runtime can be compared to the Visual Basic 6 runtime, except that the common language runtime is designed to handle all .NET languages, not just one, as the Visual Basic 6 runtime did for Visual Basic 6. The following list describes some of the benefits the common language runtime gives you: * Automatic memory management * Cross-language debugging * Cross-language exception handling * Full support for component versioning * Access to legacy COM components * XCOPY deployment * Robust security model
You might expect all those features, but this has never been possible using Microsoft development tools. Figure 1.3 shows where the common language runtime fits into the .NET Framework.

Figure 4.3. The common language runtime and the .NET Framework.

Note
Code written using a .NET language is known as managed code. Code that uses anything but the common language runtime is known as unmanaged code. The common language runtime provides a managed execution environment for .NET code, whereas the individual runtimes of non-.NET languages provide an unmanaged execution environment.

Inside the Common Language Runtime
The common language runtime enables code running in its execution environment to have features such as security, versioning, memory management and exception handling because of the way .NET code actually executes. When you compiled Visual Basic 6 forms applications, you had the ability to compile down to native node or p-code. Figure 1.4 should refresh your memory of what the Visual Basic 6 options dialog looked like.

Figure 4.4. Visual Basic 6 compiler options dialog.

When you compile your applications in .NET, you aren't creating anything in native code. When you compile in .NET, you're converting your code—no matter what .NET language you're using—into an assembly made up of an intermediate language called Microsoft Intermediate Language (MSIL or just IL, for short). The IL contains all the information about your application, including methods, properties, events, types, exceptions, security objects, and so on, and it also includes metadata about what types in your code can or cannot be exposed to other applications. This was called a type library in Visual Basic 6 or an IDL (interface definition language) file in C++. In .NET, it's simply the metadata that the IL contains about your assembly.
Note
The file format for the IL is known as PE (portable executable) format, which is a standard format for processor-specific execution.
When a user or another component executes your code, a process occurs called just-in-time (JIT) compilation, and it's at this point that the IL is converted into the specific machine language of the processor it's executing on. This makes it very easy to port a .NET application to any type of operating system on any type of processor because the IL is simply waiting to be consumed by a JIT compiler.

Figure 4.5. The JIT process and verification.

When code is JIT compiled, the common language runtime checks to make sure that the IL is correct. The rules that the common language runtime uses for verification are set forth in the Common Language Specification (CLS) and the Common Type System (CTS).
4.3 The .NET Framework Class Library
The second most important piece of the .NET Framework is the .NET Framework class library (FCL). As you've seen, the common language runtime handles the dirty work of actually running the code you write. But to write the code, you need a foundation of available classes to access the resources of the operating system, database server, or file server. The FCL is made up of a hierarchy of namespaces that expose classes, structures, interfaces, enumerations, and delegates that give you access to these resources.
The namespaces are logically defined by functionality. For example, the System.Data namespace contains all the functionality available to accessing databases. This namespace is further broken down into System.Data.SqlClient, which exposes functionality specific to SQL Server, and System.Data.OleDb, which exposes specific functionality for accessing OLEDB data sources. The bounds of a namespace aren't necessarily defined by specific assemblies within the FCL; rather, they're focused on functionality and logical grouping. In total, there are more than 20,000 classes in the FCL, all logically grouped in a hierarchical manner. Figure 1.8 shows where the FCL fits into the .NET Framework and the logical grouping of namespaces.

Figure 4.6. The .NET Framework class library.

To use an FCL class in your application, you use the Imports statement in Visual Basic .NET or the using statement in C#. When you reference a namespace in Visual Basic .NET or C#, you also get the convenience of auto-complete and auto-list members when you access the objects' types using Visual Studio .NET. This makes it very easy to determine what types are available for each class in the namespace you're using. As you'll see over the next several weeks, it's very easy to start coding in Visual Studio .NET.
4.4 The Structure of a .NET Application
To understand how the common language runtime manages code execution, you must examine the structure of a .NET application. The primary unit of a .NET application is the assembly. An assembly is a self-describing collection of code, resources, and metadata. The assembly manifest contains information about what is contained within the assembly. The assembly manifest provides: * Identity information, such as the assembly’s name and version number * A list of all types exposed by the assembly * A list of other assemblies required by the assembly * A list of code access security instructions, including permissions required by the assembly and permissions to be denied the assembly
Each assembly has one and only one assembly manifest, and it contains all the description information for the assembly. However, the assembly manifest can be contained in its own file or within one of the assembly’s modules.
An assembly contains one or more modules. A module contains the code that makes up your application or library, and it contains metadata that describes that code. When you compile a project into an assembly, your code is converted from high-level code to IL. Because all managed code is first converted to IL code, applications written in different languages can easily interact. For example, one developer might write an application in Visual C# that accesses a DLL in Visual Basic .NET. Both resources will be converted to IL modules before being executed, thus avoiding any language-incompatibility issues.
Each module also contains a number of types. Types are templates that describe a set of data encapsulation and functionality. There are two kinds of types: reference types (classes) and value types (structures). These types are discussed in greater detail in Lesson 2 of this chapter. Each type is described to the common language runtime in the assembly manifest. A type can contain fields, properties, and methods, each of which should be related to a common functionality. For example, you might have a class that represents a bank account. It contains fields, properties, and methods related to the functions needed to implement a bank account. A field represents storage of a particular type of data. One field might store the name of an account holder, for example. Properties are similar to fields, but properties usually provide some kind of validation when data is set or retrieved. You might have a property that represents an account balance. When an attempt is made to change the value, the property can check to see if the attempted change is greater than a predetermined limit. If the value is greater than the limit, the property does not allow the change. Methods represent behavior, such as actions taken on data stored within the class or changes to the user interface. Continuing with the bank account example, you might have a Transfer method that transfers a balance from a checking account to a savings account, or an Alert method that warns users when their balances fall below a predetermined level.

CHAPTER 5
IMPLEMENTATION

5. IMPLEMENTATION 5.1 OVERVIEW OF IMPLEMENTATION
Implementation is the most crucial stage in achieving a successful system and giving the user’s confidence that the new system is workable and effective. Implementation of a modified application to replace an existing one. This type of conversation is relatively easy to handle, provide there are no major changes in the system.
Each program is tested individually at the time of development using the data and has verified that this program linked together in the way specified in the programs specification, the computer system and its environment is tested to the satisfaction of the user. The system that has been developed is accepted and proved to be satisfactory for the user. And so the system is going to be implemented very soon. A simple operating procedure is included so that the user can understand the different functions clearly and quickly.
Initially as a first step the executable form of the application is to be created and loaded in the common server machine which is accessible to all the user and the server is to be connected to a network. The final stage is to document the entire system which provides components and the operating procedures of the system. 5.2 DATAFLOW DIAGRAM Data flow diagram shows the flow of data from external entities into the system, shows how data moves from one process to another,

DFD: NODE 1

NODE n

Deciding Filter Parameters NODE 3 Enter Keyword
Detecting IP Address Range NODE 2 User

5.3 MODULES INVOLVED IN THE PROJECT
Modules:
Modules:
Modules used are: * User Login Module * Homepage Module * IP Address Detection Module * LAN Range Selection Module * File Search Module * Result Display Module 5.3.1 User Login : To enter into the system one must provide the authenticated username and password and so the user can enter into the system and make use of it. 5.3.2 Home page : After login, the user can be able to enter into the homepage of this system and the user can move into further modules. 5.3.3 IP Address detection module : With this module the user will be able to obtain the IP address of any system that is connected to the network by just selecting the name of the system. 5.3.4 LAN Range Selection: In this module, the user can select the range of the IP addresses of the system where the search has to be performed. 5.3.5 File Search: In this Module, the user can give the filename he/she is searching for and also the file format. And the search is made through the intranet. This system will search the required file in various systems in the specified IP address range. 5.3.6 Result Display : In this module, the searched results will be displayed in a temporary grid view along with the location of the file and description about the file. The file can be accessed by just clicking the name which appears in the temporary grid view in this system.

5.4 EXTERNAL INTERFACE REQUIREMENTS
5.4.1 NON FUNCTIONAL REQUIREMENTS
5.4.1.1 Performance Requirements

We expect that most pages be returned in 1 second or less to users for whom bandwidth isn't an issue. We will attempt to keep pages to a reasonable size, however, in order to ensure that users with slow connections (e.g. 56K) do not experience a delay of more than 3 seconds for most pages. One way to do this is to limit queries so they do not return more than 20 events per page. For larger pages, or pages that return search results from the database, we expect page returns of 3 seconds for users with fast connections and 5 seconds for users with slower connections to be reasonable.

5.4.1.2 Safety Requirements

The software may be safety-critical. If so, there are issues associated with its integrity level. The software may not be safety-critical although it forms part of a safety-critical system. For example, software may simply log transactions. If a system must be of a high integrity level and if the software is shown to be of that integrity level, then the hardware must be at least of the same integrity level. There is little point in producing 'perfect' code in some language if hardware and system software (in widest sense) are not reliable.
If a computer system is to run software of a high integrity level then that system should not at the same time accommodate software of a lower integrity level.

Systems with different requirements for safety levels must be separated. Otherwise, the highest level of integrity required must be applied to all systems in the same environment.

Software Quality Attributes

* Functionality: are the required functions available, including nteroperability and security. * Reliability: maturity, fault tolerance and recoverability. * Usability: how easy it is to understand, learn, and operate the software system. * Efficiency: performance and resource behavior.

CHAPTER 6
TESTING

6. TESTING
6.1 UNIT TESTING:
Unit testing verification efforts on the smallest unit of software design, module. This is known as “Module Testing”. The modules are tested separately. This testing is carried out during programming stage itself. In these testing steps, each module is found to be working satisfactorily as regard to the expected output from the module.
6.2 INTEGRATION TESTING:
Integration testing is a systematic technique for constructing tests to uncover error associated within the interface. In the project, all the modules are combined and then the entire programmer is tested as a whole. In the integration-testing step, all the error uncovered is corrected for the next testing steps.
6.3 VALIDATION TESTING:
To overcome functional errors, that is to check whether functional characteristics confirm to specification or not
6.4 PERFORMANCE TESTING:
It covers a broad range of engineering or functional evaluations where a material, product, system, or person is not specified by detailed material or component specifications: rather, emphasis is on the final measurable performance characteristics.
Performance testing can refer to the assessment of the performance of a human examinee. For example, a behind-the-wheel driving test is a performance test of whether a person is able to perform the functions of a competent driver of an automobile.
In the computer industry, software performance testing is used to determine the speed or effectiveness of a computer, network, software program or device. This process can involve quantitative tests done in a lab, such as measuring the response time or the number of MIPS (millions of instructions per second) at which a system functions. Qualitative attributes such as reliability, scalability and interoperability may also be evaluated. Performance testing is often done in conjunction with stress testing.

CHAPTER 7
CONCLUSION AND FUTURE ENHANCEMENT

7. CONCLUSION AND FUTURE ENHANCEMENT

7.1 CONCLUSION:
Network storage is a key technique to solve the local storage shortage problem. Using this system the user can search the file through various systems connected to Local Area Network. The user can retrieve the file without knowing the specific IP addresses. User will search the file easily by selecting the format of the file. Then the particular file will be searched in certain IP Address range. Hence the relevant results will be displayed in the temporary grid view.

7.2 SCOPE FOR FUTURE ENHANCEMENT:
In this system the search is done only with the name of the file name but in future, the words within the file should also be searched for the keyword given as input. The future enhancement of this system is that when a particular file is searched very often from a system over the network, that particular file can be stored in a cache memory and can be retrieved quickly when it is needed for the future work. Therefore the retrieval will be quicker than normal.

APPENDICES
APPENDIX 1: SAMPLE CODING

1. SAMPLE CODING
Getting IP Address using System.Drawing; using System.Text; using System.Windows.Forms; using System.Net; using System.Configuration; using System.Collections; using System.Web;

namespace lanscan
{
public partial class dnsip : Form
{
public dnsip()
{
InitializeComponent();
}

private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
{
DNSLookup(comboBox1.Text.ToString());
}
private void GetIPAddress_Load(object sender, EventArgs e)
{
}

protected void DNSLookup(string domain)
{
try
{
//performs the DNS lookup
IPHostEntry he = Dns.GetHostByName(domain);
IPAddress[] ip_addrs = he.AddressList; label1.Text = ""; foreach (IPAddress ip in ip_addrs)
{
label1.Text += ip + "\n";
}
} catch (System.Exception ex)
{
label1.Text = ex.ToString();
}
}

private void dnsip_Load(object sender, EventArgs e)
{
try
{
NetworkBrowser nb = new NetworkBrowser(); foreach (string pc in nb.getNetworkComputers())
{
comboBox1.Items.Add(pc);
}
} catch (Exception ex)
{
MessageBox.Show("An error occurred trying to access the network computers", "error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
//Application.Exit();
}
}
}
}
Search Filter using System.IO;

namespace lanscan
{
public static class Functions
{
public static void ErrorReport(string s)
{
try
{
FileStream fs = new FileStream("Error.log", FileMode.Append);
StreamWriter sw = new StreamWriter(fs); sw.WriteLine(s); sw.WriteLine(""); sw.Close(); fs.Close();
}
catch
{
return;
}
}
}

public static class Search
{
public static string keyword; public static string[] filters; public static long minsize=-1; public static long maxsize=-1;
}

public static class Default
{
public static string videoFilter = ".avi .mpg .mpeg .mov .flv .3gp .rm .rmvb .mp4 .0gm .mkv .mov .wmv .vob"; public static string audioFilter = ".mp3 .wav .ogg .mid .rm .wma m4a"; public static string imagesFilter = ".jpg .jpeg .bmp .gif .ico .tga .png"; public static string codeFilter = ".c .cpp .h .java .class .jar .cs .csproj .vbproj"; public static string softwareFilter = ".exe .msi .rpm .bin .deb .iso .nrg .zip .rar"; public static string documentsFilter = ".pdf .doc .htm .html .mht .txt .ppt .xl .pps .tex .dvi";

public static string serverip="amitdey";

public static int searchDepth=2;

public static int threads=10;

public static int pingTimeout=1000;
}

public static class Settings
{
public static string[] ipranges = new string[8] { "", "", "", "", "", "", "", "" }; public static string[] individualips = new string[15] { "", "", "", "", "", "", "", "", "", "", "", "", "", "", "" };

public static string videoFilter; public static string audioFilter; public static string imagesFilter; public static string codeFilter; public static string softwareFilter; public static string documentsFilter;

public static string serverip;

public static int searchDepth;

public static int threads;

public static int pingTimeout;
}
}
Searching
using System; using System.Collections; using System.Collections.Specialized; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; using System.IO; using System.Threading; using System.Net.Sockets; using System.Diagnostics; using System.Net.NetworkInformation; using Trinet.Networking; public void LocateSearch(object IP)
{
Ping pingSender = new Ping();
PingReply reply = null; try { reply = pingSender.Send(IP as string, Settings.pingTimeout);
}
catch (Exception e)
{
Functions.ErrorReport(e.ToString());
}

// IP Address is active now search if (reply != null && reply.Status == IPStatus.Success)
{
ShareCollection sc = new ShareCollection(IP as string); foreach (Share share in sc)
{
if (share.ShareType != ShareType.Disk) continue; try
{
RecursiveSearch(share.ToString(), 0);
}
catch (Exception e)
{
Functions.ErrorReport(e.ToString());
}
}
}

threads2.Remove(Thread.CurrentThread);

if (threads2.Count == 0)
{
try
{
StopProgBar();
SetSearchStatus("File(s)/Folder(s) found : " + (dgvResult.DataSource as DataTable).Rows.Count);
}
catch (Exception e)
{
Functions.ErrorReport(e.ToString());
}
}
}

public void RecursiveSearch(string url, int depth)
{
DirectoryInfo di = new DirectoryInfo(url); if (!di.Exists) return; if (depth > Settings.searchDepth) return; depth++;
SetSearchStatus("Searching " + url); if (Search.filters == null)
{
if (di.Name.ToLower().Contains(Search.keyword))
{
string dirname; if (di.Parent == null) dirname = di.FullName.Substring(0, di.FullName.LastIndexOf(@"\")); else dirname = di.Parent.FullName;
AddRow(di.Name, dirname, "-");
/*Hmm parent directory ka panga*/
}
}

foreach (FileInfo fi in di.GetFiles())
{
string filename = fi.Name.ToLower();

if (filename.Contains(Search.keyword))
{
if (Search.filters != null)
{
foreach (string s in Search.filters)
{
if (filename.EndsWith(s))
{
if (fi.Length > Search.minsize && (Search.maxsize == -1 || fi.Length < Search.maxsize))
{
long length = fi.Length; string slen; if (length > 1073741824)
{
slen = (length / 1073741824) + " GB";
}
else
{
if (length > 1048576)
{
slen = (length / 1048576) + " MB";
}
else
{
if (length > 1024)
{
slen = (length / 1024) + " KB";
}
else slen = length + " B";
}
}
AddRow(fi.Name, di.FullName, slen);
}
break;
}
}
}
else
{
if (fi.Length > Search.minsize && (Search.maxsize == -1 || fi.Length < Search.maxsize))
{
long length = fi.Length; string slen; if (length > 1073741824)
{
slen = (length / 1073741824) + " GB";
}
else
{
if (length > 1048576)
{
slen = (length / 1048576) + " MB";
}
else
{
if (length > 1024)
{
slen = (length / 1024) + " KB";
}
else slen = length + " B";
}
}
AddRow(fi.Name, di.FullName, slen);
}
}
}
} foreach (DirectoryInfo subdir in di.GetDirectories())
{
try
{
RecursiveSearch(subdir.FullName, depth);
}
catch (Exception e)
{
Functions.ErrorReport(e.ToString());
}
}
}

APPENDIX 2 : SCREENSHOTS

2.SCREENSHOTS

2.1 USER LOGIN

2.2 HOMEPAGE

2.3 IP ADDRESS DETECTION MODULE

2.4 LAN RANGE SELECTION MODULE

2.5 RESULT DISPLAY MODULE

2.6 OPENING THE SEARCHED FILE

APPENDIX 3 : ANALYSIS MODELS

3. ANALYSIS MODELS

3.1. Use Case Diagrams

3.2 Sequence Diagram :

3.3 Collabration Diagram :

3.4 Activity Diagram:

APPENDIX 4 : REFERENCES

4.REFERENCES

1. Agrawal, R., and R. Srikant. 1995 Mining Sequential Patterns. Proc. of the 1995International Conference on Data Engineering (ICDE).

2. Barish, G., and K. Obraczka. 2000. World Wide Web Caching: Trends and Techniques.IEEE Communications Magazine, May 2000, 178-185.

3. Breslau, L., P. Cao, L. Fan, G. Phillips and S. Shenker. 1999. Web Caching and Zipf-like Distributions: Evidence and Implications. Proc. of IEEE INFOCOMM.

4. Cao, P. and S. Irani. 1997. Cost-aware WWW Proxy Caching Algorithm. Proc. USENIX Symp. on Internet Technologies and Systems.

5. Cao, P. and C. Liu. 1998. Maintaining Strong Cache Consistency in the World Wide Web. IEEE Transactions on Computers 47(4) 445-457.

6. Chinen, K., and S. Yamaguchi. 1997. An Interactive Prefetching Proxy Server for Improvement of WWW Latency. Proceedings of INET.97.

7. Cooley, R., B. Mobasher, J. Srivastava. 1999. Data Preparation for Mining World Wide Web Browsing Patterns. Knowledge and Information Systems 1(1) 1-27.