text: /*
   *  Copyright 2011 The WebRTC Project Authors. All rights reserved.
   *
   *  Use of this source code is governed by a BSD-style license
   *  that can be found in the LICENSE file in the root of the source
   *  tree. An additional intellectual property rights grant can be found
   *  in the file PATENTS.  All contributing project authors may
   *  be found in the AUTHORS file in the root of the source tree.
   */
  
  #include "examples/peerconnection/server/peer_channel.h"
  
  #include <assert.h>
  #include <stdio.h>
  #include <stdlib.h>
  
  #include <algorithm>
  
  #include "examples/peerconnection/server/data_socket.h"
  #include "examples/peerconnection/server/utils.h"
  
  // Set to the peer id of the originator when messages are being
  // exchanged between peers, but set to the id of the receiving peer
  // itself when notifications are sent from the server about the state
  // of other peers.
  //
  // WORKAROUND: Since support for CORS varies greatly from one browser to the
  // next, we don't use a custom name for our peer-id header (originally it was
  // "X-Peer-Id: ").  Instead, we use a "simple header", "Pragma" which should
  // always be exposed to CORS requests.  There is a special CORS header devoted
  // to exposing proprietary headers (Access-Control-Expose-Headers), however
  // at this point it is not working correctly in some popular browsers.
  static const char kPeerIdHeader[] = "Pragma: ";
  
  static const char* kRequestPaths[] = {
      "/wait",
      "/sign_out",
      "/message",
  };
  
  enum RequestPathIndex {
    kWait,
    kSignOut,
    kMessage,
  };
  
  const size_t kMaxNameLength = 512;
  
  //
  // ChannelMember
  //
  
  int ChannelMember::s_member_id_ = 0;
  
  ChannelMember::ChannelMember(DataSocket* socket)
      : waiting_socket_(NULL),
        id_(++s_member_id_),
        connected_(true),
        timestamp_(time(NULL)) {
    assert(socket);
    assert(socket->method() == DataSocket::GET);
    assert(socket->PathEquals("/sign_in"));
    name_ = socket->request_arguments();
    if (name_.empty())
      name_ = "peer_" + int2str(id_);
    else if (name_.length() > kMaxNameLength)
      name_.resize(kMaxNameLength);
  
    std::replace(name_.begin(), name_.end(), ',', '_');
  }
  
  ChannelMember::~ChannelMember() {}
  
  bool ChannelMember::is_wait_request(DataSocket* ds) const {
    return ds && ds->PathEquals(kRequestPaths[kWait]);
  }
  
  bool ChannelMember::TimedOut() {
    return waiting_socket_ == NULL && (time(NULL) - timestamp_) > 30;
  }
  
  std::string ChannelMember::GetPeerIdHeader() const {
    std::string ret(kPeerIdHeader + int2str(id_) + "\r\n");
    return ret;
  }
  
  bool ChannelMember::NotifyOfOtherMember(const ChannelMember& other) {
    assert(&other != this);
    QueueResponse("200 OK", "text/plain", GetPeerIdHeader(), other.GetEntry());
    return true;
  }
  
  // Returns a string in the form "name,id,connected\n".
  std::string ChannelMember::GetEntry() const {
    assert(name_.length() <= kMaxNameLength);
  
    // name, 11-digit int, 1-digit bool, newline, null
    char entry[kMaxNameLength + 15];
    snprintf(entry, sizeof(entry), "%s,%d,%d\n",
             name_.substr(0, kMaxNameLength).c_str(), id_, connected_);
    return entry;
  }
  
  void ChannelMember::ForwardRequestToPeer(DataSocket* ds, ChannelMember* peer) {
    assert(peer);
    assert(ds);
  
    std::string extra_headers(GetPeerIdHeader());
  
    if (peer == this) {
      ds->Send("200 OK", true, ds->content_type(), extra_headers, ds->data());
    } else {
      printf("Client %s sending to %s\n", name_.c_str(), peer->name().c_str());
      peer->QueueResponse("200 OK", ds->content_type(), extra_headers,
                          ds->data());
      ds->Send("200 OK", true, "text/plain", "", "");
    }
  }
  
  void ChannelMember::OnClosing(DataSocket* ds) {
    if (ds == waiting_socket_) {
      waiting_socket_ = NULL;
      timestamp_ = time(NULL);
    }
  }
  
  void ChannelMember::QueueResponse(const std::string& status,
                                    const std::string& content_type,
                                    const std::string& extra_headers,
                                    const std::string& data) {
    if (waiting_socket_) {
      assert(queue_.empty());
      assert(waiting_socket_->method() == DataSocket::GET);
      bool ok =
          waiting_socket_->Send(status, true, content_type, extra_headers, data);
      if (!ok) {
        printf("Failed to deliver data to waiting socket\n");
      }
      waiting_socket_ = NULL;
      timestamp_ = time(NULL);
    } else {
      QueuedResponse qr;
      qr.status = status;
      qr.content_type = content_type;
      qr.extra_headers = extra_headers;
      qr.data = data;
      queue_.push(qr);
    }
  }
  
  void ChannelMember::SetWaitingSocket(DataSocket* ds) {
    assert(ds->method() == DataSocket::GET);
    if (ds && !queue_.empty()) {
      assert(waiting_socket_ == NULL);
      const QueuedResponse& response = queue_.front();
      ds->Send(response.status, true, response.content_type,
               response.extra_headers, response.data);
      queue_.pop();
    } else {
      waiting_socket_ = ds;
    }
  }
  
  //
  // PeerChannel
  //
  
  // static
  bool PeerChannel::IsPeerConnection(const DataSocket* ds) {
    assert(ds);
    return (ds->method() == DataSocket::POST && ds->content_length() > 0) ||
           (ds->method() == DataSocket::GET && ds->PathEquals("/sign_in"));
  }
  
  ChannelMember* PeerChannel::Lookup(DataSocket* ds) const {
    assert(ds);
  
    if (ds->method() != DataSocket::GET && ds->method() != DataSocket::POST)
      return NULL;
  
    size_t i = 0;
    for (; i < ARRAYSIZE(kRequestPaths); ++i) {
      if (ds->PathEquals(kRequestPaths[i]))
        break;
    }
  
    if (i == ARRAYSIZE(kRequestPaths))
      return NULL;
  
    std::string args(ds->request_arguments());
    static const char kPeerId[] = "peer_id=";
    size_t found = args.find(kPeerId);
    if (found == std::string::npos)
      return NULL;
  
    int id = atoi(&args[found + ARRAYSIZE(kPeerId) - 1]);
    Members::const_iterator iter = members_.begin();
    for (; iter != members_.end(); ++iter) {
      if (id == (*iter)->id()) {
        if (i == kWait)
          (*iter)->SetWaitingSocket(ds);
        if (i == kSignOut)
          (*iter)->set_disconnected();
        return *iter;
      }
    }
  
    return NULL;
  }
  
  ChannelMember* PeerChannel::IsTargetedRequest(const DataSocket* ds) const {
    assert(ds);
    // Regardless of GET or POST, we look for the peer_id parameter
    // only in the request_path.
    const std::string& path = ds->request_path();
    size_t args = path.find('?');
    if (args == std::string::npos)
      return NULL;
    size_t found;
    const char kTargetPeerIdParam[] = "to=";
    do {
      found = path.find(kTargetPeerIdParam, args);
      if (found == std::string::npos)
        return NULL;
      if (found == (args + 1) || path[found - 1] == '&') {
        found += ARRAYSIZE(kTargetPeerIdParam) - 1;
        break;
      }
      args = found + ARRAYSIZE(kTargetPeerIdParam) - 1;
    } while (true);
    int id = atoi(&path[found]);
    Members::const_iterator i = members_.begin();
    for (; i != members_.end(); ++i) {
      if ((*i)->id() == id) {
        return *i;
      }
    }
    return NULL;
  }
  
  bool PeerChannel::AddMember(DataSocket* ds) {
    assert(IsPeerConnection(ds));
    ChannelMember* new_guy = new ChannelMember(ds);
    Members failures;
    BroadcastChangedState(*new_guy, &failures);
    HandleDeliveryFailures(&failures);
    members_.push_back(new_guy);
  
    printf("New member added (total=%s): %s\n",
           size_t2str(members_.size()).c_str(), new_guy->name().c_str());
  
    // Let the newly connected peer know about other members of the channel.
    std::string content_type;
    std::string response = BuildResponseForNewMember(*new_guy, &content_type);
    ds->Send("200 Added", true, content_type, new_guy->GetPeerIdHeader(),
             response);
    return true;
  }
  
  void PeerChannel::CloseAll() {
    Members::const_iterator i = members_.begin();
    for (; i != members_.end(); ++i) {
      (*i)->QueueResponse("200 OK", "text/plain", "", "Server shutting down");
    }
    DeleteAll();
  }
  
  void PeerChannel::OnClosing(DataSocket* ds) {
    for (Members::iterator i = members_.begin(); i != members_.end(); ++i) {
      ChannelMember* m = (*i);
      m->OnClosing(ds);
      if (!m->connected()) {
        i = members_.erase(i);
        Members failures;
        BroadcastChangedState(*m, &failures);
        HandleDeliveryFailures(&failures);
        delete m;
        if (i == members_.end())
          break;
      }
    }
    printf("Total connected: %s\n", size_t2str(members_.size()).c_str());
  }
  
  void PeerChannel::CheckForTimeout() {
    for (Members::iterator i = members_.begin(); i != members_.end(); ++i) {
      ChannelMember* m = (*i);
      if (m->TimedOut()) {
        printf("Timeout: %s\n", m->name().c_str());
        m->set_disconnected();
        i = members_.erase(i);
        Members failures;
        BroadcastChangedState(*m, &failures);
        HandleDeliveryFailures(&failures);
        delete m;
        if (i == members_.end())
          break;
      }
    }
  }
  
  void PeerChannel::DeleteAll() {
    for (Members::iterator i = members_.begin(); i != members_.end(); ++i)
      delete (*i);
    members_.clear();
  }
  
  void PeerChannel::BroadcastChangedState(const ChannelMember& member,
                                          Members* delivery_failures) {
    // This function should be called prior to DataSocket::Close().
    assert(delivery_failures);
  
    if (!member.connected()) {
      printf("Member disconnected: %s\n", member.name().c_str());
    }
  
    Members::iterator i = members_.begin();
    for (; i != members_.end(); ++i) {
      if (&member != (*i)) {
        if (!(*i)->NotifyOfOtherMember(member)) {
          (*i)->set_disconnected();
          delivery_failures->push_back(*i);
          i = members_.erase(i);
          if (i == members_.end())
            break;
        }
      }
    }
  }
  
  void PeerChannel::HandleDeliveryFailures(Members* failures) {
    assert(failures);
  
    while (!failures->empty()) {
      Members::iterator i = failures->begin();
      ChannelMember* member = *i;
      assert(!member->connected());
      failures->erase(i);
      BroadcastChangedState(*member, failures);
      delete member;
    }
  }
  
  // Builds a simple list of "name,id\n" entries for each member.
  std::string PeerChannel::BuildResponseForNewMember(const ChannelMember& member,
                                                     std::string* content_type) {
    assert(content_type);
  
    *content_type = "text/plain";
    // The peer itself will always be the first entry.
    std::string response(member.GetEntry());
    for (Members::iterator i = members_.begin(); i != members_.end(); ++i) {
      if (member.id() != (*i)->id()) {
        assert((*i)->connected());
        response += (*i)->GetEntry();
      }
    }
  
    return response;
  }
  