Wow... just wow.

• HTTP Echo on ports 80, 8080
• TCP Echo on port 32000
• UDP Echo on port 32000

helloworld3000.com - An alias of foobar3000.com suitable for testing CORS, XSS, etc.

What's your IP?

checkip.foobar3000.com - no muss, no fuss, no markup, no `sed`, `awk`, or `.trim()` needed.

Stuck on Windows?

• cygwin (curl, netcat, etc): cygwin.com/setup.exe
• netcat: joncraton.org/blog/46
• cURL: groups.csail.mit.edu/cag/curl/download.html

TCP Echo

Persistent connection:

Open port 5000 on your computer in one terminal and connect to foobar3000 on port 32000 in another.

Text will be echoed back as-is. JSON will be interpretted, if possible.

      nc -l -p 5000 # GNU (Linux) netcat
      # nc -l 5000 # BSD (OS X) netcat

      nc foobar3000.com 32000
      Hey you!
      { "keepalive": true }
      { "keepalive": false }
      { "body": "Hello\n" }
        { "body": "Hello\n" }
      { "body": "Hello\n" NOT JSON }
      { "body": "Hello\n", "port": 5000 }
      { "port": 5000 }
      { "body": "Hello\n", "port": 5000 }
    

• keepalive - wether or not to send extra `ACK`s to verify connection
• body - the message to send back
• port - the port to connect back to (will connect from a different port)

UDP Echo

Persistent (responds from bound listener):

Open port 5000 on your computer in one terminal and connect to foobar3000 on port 32000 in another.

Text will be echoed back as-is. JSON will be interpretted, if possible.

      nc -u -l -p 5000 # GNU (Linux) netcat
      # nc -u -l 5000 # BSD (OS X) netcat

      nc -u foobar3000.com 32000
      Hey you!
        { "body": "Hello\n" }
      { "body": "Hello\n" NOT JSON }
      { "port": 5000 }
      { "body": "Hello\n", "redial": true }
      { "body": "Hello\n", "port": 5000 }
      { "body": "Hello\n", "redial": true, "port": 5000 }
    

