database classes

		src/database.hh		\

		src/database.cc		\

		src/server.hh		\

		src/serer.cc

		src/server.cc

CLEANFILES= *~ '\#*'

#ifndef DATABASE_HH_

# define DATABASE_HH_

# include <list>

// Host

struct Host {

  string login;

  string pass;

  string ipv4;

  int level;

};

typedef std::list<Host> Hosts;

// Group

struct Group {

  string name;

  Hosts hosts;

};

typedef std::list<Group> Groups;

// User

struct User {

  string login;

  string pass;

  int level;

  bool priv;

};

typedef std::list<User> Users;

// Script

struct Script {

  string name;

  string path;

  int level;

};

typedef std::list<Script> Scripts;

// Alias

struct Alias {

  string name;

  string val;

};

typedef std::list<Alias> Aliases;

// Data container

class Database {

};

#endif

//

// server.cc for sls

//

// Made by Seblu

// Login   <seblu@epita.fr>

//

// Started on  Tue Jun  5 21:51:38 2007 Seblu

// Last update Thu Jun  7 03:41:02 2007 Seblu

//

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <errno.h>

#include "sls.hh"

const int SLServer::backlog = 10;

// -----------------------------------------------------------------------------

// PUBLIC METHODS

// -----------------------------------------------------------------------------

SLServer::SLServer(int port) : port_ (port)

{

  connect();

}

int

SLServer::run()

{

  return 0;

}

/*!

** Add a access to server

**

** @param login login to add

** @param pw_server server password

** @param pw_client client password

** @param priv client privilege

*/

void

SLServer::add_access(const char *login, const char *pw_server,

		    const char *pw_client, int priv)

{

  AccessData &newdata = *new AccessData();

  newdata.server_pw = string(pw_server);

  newdata.client_pw = string(pw_client);

  newdata.privilege = priv;

  accessDB_[string(login)] = &newdata;

}

/*!

** Delete an access

**

** @param login access login to delete

*/

void

SLServer::del_access(const string &login)

{

  //TODO

  std::cout << "should delete"<< login << std::endl;

}

/*!

** Print internal server access database to stdout

*/

void

SLServer::print_access() const

{

  for (AccessMap::const_iterator i = accessDB_.begin();

       i != accessDB_.end();

       ++i) {

    std::cout << "Login: " << (*i).first << std::endl;

    std::cout << "Server pass: " << (*i).second->server_pw << std::endl;

    std::cout << "Client pass: " << (*i).second->client_pw << std::endl;

    std::cout << "Privilege level: " << (*i).second->privilege << std::endl;

    std::cout << std::endl;

  }

}

// -----------------------------------------------------------------------------

// PROTECTED METHODS

// -----------------------------------------------------------------------------

void

SLServer::connect()

{

  int sockfd;

  struct sockaddr_in my_addr,their_addr;

  //create socket

  if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {

    Error *err = new Error();

    *err << "Unable to create socket: " << strerror(errno) << ".";

    throw *err;

  }

  //fill local ip property

  my_addr.sin_family = AF_INET;

  my_addr.sin_port = htons(port_);

  my_addr.sin_addr.s_addr = htonl(INADDR_ANY);

  memset(my_addr.sin_zero, 0, sizeof my_addr.sin_zero);

  // don't forget your error checking for bind():

  if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) {

    Error *err = new Error();

    *err << "Unable to bind : " << strerror(errno) << ".";

    close(sockfd);

    throw *err;

  }

  // listen the wire

  if (listen(sockfd, SLServer::backlog) == -1) {

    Error *err = new Error();

    *err << "Unable to listen : " << strerror(errno) << ".";

    close(sockfd);

    throw *err;

  }

  socklen_t sin_size = sizeof(struct sockaddr_in);

  accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);

  //  sleep(10);

}