The Apache HTTP Server Project

The Apache HTTP Server Project is an effort to develop and maintain an open-source HTTP server for modern operating systems including UNIX and Windows. The goal of this project is to provide a secure, efficient and extensible server that provides HTTP services in sync with the current HTTP standards.

The Apache HTTP Server (httpd) was launched in 1995 and it has been the most popular web server on the Internet since April 1996. It has celebrated its 20th birthday as a project in February 2015.

The Apache HTTP Server is a project ofThe Apache Software Foundation.

The Apache Software Foundation and the Apache HTTP Server Project are pleased toannouncethe release of version 2.4.29 of the Apache HTTP Server (httpd).

This latest release from the 2.4.x stable branch represents the best available version of Apache HTTP Server.

The Apache HTTP Server Projectannouncesthe release of version 2.2.34, the final release of the Apache httpd 2.2 series. This version will be the last release of the 2.2 legacy branch. (Version number 2.2.33 was not released.)

The Apache HTTP Server Project has long committed to providing maintenance releases of the 2.2.x flavor through June of 2017, and may continue to publish some security source code patches beyond this date through December of 2017. No further maintenance patches nor releases of 2.2.x are anticipated. Any final security patches will be published to

Great! We have updated ourdownload pagein an effort to better utilize our mirrors. We hope that by making it easier to use our mirrors, we will be able to provide a better download experience.

Please ensure that youverifyyour downloads using PGP or MD5 signatures.

Awesome! Have a look at our current Help Wanted listings then:

Copyright © 1997-2018 The Apache Software Foundation.

Apache HTTP Server, Apache, and the Apache feather logo are trademarks of The Apache Software Foundation.

TCP profile – client and server

Originally posted on 22-Feb-2008 byDavid Sherman

I have read through this forum topic with great interest. I found several messages that dealt with tcp profile optimization. I have one question though.

When configuring a TCP profile, there is an option to select Protocol Profile (Client) and Protocol Profile (Server). The default is TCP as the client profile and (Use Client Profile) as the server profile.

If configuring a VIP that will front end a pool of high end web servers that will be accessed from the Internet, should the Protocol Profile (Client) be set to the tcp-wan-optimized profile and the Protocol Profile (Server) be set to tcp-lan-optimized profile? At least as a start?

0Rate this QuestionAnswers to this QuestionUSER ACCEPTED ANSWER&F5 ACCEPTED ANSWERUpdated 22-Feb-2008Originally posted on 22-Feb-2008 byJason RahmF5I would think so intuitively, and this is the direction I received a few years ago from F5 support. However, in recent months, our ops team has received direction that the client profile in a WAN environment should be carried through to the server. Best advice is to test,test,test.0USER ACCEPTED ANSWER&F5 ACCEPTED ANSWERUpdated 22-Feb-2008Originally posted on 22-Feb-2008 byMarcus SlawikF5hi dsherman,

i have made the best experience with putting the lan-optimized profile on the Server part and the wan-optimized on the client side. so i have a lot of stuff local in my data center where bigip and servers are close together whereas my clients are far away also via lines with higher latency and it really speeded things up for the users in comparison also with users connecting directly to the servers.

schwiddy0USER ACCEPTED ANSWER&F5 ACCEPTED ANSWERUpdated 25-Feb-2008Originally posted on 25-Feb-2008 byDavid Sherman0Thanks for the info. It is really helpful. I wish though, that the F5 developers would step up and give some guidance on this. The TCP Express capabilities are prominently advertised, however, I find that configuration recommendations are lacking. It would be very helpful if the developers would say, If your web servers are high performance (Im using IBM P590), and your clients all connect on high speed LAN connections, then generally best performance would be the LAN protocol to both client and to server. If the clients are on slower links or on the internet, then generally, best performance would be with WAN optimized on client and LAN optimized on server.

Perhaps the recommendation would be to use L4 and utilize the PVA and forgo F5 SSL termination would be best, if the servers are up to the task.0USER ACCEPTED ANSWER&F5 ACCEPTED ANSWERUpdated 04-Mar-2008Originally posted on 04-Mar-2008 byJames ThomsonF5The performance of your web server doesnt matter necessarily. The conditions of the LAN are what matter. So, if you are on a local segment, use the TCP-Lan-optimized for the server-side and the WAN-optimized for the client-side.

If you have a high performance server in Hong Kong and your BIG-IP in London and youre accessing it over an internet link, then youd want to use the wan-optimized in that case.

Using FastL4 and not taking advantage of the dual tcp stacks just means that your High Powered Server is going to have to use the least common TCP options that each client supports individually and will need to negotiate different tcp options for each client. So, if some clients are coming in with windows 2000 on a dial-up connection, then your server will spend resources lowering window sizes, dropping packets and being inefficient.

With the LTM full proxy in line, your server will always get optimal tcp options from a tcp-wan-optimized profile on the server-side of the BIG-IP LTM and the clients each get handled as best they can with the wan-optimized.0You must be logged in to answer. You can loginhere.Specify an image to upload:Choose ImageCloseInsert ImagePost NotificationYour post has been identified as spam. If this is not the case, please co.CloseAbout DevCentral

We are a community of 250,000+ technical peers who solve problems together.

ClientServer Model on the Web

Prior to the popularity of the web, client/server applications often involved the creation of native applications which were deployed to clients. In this model, developers had a great deal of freedom in determining which parts of the entire client/server application would be in the client and which in the server. Consequently, very mature models for client/server development emerged, and often well designed optimal distribution of processing and logic could be achieved. When the web took off, the client was no longer a viable application platform, it was really more of a document viewer. Consequently the user interface logic existed almost entirely on the server. However, the web has matured substantially and has proven itself to be a reasonable application platform. We can once again start utilizing more efficient and well-structured client/server model design. There are certainly still technical issues, but we are in a position to better to build true client/server applications now.

The client/server model can be categorized intothree parts:

Traditional web application development has distributed the implementation of the user interface across the network, with much of the user interface logic and code executed on the server (thin client, fat server). This has several key problems:

Poor distribution of processing With a large number of clients, doing all the processing on the server is inefficient.

High user response latency Traditional web applications are not responsive enough. High quality user interaction is very sensitive to latency, and very fast response is essential.

Difficult programming model Programming a user interface across client/server is simply difficult. When every interaction with a user must involves a request/response, user interface design with this model is complicated and error prone. The vast number of web frameworks for simplifying web development testifies to this inherent difficulty. Some have mitigated this difficulty to some degree.

Increased vector of attack Unorganized mingling of user interface code with business code can increase security risks. If access rules are distributed across user interface code, as user interface code grows and evolves, new vectors of attack emerge. With mixed code, new user interface features can easily create new security holes.

Heavy state management on the servers When client user interface state information is maintained by the server, this requires a significant increase in resource utilization as server side sessions must be maintained with potentially large object structures within them. Usually these resources cant be released until a session times out, which is often 30 minutes after a user actually leaves the web site. This can reduce performance and scalability.

Offline Difficulties Adding offline capabilities to a web application can be a tremendous project when user interface code is predominantly on the server. The user interface code must be ported to run on the client in offline situations.

Reduced opportunity for interoperability When client/server communication is composed of transferring internal parts of the user interface to the browser, it can be very difficult to understand this communication and utilize it for other applications.

With the massive move of development to the web, developers have frequently complained of the idiosyncrasies of different browsers and demanded more standards compliance. However, the new major shift in development is towards interconnectivity of different services and mashups. We will once again feel the pain of programming against differing APIs. However, we wont have browser vendors to point our fingers at. This will be the fault of web developers for creating web applications with proprietary communication techniques.

Much of the Ajax movement has been related to the move of user interface code to the client. The maturing of the browser platform and the availability of HTTP client capabilities in the XMLHttpRequest object, have allowed much more comprehensive client side user interface implementations. However, with these new found capabilities, it is important to understand how to build client/server applications.

So how do you decide what code should run on the client and what should the run on the server? I have mentioned the problems with user interface code running on the server. Conversely, running business logic and/or data management on the client is simply not acceptable for security reasons. Therefore, quite simply, user interface code is best run on the browser, and application/business logic and data management is best run on the server side. We can take a valuable lesson from object oriented programming to guide this model. Good OO design involves creating objects that encapsulate most of their behavior and have a minimal surface area. It should be intuitive and easy to interact with a well designed object interface. Likewise, client and server interaction should be built on a well-designed interface. Designing for a modular reusable remote interface is often called service oriented architecture (SOA); data is communicated with a defined API, rather than incoherent chunks of user interface. A high quality client/server implementation should have a simple interface between the client and server. The client side user interface should encapsulate as much of the presentation and user interaction code as possible, and the server side code should encapsulate the security, behavior rules, and data interaction. Web applications should be a cleanly divided into two basic elements, the user interface and the web service, with a strong emphasis on minimal surface area between them.

An excellent litmus test for a good client/server model is how easy is it to create a new user interface for the same application. A well designed client/server model should have clearly defined web services such that a new user interface could easily be designed without having to modify server side application logic. A new client could easily connect to the web services and utilize them. Communication should be primarily composed of data, not portions of user interface. The advantages of a clean client/server model where user interface logic and code is delegated to the browser:

Scalability It is quite easy to observe the significant scalability advantage of client side processing. The more clients that use an application, the more client machines that are available, whereas the server processing capabilities remain constant (until you buy more servers).

Immediate user response Client side code can immediately react to user input, rather than waiting for network transfers.

Organized programming model The user interface is properly segmented from application business logic. Such a model provides a cleaner approach to security. When all requests go through user interface code, data can flow through various interfaces before security checks take place. This can make security analysis more complicated, with complex flows to analyze. On the other hand, with a clean web service interface, there is well-defined gateway for security to work on and security analysis is more straightforward, holes can be quickly found and corrected.

Client side state management Maintaining transient session state information on the client reduces the memory load on the server. This also allows clients to leverage more RESTful interaction which can further improve scalability and caching opportunities.

Offline applications If much of the code for an application is already built to run on the client, creating an offline version of the application will almost certainly be easier.

Interoperability By using structured data with minimal APIs for interaction, it is much easier to connect additional consumers and producers to interact with existing systems.

Difficulties with the Client Server Model on the Web

There are certainly difficulties with applying the client/server model to the web. Accessibility and search engine optimization can certainly be particular challenges with the web services approach. Handling these issues may suggest a hybrid approach to web applications, some user interface generation may be done on the server to create search engine accessible pages. However, having a central architectural approach based around a client/server model, with extensions for handling search engines may be a more solid and future oriented technique for many complex web applications.

SitePen is certainly not alone in working to facilitate client/server architecture. However, since I am familiar with the projects we help create, I did want to mention our approaches to the client/server model:

DWR From inception, DWR has provided an excellent framework for building client side user interfaces that can easily connect with server side business logic. DWR was years ahead of its time in establishing a framework that encouraged good client/server modeling. DWR has a solid structure for interacting with Java business logic objects. DWR has continued to progress, providing means for bi-directional Comet based communication (Reverse Ajax), and is adding more interoperability capabilities as well.

Dojo Toolkit It should be obvious that building a good client-side user interface can benefit from a good toolkit, and Dojo has long provided just that. However, Dojo is more than just a library and set of widgets. Dojo provides real tools for building client/server applications. Dojo RPC can provides tools for connecting to web services, and can even auto-generateservices based on SMD definitions. Dojo Data provides a powerful API for interacting with a data model. Dojo has lead the way with Comet technology, creating standards around browser based two-way communication. Recently we have built theJsonRestStorewhich allows one to connect to a REST web service and interact with it using the Dojo Data read and write API. This greatly simplifies the construction of user interfaces by simplifying the user interface-business logic interaction, and encouraging standards-based communication that can easily be used by others. Furthermore, Dojo provides comprehensive tools for robust data-driven applications; even templating can be done on the client instead of the server withDojos DTL support.

The benefits of using standards-based client/server communication has facilitated integration with server frameworks likeZendjabsorbPersevere, and interoperability with other frameworks will be coming soon.

Cometd Cometd provides real-time duplex communication between clients and servers. However, the distinguishing characteristic of the Cometd project is the focus on not only achieving Comet-style duplex communication, but doing so with an interoperable standard protocol,Bayeux. Comet uses a quintessential client/server approach. Any Cometd (Bayeux implementing) server can interact with any Cometd/Bayeux client. One can easily connect various different client implementations to a single server, by using the Bayeux standard.

Persevere Persevere is a recently launched project, built with this service oriented client/server approach. Persevere is a web object database and application server with RESTful HTTP/JSON interfaces, allowing applications to quickly be built with a database backend that can be directly and securely accessed through Ajax. Persevere is focused on provided a comprehensive set of web services interaction capabilities through standard interoperable communication. Data can be accessed and modified with basic RESTful JSON interaction, clients can invoke methods on the server with simple JSON-RPC, and data can be queried withJSONQuery/JSONPath. With Dojos new REST data store, and SMD driven RPC services, Dojo clients can seamlessly build applications and interact with Persevere services using the Dojo APIs. Complex application logic can be added to the persisted objects in Persevere to facilitate building service oriented applications with a straightforward interface to the user interface code on the browser. Persevere is integrated with Rhino, so model and application logic can be written in JavaScript, providing a consistent language and environment for distributing client and server roles.

For more information about any of these open source projects, visit theSitePen Labs

As the web platform matures, as applications evolve to use more interactive and rich interfaces, and as web services increasingly interact, architecting web applications with an intelligent client/server model will become increasingly important. A properly designed client/server model will provide a foundation for modular, adaptable, and interoperable applications equipped for future growth.

2 thumbs up for client-side templating:

Im trying daily to describe the benefits of separating concerns between client (in the browser) and the server, and having this short, yet very well linked and illustrated document make my work much easier, both privately and with my customers.

This is very gratifying to see. The chorus of voices that represent new thinking around user interface design in the new era is only growing. As Peter Svensson says above, were a group of practitioners trying to evolve a coherent architecture that exploits features available today and deprecates older styles that were a compromise.

Wed like you to join us! Membership is open to anyone interested, and you dont need us to sign you in.

You may already have read these earlier pieces written by us, but Im including the links anyway:

Life Above the Service Tier, an article written by myself with two co-authors:

The End of Web Frameworks Parts I and II, two blog postings by Peter:

The Future of Web Applications Parts 1 through 4, blog postings by Mario Valente:

Im sure there are others that Ive missed, but I think were getting there as a community in terms of articulating what is and what isnt a good architecture for future applications (on the user interface side of things).

We are actually using Dojo to build our application with this client/server model.

