open pdf and draw c# : Add links in pdf Library software component asp.net windows wpf mvc %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D52-part1584

var pairs = [];          // To hold name=value pairs
for(var name in data) {                                  // For each name
if (!data.hasOwnProperty(name)) continue;            // Skip inherited
if (typeof data[name] === "function") continue;      // Skip methods
var value = data[name].toString();                   // Value as string
name = encodeURIComponent(name.replace(" ", "+"));   // Encode name
value = encodeURIComponent(value.replace(" ", "+")); // Encode value
pairs.push(name + "=" + value);   // Remember name=value pair
}
return pairs.join('&'); // Return joined pairs separated with &
}
With this 
encodeFormData()
function defined, we can easily write utilities like the 
post
Data()
function of Example 18-5. Note that, for simplicity, this 
postData()
function
(and similar functions in the examples that follow) does not process the server’s re-
sponse. When the response is complete, it passes the entire XMLHttpRequest object
to the specified callback function. That callback is responsible for checking the response
status code and extracting the response text.
Example 18-5. Making an HTTP POST request with form-encoded data
function postData(url, data, callback) {
var request = new XMLHttpRequest();            
request.open("POST", url);                    // POST to the specified url
request.onreadystatechange = function() {     // Simple event handler
if (request.readyState === 4 && callback) // When response is complete
callback(request);                    // call the callback.
};
request.setRequestHeader("Content-Type",      // Set Content-Type
"application/x-www-form-urlencoded");
request.send(encodeFormData(data));           // Send form-encoded data
}
HTML forms generate POST requests by default, but they can also make GET requests.
(When the purpose of the form submission is to make a read-only query, GET is more
appropriate than POST.) GET requests never have a body, so the “payload” of form-
encoded data has to be sent to the server as the query portion of the URL (following a
question mark). The 
encodeFormData()
utility can also be useful for this kind of GET
request, and Example 18-6 demonstrates how to use it.
Example 18-6. Making a GET request with form-encoded data
function getData(url, data, callback) {
var request = new XMLHttpRequest(); 
request.open("GET", url +                     // GET the specified url
"?" + encodeFormData(data));     // with encoded data added
request.onreadystatechange = function() {     // Simple event handler
if (request.readyState === 4 && callback) callback(request);
};
request.send(null);                           // Send the request
}
18.1  Using XMLHttpRequest | 503
Client-Side
JavaScript
Add links in pdf - insert, remove PDF links in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Free C# example code is offered for users to edit PDF document hyperlink (url), like inserting and deleting
pdf link to specific page; add links to pdf document
Add links in pdf - VB.NET PDF url edit library: insert, remove PDF links in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Help to Insert a Hyperlink to Specified PDF Document Page
clickable links in pdf from word; add links to pdf
HTML forms use form-encoded query sections to encode data into a URL, but using
XMLHttpRequest gives us the freedom to encode our data however we want. With
appropriate support on the server, our pizza query data might be encoded into a more
legible URL like this one:
http://restaurantfinder.example.com/02134/1km/pizza
18.1.3.2  JSON-encoded requests
The use of form encoding in the body of POST requests is a common convention, but
it is not a requirement of the HTTP protocol by any means. In recent years, the JSON
format has gained popularity as a web interchange format. Example 18-7 shows how
you might encode a request body using 
JSON.stringify()
(§6.9). Note that this example
differs from Example 18-5 only in the last two lines.
Example 18-7. Making an HTTP POST request with a JSON-encoded body
function postJSON(url, data, callback) {
var request = new XMLHttpRequest();            
request.open("POST", url);                    // POST to the specified url
request.onreadystatechange = function() {     // Simple event handler
if (request.readyState === 4 && callback) // When response is complete
callback(request);                    // call the callback.
};
request.setRequestHeader("Content-Type", "application/json");
request.send(JSON.stringify(data));
}
18.1.3.3  XML-encoded requests
XML is sometimes also used as an encoding for data transfer. Instead of expressing our
pizza query as a form-encoded or JSON-encoded version of a JavaScript object, we
could represent it as an XML document. It might look like this, for example:
<query>
<find zipcode="02134" radius="1km">
pizza
</find>
</query>
In all the examples we’ve shown so far, the argument to the XMLHttpRequest 
send()
method has been a string or 
null
. In fact, you can also pass an XML Document object
here. Example 18-8 demonstrates how to create a simple XML Document object and
use it as the body of an HTTP request.
Example 18-8. An HTTP POST request with an XML document as its body
// Encode what, where, and radius in an XML document and post them to the 
// specified url, invoking callback when the response is received
function postQuery(url, what, where, radius, callback) {
var request = new XMLHttpRequest();            
request.open("POST", url);                  // POST to the specified url
request.onreadystatechange = function() {   // Simple event handler
504 | Chapter 18: Scripted HTTP
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
HTML converter toolkit SDK, preserves all the original anchors, links, bookmarks and to Use C#.NET Demo Code to Convert PDF Document to Add necessary references
pdf reader link; add hyperlinks to pdf online
.NET PDF Document Viewing, Annotation, Conversion & Processing
PDF Write. Insert text, text box into PDF. Edit, delete text from PDF. Insert images into PDF. Edit, remove images from PDF. Add, edit, delete links. Form Process
pdf link to attached file; add email link to pdf
if (request.readyState === 4 && callback) callback(request);
};
// Create an XML document with root element <query>
var doc = document.implementation.createDocument("", "query", null);
var query = doc.documentElement;            // The <query> element
var find = doc.createElement("find");       // Create a <find> element
query.appendChild(find);                    // And add it to the <query>
find.setAttribute("zipcode", where);        // Set attributes on <find>
find.setAttribute("radius", radius);
find.appendChild(doc.createTextNode(what)); // And set content of <find>
// Now send the XML-encoded data to the server.
// Note that the Content-Type will be automatically set.
request.send(doc); 
}
Note that Example 18-8 does not ever set the “Content-Type” header for the request.
When you pass an XML document to the 
send()
method, without previously specifying
Content-Type
header, the XMLHttpRequest object automatically sets an appropriate
header for you. (Similarly, if you pass a string to 
send()
and have not specified a
Content-Type, the XMLHttpRequest will add a “text/plain; charset=UTF-8” header
for you. The code in Example 18-1 sets this header explicitly, but that is not actually
required for plain-text request bodies.
18.1.3.4  Uploading a file
One of the features of HTML forms is that when the user selects a file through an 
<input
type="file">
element, the form will send the content of that file in the body of the
POST request it generates. HTML forms have always been able to upload files, but
until recently it was not possible to do the same thing with the XMLHttpRequest API.
The XHR2 API, however, allows you to upload files by passing a File object to the
send()
method.
There is no 
File()
object constructor: scripts can only obtain File objects that represent
files the user has selected. In browsers that support File objects, every 
<input
type="file">
element has a 
files
property that is an array-like object of File objects.
The drag-and-drop API (§17.7) also allows access to files that the user “drops” over an
element, through the 
dataTransfer.files
property of the drop event. We’ll see more
about the File object in §22.6 and §22.7. For now, we can treat it as a completely opaque
representation of a user-selected file, suitable for upload through 
send()
Exam-
ple 18-9 is a an unobtrusive JavaScript function that adds an change event handler to
certain file upload elements so that they automatically POST the contents of any se-
lected file to a specified URL.
Example 18-9. File upload with an HTTP POST request
// Find all <input type="file"> elements with a data-uploadto attribute
// and register an onchange handler so that any selected file is 
// automatically POSTED to the specified "uploadto" URL. The server's
18.1  Using XMLHttpRequest | 505
Client-Side
JavaScript
Download from Wow! eBook <www.wowebook.com>
VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
Turn PDF images to HTML images in VB.NET. Embed PDF hyperlinks to HTML links in VB.NET. Convert PDF to HTML in VB.NET Demo Code. Add necessary references:
add links to pdf online; convert doc to pdf with hyperlinks
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
the original text style (including font, size, color, links and boldness). C#.NET DLLs and Demo Code: Convert PDF to Word Document in C# Add necessary references
pdf links; chrome pdf from link
// response is ignored.
whenReady(function() {                        // Run when the document is ready
var elts = document.getElementsByTagName("input"); // All input elements
for(var i = 0; i < elts.length; i++) {             // Loop through them
var input = elts[i];
if (input.type !== "file") continue;  // Skip all but file upload elts
var url = input.getAttribute("data-uploadto"); // Get upload URL
if (!url) continue;                   // Skip any without a url
input.addEventListener("change", function() {  // When user selects file
var file = this.files[0];         // Assume a single file selection
if (!file) return;                // If no file, do nothing
var xhr = new XMLHttpRequest();   // Create a new request
xhr.open("POST", url);            // POST to the URL
xhr.send(file);                   // Send the file as body
}, false);
}
});
As we’ll see in §22.6, the File type is a subtype of the more general Blob type. XHR2
allows you to pass any Blob object to the 
send()
method. The 
type
property of the Blob
will be used to set the 
Content-Type
header for the upload, if you do not set that header
explicitly yourself. If you need to upload binary data that you have generated, you can
use the techniques shown in §22.5 and §22.6.3 to convert the data to a Blob and use
it as a request body.
18.1.3.5  multipart/form-data requests
When HTML forms include file upload elements and other elements as well, the
browser cannot use ordinary form encoding and must POST the form using a special
content-type known as “multipart/form-data”. This encoding involves the use of long
“boundary” strings to separate the body of the request into multiple parts. For textual
data, it is possible to create “multipart/form-data” request bodies by hand, but it
is tricky.
XHR2 defines a new FormData API that makes multipart request bodies simple. First,
create a FormData object with the 
FormData()
constructor and then call the 
append()
method of that object as many times as necessary to add the individual “parts” (these
can be strings or File or Blob objects) to the request. Finally, pass the FormData object
to the 
send()
method. The 
send()
method will define an appropriate boundary string
and set the “Content-Type” header for the request. Example 18-10 demonstrates the
use of FormData, and we’ll see it again in Example 18-11.
Example 18-10. POSTing multipart/form-data request body
function postFormData(url, data, callback) {
if (typeof FormData === "undefined")
throw new Error("FormData is not implemented");
var request = new XMLHttpRequest();            // New HTTP request
request.open("POST", url);                     // POST to the specified url
506 | Chapter 18: Scripted HTTP
How to C#: Basic SDK Concept of XDoc.PDF for .NET
You may add PDF document protection functionality into your C# program. to edit hyperlink of PDF document, including editing PDF url links and quick
add links pdf document; adding links to pdf in preview
C# Create PDF Library SDK to convert PDF from other file formats
PDF with a blank page, bookmarks, links, signatures, etc. PDF document in C#.NET using this PDF document creating toolkit, if you need to add some text
c# read pdf from url; add a link to a pdf in acrobat
request.onreadystatechange = function() {      // A simple event handler.
if (request.readyState === 4 && callback)  // When response is complete
callback(request);                     // ...call the callback.
};
var formdata = new FormData();
for(var name in data) {
if (!data.hasOwnProperty(name)) continue;  // Skip inherited properties
var value = data[name];
if (typeof value === "function") continue; // Skip methods
// Each property becomes one "part" of the request.
// File objects are allowed here
formdata.append(name, value);              // Add name/value as one part
}
// Send the name/value pairs in a multipart/form-data request body. Each
// pair is one part of the request. Note that send automatically sets
// the Content-Type header when you pass it a FormData object
request.send(formdata);  
}
18.1.4  HTTP Progress Events
In the examples above, we’ve used the readystatechange event to detect the completion
of an HTTP request. The XHR2 draft specification defines a more useful set of events
and these have already been implemented by Firefox, Chrome, and Safari. In this new
event model, the XMLHttpRequest object triggers different types of events at different
phases of the request so that it is no longer necessary to check the 
readyState
property.
In browsers that support them, these new events are triggered as follows. When the
send()
method is called, a single loadstart event is fired. While the server’s response is
being downloaded, the XMLHttpRequest object fires progress events, typically every
50 milliseconds or so, and you can use these events to give the user feedback about the
progress of the request. If a request completes very quickly, it may never fire a progress
event. When a request is complete, a load event is fired.
A complete request is not necessarily a successful request, and your handler for the load
event should check the 
status
code of the XMLHttpRequest object to ensure that you
received a HTTP “200 OK” response rather than a “404 Not Found” response, for
example.
There are three ways that an HTTP request can fail to complete, and three correspond-
ing events. If a request times out, the timeout event is triggered. If a request is aborted,
the abort event is triggered. (Timeouts and the 
abort()
method will be covered in
§18.1.5.) Finally, other network errors, such as too many redirects, can prevent the
completion of a request, and the error event is triggered when this happens.
A browser will fire only one of the load, abort, timeout, or error events for any given
request. The XHR2 draft says that browsers should trigger a loadend event once one
of these events has occurred. At the time of this writing, however, browsers do not
implement loadend.
18.1  Using XMLHttpRequest | 507
Client-Side
JavaScript
VB.NET PDF: Basic SDK Concept of XDoc.PDF
You may add PDF document protection functionality into your VB.NET program. to edit hyperlink of PDF document, including editing PDF url links and quick
pdf link; add hyperlink pdf document
C# Image: Tutorial for Document Management Using C#.NET Imaging
more detailed C# tutorials on each part by following the links respectively are dedicated to provide powerful & profession imaging controls, PDF document, image
adding hyperlinks to pdf; change link in pdf file
You can call the 
addEventListener()
method of the XMLHttpRequest object register
handlers for each of these progress events. If you have only one handler for each kind
of event, it is generally easier to just set the corresponding handler property, such as
onprogress
and 
onload
. You can even use the existence of these event properties to test
whether a browser supports progress events:
if ("onprogress" in (new XMLHttpRequest())) {
// Progress events are supported
}
The event object associated with these progress events has three useful properties in
addition to the normal Event object properties like 
type
and 
timestamp
. The 
loaded
property is the number of bytes that have been transferred so far. The 
total
property
is the total length (in bytes) of the data to be transferred, from the “Content-Length”
header, or 0 if the content length is not known. Finally, the 
lengthComputable
property
is 
true
if the content length is known and is 
false
otherwise. Obviously, the 
total
and
loaded
properties are particularly useful in progress event handlers:
request.onprogress = function(e) {
if (e.lengthComputable)
progress.innerHTML = Math.round(100*e.loaded/e.total) + "% Complete";
}
18.1.4.1  Upload progress events
In addition to defining these useful events for monitoring the download of an HTTP
response, XHR2 also allows the events to be used to monitor the upload of an HTTP
request. In browsers that have implemented this feature, the XMLHttpRequest object
will have an 
upload
property. The value of the 
upload
property is an object that defines
an 
addEventListener()
method and defines a full set of progress event properties, such
as 
onprogress
and 
onload
. (The upload object does not define an 
onreadystatechange
property, however: uploads only trigger the new event types.)
You can use the upload event handlers just as you would use the regular progress event
handlers. For an XMLHttpRequest object 
x
, set 
x.onprogress
to monitor the download
progress of the response. And set 
x.upload.onprogress
to monitor the upload progress
of the request.
Example 18-11 demonstrates how to use upload progress events to present upload
progress feedback to the user. This example also demonstrates how to obtain File ob-
jects from the Drag-and-Drop API and how to upload multiple files in a single
XMLHttpRequest request with the FormData API. These features are still in draft form
at the time of this writing and the example does not work in all browsers.
Example 18-11. Monitoring HTTP upload progress
// Find all elements of class "fileDropTarget" and register DnD event handlers
// to make them respond to file drops.  When files are dropped, upload them to 
// the URL specified in the data-uploadto attribute.
whenReady(function() {
var elts = document.getElementsByClassName("fileDropTarget");
508 | Chapter 18: Scripted HTTP
for(var i = 0; i < elts.length; i++) {
var target = elts[i];
var url = target.getAttribute("data-uploadto");
if (!url) continue;
createFileUploadDropTarget(target, url);
}
function createFileUploadDropTarget(target, url) {
// Keep track of whether we're currently uploading something so we can
// reject drops. We could handle multiple concurrent uploads, but 
// that would make progress notification too tricky for this example.
var uploading = false; 
console.log(target, url);
target.ondragenter = function(e) {
console.log("dragenter");
if (uploading) return;  // Ignore drags if we're busy
var types = e.dataTransfer.types;
if (types && 
((types.contains && types.contains("Files")) ||
(types.indexOf && types.indexOf("Files") !== -1))) {
target.classList.add("wantdrop");
return false;
}
};
target.ondragover = function(e) { if (!uploading) return false; };
target.ondragleave = function(e) {
if (!uploading) target.classList.remove("wantdrop");
};
target.ondrop = function(e) {
if (uploading) return false;
var files = e.dataTransfer.files;
if (files && files.length) {
uploading = true;
var message = "Uploading files:<ul>";
for(var i = 0; i < files.length; i++) 
message += "<li>" + files[i].name + "</li>";
message += "</ul>";
target.innerHTML = message;
target.classList.remove("wantdrop");
target.classList.add("uploading");
var xhr = new XMLHttpRequest();
xhr.open("POST", url);
var body = new FormData();
for(var i = 0; i < files.length; i++) body.append(i, files[i]);
xhr.upload.onprogress = function(e) {
if (e.lengthComputable) {
target.innerHTML = message +
Math.round(e.loaded/e.total*100) +
"% Complete";
}
};
xhr.upload.onload = function(e) {
18.1  Using XMLHttpRequest | 509
Client-Side
JavaScript
uploading = false;
target.classList.remove("uploading");
target.innerHTML = "Drop files to upload";
};
xhr.send(body);
return false;
}
target.classList.remove("wantdrop");
}
}
});
18.1.5  Aborting Requests and Timeouts
You can cancel an HTTP request in process by calling the 
abort()
method of the
XMLHttpRequest  object.  The 
abort()
method  is  available  in  all  versions  of
XMLHttpRequest, and in XHR2, calling 
abort()
triggers an abort event on the object.
(Some browsers support abort events at the time of this writing. You can test for the
presence of an “onabort” property on the XMLHttpRequest object.)
The primary reason to call 
abort()
is to cancel or time-out requests that have taken too
long to complete or when the responses become irrelevant. Suppose you’re using
XMLHttpRequest to request auto-complete suggestions for a text input field. If the user
types a new character into the field before the server’s suggestions can arrive, then the
pending request is no longer interesting and can be aborted.
XHR2 defines a 
timeout
property that specifies a time in milliseconds after which a
request will automatically be aborted and also defines a timeout event that is supposed
to be triggered (instead of the abort event) when such a timeout occurs. At the time of
this writing, browsers do not implement  these automatic timeouts  (and  their
XMLHttpRequest objects do not have 
timeout
or 
ontimeout
properties). You can im-
plement your own timeouts, however, with 
setTimeout()
(§14.1) and the 
abort()
method. Example 18-12 demonstrates how to do this.
Example 18-12. Implementing timeouts
// Issue an HTTP GET request for the contents of the specified URL.
// If the response arrives successfully, pass responseText to the callback.
// If the response does not arrive in less than timeout ms, abort the request.
// Browsers may fire "readystatechange" after abort(), and if a partial 
// request has been received, the status property may even be set, so 
// we need to set a flag so that we don't invoke the callback for a partial,
// timed-out response. This problem does not arise if we use the load event.
function timedGetText(url, timeout, callback) {
var request = new XMLHttpRequest();         // Create new request.
var timedout = false;                       // Whether we timed out or not.
// Start a timer that will abort the request after timeout ms.
var timer = setTimeout(function() {         // Start a timer. If triggered,
timedout = true; // set a flag and then
request.abort(); // abort the request.
},
510 | Chapter 18: Scripted HTTP
timeout);            // How long before we do this
request.open("GET", url);                   // Specify URL to fetch
request.onreadystatechange = function() {   // Define event listener.
if (request.readyState !== 4) return;   // Ignore incomplete requests.
if (timedout) return;                   // Ignore aborted requests.
clearTimeout(timer);                    // Cancel pending timeout.
if (request.status === 200)             // If request was successful
callback(request.responseText);     // pass response to callback.
};
request.send(null);                         // Send the request now
}
18.1.6  Cross-Origin HTTP Requests
As part of the same-origin security policy (§13.6.2), the XMLHttpRequest object can
normally issue HTTP requests only to the server from which the document that uses it
was downloaded. This restriction closes security holes, but it is heavy-handed and also
prevents a number of legitimate uses for cross-origin requests. You can use cross-origin
URLs with 
<form>
and 
<iframe>
elements, and the browser will display the resulting
cross-origin document. But because of the same-origin policy, the browser won’t allow
the original script to inspect the contents of the cross-origin document. With
XMLHttpRequest, document contents are always exposed through the 
responseText
property, so the same-origin policy cannot allow XMLHttpRequest to make cross-
origin requests. (Note that the 
<script>
element has never really been subject to the
same-origin policy: it will download and execute any script, regardless of origin. As
we’ll see in §18.2, this freedom to make cross-origin requests makes the 
<script>
ele-
ment an attractive Ajax transport alternative to XMLHttpRequest.)
XHR2 allows cross-origin requests to websites that opt-in by sending appropriate
CORS (Cross-Origin Resource Sharing) headers in their HTTP responses. At the time
of this writing, current versions of Firefox, Safari, and Chrome support CORS and IE8
supports it through a proprietary XDomainRequest object that is not documented here.
As a web programmer, there is nothing special you need to do to make this work: if the
browser supports CORS for XMLHttpRequest and if the website you are trying to make
a cross-origin request to has decided to allow cross-origin requests with CORS, the
same-origin policy will be relaxed and your cross-origin requests will just work.
Although there is nothing you have to do to make CORS-enabled cross-origin requests
work, there are a few security details worth understanding. First, if you pass a username
and password to the XMLHttpRequest 
open()
method, they will never be sent with a
cross-origin request (that would enable distributed password-cracking attempts). In
addition, cross-origin requests do not normally include any other user credentials ei-
ther: cookies and HTTP authentication tokens are not normally sent as part of the
request and any cookies received as part of a cross-origin response are discarded. If
your cross-origin request requires these kinds of credentials to succeed, you must set
the 
withCredentials
property of the XMLHttpRequest to 
true
before you 
send()
the
request. It is uncommon to have to do this, but testing for the presence of the
withCredentials
property is a way to test for CORS support in your browser.
18.1  Using XMLHttpRequest | 511
Client-Side
JavaScript
Example 18-13 is unobtrusive JavaScript code that uses XMLHttpRequest to make
HTTP HEAD requests to download type, size, and date information about the resour-
ces linked to by the 
<a>
elements in a document. The HEAD requests are made on
demand, and the resulting link information is displayed in tooltips. The example
assumes that information will not be available for cross-origin links, but on CORS-
enabled browsers it attempts to download it anyway.
Example 18-13. Requesting link details with HEAD and CORS
/**
* linkdetails.js
*
* This unobtrusive JavaScript module finds all <a> elements that have an href
* attribute but no title attribute and adds an onmouseover event handler to 
* them. The event handler makes an XMLHttpRequest HEAD request to fetch 
* details about the linked resource, and then sets those details in the title
* attribute of the link so that they will be displayed as a tooltip.
*/
whenReady(function() { 
// Is there any chance that cross-origin requests will succeed?
var supportsCORS = (new XMLHttpRequest()).withCredentials !== undefined;
// Loop through all links in the document
var links = document.getElementsByTagName('a');
for(var i = 0; i < links.length; i++) {
var link = links[i];
if (!link.href) continue; // Skip anchors that are not hyperlinks
if (link.title) continue; // Skip links that already have tooltips
// If this is a cross-origin link
if (link.host !== location.host || link.protocol !== location.protocol)
{
link.title = "Off-site link";  // Assume we can't get any more info 
if (!supportsCORS) continue;   // Quit now if no CORS support
// Otherwise, we might be able to learn more about the link
// So go ahead and register the event handlers so we can try.
}
// Register event handler to download link details on mouse over
if (link.addEventListener)
link.addEventListener("mouseover", mouseoverHandler, false);
else
link.attachEvent("onmouseover", mouseoverHandler);
}
function mouseoverHandler(e) {
var link = e.target || e.srcElement;      // The <a> element
var url = link.href;                      // The link URL
var req = new XMLHttpRequest();           // New request
req.open("HEAD", url);                    // Ask for just the headers
req.onreadystatechange = function() {     // Event handler
if (req.readyState !== 4) return;     // Ignore incomplete requests
if (req.status === 200) {             // If successful
var type = req.getResponseHeader("Content-Type");   // Get
512 | Chapter 18: Scripted HTTP
Documents you may be interested
Documents you may be interested