/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

//

// Network topology

//

//                 5Mb/s, 2ms

//       n0 -------------------------n1

//

//

//

//

// - all links are point-to-point links with indicated one-way BW/delay

// - HTTP requests from n1 to n0 via TCP

// - DropTail queues 

// - Tracing of queues and packet receptions to file "http-traffic.tr"

#include <iostream>

#include <fstream>

#include <string>

#include <cassert>

#include "ns3/core-module.h"

#include "ns3/simulator-module.h"

#include "ns3/node-module.h"

#include "ns3/helper-module.h"

#include "ns3/http-module.h"

#include "ns3/global-route-manager.h"

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("SimpleGlobalRoutingExample");

int 

main (int argc, char *argv[])

{

  // Users may find it convenient to turn on explicit debugging

  // for selected modules; the below lines suggest how to do this

#if 0 

  LogComponentEnable ("SimpleGlobalRoutingExample", LOG_LEVEL_INFO);

#endif

  //

  // Make the random number generators generate reproducible results.

  //

  RandomVariable::UseGlobalSeed (1, 1, 2, 3, 5, 8);

  // Set up some default values for the simulation.  Use the 

  //DefaultValue::Bind ("DropTailQueue::m_maxPackets", 30);   

  // Allow the user to override any of the defaults and the above

  // DefaultValue::Bind ()s at run-time, via command-line arguments

  CommandLine cmd;

  cmd.Parse (argc, argv);

  // Here, we will explicitly create two nodes.  In more sophisticated

  // topologies, we could configure a node factory.

  NS_LOG_INFO ("Create nodes.");

  NodeContainer c;

  c.Create (2);

  InternetStackHelper internet;

  internet.Install (c);

  // We create the channels first without any IP addressing information

  NS_LOG_INFO ("Create channels.");

  PointToPointHelper p2p;

  p2p.SetDeviceParameter ("DataRate", StringValue ("5Mbps"));

  p2p.SetChannelParameter ("Delay", StringValue ("2ms"));

  NetDeviceContainer devices = p2p.Install (c);

  // Later, we add IP addresses.  

  NS_LOG_INFO ("Assign IP Addresses.");

  Ipv4AddressHelper ipv4;

  ipv4.SetBase ("10.1.1.0", "255.255.255.0");

  Ipv4InterfaceContainer ipInterfaces = ipv4.Assign (devices);

  //Use "god" BFS static routing

  GlobalRouteManager::PopulateRoutingTables ();

  // ...instead of OLSR

  //NS_LOG_INFO ("Enabling OLSR Routing.");

  //OlsrHelper olsr;

  //olsr.InstallAll ();

  // Create the HTTP applications

  NS_LOG_INFO ("Create Applications.");

  //have to use low level/internal APIs here since I didn't make a helper

  //add the server to node0

  ObjectFactory webServerFactory;

  webServerFactory.SetTypeId ("ns3::WebServer");

  //these can be used to configure the parameters of the connection

  //webServerFactory.Set ("Protocol", TypeIdValue (TcpSocketFactory::GetTypeId ()));

  //webServerFactory.Set ("Local", AddressValue (InetSocketAddress (Ipv4Address::GetAny (), 80)));

  Ptr<Application> serverApplication = webServerFactory.Create<Application> ();

  c.Get(0)->AddApplication(serverApplication);

  serverApplication->Start(Seconds (0.0));

  //add the client to node1

  ObjectFactory webClientFactory;

  webClientFactory.SetTypeId("ns3::WebClient");

  webClientFactory.Set("Remote", AddressValue (InetSocketAddress(ipInterfaces.GetAddress(0), 80)));

  Ptr<Application> clientApplication = webClientFactory.Create<Application> ();

  c.Get(1)->AddApplication(clientApplication);

  clientApplication->Start(Seconds(0.0));

  std::ofstream ascii;

  ascii.open ("simple-http.tr");

  PointToPointHelper::EnablePcapAll ("simple-http");

  PointToPointHelper::EnableAsciiAll (ascii);

  Simulator::Stop (Seconds (30));

  NS_LOG_INFO ("Run Simulation.");

  Simulator::Run ();

  Simulator::Destroy ();

  NS_LOG_INFO ("Done.");

  return 0;

}

    obj = bld.create_ns3_program('simple-http',

        ['point-to-point', 'internet-stack', 'global-routing'])

    obj.source = 'simple-http.cc'