However, in general, I think there is a scalability issue in term of the memory usage. Let alone the memory leak by the application itself, Dojo framework, or IE / FireFox browser, when an enterprise application with many UI components and functionalities loaded into the browser, the memory usage keeps growing. If the application has multiple release cycles with more features added in each, sooner or later, the bottleneck of memory usage in the browser will be hit.

So far I havent found a way to unload the UI components in the browser and load it back when needed by using javascript yet. Kris, wonder if you have encountered this with the client/server model? and what the options are to resolve this?

Pingback:SitePen Blog Security in Ajax()

Pingback:SitePen Blog When to Use Persevere: a Comparison with CouchDB and Others()

Its been a long time I wanted to reference externally your blog entry. In my day-to-day job, I advocate for independent light clients over RESTful APIs. I did write a framework implementing the MVC pattern client-side and I know all the benefits. With the open Dojo toolkit following that path, with post like yours, anyone can envision these benefits too.

Anyway, just to let you know I referenced your post in in relation to some side-projects I started to implement a collaborative application on Google App Engine infrastructure.

Pingback:SitePen Blog JavaScriptDB: Perseveres New High-Performance Storage Engine()

Pingback:SitePen Blog MVC in the Browser()

Pingback:Introducing Pintura SitePen Blog()

This is Great post.. useful information thanks..

ClientServer the Internet and

Copyright Robelle Solutions Technology Inc. 1995-1996

OverviewTheWorld Wide Web (WWW)is a collection of servers distributed all over the world that respond to various clients. The WWW allows you to click on links to text, pictures, music, or video located on these servers and then to play the selected files on your local client PC, workstation, or terminal, along with more links to related information. You never need to know where the information is located or to learn any obscure commands to access it.

The on-line version of this paper is available as alinked set of filesor as a largesingle file.Downloading this paper as a single file may take some time, but has the advantage of making it convenient to save or print the entire paper with your Web browser.

To help you understand the World Wide Web, we have organized this paper into these major sections: Copyright 1995-1996 Robelle Solutions Technology Inc.

To understand the WWW, it helps if you understand some basic Web concepts. Fundamental to this understanding is the concept of client/server computing on a global scale.

Whether youre reading WWW documents or creating your own, it helps if you understand the basic components of the WWW language.

One powerful feature of the WWW is that the information you publish on your server can be read by many different clients. In this section, we provide a quick introduction to some of the popular WWW clients.

If you want to make your own information available to WWW clients, youll want to set up your own server. In this section, we discuss some common WWW server software and give our suggestions for how WWW server information should be designed.

The WWW is a big place. Here are a few pointers to some of the things that we have liked or found useful.

These are our parting thoughts on client/server, WWW, and the Internet.

A short list of books that we have found very useful for learning more about the WWW.

Jump on board for a ride on the Web. We hope that youll find enough information here to join us with your own WWW information.

The WWW is a new way of viewing information — and a rather different one. If, for example, you are viewing this paper as a WWW document, you will view it with a browser, in which case you can immediately access hypertext links. If you are reading this on paper, you will see the links indicated in parentheses and in a different font. Keep in mind that the WWW is constantly evolving. We have tried to pick stable links, but sites reorganize and sometimes they even move. By the time you read the printed version of this paper, some WWW links may have changed.

The World Wide WebThe WWW project has the potential to do for the Internet what Graphical User Interfaces (GUIs) have done for personal computers — make the Net useful to end users. The Internet contains vast resources in many fields of study (not just in computer and technical information). In the past, finding and using these resources has been difficult. The Web provides consistency: Servers provide information in a consistent way and clients show information in a consistent way. To add a further thread of consistency, many users view the Web through graphical browsers which are like other windows (Microsoft Windows, Macintosh windows, or X-Windows) applications that they use. A principal feature of the Web is its links between one document and another. These links, described in the section on hypertext, allow you to move from one document to another. Hypertext links can point to any server connected to the Internet and to any type of file. These links are what transform the Internet into a web.A History of the WebThe Web project was started by Tim Berners-Lee at the European Particle Physics Laboratory (CERN) in Geneva, Switzerland. Tim wanted to find a way for scientists doing projects at CERN to collaborate with each other on-line. He thought of hypertext as one possible method for this collaboration. Tim started the WWW project at CERN in March 1989. In January 1992, the first versions of WWW software, known as Hypertext Transfer Protocol (HTTP), appeared on the Internet. By October 1993, 500 known HTTP servers were active. When Robelle joined the Internet in June 1994, we were about the 80,000th registered HTTP server. By the end of 1994, it was estimated that there were over 500,000 HTTP servers. Attempts to keep track of the number of HTTP servers on the Internet have not been successful. Programs that try to automatically count HTTP servers never stop — new servers are being added constantly.

On-Line versus BatchThis paper is available on the World Wide Web (on-line) or as a paper document (batch). If you are reading this viaRobelles WWW Service,you probably already know how to access the on-line version. Much of the value of the Web lies in its links between one document and another. When you view this paper with a WWW browser, the links are hidden from you. When you read the text or paper copy of this paper, you see the links in parentheses. Because links tend to be long, they do not format well in the text and paper versions. Since more than half the effort of writing this paper went into finding and testing the links, we have left them in the text and printed versions, despite their distracting appearance. We will describe what the links mean a little later.

What is Hypertext?Hypertext provides the links between different documents and different document types. If you have used Microsoft Windows WinHelp system or theMacintoshhypercard application, you likely know how to use hypertext. In a hypertext document, links from one place in the document to another are included with the text. By selecting a link, you are able to jump immediately to another part of the document or even to a different document. In the WWW, links can go not only from one document to another, but from one computer to another.

Client/Server ComputingThe last few years have seen an explosion of information about client/server computing. For many people, the definition of client/server is still unclear. We describe it as a method of distributing applications over one or more computers. A client is one process that requests services of another process. These processes can be on different computers or on the same computer. The processes communicate via a networking protocol.

People often think of client/server computing in terms of local area networks, PCs with graphical user interface capabilities, and servers with information that is needed by the PC clients. You do not have to implement client/server computing this way. It is possible for the same computer to be both the client and the server. The key point is that there is a communications protocol that allows two processes (often on different computers) to request and to respond to demands for services.

The Hypertext Transfer ProtocolWhen you use a WWW client, it communicates with a WWW server using the Hypertext Transfer Protocol(HTTP).When you select a WWW link, the following things happen:

The client looks up the hostname and makes a connection with the WWW server.The HTTP software on the server responds to the clients request.The client and the server close the connection.Compare this with traditional terminal/host computing. Users usually logon (connect) to the server and remain connected until they logoff (disconnect). An HTTP connection, on the other hand, is made only for as long as it takes for the server to respond to a request. Once the request is completed, the client and the server are no longer in communication.

WWW clients use the same technique for other protocols. For example, if you request a directory at ananonymous FTP site,the WWW client makes an FTP connection, logs on as an anonymous user, switches to the directory, requests the directory contents, and then logs off the FTP server. If you then select a file, the WWW client once again makes an FTP connection, logs on again, changes directories, downloads the file, and then logs off. If you use an FTP client to do the same thing, you would normally log on to the FTP server, change directories several times, and download one or more files. Only when you were finished would you log off.

