ArServerUserInfo.cpp

Go to the documentation of this file.

/*
MobileRobots Advanced Robotics Interface for Applications (ARIA)
Copyright (C) 2004, 2005 ActivMedia Robotics LLC
Copyright (C) 2006, 2007 MobileRobots Inc.

     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 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

If you wish to redistribute ARIA under different terms, contact 
MobileRobots for information about a commercial version of ARIA at 
robots@mobilerobots.com or 
MobileRobots Inc, 19 Columbia Drive, Amherst, NH 03031; 800-639-9481
*/

#include "Aria.h"
#include "ArExport.h"
#include "ArServerUserInfo.h"
#include "md5.h"

AREXPORT ArServerUserInfo::ArServerUserInfo(const char *baseDirectory) :
  myV1HeaderCB(this, &ArServerUserInfo::v1HeaderCallback),
  myV1UserCB(this, &ArServerUserInfo::v1UserCallback),
  myV1DoNotUseCB(this, &ArServerUserInfo::v1DoNotUseCallback)
{
  myParser.setBaseDirectory(baseDirectory);
  myGotHeader = false;
  myDoNotUse = false;
}

AREXPORT ArServerUserInfo::~ArServerUserInfo()
{

}

AREXPORT void ArServerUserInfo::setBaseDirectory(const char *baseDirectory)
{
  myDataMutex.lock();
  myParser.setBaseDirectory(baseDirectory);
  myDataMutex.unlock();
}


bool ArServerUserInfo::v1HeaderCallback(ArArgumentBuilder * arg)
{
  removeHandlers();
  if (myParser.addHandler("user", &myV1UserCB) && 
      myParser.addHandler("doNotUse", &myV1DoNotUseCB))
  {
    myGotHeader = true;
    myDoNotUse = false;
    return true;
  }
  else
  {
    ArLog::log(ArLog::Terse, "ArServerUserInfo::Could not add user info callback");
    return false;
  }
}

bool ArServerUserInfo::v1UserCallback(ArArgumentBuilder * arg)
{
  if (arg->getArgc() < 2)
  {
    ArLog::log(ArLog::Normal, "ArServerUserInfo: Not enough arguments to user info 'user <user> <password> <reapingOptional:group>");
    return false;
  }

  const char *user;
  const char *password;
  user = arg->getArg(0);
  if (!ArUtil::isOnlyAlphaNumeric(user))
  {
    ArLog::log(ArLog::Normal, "ArServerUserInfo: user has non-alpha-numeric characters in it");
    return false;
  }
  password = arg->getArg(1);
  if (!ArUtil::isOnlyAlphaNumeric(password))
  {
    ArLog::log(ArLog::Normal, "ArServerUserInfo: password has non-alpha-numeric characters in it");
    return false;
  }
  
  if (myPasswords.find(user) != myPasswords.end())
  {
    ArLog::log(ArLog::Terse, "ArServerUserInfo: Already a user with name %s", user);
    return false;
  }
  //printf("Adding user %s with password %s and groups\n", user, password);
  myPasswords[user] = password;
  
  std::set<std::string, ArStrCaseCmpOp> *groups;
  groups = new std::set<std::string, ArStrCaseCmpOp>;
  myGroups[user] = groups;
  
  unsigned int i;
  for (i = 2; i < arg->getArgc(); i++)
  {
    groups->insert(arg->getArg(i));
  }
  return true;
}

bool ArServerUserInfo::v1DoNotUseCallback(ArArgumentBuilder * arg)
{
  myDoNotUse = true;
  return true;
}

void ArServerUserInfo::removeHandlers(void)
{
  myParser.remHandler(&myV1HeaderCB);
  myParser.remHandler(&myV1UserCB);
}