exec "`dirname "$0"`"/../../../waf "$@"

/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */

//

// Copyright (c) 2006 Georgia Tech Research Corporation

//

// This program is free software; you can redistribute it and/or modify

// it under the terms of the GNU General Public License version 2 as

// published by the Free Software Foundation;

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with this program; if not, write to the Free Software

// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

//

// Author: George F. Riley<riley@ece.gatech.edu>

//

// ns3 - On/Off Data Source Application class

// George F. Riley, Georgia Tech, Spring 2007

// Adapted from ApplicationOnOff in GTNetS.

#include "ns3/log.h"

#include "ns3/address.h"

#include "ns3/node.h"

#include "ns3/nstime.h"

#include "ns3/data-rate.h"

#include "ns3/random-variable.h"

#include "ns3/socket.h"

#include "ns3/simulator.h"

#include "ns3/socket-factory.h"

#include "ns3/packet.h"

#include "ns3/uinteger.h"

#include "ns3/trace-source-accessor.h"

#include "ns3/tcp-socket-factory.h"

#include "ns3/callback.h"

#include "web-client.h"

NS_LOG_COMPONENT_DEFINE ("WebClient");

using namespace std;

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (WebClient);

TypeId

WebClient::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::WebClient")

    .SetParent<Application> ()

    .AddConstructor<WebClient> ()

    .AddAttribute ("Remote", "The address of the destination",

                   AddressValue (),

                   MakeAddressAccessor (&WebClient::m_peer),

                   MakeAddressChecker ())

    .AddAttribute ("Protocol", "The type of protocol to use.",

                   TypeIdValue (TcpSocketFactory::GetTypeId ()),

                   MakeTypeIdAccessor (&WebClient::m_tid),

                   MakeTypeIdChecker ())

    ;

  return tid;

}

WebClient::WebClient ()

{

  NS_LOG_FUNCTION_NOARGS ();

  m_socket = 0;

  m_connected = false;

}

WebClient::~WebClient()

{

  NS_LOG_FUNCTION_NOARGS ();

}

void

WebClient::DoDispose (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_socket = 0;

  // chain up

  Application::DoDispose ();

}

// Application Methods

void WebClient::StartApplication() // Called at time specified by Start

{

  NS_LOG_FUNCTION_NOARGS ();

  // Create the socket if not already

  if (!m_socket)

    {

      m_socket = Socket::CreateSocket (GetNode(), m_tid);

      m_socket->Bind ();

      m_socket->Connect (m_peer);

      Callback<void, Ptr<Socket> > successCB = MakeCallback(&ns3::WebClient::ConnectionSucceeded, this);

      Callback<void, Ptr<Socket> > failCB = MakeCallback(&ns3::WebClient::ConnectionFailed, this);

      m_socket->SetConnectCallback (successCB,failCB);

    }

}

void WebClient::StopApplication ()

{

}

void WebClient::ConnectionSucceeded(Ptr<Socket> s)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_connected = true;

  NS_ASSERT (s==m_socket);

  HttpGet("/favicon.ico");

}

void WebClient::ConnectionFailed(Ptr<Socket> s)

{

  NS_LOG_FUNCTION_NOARGS ();

  cout << "WebClient, Connection Failed" << endl;

}

void WebClient::HttpGet(std::string url)