The InternetThe Internet is the worlds largest interconnected computer network. Computers on the Internet communicate using the Internet Protocol (IP) and the Transmission Control Protocol (TCP). You identify individual computers by their IP-address. This address is a 32-bit number that is usually represented by four octets (e.g., 192.40.254.0). Fortunately, you can usually refer to a computer by its name (e.g.,

If you can send network packets to one computer on the Internet, you can send network packets to any computer on the Internet. This feature is what makes the Internet so powerful; it is also what concerns system managers. If you can send packets to the Internet, it follows that anyone can send packets to your computer, even the PC on your desktop.Accessing the InternetIf you are reading the text or paper version of this paper, youre probably wondering How do I get started on the Internet? It is much easier to connect an individual PC and a modem to the Internet than it is to connect a server like an HP 3000 or HP 9000. We suggest that you find a local Internet access provider to connect your PC to the Net. Most access providers include everything you need to log on and start exploring. In addition, several books on connecting to the Internet also provide all the software and the telephone numbers of Internet access providers you need to get started. Once youre connected to the Internet, you can begin investigating many of the sites described in this paper. You will also be able to access and download much of the software needed to create your own WWW application which, as we discuss further on, can be of help to you, even if you never plan to connect your servers to the Internet.

In order to use the WWW, you must know something about the language used to communicate in the Web. There are three main components to this language:Uniform Resource Locators (URLs)

URLs provide the hypertext links between one document and another. These links can access a variety of protocols (e.g., ftp, gopher, or http) on different machines (or your own machine).

WWW documents contain a mixture of directives (markup), and text or graphics. The markup directives do such things as make a word appear in bold type. This is similar to the way UNIX users write nroff or troff documents, and MPE users write with Galley, TDP, or Prose. For PC users, this is completely different from WYSIWYG editing. However, a number of tools are now available on the market that hide the actual HTML.

Servers use the CGI interface to execute local programs. CGIs provide a gateway between the HTTP server software and the host machine.

Uniform Resource Locators(URLs) specify the access-method (how), the server name (where), and the location (what) needed for a WWW client to find and access a WWW object. The general form of a URL isaccess-method://server-name[:port]/locationAccess MethodsThe three most popular access methods arehttp:

This is the method provided by WWW servers. It includes hypertext linking, the hypertext markup language, and server scripts.

Gopherwas developed at the University of Minnesota as a distributed campus information service. There are gopher servers everywhere — many of them provide campus-wide information systems. Gopher information is organized into menus. Because hypertext provides the same services as gopher and more, many sites are moving from gopher-supplied information to WWW-supplied information.

The File Transfer Protocol is one of the oldest and most popular of all Internet services. You can access millions of files, documentation, source code, and other useful objects on anonymous FTP archives. You can use a WWW browser to view and to retrieve information from FTP archives.

Server NameThe server name is an IP host name or an IP address. WWW servers often start with the name www as in port number is usually not needed. If there are many servers on one machine (e.g., two different WWW servers on the same host), you would use a port number to select one of them. By default, WWW servers are on port 80. Other protocols have different ports (e.g., the default for FTP is 21). Most users never need to know about port numbers.Welcome PageMost WWW servers provide a welcome or home page. This is the document that you see if you specify a machine name, but not a document name (see all the examples above under Server Name). Good WWW welcome pages provide a short description of the information the WWW server provides, as well as links to all the other information available on the server. The welcome page must be explicitly configured for each WWW server. If you access a WWW server without giving a document name, and receive the error message no document found, you should try one of the following common document names: welcome.html, index.html, or default.html.LocationThe location can be a filename, a directory, a directory and filename, a server-script name, or something specific to the access-method. Filenames and directory structure often change, so dont be surprised if a URL that worked a few months ago no longer works now.

When you write documents for WWW, you use theHypertext Markup Language a markup language, you mix your text with the marks that indicate how formatting is to take place. Most WWW browsers have an option to View Source that will show you the HTML for the current document that you are viewing.

Each WWW browser renders HTML in its own way. Character-mode browsers use terminal highlights (e.g., inverse video, dim, or underline) to show links, bold, italics, and so on. Graphical browsers use different typefaces, colors, and bold and italic formats to display different HTML marks. Writers have to remember that each browser in effect has its own HTML style sheet. For example, Lynx and Mosaic do not insert a blank line before unnumbered user lists, but Netscape does.

If you want to see how your browser handles standard and non-standard HTML, try theWWW Test Pattern.The test pattern will show differences between your browser, standard HTML, and other broswers.Creating HTMLCreating HTML is awkward, but not that difficult. The most common method of creating HTML is to write the raw markup language using a standard text editor. If you are creating HTML yourself, we have found the chapterAuthoring for the Webin theOReillybook Managing Internet Information Services to be an excellent resource. You might also find theHTML Quick Referenceto be useful.

Bob Green, founder of Robelle, findsHTML Writerto be useful for learning HTML. Instead of hiding the HTML tags, HTML Writer provides menus with all of the HTML elements and inserts these into a text window. To see how your documents look, you must use a separate Web browser.

If you dont want to deal directly with HTML, you can get a WYSIWYG HTML editor. On the PC, we have tried HoTMetal and the Microsoft Word Internet add-on. HoTMetal is produced bySoftQuadThere is a free version, which we found somewhat unreliable, and a professional version. HoTMetal probably works best if you are writing HTML documents from scratch (we tried to edit existing documents, some of which may have had invalid HTML).

Microsoft has produced a new add-on to Microsoft Word that produces HTML.The Internet Assistantis available from Microsoft at no charge. You will need to know the basic concepts of Microsoft Word to take advantage of the Internet Assistant. Since we are not experienced Microsoft Word users, we found that the Internet Assistant didnt help us much.

The HTML area of WWW is changing quickly. Users do not want to go back to ascii text editing after theyve used WYSIWYG editors for the last several years. The Web itself carries a list ofWYSIWYG HTML editorsfor a variety of operating systems.

TheCommon Gateway Interface (CGI)provides a method for WWW servers to invoke other programs. You can write these programs with any tool or language. They usually return HTML as their output. The RobelleWWW server statisticsare provided by a CGI script that runs thegetstats program.FormsThe WWW supportssimple formswith text boxes, radio buttons, and pull-down lists. Forms are processed by CGI scripts.

You will likely first experience the World Wide Web through a WWW client. In WWW terms, these are called browsers. Browsers are available for almost all major computer platforms, however you also need the appropriate network infrastructure to make them work.Network Infrastructure

What browser you use depends largely on how you are connected to the Internet. If you are using a terminal emulator and a serial connection, you will most likely use a character-mode browser. If you can send network packets from your computer to the Internet, you will probably use a graphical-mode browser.

A popular character-mode browser isLynx.You cannot use Lynx to display graphical images, but it does support forms, as well as all HTML 2.0.

Three popular graphical browsers areMosaicNetscapeandMicrosoft Internet Explorer.

Mosaic and Netscape are available for Microsoft Windows, X-Windows, and the Macintosh, while Microsofts IE is only available for Microsoft Windows. Mosaic and Microsoft IE are free to anyone; Netscape is free to any not-for-profit institution.

How you connect to the Internet affects how you view the WWW. If you connect via a modem, you wont be able to view large WWW pages, images, sounds, or video; if you have a T1 connection (1.544M bits/second), you will be able to enjoy these features. Some WWW pages assume that you have a fast connection to the Internet.

Local Area NetworksIf your Local Area Network has a gateway to the Internet (there are several different methods to do this), you should be able to use a graphical browser on your own workstation to cruise the WWW. If you are using a PC with Microsoft Windows, youll need to have aWinsockinterface installed (in addition to the regular networking configuration). Macintosh users already have network support via MacTCP. UNIX workstation users should also have built-in support for networking.Dial-in AccessThere are two methods of dialing into a machine to get access to the Internet. If you dial in and log on as usual (on UNIX you see login: and shell prompt or on MPE you type HELLO and get a colon prompt), your computer is not directly connected to the Internet, so it cannot send network packets from your PC to the Internet. In this case, you will have to use Lynx to access the WWW.

If you dial-in using SLIP (Serial Line IP) or PPP (Point-to-Point Protocol), your computer becomes part of the Internet, which means it can send network packets to and from the Internet. In this case, you can use graphical browsers like Mosaic or Netscape to access the WWW.The Internet Adapteris supposed to allow users with only shell account access to obtain a SLIP connection.ShivaandLivingstonprovide products that allow users to dial into hosts using SLIP or PPP.

While Lynx is not the only character-mode browser, it is one of the most powerful.Lynxis available for many platforms. You can obtain a pre-compiled version of Lynx for MPE/iX .Some users are disappointed that Lynxs display is limited to text. What Lynx does demonstrate is that a single server can provide information to both character-mode and graphical clients. Still, to gain a full understanding of how powerful the client/server concept can be, you should compare Lynxs capabilities to the capabilities of graphical browsers such as Mosaic or Netscape.

Mosaic is one of the tools that makes the WWW so popular. With Mosaic, you can view in-line graphical images surrounded by proportional font text in multiple colors. For an excellent introduction to Mosaic, see the OReilly bookThe Mosaic Handbook.Three versions of the book are available (Windows, Macintosh, and X-Windows). The PC version of Mosaic requires the Win32s subsystem which is described in theMosaic readme file.

While Mosaic is popular, the newer Netscape browser is even more appealing, especially when used with slower network connections. Earlier versions of Mosaic did not display anything until an entire URL (and its associated graphical images) had been downloaded. Netscape, by contrast, starts displaying as soon as a screenful of information is available. As you page down through a document, Netscape barely pauses as it continues to download the URL in the background.

The newest graphical browser is theMicrosoft Internet Explorer.This browser is part of Microsofts strategy to make the Internet an important part of all Microsoft products. Like Netscape, the Microsoft IE also does background network transfers. We perfer Netscape over Microsoft IE, due to Netscapes user interface and better reliability.External ViewersNeither Mosaic nor Netscape tries to handle all the data that can potentially be served up on the Web. They both understand HTML, in-line graphics, and URLs. Netscape can display external GIF (Graphics Interchange Format) files, but Mosaic cannot. To view images, listen to sound, watch movies, or view spread sheets, you must haveexternal toolsto support these data formats. For Microsoft Windows users, a popular graphical viewer isLView.The Mosaic Handbook provides a good introduction to the external tools that you need to support full multimedia applications. Most of these tools also work with Netscape.

WWW servers provide information to the Web. Server software is available for many computer platforms, but setting up a server isnt always easy.Why Set Up a WWW Server?

Even if you dont have an Internet connection, there are lots of uses for an internal WWW server.

Setting up a server to provide information to the many different Internet clients requires extra thought, but the effort is worth it.

Server software exits for UNIX, MPE, Windows NT, Microsoft Windows, and even MS-DOS.

Like most applications, your WWW server will need a little help from time to time.

If you have a full-time Internet connection, you might want to set up a WWW server to provide information about your company, your division, your group, or yourself. Even if you are not connected to the Internet, you still might want to set up a server.

Hypertext is a useful way to distribute information because it can contain mixed text and graphics (or more), as well as links to other documents. Using WWW servers, you can create sophisticated help systems without a lot of work. Once established, these systems then become available to all users on your internal network who have suitable client software (browsers).

With CGI scripts and e-mail, you can automate forms which you now process by hand (e.g., expense reports, travel reports, or purchase requisitions). With some extra work, you could even have the forms processed directly into a database. You can also design scripts to look up information in your existing databases and display it for clients.

If your users are pushing for Microsoft Windows interfaces to all of their database data, you can use your WWW server as an intermediate solution. This way users get an immediate graphical interface and managers can experience the difficulties of managing client/server configurations.

When you set up a WWW server, keep in mind that many different clients will be accessing your server. If your server is available on the Internet, you should not assume that the clients will all have high-speed Internet connections and graphical browsers.

Consider these things when designing your WWW server:

Concentrate on your text. Well-written text conveys a lot of information. If you use text to convey essential information, then your server will be friendly to text-based clients like Lynx.

Organize documents the way you would organize a book: gather information together into chapters; each chapter should describe a single idea or related topics. Provide navigational tools (like previous or next chapter) and an overview with a table-of-contents. We have attempted to have all of these elements in this paper.

Question each graphical image that you provide. Does the graphic add meaning to the text or is it just neat? Compare the size of the graphics file to the size of your text files. If the graphical image is much larger, does it really add a lot of necessary information?

If your WWW server is on a fast network, do all the clients have fast access to your server? You may have a T1 connection (1.544M bits/sec), but many WWW clients connect via 14.4 modems. Some commercial Internet providers even charge by the hour, which makes it more expensive for clients to download large files and graphics. If your clients have a fast connection to the Internet, you can provide more graphical information and larger text files without annoying them. Nevertheless, its a good idea to keep these limitations in mind when youre developing your server.

Try to keep files to a reasonable size (we suggest three to ten thousand bytes long). When converting existing documents to HTML, remember that they will often end up quite large (tens of thousands of bytes). Do clients want to download such a large file only to find that it is of no interest? The converse is also true. Can clients download a single file with the complete text (e.g., this paper), without having to follow all the hypertext links?

Hypertext does not mean disorganization. Provide an index or a table of contents to your web pages, so users can quickly find information. Provide summaries for long articles and files.

Use graphic-design common sense. Use white space to increase readability. If you use special effects (bold, italics, underline, horizontal rules, etc), use them sparingly to increase their effect.

If your WWW server is available on the Internet, many visitors will access your server out of curiosity. Make your welcome page attractive, but clearly identify what information your WWW server is providing. Of all the files you publish, be most careful of the size of your welcome page. It will likely be the most frequently accessed page.

We also suggest that you look at theW3 Style Guide.

First, you need to decide what computer will host your WWW information (or you could pick several hosts). If your WWW server will make information available to many machines, the host must be connected to your network or the Internet.

While WWW server software is available for a variety of machines, each server software package runs only on certain operating systems. The server software you pick will have to be compatible with the host machine that provides the WWW service.WWW Server SoftwareW3 maintain a good list ofWWW server software. Two of the most popular UNIX WWW server software packages areNCSA HTTPDandCERN HTTPD. A pre-compiled copy of the NCSA HTTPD software is available forMPE/iX.

Windows NT is becoming more popular as a WWW server, largely due to its built-in networking support and its familiar Windows interface. FreeWindows NT HTTP Server softwareis available from theEuropean Microsoft Windows NT Academic Center.TheRobelle Windows NT WWW Serveruses the OReillyWebsitesoftware. Website comes with comprehensive documentation — something other server software is lacking.

Configuration and management is different for each package. We found theOReilly BookManaging Internet Information Services to be a valuable resource in setting up our WWW servers. The book is an excellent introduction to HTML, with many good examples of configurations. Unfortunately, the book only covers the configuration of the NCSA HTTPD software.SecurityThe CERN and NCSA HTTPD packages allow the WWW administrator to configure security. By default, both packages allow anyone to connect to your WWW service. However, you can configure the servers to allow connections only from specific IP addresses (be sure to do this if your WWW service is for internal use only). You can also password protect individual files. TheMPE WWW Serverincludes a demonstration of the NCSA security features.

By default, the CERN and NCSA server software allow individual directories of hypertext files. If someone specifies a URL with a directory starting with tilde (~), the server software looks for a user directory of that name and then searches under the user name for the directory public_html.

Writing HTMLOnce you have the WWW server software running, you need to create WWW information. WWW documents use the Hypertext Markup Language (HTML). See theHTML descriptionearlier in this paper for suggestions and tools for writing HTML.

Be sure to test your files before adding them to your WWW server. We test with at least three different browsers (Lynx, Mosaic, and Netscape). We also useWeblinton all of our Web documents. Weblint checks for common errors in HTML. While Weblint isnt perfect, it does help produce HTML that is acceptable to the widest range of WWW browsers.

Weblint is written inPerl.To use Weblint, you must have a working copy of Perl. Perl is short for Practical Extraction and Report Language. Perl is designed to be more powerful than the shell, but easier to use than C.Host NameIf your WWW server is available on the Internet, its a good idea to create an alias for the actual computer that hosts your WWW service. Most people chose www as the alias name. This will make it easier for you to change the host without affecting users of your WWW service.RobotsWWW s

socket_server_and_client

c++socket

(c++ to write high performance socket, has been packaged into a dynamic library, Can be used directly,)socket_server_&_client\Common\Src\socket\IocpServer.cpp

socket_server_&_client\Common\Src\CriticalSection.cpp

socket_server_&_client\Common\Src\CriticalSection.h

socket_server_&_client\Common\Src\Event.cpp

socket_server_&_client\Common\Src\Event.h

socket_server_&_client\Common\Src\FuncHelper.cpp

socket_server_&_client\Common\Src\FuncHelper.h

socket_server_&_client\Common\Src\GeneralHelper.cpp

socket_server_&_client\Common\Src\GeneralHelper.h

socket_server_&_client\Common\Src\InitCOM.cpp

socket_server_&_client\Common\Src\InitCOM.h

socket_server_&_client\Common\Src\PrivateHeap.cpp

socket_server_&_client\Common\Src\PrivateHeap.h

socket_server_&_client\Common\Src\STLHelper.h

socket_server_&_client\Common\Src\Semaphore.cpp

socket_server_&_client\Common\Src\Semaphore.h

socket_server_&_client\Common\Src\Singleton.h

socket_server_&_client\Common\Src\WaitFor.cpp

socket_server_&_client\Common\Src\WaitFor.h

socket_server_&_client\Common\Src\Win32Helper.h

socket_server_&_client\Common\Src\bufferptr.cpp

socket_server_&_client\Common\Src\bufferptr.h

socket_server_&_client\Common\Src\debug

socket_server_&_client\Common\Src\debug\ce_crtdbg.cpp

socket_server_&_client\Common\Src\debug\ce_crtdbg.h

socket_server_&_client\Common\Src\debug\win32_crtdbg.cpp

socket_server_&_client\Common\Src\debug\win32_crtdbg.h

socket_server_&_client\Common\Src\socket

socket_server_&_client\Common\Src\socket\IocpServer.h

socket_server_&_client\Common\Src\socket\SocketClient.cpp

socket_server_&_client\Common\Src\socket\SocketClient.h

socket_server_&_client\Common\Src\socket\SocketHelper.cpp

socket_server_&_client\Common\Src\socket\SocketHelper.h

socket_server_&_client\TestEcho\Client

socket_server_&_client\TestEcho\Client\Client.cpp

socket_server_&_client\TestEcho\Client\Client.h

socket_server_&_client\TestEcho\Client\Client.rc

socket_server_&_client\TestEcho\Client\Client.vcxproj

socket_server_&_client\TestEcho\Client\Client.vcxproj.filters

socket_server_&_client\TestEcho\Client\ClientDlg.cpp

socket_server_&_client\TestEcho\Client\ClientDlg.h

socket_server_&_client\TestEcho\Client\ReadMe.txt

socket_server_&_client\TestEcho\Client\res

socket_server_&_client\TestEcho\Client\res\Client.ico

socket_server_&_client\TestEcho\Client\res\Client.rc2

socket_server_&_client\TestEcho\Client\resource.h

socket_server_&_client\TestEcho\Client\stdafx.cpp

socket_server_&_client\TestEcho\Client\stdafx.h

socket_server_&_client\TestEcho\Client\targetver.h

socket_server_&_client\TestEcho\Debug

socket_server_&_client\TestEcho\Debug\Client.exe

socket_server_&_client\TestEcho\Debug\Server.exe

socket_server_&_client\TestEcho\Global

socket_server_&_client\TestEcho\Global\helper.cpp

socket_server_&_client\TestEcho\Global\helper.h

socket_server_&_client\TestEcho\Release

socket_server_&_client\TestEcho\Release\Client.exe

socket_server_&_client\TestEcho\Release\Server.exe

socket_server_&_client\TestEcho\Server

socket_server_&_client\TestEcho\Server\ReadMe.txt

socket_server_&_client\TestEcho\Server\Server.cpp

socket_server_&_client\TestEcho\Server\Server.h

socket_server_&_client\TestEcho\Server\Server.rc

socket_server_&_client\TestEcho\Server\Server.vcxproj

socket_server_&_client\TestEcho\Server\Server.vcxproj.filters

socket_server_&_client\TestEcho\Server\Server.vcxproj.user

socket_server_&_client\TestEcho\Server\ServerDlg.cpp

socket_server_&_client\TestEcho\Server\ServerDlg.h

socket_server_&_client\TestEcho\Server\res

socket_server_&_client\TestEcho\Server\res\Server.ico

socket_server_&_client\TestEcho\Server\res\Server.rc2

socket_server_&_client\TestEcho\Server\resource.h

socket_server_&_client\TestEcho\Server\stdafx.cpp

socket_server_&_client\TestEcho\Server\stdafx.h

socket_server_&_client\TestEcho\Server\targetver.h

socket_server_&_client\TestEcho\TestEcho.sln

socket_server_&_client\TestEcho\TestEcho.suo

socket_server_&_client\TestEcho-PFM\Client

socket_server_&_client\TestEcho-PFM\Client\Client.cpp

socket_server_&_client\TestEcho-PFM\Client\Client.h

socket_server_&_client\TestEcho-PFM\Client\Client.rc

socket_server_&_client\TestEcho-PFM\Client\Client.vcxproj

socket_server_&_client\TestEcho-PFM\Client\Client.vcxproj.filters

socket_server_&_client\TestEcho-PFM\Client\Client.vcxproj.user

socket_server_&_client\TestEcho-PFM\Client\ClientDlg.cpp

socket_server_&_client\TestEcho-PFM\Client\ClientDlg.h

socket_server_&_client\TestEcho-PFM\Client\ReadMe.txt

socket_server_&_client\TestEcho-PFM\Client\Worker.cpp

socket_server_&_client\TestEcho-PFM\Client\Worker.h

socket_server_&_client\TestEcho-PFM\Client\res

socket_server_&_client\TestEcho-PFM\Client\res\Client.ico

socket_server_&_client\TestEcho-PFM\Client\res\Client.rc2

socket_server_&_client\TestEcho-PFM\Client\resource.h

socket_server_&_client\TestEcho-PFM\Client\stdafx.cpp

ClientServer mode

This page is related toHMP200HMP130, andHMP100devices. ForHMP350andHMP300, seeLive Sourcepage.

Client/Server mode(also called Network mode) is acontent pull methodwhereby theHMPis requesting and displaying an entireprojectlocated on a remotecontent server. To enable this mode, you need toconfigure a network projectas primary content source, as detailed below.

Each resource included in the network project is verified & retrieved when it needs to be played, therefore the content server must be accessible all the time, if possible. And the network connection needs to be (very) fast, so that, for instance, a large video file could be downloaded and played in real-time. Some resources (like SVG files, images, small video files etc.) might becachedlocally tominimize the network bandwidth, nevertheless, the Client/Server mode is generally not resilient to network failures.

But what happens when network failures occur? Well, the HMP tries to play the primary content source as much as possible, so if the content server is not reachable or the network is disconnected, the HMP tries to play the network content from its local cache, while waiting for the issue to be resolved. In some cases, it might also switch to the fallback source of content -the exact process is described in detail below.

Note:Serious testing & validation of the bandwidth and quality of the network should be done before using Client/Server mode in a production environment. In case of issues, you should switch to usingPull Modeinstead.

Comparing to thePull Mode, where the local project is synchronized with the server periodically, the Client/Server mode has the advantage of retrieving the new / changed resource as soon as is needed to be displayed. However, the disadvantage is that the connection between the HMP and the server must be reliable and must transmit the files fast enough when needed to be displayed (otherwise the resource will be displayed when available or skipped).

To enable the Client/Server mode onHMP200HMP130, andHMP100devices, follow these steps:

OpenHMP Control Centerand go to theContent Settingspage Content Source tab.

Set the Primary source option to Network Project and enter the network project location URI in the field appearing next to it.

This must be a valid HTTP(S) address, ending with a trailing slash, something like:

The HMP looks for and tries to open theindex.svgfile in the root of the entered URI.

In case the network content cannot be played, the HMP uses the Fallback source – it is recommended to leave this option as Local Storage.

Click the Apply button to save the configuration.

Note:If the network location requires username and password to be accessed, then enter the credentials underNetwork Settingspage Credentialstab.SeeWeb serverspage for information on supported authentication schemes.

This section describes in detail the actions done by the HMP when Client/Server mode is employed. For a quick description, see the introductory section above.

Right afterconfiguring the network projectas primary source, sub-process I is activated; the rest of actions done by the HMP follow from there.

The HMP tries to open theindex.svgfile in the root of the specified network location.

This sub-process is employed when the HMP starts playing the main index.svg of the network project.

Each time a resource included in the network project, including its main index.svg, needs to be played by the HMP, the following actions are done:

If the resource isactively cached, then the HMP displays the resource from its localcache.

This process continues to the next resource.

Else, the HMP requests the status of the resource from the content server.

If, for any reasons, the server cannot be contacted, then the HMP displays the resource from its local cache, or skips it.

This process continues to the next resource.

This means that the HMP does not switch to the Fallback source in case that, for instance, the server is down or the HMP network cable was removed.

not found (404 error) on main index.svg, thenProcess IIIis activated.

not found (404 error) on any other resource, then the HMP skips playing that resource.

This process continues to the next resource.

new / changed, then the resource is marked for download.

unchanged, but the resource is not present on the HMPcache, then it is also marked for download.

If the resource is marked for download, then the HMP downloads the resource from the server and adds it to its localcache(according to thecaching directives).

Finally, the HMP tries to display the resource from its local cache, otherwise, it skips that resource.

This process continues to the next resource.

This sub-process is employed when the HMP decides that it cannot play the network project set as primary source.

In this case, the following actions are done:

The network project is temporarily discarded and the Fallback source is used instead.

The HMP checks every 5 minutes if the network project is accessible again. When that happens, thenProcess Iis activated.

The HMP tries to play the content as much as possible from its local cache (tominimize the network bandwidth), however a stable network connection is necessary to regularly connect to the server and check for updates.

The HMP will use up to 70% of its free space for the cache, without overwrite any existing content.

Although possible, the Fallback source should not be set to a network project as well, because in case of network issues, the HMP might not be able to find any content and consequently, a black screen might be displayed – it is recommended to leave the Fallback source option as Local Storage.

Do not use another HMP as content server, because this might have unexpected results on the client(s) and will definitely have a negative impact on the performance of the HMP used as server.

Here is a list of tutorials where Client / Server is used:

The HMP cannot connect to UNC paths – see theWeb serverspage for more details.

URLs are resolved using DNS; WINS is not supported by the HMP. You may use hostnames which are not Fully Qualified Domain Names, but they will only be resolved if your local DNS is properly configured.

Custom fonts cannot be used remotely, so they must be first installed on the player in order to be used – this is a known limitation. An workaround is topublishan Elementi, which can be used as fallback source, before activating the network project; you only need to do this once.

Content is available under theCreative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.

This page was last modified on 8 January 2018, at 16:20.

Writing the Server Side of a Socket

Home PageCustom NetworkingAll About Sockets PreviousTrailNext

The Java Tutorials have been written for JDK 8. Examples and practices described in this page dont take advantage of improvements introduced in later releases.

This section shows you how to write a server and the client that goes with it. The server in the client/server pair serves up Knock Knock jokes. Knock Knock jokes are favored by children and are usually vehicles for bad puns. They go like this:

Server: Knock knock!Client: Whos there?Server: Dexter.Client: Dexter who?Server: Dexter halls with boughs of holly.Client: Groan.

The example consists of two independently running Java programs: the client program and the server program. The client program is implemented by a single class,KnockKnockClient, and is very similar to theEchoClientexample from the previous section. The server program is implemented by two classes:KnockKnockServerandKnockKnockProtocol.KnockKnockServer, which is similar toEchoServer, contains themainmethod for the server program and performs the work of listening to the port, establishing connections, and reading from and writing to the socket. The classKnockKnockProtocolserves up the jokes. It keeps track of the current joke, the current state (sent knock knock, sent clue, and so on), and returns the various text pieces of the joke depending on the current state. This object implements the protocolthe language that the client and server have agreed to use to communicate.

The following section looks in detail at each class in both the client and the server and then shows you how to run them.

This section walks through the code that implements the Knock Knock server program,KnockKnockServer.

The server program begins by creating a newServerSocketobject to listen on a specific port (see the statement in bold in the following code segment). When running this server, choose a port that is not already dedicated to some other service. For example, this command starts the server programKnockKnockServerso that it listens on port 4444:

The server program creates theServerSocketobject in atry-with-resources statement:

int portNumber = Integer.parseInt(args[0]); try (

ServerSocket serverSocket = new ServerSocket(portNumber);

Socket clientSocket = serverSocket.accept(); PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true); BufferedReader in = new BufferedReader( new InputStreamReader(clientSocket.getInputStream())); )

