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

/*

 * Copyright (c) 2015 Universidad de la República - Uruguay

 *

 * 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: Matias Richart <mrichart@fing.edu.uy>

 */

#include <sstream>

#include <fstream>

#include "ns3/core-module.h"

#include "ns3/network-module.h"

#include "ns3/dce-module.h"

#include "ns3/internet-module.h"

#include "ns3/mobility-module.h"

#include "ns3/wifi-module.h"

using namespace ns3;

using namespace std;

NS_LOG_COMPONENT_DEFINE ("DceWireless");

static void

SetPosition (Ptr<Node> node, Vector position)

{

  Ptr<MobilityModel> mobility = node->GetObject<MobilityModel> ();

  mobility->SetPosition (position);

}

static Vector

GetPosition (Ptr<Node> node)

{

  Ptr<MobilityModel> mobility = node->GetObject<MobilityModel> ();

  return mobility->GetPosition ();

}

static void

AdvancePosition (Ptr<Node> node, int stepsSize)

{

  Vector pos = GetPosition (node);

  pos.x += stepsSize;

  SetPosition (node, pos);

  NS_LOG_INFO ("At time " << Simulator::Now ().GetSeconds () << " sec; setting new position to " << pos);

}

int main (int argc, char *argv[])

{

  uint32_t rtsThreshold = 2346;

  int ap1_x = 0;

  int ap1_y = 0;

  int sta1_x = 30;

  int sta1_y = 0;

  uint32_t simuTime = 300;

  CommandLine cmd;

  cmd.AddValue ("simuTime", "Total simulation time (sec)", simuTime);

  cmd.AddValue ("AP1_x", "Position of AP1 in x coordinate", ap1_x);

  cmd.AddValue ("AP1_y", "Position of AP1 in y coordinate", ap1_y);

  cmd.AddValue ("STA1_x", "Position of STA1 in x coordinate", sta1_x);

  cmd.AddValue ("STA1_y", "Position of STA1 in y coordinate", sta1_y);

  cmd.Parse (argc, argv);

  // Define the AP

  NodeContainer wifiApNodes;

  wifiApNodes.Create (1);

  //Define the STA

  NodeContainer wifiStaNodes;

  wifiStaNodes.Create (1);

  WifiHelper wifi = WifiHelper::Default ();

  wifi.SetStandard (WIFI_PHY_STANDARD_80211a);

  NqosWifiMacHelper wifiMac = NqosWifiMacHelper::Default ();

  YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

  wifiPhy.SetChannel (wifiChannel.Create ());

  NetDeviceContainer wifiApDevices;

  NetDeviceContainer wifiStaDevices;

  NetDeviceContainer wifiDevices;

  //Configure the STA node

  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode", StringValue ("OfdmRate6Mbps"), "ControlMode", StringValue ("ErpOfdmRate6Mbps"));

  Ssid ssid = Ssid ("AP0");

  wifiMac.SetType ("ns3::StaWifiMac",

                   "Ssid", SsidValue (ssid),

                   "ActiveProbing", BooleanValue (false),

                   "MaxMissedBeacons", UintegerValue (1000));

  wifiStaDevices.Add (wifi.Install (wifiPhy, wifiMac, wifiStaNodes.Get (0)));

  //Configure the AP node

  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode", StringValue ("OfdmRate54Mbps"),"ControlMode", StringValue ("OfdmRate6Mbps"), "RtsCtsThreshold", UintegerValue (rtsThreshold));

  ssid = Ssid ("AP0");

  wifiMac.SetType ("ns3::ApWifiMac",

                   "Ssid", SsidValue (ssid));

  wifiApDevices.Add (wifi.Install (wifiPhy, wifiMac, wifiApNodes.Get (0)));

  wifiDevices.Add (wifiStaDevices);

  wifiDevices.Add (wifiApDevices);

  // Configure the mobility.

  MobilityHelper mobility;

  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();

  positionAlloc->Add (Vector (ap1_x, ap1_y, 0.0));

  positionAlloc->Add (Vector (sta1_x, sta1_y, 0.0));

  mobility.SetPositionAllocator (positionAlloc);

  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");

  mobility.Install (wifiApNodes.Get (0));

  mobility.Install (wifiStaNodes.Get (0));

  //Configure the IP stack

  InternetStackHelper stack;

  stack.Install (wifiApNodes);

  stack.Install (wifiStaNodes);

  Ipv4AddressHelper address;

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

  Ipv4InterfaceContainer i = address.Assign (wifiDevices);

  Ipv4Address sinkAddress = i.GetAddress (0);

  uint16_t port = 9; 

  DceManagerHelper dceManager;

  dceManager.Install (wifiApNodes);

  dceManager.Install (wifiStaNodes);

  DceApplicationHelper dce;

  ApplicationContainer apps;

  dce.SetBinary ("tcp-server-2");

  dce.ResetArguments ();

  dce.SetStackSize (1 << 16);

  apps = dce.Install (wifiStaNodes.Get (0));

  apps.Start (Seconds (2.0));

  dce.SetBinary ("tcp-client-2");

  dce.ResetArguments ();

  dce.ParseArguments ("10.1.1.1");

  apps = dce.Install (wifiApNodes.Get (0));

  apps.Start (Seconds (2.5));

  Simulator::Schedule (Seconds (2.51), &AdvancePosition, wifiApNodes.Get (0), -50);

  Simulator::Schedule (Seconds (200), &AdvancePosition, wifiApNodes.Get (0), 50);

  Simulator::Stop (Seconds (simuTime));

  Simulator::Run ();

  Simulator::Destroy ();

  return 0;

}