{

  std::string request = std::string("GET ").append(url).append(" HTTP/1.1\r\n");

  const uint8_t* data = reinterpret_cast<const uint8_t*>(request.data());

  m_socket->Send(data, request.length(), 0);

}

} // Namespace ns3

/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */

//

// Copyright (c) 2006 Georgia Tech Research Corporation

//

// This program is free software; you can redistribute it and/or modify

// it under the terms of the GNU General Public License version 2 as

// published by the Free Software Foundation;

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with this program; if not, write to the Free Software

// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

//

// Author: George F. Riley<riley@ece.gatech.edu>

//

// ns3 - On/Off Data Source Application class

// George F. Riley, Georgia Tech, Spring 2007

// Adapted from ApplicationOnOff in GTNetS.

#ifndef __web_client_h__

#define __web_client_h__

#include "ns3/address.h"

#include "ns3/application.h"

#include "ns3/event-id.h"

#include "ns3/ptr.h"

#include "ns3/data-rate.h"

#include "ns3/random-variable.h"

#include "ns3/traced-callback.h"

#include <string>

namespace ns3 {

class Address;

class RandomVariable;

class Socket;

class WebClient : public Application 

{

public:

  static TypeId GetTypeId (void);

  WebClient ();

  virtual ~WebClient();

  //issue an http get request

  void HttpGet(std::string url);

protected:

  virtual void DoDispose (void);

private:

  // inherited from Application base class.

  virtual void StartApplication (void);    // Called at time specified by Start

  virtual void StopApplication (void);     // Called at time specified by Stop

  void Construct (Ptr<Node> n,

                  const Address &remote,

                  std::string tid,

                  const RandomVariable& ontime,

                  const RandomVariable& offtime,

                  uint32_t size);

  // Event handlers

  void StartSending();

  void StopSending();

  void SendPacket();

  Ptr<Socket>     m_socket;       // Associated socket

  Address         m_peer;         // Peer address

  bool            m_connected;    // True if connected

  TypeId          m_tid;

private:

  void ConnectionSucceeded(Ptr<Socket>);

  void ConnectionFailed(Ptr<Socket>);

};

} // namespace ns3

#endif

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright 2007 University of Washington

 * 

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author:  Tom Henderson (tomhend@u.washington.edu)

 */

#include "ns3/address.h"

#include "ns3/log.h"

#include "ns3/inet-socket-address.h"

#include "ns3/node.h"

#include "ns3/socket.h"

#include "ns3/simulator.h"

#include "ns3/socket-factory.h"

#include "ns3/packet.h"

#include "ns3/trace-source-accessor.h"

#include "ns3/tcp-socket-factory.h"

#include "web-server.h"

using namespace std;

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("WebServer");

NS_OBJECT_ENSURE_REGISTERED (WebServer);

TypeId 

WebServer::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::WebServer")

    .SetParent<Application> ()

    .AddConstructor<WebServer> ()

    .AddAttribute ("Local", "The Address on which to Bind the rx socket.",

                   AddressValue (InetSocketAddress (Ipv4Address::GetAny (), 80)),

                   MakeAddressAccessor (&WebServer::m_local),

                   MakeAddressChecker ())

    .AddAttribute ("Protocol", "The type id of the protocol to use for the rx socket.",

                   TypeIdValue (TcpSocketFactory::GetTypeId ()),

                   MakeTypeIdAccessor (&WebServer::m_tid),

                   MakeTypeIdChecker ())

    ;

  return tid;

}

WebServer::WebServer ()

  : m_stopped(true), m_connections(0), m_maxConnections(1)

{

  m_socket = 0;

}

WebServer::~WebServer()

{}

void

WebServer::DoDispose (void)

{

  if (m_socket != 0)

    {

      m_socket->Close ();

    }

  m_socket = 0;

  // chain up

  Application::DoDispose ();

}

// Application Methods

void WebServer::StartApplication()    // Called at time specified by Start

