server_side.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : example rpc server                                                *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1995-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "implem_only.h"
#include "server_side.h"

#include <opsystem/path_configuration.h>
#include <geometric/point.cpp>


// pries the "to_detach" object off of an array called "data" and if this
// cannot be done, it complains and returns "to_return".
#define DETACH(to_detach, to_return) { \
  if (!detach(data, (int &)to_detach)) { \
    LOG("detach failed on " #to_detach); \
    return to_return; \
  } \
}


const int MAX_CLIENTS = 10;
  // maximum number of simultaneous client calls.
const int MAX_SLUSH = 15;
  // this is the number of extra calls that could occur even though the limit
  // is set above.  the limits are "recommendations" according to MS docs;
  // the slush keeps things from blowing up, hopefully.


example_rpc_server *single_server_instance = NIL;

example_rpc_server::example_rpc_server(CFrameWnd *parent, window_handle _alert)
: alert(_alert),
  ng_rpc_server(),
  mouser(new drawing_window(*this))
{
  mouser->Create(parent, "server win", _alert, true);
//attempt to show it.  mouser->ShowWindow(SW_RESTORE);
  begin_service();
  single_server_instance = this;
}

example_rpc_server::~example_rpc_server()
{
  single_server_instance = NIL;
  stop_accepting();
  shut_down();
  mouser->be_gone();
}

byte_array example_rpc_server::register_client(const byte_array &_data)
{
  FUNCDEF("register_client");
  byte_array data(_data);
  window_handle new_client;
  DETACH(new_client, byte_array());
  client_record to_add;
  to_add.window = new_client;
  mouser->lock();
  client_list += to_add;
  mouser->unlock();
  return byte_array();
}

byte_array example_rpc_server::unregister_client(const byte_array &_data)
{
  FUNCDEF("unregister_client");
  byte_array data(_data);
  window_handle old_client;
  DETACH(old_client, byte_array());
  mouser->lock();
  for (int i = 0; i < client_list.length(); i++) {
    if (client_list[i].window == old_client) {
      client_list.zap(i, i);
      mouser->unlock();
      return byte_array();
    }
  }
  mouser->unlock();
  LOG(istring(istring::SPRINTF, "client to whack (%d) not "
      "found!", old_client));
  return byte_array();
}

byte_array example_rpc_server::add_point(const byte_array &data)
{
  array<rpc_point> found;
  mouser->pull_out_mice(data, found);
  for (int i = 0; i < found.length(); i++) mouser->add_dot(found[i]);
  mouser->start_timer(50);
  return byte_array();
}

byte_array example_rpc_server::get_entire_list(const byte_array &formal(data))
{
  byte_array to_return;
  array<rpc_point> the_list;
  mouser->get_mouse_list(the_list);
  mouser->push_in_mice(the_list, to_return);
  return to_return;
}

byte_array example_rpc_server::get_partial_list(const byte_array &_data)
{
  FUNCDEF("get_partial_list");
  byte_array data(_data);
  int index;
  DETACH(index, byte_array());
  LOG(istring(istring::SPRINTF, "got a request starting at index %d, where our list goes to %d.",
      index, mouser->length()));
  // get the full mouse list.
  array<rpc_point> meese;
  mouser->get_mouse_list(meese);
  // chop the entries they don't care about.
  meese.zap(0, index - 1);
  // stuff the list into a block to return.
  byte_array to_return;
  mouser->push_in_mice(meese, to_return);
  return to_return;
}

void example_rpc_server::update()
{
  FUNCDEF("update");
  mouser->lock();
  LOG(istring(istring::SPRINTF, "updating %d clients...", client_list.length()));
  for (int i = 0; i < client_list.length(); i++)
    PostMessage(client_list[i].window, POINT_ALERT(), 0, 0);
  mouser->unlock();
}

void example_rpc_server::mouse_hit(const rpc_point &position)
{
  FUNCDEF("mouse_hit");
  mouser->add_dot(position);
  mouser->start_timer(50);
  LOG("got a hit, started timer.");
}

void example_rpc_server::process_client_request(const char *_transaction_name,
    const rpc_data_block &request, rpc_data_block &response)
{
  FUNCDEF("process_client_request");
  istring to_print(istring::SPRINTF, "request %s came with %d bytes of data.",
      _transaction_name, request.length);
  LOG(to_print);

  byte_array passed(request.length, request.data);

  byte_array found;
  istring transaction_name = _transaction_name;
  if (transaction_name == REGISTER_CLIENT) {
    found = register_client(passed);
  } else if (transaction_name == UNREGISTER_CLIENT) {
    found = unregister_client(passed);
  } else if (transaction_name == NEW_POINT) {
    found = add_point(passed);
  } else if (transaction_name == GET_LIST) {
    found = get_entire_list(passed);
  } else if (transaction_name == GET_PARTIAL) {
    found = get_partial_list(passed);
  } else {
    LOG(istring("unknown request: ") + transaction_name);
  }

  // if the reply is too big, truncate it to the given length.
  if (found.length() > response.length) {
    found.zap(response.length - 1, found.length() - 1);
    LOG("response too big for passed storage.  truncating it.");
  }

  // store the reply.
  found.stuff(found.length(), response.data);
  response.length = found.length();
}


/*
void example_rpc_server::server_thread(void *hidden_pointer)
{
  FUNCDEF("server_thread");
  #define alert the_server->alert
  example_rpc_server *the_server = (example_rpc_server *)hidden_pointer;
  rpc_common::outcomes outcome = the_server->setup(MAX_CLIENTS,
      rpc_common::LOCAL, "1", "");
  if (outcome != rpc_common::OKAY)
    KABOOM(istring("problem setting up rpc server: ")
        + rpc_common::outcome_name(outcome));

// question: does the maximum calls number have to be lower than the maximum
// number that was established above?
  outcome = the_server->accept_clients(1, MAX_CLIENTS + MAX_SLUSH, true);
    // at least one client must connect for service to be granted, the maximum
    // number of clients at once is specified by the configuration above,
    // and wait for clients to be serviced (don't return from thread until
    // server stops listening).
  if (outcome != rpc_common::OKAY)
    KABOOM(istring("problem accepting clients: ")
        + rpc_common::outcome_name(outcome));
  #undef alert
}
*/


// this is the root communication function between server and clients.
int named_byte_transaction(handle_t h, const byte *service, const byte *topic,
    int uid, const rpc_data_block *request, rpc_data_block *response)
{
  FUNCDEF("named_byte_transaction");
  if (!single_server_instance) {
    MessageBox(0, "named_byte_transaction has no server!", "Yikes!",
        MB_OK | MB_ICONWARNING);
    return 0;
  }
  if (!request || !response) {
    MessageBox(0, "named_byte_transaction got a nil data block!", "Yikes!",
        MB_OK | MB_ICONWARNING);
    return 0;
  }
  single_server_instance->process_client_request((char *)topic, *request,
      *response);
  return 0;
}

int ng_login(handle_t h, const byte *entity, int root_id, int *id)
{ return NG_RPC_OKAY; }

int ng_logout(handle_t h, int id) { return NG_RPC_OKAY; }

---