• body - the message to send back
• port - the port to send back to (will be the same unless `redial` is requested
• redial - whether to use the bound port or a random port to respond

HTTP Echo

• Resources

  • `/echo` - for echoing back responses
  • `/meta` - for creating resources
  • `/checkip` - to check ip :-D

• Parameters (either as GET query params or POST body

  • `headers` - send these headers as part of the response - Array or String in the format of `["X-My-Header: x-my-value"]`
  • `defaultHeaders` - use with `session` to use these headers when other headers aren't specified
  • `body` - data to use as the response body for a GET request
  • `rawBody` - if `true`, send the POST body instead of echo-ing parameters
  • `raw` - send this as the response via TCP (no http headers)
    (good for testing how a client handles malformed responses)
  • `session` - for use with `/meta` and or `defaultHeaders` to store resources for this session in memory
  • `status` - set the response status code

• This Page

  `GET /`
  with no parameters

• Echo GET/POST/PUT/etc parameters as a JSON body

  `[VERB] /echo?foo=bar`
  will echo the parameters you have given

• Set this repsonse's headers

  `GET /echo?headers=X-Test-Header%3A%20Hello%2FWorld`
  replies to the request with the additional header `X-Test-Header: Hello World`

• Set the response's body

  `GET /echo?body=Hello%20World%0A`
  replies to the request with the body `Hello World\n`

• Set the response's tcp stream (headers + body)

  `POST /echo?raw=true`
  `HTTP/1.1 200 OK\r\nContent-Type: text/plain; charset=utf-8\r\nContent-Length: 12\r\nConnection: keep-alive\r\n\r\nHello World\n`

  
  Text:
  
      curl -v "http://${HOST}" \
        -H 'Content-Type: application/json' \
        -d '{
                "raw": "HTTP/1.1 200 OK\r\nContent-Type: text/plain; charset=utf-8\r\nContent-Length: 12\r\nConnection: keep-alive\r\n\r\nHello World\n"
            }'
  
  Binary:
  
      curl -v "http://${HOST}/?rawResponse=true" \
        -H 'Content-Type: application/octet-stream' \
        -d @hello.http.bin
  

• Create a temporary text resource with specific body and headers

  `GET /meta?session=same-token&pathname=%2Ffoobar&body=Hello%20Foo%0A&headers=Content-Type%3A%20text/plain` creates the resource `/foobar` for the session `same-token` with whatever headers and body specified

• Get the resource you created

  `GET /foobar?session=same-token`
  response with the resource just created (or an echo if there was none)
  NOTE:Any sessions created will be deleted after 10 minutes of inactivity

• Create a temporary binary resource with specific body and headers

  `POST /meta?session=same-token&pathname=%2Ffoobar&rawBody=true`
  creates the resource `/foobar` for the session `same-token` with whatever headers and body specified
  TODO: should respond with a URL

  
      var buffer
        ;
  
      function saveBinary(cb, token, path, headers, buffer) {
        var xhr2 = new XMLHttpRequest();
  
        xhr2.open('POST', '/meta'
          + '?session=' + encodeURIComponent(token) 
          + '&pathname='+ encodeURIComponent(path)
          + '&headers=' + encodeURIComponent(JSON.stringify(headers))
          + '&rawBody=true'
        , true);
  
        xhr2.send(buffer);
  
        xhr2.addEventListener('load', function () {
          cb(
              null
            , JSON.parse(xhr2.responseText)
            , 'http://foobar3000.com' + path + '?session=' + encodeURIComponent(token)
          );
        });
      }
  
      function onSaved(err, result, url) {
        console.log('succeeded');
        console.log(url);
      }
  
      // "Hello ☢☃ (radioactive snowman in utf-8)"
      buffer = new Uint8Array([
        72,101,108,108,111,32,226,152,162,226,152,131,32,40,114,97,
        100,105,111,97,99,116,105,118,101,32,115,110,111,119,109,
        97,110,32,105,110,32,117,116,102,45,56,41,10
      ]).buffer;
  
      saveBinary(
          onSaved
        , 'any-token-you-like'
        , '/any-path-you-like'
        , ["Content-Type: text/plain; charset=utf-8"]
        , buffer
      );
  

• Check your IP Address

  `GET /checkip`
  returns your IP Address as `text/plain`, no html, no spaces, no need to `.trim()`
  TODO: add udp and tcp checkip

For your prototyping pleasure, Ender.JS is loaded on this page with the following modules:

• jeesh
• reqwest
• jQuery
• ahr2

Open up your console and play away:

  var jQuery = require('jQuery')  // jQuery 1.6.3
    , $ = require('ender')        // same DOM API as jQuery
    , ajax = require('reqwest')   // same API as jQuery.ajax
    , request = require('ahr2')   // similar API to Node.JS' `request`, supports XHR2
    ;

  request('/echo').when(function (err, ahr, data) {
    console.log(arguments);
  });


  // Use foobar3000.com to create a CORS resource
  // (attached to session)
  function createCorsResource() {
    request.post('/meta', null, {
        session: "make-up-your-own-key"
      , pathname: "/hello-cors"
      , headers: [
            "Access-Control-Allow-Origin: *"
          , "Access-Control-Allow-Methods: POST, GET, PUT, DELETE, OPTIONS"
          , "Access-Control-Allow-Headers: Content-Type, Accept"
        ]
      , body: "Hello CORS World!"
    }, { headers: { "content-type": "application/json"} }).when(function (err, ahr, data) {
      console.log(arguments);
      getCorsResource();
    });
  }

  // Access the aforementioned resource from helloworld3000.com
  // (must use same session key)
  function getCorsResource() {
    request.get('http://helloworld3000.com/hello-cors?session=make-up-your-own-key').when(function (err, ahr, data) {
      console.log(arguments);
    });
  }

  createCorsResource();

    

Or play from another browser page:

  var script = document.createElement('script');
  script.src = 'http://foobar3000.com/assets/ender.js';
  script = document.body.appendChild(script);