{

  // Create the socket if not already

  if (!m_socket)

    {

      m_socket = Socket::CreateSocket (GetNode(), m_tid);

      m_socket->Bind (m_local);

      m_socket->Listen (0);

    }

  m_socket->SetRecvCallback (MakeCallback(&WebServer::HandleRead, this));

  m_socket->SetAcceptCallback (MakeCallback(&WebServer::ConnectionRequested, this),

                               MakeCallback(&WebServer::ConnectionAccepted, this));

}

void WebServer::StopApplication()     // Called at time specified by Stop

{

  if (m_socket) 

    {

      m_socket->SetRecvCallback (MakeNullCallback<void, Ptr<Socket> > ());

    }

}

bool WebServer::ConnectionRequested(Ptr<Socket> s, const Address& a)

{

  NS_LOG_FUNCTION(this << s << a );

  return m_connections < m_maxConnections;

}

void WebServer::ConnectionAccepted(Ptr<Socket> s, const Address& a)

{ // We have a new socket. We need to set the receive callback and

  // respond with the web-page response when the request arrives

  NS_LOG_FUNCTION (this << s << a);

  m_socket = s;

  Ptr<Packet> p;

  //read until it "blocks"

  while(p = m_socket->Recv())

  {

    const char* data = reinterpret_cast<const char*>(p->PeekData());

    m_data.append(data,p->GetSize());

  }

  //now we've blocked, so register the upcall for later

  s->SetRecvCallback(MakeCallback(&WebServer::HandleRead, this));

  //and parse out any HTTP we got

  if (m_data.length() > 0)

  {

    ParseHttp();

  }

}

void WebServer::HandleRead (Ptr<Socket> socket)

{

  Ptr<Packet> p;

  //read until it "blocks"

  while(p = m_socket->Recv())

  {

    const char* data = reinterpret_cast<const char*>(p->PeekData());

    m_data.append(data,p->GetSize());

  }

  //and parse out any HTTP we got

  if (m_data.length() > 0)

  {

    ParseHttp();

  }

}

void WebServer::ParseHttp()

{

  std::cout<<m_data<<std::endl;

}

} // Namespace ns3

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright 2007 University of Washington

 * 

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author:  Tom Henderson (tomhend@u.washington.edu)

 */

#ifndef __web_server_h__

#define __web_server_h__

#include "ns3/application.h"

#include "ns3/event-id.h"

#include "ns3/ptr.h"

#include "ns3/traced-callback.h"

#include "ns3/address.h"

#include <vector>

namespace ns3 {

class Address;

class Socket;

class Packet;

class WebServer : public Application 

{

public:

  static TypeId GetTypeId (void);

  WebServer ();

  virtual ~WebServer ();

protected:

  virtual void DoDispose (void);

private:

  // inherited from Application base class.

  virtual void StartApplication (void);    // Called at time specified by Start

  virtual void StopApplication (void);     // Called at time specified by Stop

  void HandleRead (Ptr<Socket> socket);

  virtual bool ConnectionRequested(Ptr<Socket>, const Address&);

  virtual void ConnectionAccepted (Ptr<Socket>, const Address&);

  //Helpers

  void ParseHttp();

  Ptr<Socket>     m_socket;       // Associated socket

  Address         m_local;        // Local address to bind to

  TypeId          m_tid;          // Protocol TypeId

  std::string m_data;

  bool        m_stopped;        // Rejects all connection requests if true

  uint32_t    m_connections;    // Current active connection count

  uint32_t    m_maxConnections; // Maximum simultaneous connections allowed

};

} // namespace ns3

#endif

## -*- Mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8; -*-

def build(bld):

    module = bld.create_ns3_module('http', ['core', 'simulator', 'node'])

    module.source = [

        'web-client.cc',

        'web-server.cc',

        ]

    headers = bld.create_obj('ns3header')

    headers.module = 'http'

    headers.source = [

        'web-client.h',

        'web-server.h',

        ]

    'applications/http',