#include <unistd.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netdb.h>

#include <string.h>

#include <iostream>

int main (int argc, char *argv[])

{

  int sock;

  sock = socket (PF_INET, SOCK_STREAM, 0);

  struct sockaddr_in addr;

  addr.sin_family = AF_INET;

  addr.sin_port = htons (2000);

  struct hostent *host = gethostbyname (argv[1]);

  memcpy (&addr.sin_addr.s_addr, host->h_addr_list[0], host->h_length);

  int result;

  result = connect (sock, (const struct sockaddr *) &addr, sizeof (addr));

  if (result != -1)

    {

      uint8_t buf[1024];

      memset (buf, 0x66, 20);

      memset (buf + 20, 0x67, 1004);

      ssize_t tot = 0;

      for (uint32_t i = 0; i < 1000; i++)

        {

          ssize_t n = 1024;

          while (n > 0)

            {

              ssize_t e  = write (sock, &(buf[1024 - n]), n);

              if (e < 0)

                {

                  break;

                }

              if (e < n)

                {

                  sleep (1);

                  std::cout << "e < n : " << e << "<" << n << std::endl;

                }

              n -= e;

              tot += e;

            }

          std::cout << "write: " << tot << std::endl;

           sleep (1);

        }

      std::cout << "did write all buffers total:" << tot << std::endl;

    }

  else

    {

      std::cout << "Connection failed." << std::endl;

    }

  close (sock);

  return 0;

}

#include <unistd.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netdb.h>

#include <string.h>

#include <iostream>

#include <sys/fcntl.h>

#include <assert.h>

#define SERVER_PORT 2000

int

main (int argc, char *argv[])

{

  int sock;

  sock = socket (PF_INET, SOCK_STREAM, 0);

  struct sockaddr_in addr;

  addr.sin_family = AF_INET;

  addr.sin_port = htons (SERVER_PORT);

  addr.sin_addr.s_addr = INADDR_ANY;

  fcntl(sock, F_SETFL, O_NONBLOCK);

  int status;

  status = bind (sock, (const struct sockaddr *) &addr, sizeof(addr));

  status = listen (sock, 1);

  fd_set fds;

  FD_ZERO (&fds);

  FD_SET (sock, &fds);

  int nfds = select (sock + 1, &fds, NULL, NULL, NULL);

  int fd = accept (sock, 0, 0);

  /*

  * The select should return a socket ready for the accept.

  */

  assert(fd != -1);

  std::cout << " accept -> " << fd << std::endl;

  uint8_t buf[10240];

  memset (buf, 0, 10240);

  ssize_t tot = 0;

  for (uint32_t i = 0; i < 100; i++)

    {

      ssize_t n = 10240;

      while (n > 0)

        {

          ssize_t bytes_read = read (fd, &buf[10240 - n], n);

          if (bytes_read > 0)

            {

              n -= bytes_read;

              std::cout << "read:" << bytes_read << " n:" << n << std::endl;

              tot += bytes_read;

            }

          else

            {

              break;

            }

        }

         sleep (1);

    }

  std::cout << "did read all buffers tot:" << tot << std::endl;

  close (sock);

  close (fd);

  return 0;

}

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

import ns3waf

import os

def configure(conf):

    ns3waf.check_modules(conf, ['core', 'network', 'dce', 'wifi', 'point-to-point', 'csma', 'mobility'], mandatory = True)

def build(bld):

    bld.build_a_script('dce-wireless', needed = ['core', 'network', 'dce', 'wifi', 'point-to-point', 'csma', 'mobility', 'flow-monitor', 'applications'],

				  target='bin/dce-wireless', 

				  source=['dce-wireless.cc'],

				  )

    bld.program(source='tcp-server-2.cc', target='../../bin_dce/tcp-server-2', cxxflags = [ '-fPIC'], linkflags = ['-pie', '-rdynamic'])

    bld.program(source='tcp-client-2.cc', target='../../bin_dce/tcp-client-2', cxxflags = [ '-fPIC'], linkflags = ['-pie', '-rdynamic'])