admin.cpp

可用该程序将avi的电影文件转化为TS流

      if(cTokenizer.CountTokens() != 2)
      {
        Log(m_hLog, LOG_ERROR, "Admin user \"" + strUserLogin + "\" not valid");
        iRc = GEN_ERR;
        break;
      }

      C_String strEncPasswd = cTokenizer.NextToken();
      C_String strGroup = cTokenizer.NextToken();

      C_AdminGroup* pGroup = m_cGroups.Get(strGroup);
      if(!pGroup)
      {
        Log(m_hLog, LOG_ERROR, "Admin user \"" + strUserLogin +
            "\" not valid (the group \"" + strGroup + "\" doesn't exists");
        iRc = GEN_ERR;
        break;
      }

      C_AdminUser* pUser = new C_AdminUser(strUserLogin, strEncPasswd, pGroup);
      ASSERT(pUser);

      Log(m_hLog, LOG_NOTE, "New admin user \"" + strUserLogin + "\" is ok");
      m_cUsers.Add(strUserLogin, pUser);
    }
  }

//  if(!iRc)
//    iRc = m_pNativeAdmin->Init();

  if(!iRc)
    iRc = m_pTelnet->Init();

  // Automatic launch of commands
  C_Vector<C_Setting> vLaunch = pApp->GetSettings("LaunchOnStartUp");

  for(unsigned int i = 0; i < vLaunch.Size(); i++)
  {
    C_String strCmd   = vLaunch[i].GetValue();

    Log(m_hLog, LOG_NOTE,"Executing " +vLaunch[i].GetName()+ " : '"
             + strCmd +"'");

    C_Request cRequest("");

    // Get input name and type
    C_Answer cAnswer = ParseCmdLine(NULL,vLaunch[i].GetValue(),cRequest);

    if (cAnswer.GetStatus() == ADMIN_WELLFORMED_COMMAND)
        cAnswer = HandleRequest(cRequest);
    
    C_List<C_String> cMessageList = cAnswer.GetMessages();

    unsigned int iSize = cMessageList.Size();
    for(unsigned int i = 0; i < iSize; i++)
    {
      Log(m_hLog, LOG_WARN,cMessageList[i]);
    }

  }
  return iRc;
}


//------------------------------------------------------------------------------
// Execution
//------------------------------------------------------------------------------
int C_Admin::Run()
{
//  int iRc = m_pNativeAdmin->Run();

  int iRc = 0;
  if(!iRc)
    iRc = m_pTelnet->Run();

  iRc |= FullStop();

  return iRc;
}


//------------------------------------------------------------------------------
// Stop the execution of the telnet daemon (main thread)
//------------------------------------------------------------------------------
int C_Admin::Stop()
{
  return m_pTelnet->Stop();
}

//------------------------------------------------------------------------------
// Stop the execution of the the remaining daemons
//------------------------------------------------------------------------------
int C_Admin::FullStop()
{
//  return m_pNativeAdmin->Stop();
  return 0;
}


