dnxProtocol.c

Go to the documentation of this file.

/*--------------------------------------------------------------------------

   Copyright (c) 2006-2007, Intellectual Reserve, Inc. All rights reserved.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation.

   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

  --------------------------------------------------------------------------*/

#include "dnxProtocol.h"

#include "dnxError.h"
#include "dnxDebug.h"
#include "dnxTransport.h"
#include "dnxXml.h"
#include "dnxLogging.h"

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <syslog.h>
#include <assert.h>

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

int dnxMakeXID(DnxXID * pxid, DnxObjType xType, unsigned long xSerial,
      unsigned long xSlot)
{
   assert(pxid && xType >= 0 && xType < DNX_OBJ_MAX);

   pxid->objType   = xType;
   pxid->objSerial = xSerial;
   pxid->objSlot   = xSlot;

   return DNX_OK;
}

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

int dnxEqualXIDs(DnxXID * pxa, DnxXID * pxb)
{
   return pxa->objType == pxb->objType
         && pxa->objSerial == pxb->objSerial
         && pxa->objSlot == pxb->objSlot;
}

//--------------------------------------------------------------------------*/

int dnxSendMgmtRequest(DnxChannel * channel, DnxMgmtRequest * pRequest)
{
   DnxXmlBuf xbuf;

   assert(channel && pRequest);

   // create the XML message
   dnxXmlOpen (&xbuf, "MgmtRequest");
   dnxXmlAdd  (&xbuf, "XID",    DNX_XML_XID, &pRequest->xid);
   dnxXmlAdd  (&xbuf, "GUID",   DNX_XML_XID, &pRequest->xid);  // old format - for bc
   dnxXmlAdd  (&xbuf, "Action", DNX_XML_STR,  pRequest->action);
   dnxXmlClose(&xbuf);

   dnxDebug(3, "dnxSendMgmtRequest: XML msg(%d bytes)=%s.", 
         xbuf.size, xbuf.buf);

   // send it on the specified channel
   return dnxPut(channel, xbuf.buf, xbuf.size, 0, 0);
}

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

int dnxSendMgmtReply(DnxChannel * channel, DnxMgmtReply * pReply, 
      char * address)
{
   DnxXmlBuf xbuf;
   char addrstr[DNX_MAX_ADDRSTR];

   assert(channel && pReply);

   // create the XML message
   dnxXmlOpen (&xbuf, "MgmtReply");
   dnxXmlAdd  (&xbuf, "XID",    DNX_XML_XID, &pReply->xid);
   dnxXmlAdd  (&xbuf, "Status", DNX_XML_INT, &pReply->status);
   dnxXmlAdd  (&xbuf, "Result", DNX_XML_STR,  pReply->reply);
   dnxXmlClose(&xbuf);

   dnxDebug(3, "dnxSendMgmtReply: XML msg(%d bytes) = %s to %s.", 
         xbuf.size, xbuf.buf, dnxNtop(address, addrstr, sizeof addrstr));
   
   // send it on the specified channel
   return dnxPut(channel, xbuf.buf, xbuf.size, 0, address);
}

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

int dnxWaitForMgmtReply(DnxChannel * channel, DnxMgmtReply * pReply, int timeout)
{
   DnxXmlBuf xbuf;
   int ret;

   assert(channel && pReply);

   memset(pReply, 0, sizeof *pReply);

   // await a message from the specified channel
   xbuf.size = sizeof xbuf.buf - 1;
   if ((ret = dnxGet(channel, xbuf.buf, &xbuf.size, timeout, 0)) != DNX_OK)
      return ret;

   // decode the XML message
   xbuf.buf[xbuf.size] = 0;
   dnxDebug(3, "dnxWaitForMgmtReply: XML msg(%d bytes)=%s.", xbuf.size, xbuf.buf);

   // verify this is a "MgmtRequest" message
   if ((ret = dnxXmlCmpStr(&xbuf, "Request", "MgmtReply")) != DNX_OK)
      return ret;

   // decode the Manager's XID.
   if ((ret = dnxXmlGet(&xbuf, "XID", DNX_XML_XID, &pReply->xid)) != DNX_OK)
      return ret;

   // decode the Manager's XID.
   if ((ret = dnxXmlGet(&xbuf, "Status", DNX_XML_INT, &pReply->status)) != DNX_OK)
      return ret;

   // decode the management request
   return dnxXmlGet(&xbuf, "Result", DNX_XML_STR, &pReply->reply);
}

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

int dnxWaitForMgmtRequest(DnxChannel * channel, DnxMgmtRequest * pRequest,
      char * address, int timeout)
{
   DnxXmlBuf xbuf;
   int ret;
   char addrstr[DNX_MAX_ADDRSTR];
   assert(channel && pRequest);

   memset(pRequest, 0, sizeof *pRequest);

   // await a message from the specified channel
   xbuf.size = sizeof xbuf.buf - 1;
   if ((ret = dnxGet(channel, xbuf.buf, &xbuf.size, timeout, address)) != DNX_OK)
      return ret;

   // decode the XML message
   xbuf.buf[xbuf.size] = 0;
   dnxNtop(address, addrstr, sizeof addrstr);
   dnxDebug(3, "dnxWaitForMgmtRequest: XML msg(%d bytes)=%s. from %s", 
         xbuf.size, xbuf.buf, addrstr);

   // verify this is a "MgmtRequest" message
   if ((ret = dnxXmlCmpStr(&xbuf, "Request", "MgmtRequest")) != DNX_OK)
      return ret;

   // decode the Manager's XID (support older GUID format as well).
   if ((ret = dnxXmlGet(&xbuf, "XID", DNX_XML_XID, &pRequest->xid)) != DNX_OK
         && (ret = dnxXmlGet(&xbuf, "GUID", DNX_XML_XID, &pRequest->xid)) != DNX_OK)
      return ret;

   // decode the management request
   return dnxXmlGet(&xbuf, "Action", DNX_XML_STR, &pRequest->action);
}

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