ServerSocketis aclass that provides a system-independent implementation of the server side of a client/server socket connection. The constructor forServerSocketthrows an exception if it cant listen on the specified port (for example, the port is already being used). In this case, theKnockKnockServerhas no choice but to exit.

If the server successfully binds to its port, then theServerSocketobject is successfully created and the server continues to the next stepaccepting a connection from a client (the next statement in thetry-with-resources statement):

Theacceptmethod waits until a client starts up and requests a connection on the host and port of this server. (Lets assume that you ran the server programKnockKnockServeron the computer named.) In this example, the server is running on the port number specified by the first command-line argument. When a connection is requested and successfully established, the accept method returns a newSocketobject which is bound to the same local port and has its remote address and remote port set to that of the client. The server can communicate with the client over this newSocketand continue to listen for client connection requests on the originalServerSocketThis particular version of the program doesnt listen for more client connection requests. However, a modified version of the program is provided inSupporting Multiple Clients.

After the server successfully establishes a connection with a client, it communicates with the client using this code:

try ( // … PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true); BufferedReader in = new BufferedReader( new InputStreamReader(clientSocket.getInputStream())); ) String inputLine, outputLine;

// Initiate conversation with client KnockKnockProtocol kkp = new KnockKnockProtocol(); outputLine = kkp.processInput(null); out.println(outputLine);

while ((inputLine = in.readLine()) != null) outputLine = kkp.processInput(inputLine); out.println(outputLine); if (outputLine.equals(Bye.)) break;

Gets the sockets input and output stream and opens readers and writers on them.

Initiates communication with the client by writing to the socket (shown in bold).

Communicates with the client by reading from and writing to the socket (the

Step 1 is already familiar. Step 2 is shown in bold and is worth a few comments. The bold statements in the code segment above initiate the conversation with the client. The code creates aKnockKnockProtocolobjectthe object that keeps track of the current joke, the current state within the joke, and so on.

After theKnockKnockProtocolis created, the code callsKnockKnockProtocolsprocessInputmethod to get the first message that the server sends to the client. For this example, the first thing that the server says is Knock! Knock! Next, the server writes the information to thePrintWriterconnected to the client socket, thereby sending the message to the client.

Step 3 is encoded in thewhileloop. As long as the client and server still have something to say to each other, the server reads from and writes to the socket, sending messages back and forth between the client and the server.

The server initiated the conversation with a Knock! Knock! so afterwards the server must wait for the client to say Whos there? As a result, thewhileloop iterates on a read from the input stream. ThereadLinemethod waits until the client responds by writing something to its output stream (the servers input stream). When the client responds, the server passes the clients response to theKnockKnockProtocolobject and asks theKnockKnockProtocolobject for a suitable reply. The server immediately sends the reply to the client via the output stream connected to the socket, using a call to println. If the servers response generated from theKnockKnockServerobject is Bye. this indicates that the client doesnt want any more jokes and the loop quits.

The Java runtime automatically closes the input and output streams, the client socket, and the server socket because they have been created in thetry-with-resources statement.

TheKnockKnockProtocolclass implements the protocol that the client and server use to communicate. This class keeps track of where the client and the server are in their conversation and serves up the servers response to the clients statements. TheKnockKnockProtocolobject contains the text of all the jokes and makes sure that the client gives the proper response to the servers statements. It wouldnt do to have the client say Dexter who? when the server says Knock! Knock!

All client/server pairs must have some protocol by which they speak to each other; otherwise, the data that passes back and forth would be meaningless. The protocol that your own clients and servers use depends entirely on the communication required by them to accomplish the task.

TheKnockKnockClientclass implements the client program that speaks to theKnockKnockServer.KnockKnockClientis based on theEchoClientprogram in the previous section,Reading from and Writing to a Socketand should be somewhat familiar to you. But well go over the program anyway and look at whats happening in the client in the context of whats going on in the server.

When you start the client program, the server should already be running and listening to the port, waiting for a client to request a connection. So, the first thing the client program does is to open a socket that is connected to the server running on the specified host name and port:

String hostName = args[0]; int portNumber = Integer.parseInt(args[1]); try (

Socket kkSocket = new Socket(hostName, portNumber);

PrintWriter out = new PrintWriter(kkSocket.getOutputStream(), true); BufferedReader in = new BufferedReader( new InputStreamReader(kkSocket.getInputStream())); )

When creating its socket, theKnockKnockClientexample uses the host name of the first command-line argument, the name of the computer on your network that is running the server programKnockKnockServer.

TheKnockKnockClientexample uses the second command-line argument as the port number when creating its socket. This is aremote port numberthe number of a port on the server computerand is the port to whichKnockKnockServeris listening. For example, the following command runs theKnockKnockClientexample withas the name of the computer that is running the server programKnockKnockServerand 4444 as the remote port number:

The clients socket is bound to any availablelocal porta port on the client computer. Remember that the server gets a new socket as well. If you run theKnockKnockClientexample with the command-line arguments in the previous example, then this socket is bound to local port number 4444 on the computer from which you ran theKnockKnockClientexample. The servers socket and the clients socket are connected.

Next comes thewhileloop that implements the communication between the client and the server. The server speaks first, so the client must listen first. The client does this by reading from the input stream attached to the socket. If the server does speak, it says Bye. and the client exits the loop. Otherwise, the client displays the text to the standard output and then reads the response from the user, who types into the standard input. After the user types a carriage return, the client sends the text to the server through the output stream attached to the socket.

while ((fromServer = in.readLine()) != null) System.out.println(Server: + fromServer); if (fromServer.equals(Bye.)) break; fromUser = stdIn.readLine(); if (fromUser != null) System.out.println(Client: + fromUser); out.println(fromUser);

The communication ends when the server asks if the client wishes to hear another joke, the client says no, and the server says Bye.

The client automatically closes its input and output streams and the socket because they were created in thetry-with-resources statement.

You must start the server program first. To do this, run the server program using the Java interpreter, just as you would any other Java application. Specify as a command-line argument the port number on which the server program listens:

Next, run the client program. Note that you can run the client on any computer on your network; it does not have to run on the same computer as the server. Specify as command-line arguments the host name and the port number of the computer running theKnockKnockServerserver program:

If you are too quick, you might start the client before the server has a chance to initialize itself and begin listening on the port. If this happens, you will see a stack trace from the client. If this happens, just restart the client.

If you try to start a second client while the first client is connected to the server, the second client just hangs. The next section,Supporting Multiple Clients, talks about supporting multiple clients.

When you successfully get a connection between the client and server, you will see the following text displayed on your screen:

The client echoes what you type and sends the text to the server. The server responds with the first line of one of the many Knock Knock jokes in its repertoire. Now your screen should contain this (the text you typed is in bold):

Again, the client echoes what you type and sends the text to the server. The server responds with the punch line. Now your screen should contain this:

If you want to hear another joke, typey; if not, typen. If you typey, the server begins again with Knock! Knock! If you typen, the server says Bye. thus causing both the client and the server to exit.

If at any point you make a typing mistake, theKnockKnockServerobject catches it and the server responds with a message similar to this:

The server then starts the joke over again:

Note that theKnockKnockProtocolobject is particular about spelling and punctuation but not about capitalization.

To keep theKnockKnockServerexample simple, we designed it to listen for and handle a single connection request. However, multiple client requests can come into the same port and, consequently, into the sameServerSocket. Client connection requests are queued at the port, so the server must accept the connections sequentially. However, the server can service them simultaneously through the use of threadsone thread per each client connection.

The basic flow of logic in such a server is this:

The thread reads from and writes to the client connection as necessary.

Modify theKnockKnockServerso that it can service multiple clients at the same time. Two classes compose our solution:KKMultiServerandKKMultiServerThread.KKMultiServerloops forever, listening for client connection requests on aServerSocket. When a request comes in,KKMultiServeraccepts the connection, creates a newKKMultiServerThreadobject to process it, hands it the socket returned from accept, and starts the thread. Then the server goes back to listening for connection requests. TheKKMultiServerThreadobject communicates to the client by reading from and writing to the socket. Run the new Knock Knock serverKKMultiServerand then run several clients in succession.

Client-Server Model

The client-server model describes how aserverprovides resources and services to one or moreclients. Examples of servers includeweb serversmail servers, andfile servers. Each of these servers provide resources to client devices, such asdesktop computerslaptopstablets, andsmartphones. Most servers have a one-to-many relationship with clients, meaning a single server can provide resources to multiple clients at one time.

When a client requests a connection to a server, the server can either accept or reject the connection. If the connection is accepted, the server establishes and maintains a connection with the client over a specificprotocol. For example, anemailclient may request anSMTPconnection to a mail server in order to send a message. The SMTP application on the mail server will then request authentication from the client, such as the email address and password. If these credentials match an account on the mail server, the server will send the email to the intended recipient.

Online multiplayer gaming also uses the client-server model. One example is Blizzards service, which hosts online games for World of Warcraft, StarCraft, Overwatch, and others. When players open a Blizzardapplication, the game client automatically connects to a Battle.net server. Once players log in to Battle.net, they can see who else isonline, chat with other players, and play matches with or against other gamers.

While Internet servers typically provide connections to multiple clients at a time, each physical machine can only handle so much traffic. Therefore, popular online services distribute clients across multiple physical servers, using a technique calleddistributed computing. In most cases, it does not matter which specific machine users are connected to, since the servers all provide the same service.

NOTE:The client-server model may be contrasted to theP2Pmodel, in which clients connect directly to each other. In a P2P connection, there is no central server required, since each machine acts as both a client and a server.

This page contains a technical definiton of Client-Server Model. It explains in computing terminology what Client-Server Model means and is one of many technical terms in the TechTerms dictionary.

All definitions on the TechTerms website are written to be technically accurate but also easy to understand. If you find this Client-Server Model definition to be helpful, you can reference it using the citation links above. If you think a term should be updated or added to the TechTerms dictionary, pleaseemail TechTerms!

ClientServer Authentication

I have a client/server socket application that enables file transfer between the client and the server, however, i want the client to be authenticated with the server before a file is transferred. the client should prompt for a user name and password which

is used for authentication with the server. The server should be configured with user name/password pairs so that it is able to

authenticate client. I have been searching for related work for quite sometime now but havent come across anything close to this yet. Please i want any1 to help me settle this issues, i would appreciate if i am directed to an article or any other resources that is helpful, or pasting sample code/ uploading sample application would be of greatest help..Thank you all in advance.

Microsoft is conducting an online survey to understand your opinion of the Msdn Web site. If you choose to participate, the online survey will be presented to you when you leave the Msdn Web site.

Thank you! The survey will appear here when youve completed your visit, soplease do not close this window.

What is ClientServer Software (With Best Examples

Task Management Software for Team Collaboration

What is Client/Server Software (With Best Examples)

HomeSolutionsTechnology

What is Client/Server Software (With Best Examples)

Client-server (C/S) or two-tier architecture (in comparison with a peer-to-peer architecture) has two separate types of nodes on the network: servers, that store information and clients, that send requests for information to servers. Usually, but not always, a client computer and a server computer are two separate devices. A server computer contains large amounts of memory and disk space, while client computers features graphic user interface to support the display of data stored on server. There are many different types ofclient/server softwarehowever their basic architecture remains the same.

Client/server approach to networking has proven to be a cost-effective way to share data between tens or hundreds of computers. Considering the client/server computing in terms of a manager-employee relationship, the following list outlines some of the benefits and drawbacks of client/server solutions.

The server stores the data and coordinates the access to information and its modification. This helps to keep the data consistent and up-to-date, even when multiple users/clients are working with it simultaneously.

Managers or team leaders have more information, experience and knowledge about the company and day-to-day operations. Their deep understanding of the business processes, priorities, strategy, goals, and important tasks allows them to easily share information as needed and delegate work to their employees.

The employees or team members may have less knowledge and experience or their vision of the strategy and goals is far from clear. By usingclient/server softwarethey have more focused tasks and also they might get a clear picture of company strategy if their team leaders provide them with access to such information.

This is the essential aspect of how client/server computing works. It lets the manager plan, assign and notify the team members of their tasks. Once finished with their work, employees report the results back to the manager for verification.

Very often the database is securely locked away from unauthorized access and its data is denied view and/or edit permission, that prevents violations from outside and inside the office.

CentriQS provides business management solutionsempowered by client-server data exchange. This software enables businesses to keep all their data in one centralized database which can be customized and tailored according to their needs. Customer records, account history, documents, projects, tasks, campaigns, and other business data can be safely stored, updated, and retrieved when required. CentriQS is best to manage business activities, enable user collaboration, and generate analytics for better decision making.

VIP Task Manageris a client/server application forgroup task managementandcollaboration. It uses Firebird database management system that allows any PC in your Local Network to function as both client and server, so you dont need a dedicated server in your LAN. You can install server or client&server part on your server computer or any PC in the office to keep the common database with company tasks there, while other computers require client installation only.

Available: Workdays, Monday – Friday

Feb 1, 2016TopTenReview: VIP Organizer is one of the best organizer software

TopTenReview has published Organizer Software Review 2016 and our product has been included to the list of the best software programs for personal information management. The author considers VIP Organizer to be a good choice if you are looking for something simple to help you organize your days.

P2P Client and Server (Servent

Brought to you by:clubifaximaticjuanjobntmvidal

Get project updates, sponsored content from our select partners, and more.

Congo, The Democratic Republic of the

Korea, Democratic Peoples Republic of

Lao Peoples Democratic Republic

South Georgia and the South Sandwich Islands

United States Minor Outlying Islands

Get notifications on updates for this project.

Get newsletters and notices that include site news, special offers and exclusive discounts about IT products & services.

Yes, also send me special offers about products & services regarding:

I agree to receive these communications from . I understand that I can withdraw my consent at anytime. Please refer to ourTerms of UseandPrivacy PolicyorContact Usfor more details.

I agree to receive these communications from SourceForge.net via the means indicated above. I understand that I can withdraw my consent at anytime. Please refer to ourTerms of UseandPrivacy PolicyorContact Usfor more details.

JavaScript is required for this form.

You seem to have CSS turned off. Please dont fill out this field.

You seem to have CSS turned off. Please dont fill out this field.

A peer2peer application container that isolates the programer form the peer2peer coding complexity. Applications are coded as a POJO object without any knowledge of distributed programming.

P2P Client and Server (Servent) Web Site

Be the first topost a reviewof P2P Client and Server (Servent)!

A free peer-to-peer (P2P) file sharing client

© 2018 Slashdot Media. All Rights Reserved.

Thanks for helping keep SourceForge clean.

You seem to have CSS turned off. Please dont fill out this field.

You seem to have CSS turned off. Please dont fill out this field.

Right-click on the ad, choose Copy Link, then paste here

(This may not be possible with some types of ads)

Please provide the ad click URL, if possible:

Get latest updates about Open Source Projects, Conferences and News.

Congo, The Democratic Republic of the

Korea, Democratic Peoples Republic of

Lao Peoples Democratic Republic

South Georgia and the South Sandwich Islands

United States Minor Outlying Islands

Yes, also send me special offers about products & services regarding:

JavaScript is required for this form.

I agree to receive these communications from SourceForge.net. I understand that I can withdraw my consent at anytime. Please refer to ourTerms of UseandPrivacy PolicyorContact Usfor more details.I agree to receive these communications from SourceForge.net via the means indicated above. I understand that I can withdraw my consent at anytime. Please refer to ourTerms of UseandPrivacy PolicyorContact Usfor more details.

You seem to have CSS turned off. Please dont fill out this field.

You seem to have CSS turned off. Please dont fill out this field.

Latency Compensating Methods in ClientServer In-game Protocol Design and Optimization

Basic Architecture of a Client / Server Game

Contents of the User Input messages

Client-Side Prediction of Weapon Firing

Game Design Implications of Lag Compensation

Designing first-person action games for Internet play is a challenging process. Having robust on-line gameplay in your action title, however, is becoming essential to the success and longevity of the title. In addition, the PC space is well known for requiring developers to support a wide variety of customer setups. Often, customers are running on less than state-of-the-art hardware. The same holds true for their network connections.

While broadband has been held out as a panacea for all of the current woes of on-line gaming, broadband is not a simple solution allowing developers to ignore the implications of latency and other network factors in game designs. It will be some time before broadband truly becomes adopted in the United States, and much longer before it can be assumed to exist for your clients in the rest of the world. In addition, there are a lot of poor broadband solutions, where users may occasionally have high bandwidth, but more often than not also have significant latency and packet loss in their connections.

Your game must behave well in this world. This discussion will give you a sense of some of the tradeoffs required to deliver a cutting-edge action experience on the Internet. The discussion will provide some background on how client / server architectures work in many on-line action games. In addition, the discussion will show how predictive modeling can be used to mask the effects of latency. Finally, the discussion will describe a specific mechanism, lag compensation, for allowing the game to compensate for connection quality.

Most action games played on the net today are modified client / server games. Games such as Half-Life, including its mods such as Counter-Strike and Team Fortress Classic, operate on such a system, as do games based on the Quake3 engine and the Unreal Tournament engine. In these games, there is a single, authoritative server that is responsible for running the main game logic. To this are connected one or more dumb clients. These clients, initially, were nothing more than a way for the user input to be sampled and forwarded to the server for execution. The server would execute the input commands, move around other objects, and then send back to the client a list of objects to render. Of course, the real world system has more components to it, but the simplified breakdown is useful for thinking about prediction and lag compensation.

With this in mind, the typical client / server game engine architecture generally looks like this:

For this discussion, all of the messaging and coordination needed to start up the connection between client and server is omitted. The clients frame loop looks something like the following:

Sample user input (mouse, keyboard, joystick)

Package up and send movement command using simulation time

Read any packets from the server from the network system

Use packets to determine visible objects and their state

End time minus start time is the simulation time for the next frame

Each time the client makes a full pass through this loop, the frametime is used for determining how much simulation is needed on the next frame. If your framerate is totally constant then frametime will be a correct measure. Otherwise, the frametimes will be incorrect, but there isnt really a solution to this (unless you could deterministically figure out exactly how long it was going to take to run the next frame loop iteration before running it…).

The server has a somewhat similar loop:

Read client user input messages from network

Simulate server-controlled objects using simulation time from last full pass

For each connected client, package up visible objects/world state and send to client

End time minus start time is the simulation time for the next frame

In this model, non-player objects run purely on the server, while player objects drive their movements based on incoming packets. Of course, this is not the only possible way to accomplish this task, but it does make sense.

In Half-Life engine games, the user input message format is quite simple and is encapsulated in a data structure containing just a few essential fields:

The critical fields here are the msec, viewangles, forward, side, and upmove, and buttons fields. The msec field corresponds to the number of milliseconds of simulation that the command corresponds to (its the frametime). The viewangles field is a vector representing the direction the player was looking during the frame. The forward, side, and upmove fields are the impulses determined by examining the keyboard, mouse, and joystick to see if any movement keys were held down. Finally, the buttons field is just a bit field with one or more bits set for each button that is being held down.

Using the above data structures and client / server architecture, the core of the simulation is as follows. First, the client creates and sends a user command to the server. The server then executes the user command and sends updated positions of everything back to client. Finally, the client renders the scene with all of these objects. This core, though quite simple, does not react well under real world situations, where users can experience significant amounts of latency in their Internet connections. The main problem is that the client truly is dumb and all it does is the simple task of sampling movement inputs and waiting for the server to tell it the results. If the client has 500 milliseconds of latency in its connection to the server, then it will take 500 milliseconds for any client actions to be acknowledged by the server and for the results to be perceptible on the client. While this round trip delay may be acceptable on a Local Area Network (LAN), it is not acceptable on the Internet.

One method for ameliorating this problem is to perform the clients movement locally and just assume, temporarily, that the server will accept and acknowledge the client commands directly. This method is labeled as client-side prediction.

Client-side prediction of movements requires us to let go of the dumb or minimal client principle. Thats not to say that the client is fully in control of its simulation, as in a peer-to-peer game with no central server. There still is an authoritative server running the simulation just as noted above. Having an authoritative server means that even if the client simulates different results than the server, the servers results will eventually correct the clients incorrect simulation. Because of the latency in the connection, the correction might not occur until a full round trips worth of time has passed. The downside is that this can cause a very perceptible shift in the players position due to the fixing up of the prediction error that occurred in the past.

To implement client-side prediction of movement, the following general procedure is used. As before, client inputs are sampled and a user command is generated. Also as before, this user command is sent off to the server. However, each user command (and the exact time it was generated) is stored on the client. The prediction algorithm uses these stored commands.

For prediction, the last acknowledged movement from the server is used as a starting point. The acknowledgement indicates which user command was last acted upon by the server and also tells us the exact position (and other state data) of the player after that movement command was simulated on the server. The last acknowledged command will be somewhere in the past if there is any lag in the connection. For instance, if the client is running at 50 frames per second (fps) and has 100 milliseconds of latency (roundtrip), then the client will have stored up five user commands ahead of the last one acknowledged by the server. These five user commands are simulated on the client as a part of client-side prediction. Assuming full prediction1, the client will want to start with the latest data from the server, and then run the five user commands through similar logic to what the server uses for simulation of client movement. Running these commands should produce an accurate final state on the client (final player position is most important) that can be used to determine from what position to render the scene during the current frame.

In Half-Life, minimizing discrepancies between client and server in the prediction logic is accomplished by sharing the identical movement code for players in both the server-side game code and the client-side game code. These are the routines in thepm_shared/(which stands for player movement shared) folder of theHL SDK. The input to the shared routines is encapsulated by the user command and a from player state. The output is the new player state after issuing the user command. The general algorithm on the client is as follows:

from state – state after last user command acknowledged by the server; command – first command after last user command acknowledged by server; while (true) run command on from state to generate to state; if (this was the most up to date command) break; from state = to state; command = next command; ;

The origin and other state info in the final to state is the prediction result and is used for rendering the scene that frame. The portion where the command is run is simply the portion where all of the player state data is copied into the shared data structure, the user command is processed (by executing the common code in the pm_shared routines in Half-Lifes case), and the resulting data is copied back out to the to state.

There are a few important caveats to this system. First, youll notice that, depending upon the clients latency and how fast the client is generating user commands (i.e., the clients framerate), the client will most often end up running the same commands over and over again until they are finally acknowledged by the server and dropped from the list (a sliding window in Half-Lifes case) of commands yet to be acknowledged. The first consideration is how to handle any sound effects and visual effects that are created in the shared code. Because commands can be run over and over again, its important not to create footstep sounds, etc. multiple times as the old commands are re-run to update the predicted position. In addition, its important for the server not to send the client effects that are already being predicted on the client. However, the client still must re-run the old commands or else there will be no way for the server to correct any erroneous prediction by the client. The solution to this problem is easy: the client just marks those commands which have not been predicted yet on the client and only plays effects if the user command is being run for the first time on the client.

The other caveat is with respect to state data that exists solely on the client and is not part of the authoritative update data from the server. If you dont have any of this type of data, then you can simply use the last acknowledged state from the server as a starting point, and run the prediction user commands in-place on that data to arrive at a final state (which includes your position for rendering). In this case, you dont need to keep all of the intermediate results along the route for predicting from the last acknowledged state to the current time. However, if you are doing any logic totally client side (this logic could include functionality such as determining where the eye position is when you are in the process of crouchingand its not really totally client side since the server still simulates this data also) that affects fields that are not replicated from the server to the client by the networking layer handling the players state info, then you will need to store the intermediate results of prediction. This can be done with a sliding window, where the from state is at the start and then each time you run a user command through prediction, you fill in the next state in the window. When the server finally acknowledges receiving one or more commands that had been predicted, it is a simple matter of looking up which state the server is acknowledging and copying over the data that is totally client side to the new starting or from state.

So far, the above procedure describes how to accomplish client side prediction of movements. This system is similar to the system used inQuakeWorld2.

Layering prediction of the firing effects of weapons onto the above system is straightforward. Additional state information is needed for the local player on the client, of course, including which weapons are being held, which one is active, and how much ammo each of these weapons has remaining. With this information, the firing logic can be layered on top of the movement logic because, once again, the state of the firing buttons is included in the user command data structure that is shared between the client and the server. Of course, this can get complicated if the actual weapon logic is different between client and server. In Half-Life, we chose to avoid this complication by moving the implementation of a weapons firing logic into shared code just like the player movement code. All of the variables that contribute to determining weapon state (e.g., ammo, when the next firing of the weapon can occur, what weapon animation is playing, etc.), are then part of the authoritative server state and are replicated to the client-side so there, they can be used for prediction of weapon state.

Predicting weapon firing on the client will likely lead to the decision also to predict weapon switching, deployment, and holstering. In this fashion, the user feels that the game is 100% responsive to his or her movement and weapon activation activities. This goes a long way toward reducing the feeling of latency that many players have come to endure with todays Internet-enabled action experiences.

Replicating the necessary fields to the client and handling all of the intermediate state is a fair amount of work. At this point, you may be asking, why not eliminate all of the server stuff and just have the client report where s/he is after each movement? In other words, why not ditch the server stuff and just run the movement and weapons purely on the client-side? Then, the client would just send results to the server along the lines of, Im now at position x and, by the way, I just shot player 2 in the head. This is fine if you can trust the client. This is how a lot of the military simulation systems work (i.e., they are a closed system and they trust all of the clients). This is how peer-to-peer games generally work. For Half-Life, this mechanism is unworkable because of realistic concerns about cheating. If we encapsulated absolute state data in this fashion, wed raise the motivation to hack the client even higher than it already is3. For our games, this risk is too high and we fall back to requiring an authoritative server.

A system where movements and weapon effects are predicted client-side is a very workable system. For instance, this is the system that the Quake3 engine supports. One of the problems with this system is that you still have to have a feel for your latency to determine how to lead your targets (for instant hit weapons). In other words, although you get to hear the weapons firing immediately, and your position is totally up-to-date, the results of your shots are still subject to latency. For example, if you are aiming at a player running perpendicular to your view and you have 100 milliseconds of latency and the player is running at 500 units per second, then youll need to aim 50 units in front of the target to hit the target with an instant hit weapon. The greater the latency, the greater the lead targeting needed. Getting a feel for your latency is difficult. Quake3 attempted to mitigate this by playing a brief tone whenever you received confirmation of your hits. That way, you could figure out how far to lead by firing your weapons in rapid succession and adjusting your leading amount until you started to hear a steady stream of tones. Obviously, with sufficient latency and an opponent who is actively dodging, it is quite difficult to get enough feedback to focus in on the opponent in a consistent fashion. If your latency is fluctuating, it can be even harder.

Another important aspect influencing how a user perceives the responsiveness of the world is the mechanism for determining, on the client, where to render the other players. The two most basic mechanisms for determining where to display objects are extrapolation and interpolation4.

For extrapolation, the other player/object is simulated forward in time from the last known spot, direction, and velocity in more or less a ballistic manner. Thus, if you are 100 milliseconds lagged, and the last update you received was that (as above) the other player was running 500 units per second perpendicular to your view, then the client could assume that in real time the player has moved 50 units straight ahead from that last known position. The client could then just draw the player at that extrapolated position and the local player could still more or less aim right at the other player.

The biggest drawback of using extrapolation is that players movements are not very ballistic, but instead are very non-deterministic and subject to high jerk5. Layer on top of this the unrealistic player physics models that most FPS games use, where players can turn instantaneously and apply unrealistic forces to create huge accelerations at arbitrary angles and youll see that the extrapolation is quite often incorrect. The developer can mitigate the error by limiting the extrapolation time to a reasonable value (QuakeWorld, for instance, limited extrapolation to 100 milliseconds). This limitation helps because, once the true player position is finally received, there will be a limited amount of corrective warping. In a world where most players still have greater than 150 milliseconds of latency, the player must still lead other players in order to hit them. If those players are warping to new spots because of extrapolation errors, then the gameplay suffers nonetheless.

The other method for determining where to display objects and players is interpolation. Interpolation can be viewed as always moving objects somewhat in the past with respect to the last valid position received for the object. For instance, if the server is sending 10 updates per second (exactly) of the world state, then we might impose 100 milliseconds of interpolation delay in our rendering. Then, as we render frames, we interpolate the position of the object between the last updated position and the position one update before that (alternatively, the last render position) over that 100 milliseconds. As the object just gets to the last updated position, we receive a new update from the server (since 10 updates per second means that the updates come in every 100 milliseconds) we can start moving toward this new position over the next 100 milliseconds.

If one of the update packets fails to arrive, then there are two choices: We can start extrapolating the player position as noted above (with the large potential errors noted) or we can simply have the player rest at the position in the last update until a new update arrives (causing the players movement to stutter).

The general algorithm for this type of interpolation is as follows:

Each update contains the server time stamp for when it was generated

From the current client time, the client computes a target time by subtracting the interpolation time delta (100 ms)

If the target time is in between the timestamp of the last update and the one before that, then those timestamps determine what fraction of the time gap has passed.

This fraction is used to interpolate any values (e.g., position and angles).

In essence, you can think of interpolation, in the above example, as buffering an additional 100 milliseconds of data on the client. The other players, therefore, are drawn where they were at a point in the past that is equal to your exact latency plus the amount of time over which you are interpolating. To deal with the occasional dropped packet, we could set the interpolation time as 200 milliseconds instead of 100 milliseconds. This would (again assuming 10 updates per second from the server) allow us to entirely miss one update and still have the player interpolating toward a valid position, often moving through this interpolation without a hitch. Of course, interpolating for more time is a tradeoff, because it is trading additional latency (making the interpolated player harder to hit) for visual smoothness.

In addition, the above type of interpolation (where the client tracks only the last two updates and is always moving directly toward the most recent update) requires a fixed time interval between server updates. The method also suffers from visual quality issues that are difficult to resolve. The visual quality issue is as follows. Imagine that the object being interpolated is a bouncing ball (which actually accurately describes some of our players). At the extremes, the ball is either high in the air or hitting the pavement. However, on average, the ball is somewhere in between. If we only interpolate to the last position, it is very likely that this position is not on the ground or at the high point. The bounciness of the ball is flattened out and it never seems to hit the ground. This is a classical sampling problem and can be alleviated by sampling the world state more frequently. However, we are still quite likely never actually to have an interpolation target state be at the ground or at the high point and this will still flatten out the positions.

In addition, because different users have different connections, forcing updates to occur at a lockstep like 10 updates per second is forcing a lowest common denominator on users unnecessarily. In Half-Life, we allow the user to ask for as many updates per second as he or she wants (within limit). Thus, a user with a fast connection could receive 50 updates per second if the user wanted. By default, Half-Life sends 20 updates per second to each player the Half-Life client interpolates players (and many other objects) over a period of 100 milliseconds.7

To avoid the flattening of the bouncing ball problem, we employ a different algorithm for interpolation. In this method, we keep a more complete position history for each object that might be interpolated.

The position history is the timestamp and origin and angles (and could include any other data we want to interpolate) for the object. Each update we receive from the server creates a new position history entry, including timestamp and origin/angles for that timestamp. To interpolate, we compute the target time as above, but then we search backward through the history of positions looking for a pair of updates that straddle the target time. We then use these to interpolate and compute the final position for that frame. This allows us to smoothly follow the curve that completely includes all of our sample points. If we are running at a higher framerate than the incoming update rate, we are almost assured of smoothly moving through the sample points, thereby minimizing (but not eliminating, of course, since the pure sampling rate of the world updates is the limiting factor) the flattening problem described above.

The only consideration we have to layer on top of either interpolation scheme is some way to determine that an object has been forcibly teleported, rather than just moving really quickly. Otherwise we might smoothly move the object over great distances, causing the object to look like its traveling way too fast. We can either set a flag in the update that says, dont interpolate or clear out the position history, or we can determine if the distance between the origin and one update and another is too big, and thereby presumed to be a teleportation/warp. In that case, the solution is probably to just move the object to the latest know position and start interpolating from there.

Understanding interpolation is important in designing for lag compensation because interpolation is another type of latency in a users experience. To the extent that a player is looking at other objects that have been interpolated, then the amount of interpolation must be taken into consideration in computing, on the server, whether the players aim was true.

Lag compensation is a method of normalizing server-side the state of the world for each player as that players user commands are executed. You can think of lag compensation as taking a step back in time, on the server, and looking at the state of the world at the exact instant that the user performed some action. The algorithm works as follows:

Before executing a players current user command, the server:

Computes a fairly accurate latency for the player

Searches the server history (for the current player) for the world update that was sent to the player and received by the player just before the player would have issued the movement command

From that update (and the one following it based on the exact target time being used), for each player in the update, move the other players backwards in time to exactly where they were when the current players user command was created. This moving backwards must account for both connection latency and the interpolation amount

Allow the user command to execute (including any weapon firing commands, etc., that will run ray casts against all of the other players in their old positions).

Move all of the moved/time-warped players back to their correct/current positions

Note that in the step where we move the player backwards in time, this might actually require forcing additional state info backwards, too (for instance, whether the player was alive or dead or whether the player was ducking). The end result of lag compensation is that each local client is able to directly aim at other players without having to worry about leading his or her target in order to score a hit. Of course, this behavior is a game design tradeoff.

The introduction of lag compensation allows for each player to run on his or her own clock with no apparent latency. In this respect, it is important to understand that certain paradoxes or inconsistencies can occur. Of course, the old system with the authoritative server and dumb or simple clients had its own paradoxes. In the end, making this tradeoff is a game design decision. For Half-Life, we believe deciding in favor of lag compensation was a justified game design decision.

The first problem of the old system was that you had to lead your target by some amount that was related to your latency to the server. Aiming directly at another player and pressing the fire button was almost assured to miss that player. The inconsistency here is that aiming is just not realistic and that the player controls have non-predictable responsiveness.

With lag compensation, the inconsistencies are different. For most players, all they have to do is acquire some aiming skill and they can become proficient (you still have to be able to aim). Lag compensation allows the player to aim directly at his or her target and press the fire button (for instant hit weapons9). The inconsistencies that sometimes occur, however, are from the points of view of the players being fired upon.

For instance, if a highly lagged player shoots at a less lagged player and scores a hit, it can appear to the less lagged player that the lagged player has somehow shot around a corner10. In this case, the lower lag player may have darted around a corner. But the lagged player is seeing everything in the past. To the lagged player, s/he has a direct line of sight to the other player. The player lines up the crosshairs and presses the fire button. In the meantime, the low lag player has run around a corner and maybe even crouched behind a crate. If the high lag player is sufficiently lagged, say 500 milliseconds or so, this scenario is quite possible. Then, when the lagged players user command arrives at the server, the hiding player is transported backward in time and is hit. This is the extreme case, and in this case, the low ping player says that s/he was shot from around the corner. However, from the lagged players point of view, they lined up their crosshairs on the other player and fired a direct hit. From a game design point of view, the decision for us was easy: let each individual player have completely responsive interaction with the world and his or her weapons.

In addition, the inconsistency described above is much less pronounced in normal combat situations. For first-person shooters, there are two more typical cases. First, consider two players running straight at each other pressing the fire button. In this case, its quite likely that lag compensation will just move the other player backwards along the same line as his or her movement. The person being shot will be looking straight at his attacker and no bullets bending around corners feeling will be present.

The next example is two players, one aiming at the other while the other dashes in front perpendicular to the first player. In this case, the paradox is minimized for a wholly different reason. The player who is dashing across the line of sight of the shooter probably has (in f

Python Socket ClientServer

Socket

:stream,datagramrawstreamdatagramTCPrawIP

Python SocketBSDTCPsocket.html

-*- coding:utf-8 -*- from socket import * def SocketServer(): try: Colon = ServerUrl.find(:) IP = ServerUrl[0:Colon] Port = int(ServerUrl[Colon+1:]) socket print Server start:%s%ServerUrl sockobj = socket(AF_INET, SOCK_STREAM) sockobj.setsockopt(SOL_SOCKET,SO_REUSEADDR, 1) IP sockobj.bind((IP, Port)) 5 sockobj.listen(5) while True: client connection, address = sockobj.accept( ) print Server connected by client:, address while True: Client data = connection.recv(1024) data if not data: break Client RES=200 OK connection.send(RES) print Receive MSG:%s%data.strip() print Send RES:%s\r\n%RES Socket connection.close( ) except Exception,ex: print ex ServerUrl = 192.168.16.15:9999 SocketServer()

Socketsockobj.setsockopt(SOL_SOCKET,SO_REUSEADDR, 1)PythonSocketServer

-*- coding:utf-8 -*- from socket import * def SocketClient(): try: socket s=socket(AF_INET,SOCK_STREAM,0) Colon = ServerUrl.find(:) IP = ServerUrl[0:Colon] Port = ServerUrl[Colon+1:] nnect((IP,int(Port))) sdata=GET /Test HTTP/1.1\r\n\ Host: %s\r\n\r\n%ServerUrl print Request:\r\n%s\r\n%sdata s.send(sdata) sresult=s.recv(1024) print Response:\r\n%s\r\n %sresult Socket s.close() except Exception,ex: print ex ServerUrl = 192.168.16.15:9999 SocketClient()

Home Control Assistant

Home Control AssistantFeaturesClient Server

This HCA Server application loads and execute your automation design. It has no user interface but it communicates with all your attached interfaces, runs schedules and programs contained in your design, and handles triggers for programs and devices. You can think of the server as what you had with previous versions of HCA after it loaded your design and then you didnt touch the UI. Your design just ran in the background.

There is no separate Windows based Client application to pair with the server. The client is just HCA running in client-mode. This same HCA.exe can also work as a stand-alone application exactly like it did in previous versions of HCA.

What can HCA do when operating as a client? It can do anything that you could do in previous versions of HCA except for creation of a whole new design. The client can modify programs, add new devices, scan an Insteon network, control devices, etc. Our goal was that the experience working with the client would be the same as when working with HCA in stand-alone mode.And the most important point is that several clients can be connected to the HCA server at one time. When you do this, any change made on one client to the state of an object – on, off, or dim – or a change to the design – adding a new device, changing a program etc – automatically updates the other clients with those same changes.

HCA was re-architected to create the Client-Server for several reasons. Since HCA needs to run 24/7 lots of users look for an unobtrusive means to do that. Downloading into an automation interface just doesnt work. It isnt powerful enough to run your design well and cant bridge technologies. We have recommended for some time now to use a low-end Windows box as the download target for HCA. With Client-Server you can hide that machine in a closet and administer it – with all the capabilities of HCA – from another computer in your home. Also, you can install HCA on a computer at work, or a laptop, to access your design.

Dont be confused with the term HCA Server. HCA continues to have the web based client – what we call the Web Component. Nor is the HCA Server a Windows Service. The HCA Server is just another Windows application. And, unlike the Web Component which can be accessed from any computer that has a compatible browser, the HCA client – being just HCA – requires Windows XP, Vista, Windows 7, or Windows 8.x.

Difference Between Client Server Application and Web Application

Difference Between Things, Terms and Objects

Professional & Certification bodies

Difference Between Client Server Application and Web Application

Difference Between Client Server Application and Web Application

Posted onJanuary 26, 2011byoliviaLast updated on: January 26, 2011

Client Server Application vs Web Application

Client/server application and web application are two types of applications that are used in the world of web. The applications that run on the client side and access the remote server is called client/server applications whereas applications that run completely on the browser are called web applications.

A piece of software application that runs on the client or the user side and make requests to the server or access information from it is called client-server application. High-level languages are used to write these applications which include business logic, forms and user interface. Most applications of this type have a database and they make queries from this database stored on the remote server.

A client-server application can be platform specific or it can also be cross platform if a cross platform programming language is used. The advantage of using a cross platform language is that the application looks native to the platform or the operating system of the client.

Every client-server application must be installed on the clients computer. This can be a very easy job or it may take hours to install the application as it depends on the applications complexity, care taken by the developer while packaging it and the platform in which it is written.

These applications can run on the users computer or there may be some kind of VNC, Citrix or terminal server that works with the operating system in order to provide robust, powerful, easy to use and rich interface.

An application that runs completely on the users browser is called a web application. An interface similar to client-server application is provided to the user in a web application and the user interacts with in same manner as the client-server application.

A web application can provide the same functionality similar to client-server application. As these applications run on the browser so they can run on any platform or operating system having a web browser. For example, a word processor can also be a web application that may allow the users to download data into their hard disk drives.

Yahoo mail and Gmail clients are examples of powerful web applications and much of the sophistication is provided by AJAX that is used to create more responsive web applications. Other examples of next-gen web applications include WebEx, WebOffice, Microsoft Office Live and Google Apps.

Difference between client-server application and web application

• In a client-server application, the user interacts with the server through a user interface or application that is installed on the client side whereas in a web application, the user interacts with it through the web browser.

• A client-server application must be installed on the clients machine whereas this is not the case with a web application as it runs on the browser only.

• Some client-server applications run only on specific platforms whereas web applications are platform independent as they only need a web browser for their working.

• Examples of client-server applications include Microsoft Outlook, Yahoo messenger, Windows Live etc while examples of web application are Google Apps, Gmail, Yahoo mail and Microsoft Office Live.

Help us to improve our writing. Please Rate.

Difference Between Client Server Application and Web Application. . January 26, 2011.

Filed Under:ApplicationsTagged With:AJAXCitrixClient/server applicationscross platform languageGmailGoogle AppsMicrosoft Office LiveMicrosoft Outlookterminal serverVNCWeb ApplicationsWebExWebOfficeWindows LiveYahoo mailYahoo messenger

Difference Between Apple iPhone 8 Plus and Samsung Galaxy S8 Plus

Difference Between Apple iPhone X and Samsung Galaxy Note 8

Difference Between iPhone 8 and iPhone X

Difference Between C and Objective C

Difference Between Translocation and Crossing Over

Difference Between Arthritis and Carpal Tunnel Syndrome

Difference Between Objective C and Swift

Difference Between Protonema and Prothallus

Client Access services

This site uses cookies for analytics, personalized content and ads. By continuing to browse this site, you agree to this use.

Microsoft Official Courses On-Demand

MCSE Cloud Platform and Infrastructure

MCSE: Data Management and Analytics

Find technical communities in your area

Were sorry. The content you requested has been removed. Youll be auto redirected in 1 second.

Exchange admin center in Exchange 2016

Configuring Kerberos authentication for load-balanced Client Access services

Digital certificates and encryption in Exchange 2016

Configure client-specific message size limits

Availability service in Exchange 2016

This documentation is archived and is not being maintained.

This documentation is archived and is not being maintained.

Overview of the Client Access services on Mailbox servers in Exchange 2016

In Exchange Server 2016, the Client Access services on Mailbox servers provide authentication and proxy services for internal and external client connections. The Client Access services are stateless, so data isnt queued or stored in them. In Exchange 2016, the Client Access services are part of the Mailbox server, so you cant configure a standalone Client Access server like you could in previous versions of Exchange. For more information, seeClient access protocol architecture.

Client connectivity in Exchange 2016 is similar to Exchange 2013, but different from Exchange 2010:

Outlook clients use MAPI over HTTP or Outlook Anywhere (RPC over HTTP). In Exchange 2016, MAPI over HTTP is enabled by default.

Exchange 2016 requires fewer namespaces for site-resilient solutions than Exchange 2010. For more information, seeNamespace Planning in Exchange 2016.

The Client Access services in Exchange 2016 function much like a front door, admitting all client connection requests and routing them to the correct mailbox database. The Client Access services provide network security such as Transport Layer Security (TLS) encryption, and manage client connections through redirection and proxying. The Client Access services authenticate client connections and typically proxy the connection request to the Mailbox server that holds the active copy of the users mailbox. In some cases, the Client Access services might redirect the request to the Client Access services on another Exchange server, either in a different location or on a more recent version of Exchange.

The Client Access services have the following features:

Stateless servicesIn previous versions of Exchange, many of the Client Access protocols required session affinity. For example, Outlook Web App in Exchange 2010 required that all requests from a particular client be handled by a specific Client Access server within a load balanced array of Client Access servers. In Exchange 2016, the Client Access services are stateless. In other words, because all processing for the mailbox happens in the backend services on the Mailbox server, it doesnt matter which instance of the Client Access service in an array of Client Access services receives each individual client request. This means that session affinity is no longer required at the load balancer level. This allows inbound connections to Client Access services to be balanced by using simple load balancing techniques such as DNS round-robin. It also allows hardware load balancing devices to support significantly more concurrent connections. For more information, seeLoad Balancing in Exchange 2016.

Connection poolingThe Client Access services handle client authentication and send theAuthNdata to the backend services on the Mailbox server. The account thats used by the Client Access services to connect to the backend services on Mailbox servers is a privileged account thats a member of the Exchange Servers group. This allows the Client Access services to pool connections to the backend services on Mailbox servers effectively. An array of Client Access services can handle millions of client connections from the Internet, but far fewer connections are used to proxy the requests to the backend services on Mailbox servers than in Exchange 2010. This improves processing efficiency and end-to-end latency.

Dont confuse an array of Client Access services with an RPC Client Access Server array that was used for RPC over TCP client connections in Exchange 2010. In Exchange 2016, an array of Client Access services simply indicates a group of load-balanced Client Access services on Exchange 2016 servers.

Management tasks in the Client Access services

Digital certificatesAlthough Exchange 2016 uses self-signed certificates to encrypt and authenticate connections between Exchange servers, you need to install and configure certificates to encrypt client connections. For more information, seeDigital certificates and encryption in Exchange.

Kerberos authentication for load-balanced Client Access servicesFor more information, seeConfiguring Kerberos authentication for load-balanced Client Access services.

Networking – 3-Tier ClientServer Architecture

2-tier architecture is used to describe client/server systems where the client requests resources and the server responds directly to the request, using its own resources. This means that the server does not call on another application in order to provide part of the service.

In 3-tier architecture, there is an intermediary level, meaning the architecture is generally split up between:

A client, i.e. thecomputer, which requests the resources, equipped with a user interface (usually aweb browser) for presentation purposes

The application server (also called

), whose task it is to provide the requested resources, but by calling on another server

The data server, which provides the application server with the data it requires

The widespread use of the term 3-tier architecture also denotes the following architectures:

Application sharing between a client, middleware and enterprise server

Application sharing between a client, application server and enterprisedatabaseserver.

Comparing both types of architecture

2-tier architecture is therefore a client-server architecture where the server is versatile, i.e. it is capable of directly responding to all of the clients resource requests.

In 3-tier architecture however, the server-level applications are remote from one another, i.e. each server is specialized with a certain task (for example: web server/database server). 3-tier architecture provides:

Increased security, as security can be defined for each service, and at each level

Increased performance, as tasks are shared between servers

In 3-tier architecture, each server (tier 2 and 3) performs a specialized task (a service). A server can therefore use services from other servers in order to provide its own service. As a result, 3-tier architecture is potentially an n-tiered architecture

Types of client server architecture

3 tier architecture of client server computing

Windows 7 – Enable Telnet Client/Server

PlayStation 3 – Disable Media Server Connection

Wat is client/server networking plz? [Solved]

Download this article for free (PDF)

Redes – Arquitectura Cliente/Servidor en 3 niveles

Client-Server-Netzwerk: Drei-Schichten-Architektur

Rseaux – Architecture client/serveur 3 niveaux

Reti – Architettura client/server a 3 livelli

A tecnologia da arquitetura cliente/servidor

Latest update on October 16, 2008 at 09:43 AM by Jeff.

This document, titled Networking – 3-Tier Client/Server Architecture, is available under theCreative Commonslicense. Any copy, reuse, or modification of the content should be sufficiently credited ).

Client-Cloud Applications The Rebirth of ClientServer Architecture

Sign in to view this research document.

To purchase this document, you will need to register or sign in above.

Enterprises are faced with the increasing power of mobile devices, the advantages of cloud computing as a delivery model for applications, and the need for better and more-differentiated user experiences. The client-cloud application model sits at the intersection of these trends.

Client/Server Computing: The Bad Old Days?

Cloud Computing: Paying by the Drink

The Era of the PC is Ending; the Mobile Era Has Begun

© 2011 Gartner, Inc. and/or its Affiliates. All Rights Reserved. Reproduction and distribution of this publication in any form without prior written permission is forbidden. The information contained herein has been obtained from sources believed to be reliable. Gartner disclaims all warranties as to the accuracy, completeness or adequacy of such information. Although Gartners research may discuss legal issues related to the information technology business, Gartner does not provide legal advice or services and its research should not be construed or used as such. Gartner shall have no liability for errors, omissions or inadequacies in the information contained herein or for interpretations thereof. The opinions expressed herein are subject to change without notice.

Talk to Gartner now andlearn the benefitsof becoming a Gartner client.

Gartner delivers the technology-related insight you need to make the right decisions, every day.

ClientServer Simulator Model?

Were sorry. The content you requested has been removed. Youll be auto redirected in 1 second.

I am more than willing to read the extensive documentation if I can get some better idea of the general capabilities of this tool.

I have developed my own robot for use in a university curriculum. We can program it without this system (and will do so), but I want to develop a simulator for our system. I suspect that Microsoft Robotics Studio can do this for me. Can somebody please advise which (if any) of the following steps are possible in Robotics Studio?

1) Model my own robot – simple treaded vehicle with optical sensors, camera, GPS, compass, that sort of thing.2) Have the Robotics Studio simulator act as a server, accepting network connections from client apps that are simulating the actual control code.3) Have the Robotics Studio be capable of accepting multiple client connections and simultaneously simulate multiple robots.4) Export the simulation environment to a stand-alone executable (with the academic version, I can utilize the complete version of the robotics studio, but I would like to distribute a smaller, simpler executable designed just to run the simulation.

Can somebody verify whether or not this tool can do these things, and point me to the block of documentation that will get me going?

What you suggest would work if your Perl / Python client sends messages conforming to the DSSP specification (see:

Another option (much better in my opinon) is to make a tiny helper DSS service that acts as a translator between messages your client sends and messages DSS know how to process. This way you wouldnt need to send / receive DSS messages. We do this for communicating with robotics hardware (eg, the Lego NXT and others) that know nothing of DSS or .

A third option is, if you want to use Python, just use IronPython as you could write a DSS service in any .NET language.

1) Model my own robot – simple treaded vehicle with optical sensors, camera, GPS, compass, that sort of thing.

Yes you can do this. In general, the steps would be:

(1) Add a Pioneer3DX (or other robot) using the VSE editor to a scene.

(a) You can also change the mesh of the P3DX to anything from the editor

(2) Save the scene (File – Save Scene as)

(a) Two files will be generated, a scene file and a manifest

(3) Open the manifest in DssMe (Dss Manifest Editor)

(4) Add the services you want to the manifest

(6) Start this manifest by saying: DssHost32 -p:50000 -m:ManifestFileName

However, the GPS and compass sensors are currently not available for sim. We do realize the need for these and plan to ship these in a later version.

We are moving to Forums v3.0 soon (we are on v2.0 now) and supposedly there will be a place to upload files. If you want an early preview of these services, we might be able to host them on the forums.

2) Have the Robotics Studio simulator act as a server, accepting network connections from client apps that are simulating the actual control code.