//------------------------------------------------------------------------------
// Destruction
//------------------------------------------------------------------------------
int C_Admin::Destroy()
{
  int iRc = m_pTelnet->Destroy();
//  iRc |= m_pNativeAdmin->Destroy();
  return iRc;
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
int C_Admin::Authenticate(C_AdminSession *pSession,
                          const C_String& strLogin,
                          const C_String& strPasswd)
{
  C_AdminUser* pUser = m_cUsers.Get(strLogin);
  if(!pUser)
  {
    Log(m_hLog, LOG_WARN,
        "Authentication failed for user \"" + strLogin + "\"");
    return GEN_ERR;
  }

#ifdef _WIN32
  C_String strCrypt(strPasswd);
#else
  C_String strCrypt(crypt(strPasswd.GetString(),
                          pUser->m_strEncPasswd.GetString()));
#endif
  if(strCrypt == pUser->m_strEncPasswd.GetString())
  {
    Log(m_hLog, LOG_NOTE,
        "User \"" + strLogin + "\" successfully authenticated");
    pSession->m_strUser = strLogin;
    pSession->m_strGroup = strLogin;
    pSession->m_vCommands = pUser->m_pGroup->m_vCommands;
    return 0;
  }

  Log(m_hLog, LOG_WARN,
      "Authentication failed for user \"" + strLogin + "\"");
  return GEN_ERR;
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
C_Answer C_Admin::ParseCmdLine(C_AdminSession* pSession,
                               const C_String& strCmdLine,
                               C_Request& cRequest)
{
//  ASSERT(pSession);

  C_Answer cAnswer("Admin");

  // Hash the command line
  // #### to be replaced by a shell-like hash -- bozo
  C_Vector<C_String> vArgs;
  C_StringTokenizer cTokenizer(strCmdLine, ' ');
  while(cTokenizer.HasMoreToken())
  {
    C_String* pStr = new C_String(cTokenizer.NextToken());
    vArgs.Add(pStr);
  }

  // Empty command line ?
  if(vArgs.Size() == 0)
  {
    cAnswer.SetStatus(ADMIN_EMPTY_COMMAND);
    cAnswer.AddMessage(" empty command.");
    return cAnswer;
  }

  // Unknown command ?
  C_String strCmd = vArgs[0];
 
  C_CommandDesc* pCmdDesc = m_cCmdDescriptions.Get(strCmd);
  if(!pCmdDesc)
  {
    cAnswer.SetStatus(ADMIN_UNKNOWN_COMMAND);
    cAnswer.AddMessage(strCmd + ": unknown command.");
    return cAnswer;
  }

  // The user is not allowed to run this command ?
  if (pSession != NULL)
    if(pSession->m_vCommands.Find(strCmd) < 0)
    {
      cAnswer.SetStatus(ADMIN_COMMAND_DENIED);
      cAnswer.AddMessage(strCmd + ": permission denied.");
      return cAnswer;
    }

  // Command is OK, now parse the arguments
  C_Request cRq(strCmd);
  
  // Default boolean value is "0"
  unsigned int ui;
  for(ui = 0; ui < pCmdDesc->m_vBooleans.Size(); ui++)
    cRq.SetArg(pCmdDesc->m_vBooleans[ui], "0");

  int iError = 0;
  unsigned int uiMandatory = 0;
  unsigned int uiOptional = 0;

  for(ui = 1; ui < vArgs.Size(); ui++)
  {
    C_String strArg(vArgs[ui]);
    if(strArg.StartsWith("--"))
    {
      C_String strTmp(strArg.SubString(2, strArg.Length()));
      if(pCmdDesc->m_vOptions.Find(strTmp) >= 0)
      {
        // The argument is an option
        if(++ui < vArgs.Size())
        {
          cRq.SetArg(strTmp, vArgs[ui]);
        }
        else
        {
          // Missing value
          cAnswer.AddMessage(strCmd + ": missing value for option \"" +
                             strTmp + "\"");
          cAnswer.AddMessage(pCmdDesc->m_strUsage);
          iError = GEN_ERR;
          break;
        }
      }
      else if(pCmdDesc->m_vBooleans.Find(strTmp) >= 0)
      {
        // The argument is a boolean
        cRq.SetArg(strTmp, "1");
      }
      else if(pCmdDesc->m_bExtendedOptions)
      {
        // Extended option or boolean
        if(++ui < vArgs.Size())
        {
          strArg = vArgs[ui];
          if(strArg.StartsWith("--"))
          {
            // The argument is a boolean
            cRq.SetArg(strTmp, "1");
            ui--;
          }
          else
          {
            // The argument is an option
            cRq.SetArg(strTmp, vArgs[ui]);
          }
        }
        else
        {
          // The argument is a boolean
          cRq.SetArg(strTmp, "1");
        }
      }
      else
      {
        // Bad argument
        cAnswer.AddMessage(strCmd + ": unknown option \"" + strTmp + "\"");
        cAnswer.AddMessage(pCmdDesc->m_strUsage);
        iError = GEN_ERR;
        break;
      }
    }
    else
    {
      if(uiMandatory < pCmdDesc->m_vMandatoryArgs.Size())
      {
        // Mandatory argument
        cRq.SetArg(pCmdDesc->m_vMandatoryArgs[uiMandatory++], strArg);
      }
      else if(uiOptional < pCmdDesc->m_vOptionalArgs.Size())
      {
        // Optional argument
        cRq.SetArg(pCmdDesc->m_vOptionalArgs[uiOptional++], strArg);
      }
      else
      {
        // Standalone arguments overflow
        cAnswer.AddMessage(strCmd + ": too many arguments");
        cAnswer.AddMessage(pCmdDesc->m_strUsage);
        iError = GEN_ERR;
        break;
      }
    }
  }
  
  // Check if there are enough arguments
  if(uiMandatory < pCmdDesc->m_vMandatoryArgs.Size())
  {
    cAnswer.AddMessage(strCmd + ": too few arguments");
    cAnswer.AddMessage(pCmdDesc->m_strUsage);
    iError = GEN_ERR;
  }

  if(iError)
  {
    cAnswer.SetStatus(ADMIN_COMMAND_NOT_VALID);
  }
  else
  {
    cRequest = cRq;
    cAnswer.SetStatus(ADMIN_WELLFORMED_COMMAND);
  }

  return cAnswer;
}

//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
C_Answer C_Admin::ValidateRequest(C_AdminSession* pSession,
                                  C_Request& cRequest)
{
  ASSERT(pSession);

  C_Answer cAnswer("Admin");

  C_String strCmd = cRequest.GetCmd();

   // Empty command line ?
  if(strCmd.Length() == 0)
  {
    cAnswer.SetStatus(ADMIN_EMPTY_COMMAND);
    return cAnswer;
  }

  // Unknown command ?
  C_CommandDesc* pCmdDesc = m_cCmdDescriptions.Get(strCmd);
  if(!pCmdDesc)
  {
    cAnswer.SetStatus(ADMIN_UNKNOWN_COMMAND);
    cAnswer.AddMessage(strCmd + ": unknown command.");
    return cAnswer;
  }

  // The user is not allowed to run this command ?
  if(pSession->m_vCommands.Find(strCmd) < 0)
  {
    cAnswer.SetStatus(ADMIN_COMMAND_DENIED);
    cAnswer.AddMessage(strCmd + ": permission denied.");
    return cAnswer;
  }

  // Check arguments' validity
  //   - mandatory arguments shouldn't be empty;
  //   - booleans should be "0" or "1";
  //   - we don't check arguments which aren't in the description because we
  //     don't have access to the hashtable in the C_Request. It doesn't matter
  //     because they are ignored.
  int iError = 0;

  unsigned int ui;

  for(ui = 0; ui < pCmdDesc->m_vMandatoryArgs.Size(); ui++)
  {
    C_String strArg = cRequest.GetArg(pCmdDesc->m_vMandatoryArgs[ui]);
    if(strArg.Length() == 0)
    {
      cAnswer.AddMessage(strCmd + ": \"" +
                         pCmdDesc->m_vMandatoryArgs[ui] + "\" is mandatory");
      cAnswer.AddMessage(pCmdDesc->m_strUsage);
      iError = GEN_ERR;
    }
  }

  for(ui = 0; ui < pCmdDesc->m_vBooleans.Size(); ui++)
  {
    C_String strArg = cRequest.GetArg(pCmdDesc->m_vBooleans[ui]);
    if((strArg != "0") && (strArg != "1"))
    {
      cAnswer.AddMessage(strCmd + ": \"" +
                         strArg + " isn't a boolean value (\"0\" or \"1\")");
      cAnswer.AddMessage(pCmdDesc->m_strUsage);
      iError = GEN_ERR;
    }
  }


  if(iError)
    cAnswer.SetStatus(ADMIN_COMMAND_NOT_VALID);
  else
    cAnswer.SetStatus(ADMIN_WELLFORMED_COMMAND);

  return cAnswer;
}


//------------------------------------------------------------------------------
// Request treatment
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
C_Answer C_Admin::HandleRequest(const C_Request& cRequest)
{
  C_Answer cAnswer("Admin");

  if(m_bRequestsEnabled)
  {
    // Lock the mutex so that only one command can be processed at a time
    // No more needed, done in the manager
    m_cRequestLock.Lock();

    C_String strCmd = cRequest.GetCmd();
    if(strCmd == "help")
    {
      C_String strArg = cRequest.GetArg("command");
      if(strArg.Length() == 0)
      {
        cAnswer.SetStatus(NO_ERR);
        C_HashTableIterator<C_String, C_CommandDesc> cIterator =
                        m_cCmdDescriptions.CreateIterator();
        while(cIterator.HasNext())
        {
          C_HashTableNode<C_String, C_CommandDesc>* pNode =
                        cIterator.GetNext();
          C_CommandDesc* pCmdDesc = pNode->GetValue();
          cAnswer.AddMessage(pCmdDesc->m_strName + ": " + pCmdDesc->m_strHelp);
        }
      }
      else
      {
        C_CommandDesc* pCmdDesc = m_cCmdDescriptions.Get(strArg);
        if(pCmdDesc)
        {
          cAnswer.SetStatus(NO_ERR);
          cAnswer.AddMessage(pCmdDesc->m_strUsage);
          cAnswer.AddMessage(pCmdDesc->m_strLongHelp);
        }
        else
        {
          cAnswer.AddMessage(strArg + ": unknown command.");
        }
      }
    }
    else if(strCmd == "shutdown")
    {
      Log(m_hLog, LOG_NOTE, "Received 'shutdown' command: stopping vls");
      C_Application* pApp = C_Application::GetApp();
      pApp->Stop();

      cAnswer.SetStatus(NO_ERR);
      cAnswer.AddMessage("Shutdowning the server");
    }
    else
    {
      // Forward the request to the app
      cAnswer = m_pRequestHub->ForwardRequest(cRequest);
    }
  }
  else
  {
    cAnswer.SetStatus(GEN_ERR);
    cAnswer.AddMessage("Requests are disabled");
  }

  // Unlock the mutex to allow another request to be processed
  m_cRequestLock.UnLock();

  return cAnswer;
}

//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void C_Admin::HandleEvent(const C_Event& cEvent)
{
//  m_pNativeAdmin->PropagateEvent(cEvent);

  // To do: send something to the users loggued by telnet
}