AREXPORT bool ArServerUserInfo::readFile(const char *fileName)
{
  myDataMutex.lock();
  removeHandlers();
  myPasswords.clear();
  ArUtil::deleteSetPairs(myGroups.begin(), myGroups.end());
  myGroups.clear();
  myParser.addHandler("UserInfoVersion1", &myV1HeaderCB);
  myGotHeader = false;
  if (!myParser.parseFile(fileName, false))
  {
    myDataMutex.unlock();
    ArLog::log(ArLog::Terse, "Problem loading server user info");
    return false;
  }
  removeHandlers();
  if (myGotHeader)
  {
    myDataMutex.unlock();
    ArLog::log(ArLog::Verbose, "Loaded server user info");
    return true;
  }
  else
  {
    myDataMutex.unlock();
    ArLog::log(ArLog::Normal, "Problem loading server user info: no header");
    return false;
  }
}

AREXPORT bool ArServerUserInfo::matchUserPassword(
        const char *user, unsigned char password[16], const char *passwordKey,
        const char *serverKey) const
{
  std::map<std::string, std::string, ArStrCaseCmpOp>::const_iterator it;
  if (!ArUtil::isOnlyAlphaNumeric(user))
  {
    ArLog::log(ArLog::Normal, 
               "ArServerUserInfo: login denied: user '%s' has non alpha-numeric characters", 
               user);
    return false;
  }
  it = myPasswords.find(user);
  if (it == myPasswords.end())
  {
    ArLog::log(ArLog::Normal, "ArServerUserInfo: login denied: No user %s", 
               user);
    return false;
  }
  /*  thd old simple clear text way
  if (ArUtil::strcmp((*it).second, password) != 0)
  {
    ArLog::log(ArLog::Normal, 
               "ArServerUserInfo: login denied: Wrong password for user %s", 
               user);
    return false;
    }*/
  md5_state_t md5State;
  unsigned char md5Digest[16];

  md5_init(&md5State);
  md5_append(&md5State, (unsigned char *)serverKey, strlen(serverKey));
  md5_append(&md5State, (unsigned char *)passwordKey, strlen(passwordKey));
  md5_append(&md5State, (unsigned char *)(*it).second.c_str(), 
             (*it).second.size());
  md5_finish(&md5State, md5Digest);
  
  if (memcmp(md5Digest, password, 16) != 0)
  {
    ArLog::log(ArLog::Normal, 
               "ArServerUserInfo: login denied: Wrong password for user %s", 
               user);
    return false;
  }
  return true;
}

AREXPORT std::set<std::string, ArStrCaseCmpOp> 
ArServerUserInfo::getUsersGroups(const char *user) const
{
  std::map<std::string, std::set<std::string, ArStrCaseCmpOp> *, ArStrCaseCmpOp>::const_iterator sit;
  std::set<std::string, ArStrCaseCmpOp> ret;
  
  if ((sit = myGroups.find(user)) == myGroups.end())
  {
    ArLog::log(ArLog::Terse, "No user %s", user);
    return ret;
  }
  
  ret = *((*sit).second);
  return ret;
}

AREXPORT void ArServerUserInfo::logUsers(void) const
{
  std::map<std::string, std::string, ArStrCaseCmpOp>::const_iterator it;
  std::set<std::string, ArStrCaseCmpOp> groups;
  std::set<std::string, ArStrCaseCmpOp>::const_iterator git;
  std::string line;
  if (myDoNotUse)
    ArLog::log(ArLog::Terse, "The user info should not be used");
  else
    ArLog::log(ArLog::Terse, "The user info should be used");
  for (it = myPasswords.begin(); it != myPasswords.end(); it++)
  {
    line = "User ";
    line += (*it).first;
    line += " has groups:";

    groups = getUsersGroups((*it).first.c_str());
      /*
    if ((sit = myGroups.find((*it).first)) == myGroups.end())
    {
      ArLog::log(ArLog::Terse, "ArServerUserInfo::logUsersAndGroups: Hideous error with the groups of user '%s'", (*it).first.c_str());
      continue;
    } 
    groups = (*sit).second;
      */
    for (git = groups.begin(); git != groups.end(); git++)
    {
      line += " ";
      line += (*git);
    }
    ArLog::log(ArLog::Terse, line.c_str());
  }
}

AREXPORT bool ArServerUserInfo::doNotUse(void) const
{
  return myDoNotUse;
}

---