Yes, the DSS service model that sim and all of MRDS uses allows for this. VSE is running as a service and works perfectly well with other services (you can think of them as clients) that are say running the algorithms for controlling a robot.

3) Have the Robotics Studio be capable of accepting multiple client connections and simultaneously simulate multiple robots.

You can add multiple robots, sensors, services etc and communicate with these from any number of services running on different PCs.

4) Export the simulation environment to a stand-alone executable (with the academic version, I can utilize the complete version of the robotics studio, but I would like to distribute a smaller, simpler executable designed just to run the simulation.

If you are referring to the large size of RDS standard, services written for standard will run in express. The only step here you need Standard for is using the VSE editor.

Thanks for the response. Please allow me to clarify.

When you say that the DSS service model works perfectly with other services, you mean that these services do NOT have to be compiled in or in any way associated with MRDS? That would make sense to me. I would expect that I can run a client written in Perl or Python and do simple message passing across the network to the DSS service running in the simulator. So – the simulator is simply displaying the robot action – all robot control happens in a completely different environment?

What you suggest would work if your Perl / Python client sends messages conforming to the DSSP specification (see:

Another option (much better in my opinon) is to make a tiny helper DSS service that acts as a translator between messages your client sends and messages DSS know how to process. This way you wouldnt need to send / receive DSS messages. We do this for communicating with robotics hardware (eg, the Lego NXT and others) that know nothing of DSS or .NET.

A third option is, if you want to use Python, just use IronPython as you could write a DSS service in any .NET language.

Microsoft is conducting an online survey to understand your opinion of the Msdn Web site. If you choose to participate, the online survey will be presented to you when you leave the Msdn Web site.

Thank you! The survey will appear here when youve completed your visit, soplease do not close this window.

Client Server Software Engineering

Application Migration and Conversion

Assessments, Strategy and Consulting

Continuous Diagnostics and Mitigation

Hybrid IT Transformation & Optimization

Recent Graduates and College Students

At NJVC, Helping Veterans Find New Missions Is a Matter of Familiarity

Cloud Is More Than the New Data Center

Enterprise Defined Data Center: Because Outcomes Matter, Not Tools

For Tiny Heroes, a Night of Games With Only Winners

Heres a Security Model: Trust No One in Zero Trust

Hybrid IT: How to Cultivate the Best IT Enterprise Possible

Insider Threat Q&A: How to Detect and Deter Those Within

Lessons in Leadership From a Lifetime in Service

PaaS Definition? Developers Nirvana, Budgets Best Friend

Q&A: Metrics Empower Cyber Security

Remembering Those We Should Never Forget

Show and Tell: Multiple Systems. One (Servicefront) Solution.

The Frustration Free Enterprise Is Built on Servicefront (and Hockey)

The Pen Test Is Mightier Than the Threat Actor

What a Hackathon Taught a Veteran Coder

Why a Successful Cloud Migration Starts With Tossing VHS Tapes

With the First Pick in the Cloud Strategy Draft …

NJVC Earns AWS Advanced Consulting Partner Status

GEOINT 2016: NJVC Raises Mission Capability to Power of Cloud

NJVC Joins Amazon Web Services Public Sector Partner Program

Identify problems in your enterprise before they become threats to your mission.

In cloud. On premises. Get the benefit of multi-platform IT with our commitment to security and ease of use.

We deliver enterprise cyber security, because a weakness anywhere in your enterprise is a weakness everywhere in your enterprise.

Get to the cloud without interruption — or threat — to mission.

Our professional engineering services include planning, engineering, testing and implementation, ensuring full lifecycle systems management to achieve your mission.

Empower the enterprise. Empower your mission. Our agile-based software service build custom tools to achieve customer goals and maximize IT integration.

The latest trends and information in cloud computing, cyber security, enterprise management & monitoring, hybrid IT and more.

NJVCommentary features expert insight across our portfolio of services offerings, including cloud migration, hybrid IT transformation & optimization, enterprise management and monitoring and cyber security.

Our leadership has decades of experience and are highly respected in the intelligence community, Department of Defense, and federal civilian agencies.

We will see mission challenges through our customers eyes and provide the best-value solutions possible.

At NJVC, innovation comes bundled in everything we do.

If youre visiting NJVC for a meeting, job interview, or career fair, your first stop is likely one of our three primary corporate locations.

NJVC welcomes business of all sizes for future opportunities. NJVC qualifies as a small business for all subcontracting opportunities.

At NJVC, we go wherever our customers missions take usand thats around the globe.

Contact us today for more information.

NJVC believes in the power innovation through collaboration.

We are vested in supporting the future technology workforce and supporting youth education, particularly science, technology, engineering and math (STEM).

Join us at a conference or learn about a new career with NJVC at one of our career events.

Get the latest news releases from NJVC.

NJVC is the partner of choice for federal IT projects.

NJVC is the engine of the secure mission-enabled enterprise. We solve complex IT challenges in secure environments with a highly cleared workforce.

Do more with everything. NJVCs federal civilian expertise helps customers align and maintain efficient, secure enterprises.

We bring the technology and expertise that helps manage and defend the nations front lines to the complex IT problems of the homefront.

At NJVC, our support of our team doesnt end when the workday does.

We believe that we best serve our customers by best serving our employees, creating a culture that supports growth and rewards innovation.

NJVC hopes to make your transition to civilian employment as simple as possible, whether with our team or elsewhere.

NJVC maintains a workforce of highly cleared personnel to best meet customer needswherever and whenever they emerge.

Starting your career at NJVC isnt just getting a first job, its getting a framework for success.

NJVC is an innovative leader in the area of Client Server Software Engineering and development. Our applications, systems and technologies are used throughout the Intelligence Community and Department of Defense (DoD). Our clients turn to us to solve their toughest problems because we deliver the full solution, including:

A best practices approach based on leading industry standards

The right mix of skilled engineers and functional experts

The right solution, at the right time, for the greatest impact

NJVC supplies world-class Client Server Software Engineering solutions to cover a variety of challenges and applications.

By employing techniques such as agile (rapid) development, Scrum application development and others, we deliver the right solutions quickly and efficiently. We are recognized for delivering unified and high- performance solutions that are robust, scalable, flexible, cost-effective and secure. NJVC provide rapid application development in support of clients missions in a coordinated and controlled operational setting.

We recognize that our clients have a sizable investment in their system architecture and legacy systems, so our solutions employ an integrated cross-functional approach to maximize investments in existing systems, applications and capabilities, while leveraging the potential of advanced technologies to implement new, high-payback solutions.

In addition to working with longstanding systems and software architectures such as Microsoft Enterprise tools, we also develop Client Server Software Engineering solutions for such cutting-edge applications as Web 2.0, widgets, virtualization, cloud computing and mobile devices.

NJVC also develops middleware solutions to link applications such as Cold Fusion and Ajax as front-ends and interfaces to Web databases.

Benefits of NJVC Client Server Software Engineering includes:

Repeatable success on systems, applications and capabilities on time, on budget, with high mission value

Deep DoD and intelligence community cross-functional domain knowledge

Latest technology and development approaches including:

Web and portal systems (Drupal, Liferay, Ozone and Redhat jBoss)

Web 2.0; WebTop and Widget architectures

Mobile devices (IOS, Web OS, BlackBerry, Android, Maemo)

Process discipline and rigorous adherence to industry standards and practices, including SEI CMMI, ISO 9000:2001, ISO 20000, ITIL and PMP

Our offerings include consulting, development and software integration, supporting the full lifecycle of Client Server Software Engineering and technology implementation from design through operations, to maintenance and sustainment.

One of NJVCs key assets in Client Server Software Engineering development is our Center for Technology Innovation, which provides software development, prototyping and testing services across all of our offerings. This high-powered development laboratory gives NJVC a competitive advantage to quickly develop and deploy solutions for our clients.

Our Client Server Software Engineering success results from our company-wide focus on quality and service in everything we do. Our corporate commitment is to increase the success of our clients missions and to improve their operational efficiency in ways that make a tangible difference.

Mission Critical IT for National Security

Enterprise Management and Monitoring

We Manage Cloud. You Manage Mission.

NJVC is the engine of the secure, integrated enterprise, delivering mission-critical IT solutions for critical missions in enterprise management & monitoring, hybrid IT transformation & optimization, cloud migration and cyber security.

NJVC is proud to be one of the largest federal contractors in metropolitan St. Louis, providing the government with expertise to solve its most pressing challenges in enterprise solutions, cyber security, networking, analytics and intelligence and IT transformation.

NJVC is the engine of the secure, integrated enterprise, delivering innovative technology to maximize IT impact on critical missions in the intelligence and defense communities, federal civilian agencies and critical commercial infrastructure.

14295 Park Meadow Drive Chantilly, VA 20151

Excellence Is Our PromiseAt NJVC, innovation comes bundled with everything we do.

RTSP ClienttLive555RTSP Server

Live555Live555RTSPLive555 RTSP server

RTSP ClientserverRTSP

VS2010Live555mediaServer.exe

PS:VS2010Live555live555VS2010 live555

ClientOPTIONDESCRIBESetup405

RTSP/1.0 405 Method Not Allowed

Live555 void RTSPServer::RTSPClientSession::handleRequestBytes(int newBytesRead) cmdNameASCII1310RTSP

if (ptr + newBytesRead tmpPtr + 2 + contentLength) break;

while(cmdName[i++]==\r cmdName[i]==\n)

strcpy(cmdName,&cmdName[i+1]);

RTSP Clientbug

OPTIONS rtsp://192.168.10.177/bipbop-gear1-all.ts RTSP/1.0

Public: OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE, GET_PARAMETER, SET_PARAMETER

DESCRIBE rtsp://192.168.10.177/bipbop-gear1-all.ts RTSP/1.0

Content-Base: rtsp://192.168.10.177/bipbop-gear1-all.ts/

s=MPEG Transport Stream, streamed by the LIVE555 Media Server

a=tool:LIVE555 Streaming Media v2012.04.04

a=x-qt-text-nam:MPEG Transport Stream, streamed by the LIVE555 Media Server

SETUP rtsp://192.168.10.177/bipbop-gear1-all.ts/track1 RTSP/1.0

Transport: RTP/AVP;unicast;client_port=37145-36889

Transport: RTP/AVP;unicast;destination=192.168.10.177;source=192.168.10.177;client_port=37145-36889;server_port=6970-6971

PLAY rtsp://192.168.10.177/bipbop-gear1-all.ts RTSP/1.0

RTP-Info: url=rtsp://192.168.10.177/bipbop-gear1-all.ts/track1;seq=33245;rtptime=3329050316

Qtwidgets / QSettings

TCP Client Server Download

Simple network utility that provides a TCP connection between at least two machines in order to exchange message in order to test applications, network services or firewalls

Testing network programs or services requires, among other things, a utility such asNsasofts TCP Client Server. It can also be used for checking how firewalls and intrusion detection systems work.

Installing the product is an easy task that does not require any effort at all; all you have to do is follow the instructions on the screen and the processes completes in a jiffy.

The application window is simple and does not beat around the bush, with all the options available in plain sight.

Working with the program is so easy that any sort of documentation would be superfluous. Most part of the application is occupied by the dialogs for sending and receiving data but there are also options for settings the current machine into server or client mode in order to exchange the messages.

When in server mode there isnt any tinkering to be done but if set in client mode the you have to provide the address of the server to connect to.

The interaction between the two systems is logged in the lower screen and includes status of the connection and the time it was established as well as the messages exchanged between the two machines.

Additional options include cutting off the connection from both sides as well as putting the server into listening state in order to detect the addresses that want to establish a connection.

TCP Client Server is simple and efficient. It does not integrate more than it is absolutely necessary to set up a TCP connection between two or multiple machines and trading messages.

Windows XP Windows XP 64 bit Windows Vista Windows Vista 64 bit Windows 7 Windows 7 64 bit Windows 8 Windows 8 64 bit

Client (computing

From Wikipedia, the free encyclopedia

needs additional citations forverification

Please helpimprove this articlebyadding citations to reliable sources. Unsourced material may be challenged and removed.

(Learn how and when to remove this template message)

Acomputer network diagramof client computers communicating with a server computer via theInternet

Aclientis a piece ofcomputer hardwareorsoftwarethat accesses a service made available by aserver. The server is often (but not always) on anothercomputer system, in which case the client accesses the service by way of anetwork.[1]The term applies to the role that programs or devices play in theclientserver model.

A client is a computer or a program that, as part of its operation, relies on sending a request to anothercomputer program(which may or may not be located on another computer). For example,web browsersare clients that connect toweb serversand retrieveweb pagesfor display.Email clientsretrieveemailfrommail serversOnline chatuses a variety of clients, which vary depending on the chat protocol being used.Multiplayer video gamesoronline video gamesmay run as a client on each computer. The term client may also be applied to computers or devices that run the client software or users that use the client software.

A client is part of aclientserver model, which is still used today. Clients and servers may be computer programs run on the same machine and connect viainter-process communicationtechniques. Combined withInternet sockets, programs may connect to a service operating on a possibly remote system through theInternet protocol suite. Servers wait for potential clients to initiate connections that they may accept.

The term was first applied todevicesthat were not capable of running their own stand-aloneprograms, but could interact with remote computers via a network. Thesedumb terminalswere clients of the.

In one classification, client computers and devices are eitherthick clientsthin clients, orhybrid clients.

AThick client, also known as arich clientorfat client, is a client that performs the bulk of any data processing operations itself, and does not necessarily rely on theserver. Thepersonal computeris a common example of a fat client, because of its relatively large set of features and capabilities and its light reliance upon a server. For example, a computer running anArt program(such asKritaorSketchup) that ultimately shares the result of its work on a network is a thick client. A computer that runs almost entirely as a standalone machine save to send or receive files via a network is by standard called aworkstation.

Athin clientis a minimal sort of client. Thinclientsuse the resources of the host computer. A thin client generally only presents processed data provided by anapplication server, which performs the bulk of any required data processing. A device usingweb application(such asOffice Web Apps) is a thin client.

Ahybrid clientis a mixture of the above two client models. Similar to a fat client, it processes locally, but relies on the server for storing persistent data. This approach offers features from both the fat client (multimedia support, high performance) and the thin client (high manageability, flexibility). A device running an online version of theis an example of hybrid client.

Articles needing additional references from January 2014

All articles needing additional references

This page was last edited on 11 January 2018, at 21:35.

Text is available under the; additional terms may apply. By using this site, you agree to theTerms of UseandPrivacy Policy. Wikipedia® is a registered trademark of theWikimedia Foundation, Inc., a non-profit organization.