/*
 * CM_STATE.C - q931 state managment code
 */

#include <ndis.h>
#include <ndiswan.h>
#include <mytypes.h>
#include <mydefs.h>
#include <disp.h>
#include <util.h>
#include <opcodes.h>
#include <adapter.h>
#include <idd.h>
#include <mtl.h>
#include <cm.h>

#include <ansihelp.h>

/* (ans) process incoming connections */
INT
cm__ans_est_ind(CM_CHAN *chan, IDD_MSG *msg, VOID *idd, USHORT lterm)
{
    USHORT  bchan, type, cid;
   INT   RetCode;
    
   D_LOG(D_ENTRY|DIGIQ931, ("cm__ans_est_ind: entry, chan: 0x%lx, msg: 0x%lx\n", \
                                   chan, msg));

    cid = HIWORD(msg->bufid);

    /* must not have a channel at this time */
    if ( chan )
    {
      D_LOG(D_ALWAYS|DIGIQ931, ("cm__ans_est_ind: on used channel, ignored!\n"));

      RetCode = CM_E_BADPARAM;

      //
      // we need to let the adapter know that we are not processing
      // this incoming call indication
      //
      ignored:

      /* answer channel */
      cm__est_ignore(idd, cid, lterm);

        return(RetCode);
    }

    /* extract info out of message, must have bchan/type */
    if ( (cm__get_bchan(msg, &bchan) != CM_E_SUCC) ||
         (cm__get_type(msg, &type) != CM_E_SUCC) )
    {
      D_LOG(D_ALWAYS|DIGIQ931, ("cm__ans_est_ind: bchan or type missing, ignored!\n"));

      RetCode = CM_E_BADPARAM;
      goto ignored;
    }

    if ( !CM_BCHAN_ASSIGNED(bchan) )
    {
      D_LOG(D_ALWAYS|DIGIQ931, ("cm__ans_est_ind: bchan: %d, unassigned, ignored!\n",\
                                bchan));
      RetCode = CM_E_BADPARAM;
      goto ignored;
    }

   D_LOG(D_ALWAYS|DIGIQ931, ("cm__ans_est_ind: cid: 0x%x, bchan: %d, type: 0x%d\n",\
                                               cid, bchan, type));

    /* channel will be answered only if a listening profile exists */
    if ( !cm__find_listen_conn("*", "*", "*", idd) )
    {
      D_LOG(D_ALWAYS|DIGIQ931, ("cm__ans_est_ind: not listening profile, ignored!\n"));
      RetCode = CM_E_NOSUCH;
      goto ignored;
    }

    /* allocate a channel out of incoming channel poll */
    if ( !(chan = cm__chan_alloc()) )
    {
      D_LOG(D_ALWAYS|DIGIQ931, ("cm__ans_est_ind: no channel slot, ignored!\n"));
      RetCode = CM_E_NOSLOT;
      goto ignored;
    }

    /* fillup channel structure */
    NdisZeroMemory(chan, sizeof(*chan));
    chan->idd = idd;
    chan->lterm = lterm;
    chan->bchan = bchan;    
    chan->type = type;
    chan->speed = cm__type2speed(type);
    chan->ustate = CM_US_UNDEF;
    chan->cid = cid;
    chan->timeout = ut_time_now();

    /* extract caller address, if present */
    if ( cm__get_addr(msg, chan->addr) != CM_E_SUCC )
        __strcpy(chan->addr, "<unknown>");

   D_LOG(D_ALWAYS|DIGIQ931, ("cm__ans_est_ind: caller address is: %s\n", \
                                                          chan->addr));

    /* answer channel */
    cm__est_rsp(chan);

    /* return succ */
    return(CM_E_SUCC);
}

/* (ans) process state indications */
INT
cm__ans_state_ind(CM_CHAN *chan, IDD_MSG *msg)
{
   D_LOG(D_ENTRY|DIGIQ931, ("cm__ans_state_ind: entry, chan: 0x%lx, msg: 0x%lx\n", \
                                   chan, msg));

    /* log state change */
    chan->ustate = LOWORD(msg->bufid);
   D_LOG(D_ALWAYS|DIGIQ931, ("cm__ans_state_ind: ustate: %d\n", chan->ustate));

   /* if changed to U0, has been released */
    if ( !chan->ustate )
    {
      cm__bchan_ctrl(chan, 0);
        cm__chan_free(chan);
        return(CM_E_SUCC);
    }

    /* if changed to U10, just got connected, open data path */
    if ( chan->ustate == 10 )
    {
        cm__bchan_ctrl(chan, 1);
        chan->timeout = ut_time_now();
        return(CM_E_SUCC);
    }

    /* else ignore */
    return(CM_E_SUCC);
}

/* (ans) process data indications */
INT
cm__ans_data_ind(CM_CHAN *chan, IDD_MSG *msg)
{
    CM_UUS      *uus;
    ULONG       chan_num, n;
    UCHAR       cause;
    CM          *cm;
   ULONG    CompressionFlag = 0;
   IDD_MSG     msg1;
    
   D_LOG(D_ENTRY|DIGIQ931, ("cm__ans_data_ind: entry, chan: 0x%lx, msg: 0x%lx\n", \
                            chan, msg));

   /* assign UUS pointer & do some basic checks */
    uus = (CM_UUS*)msg->bufptr;
    if ( msg->buflen < CM_UUS_SIZE )
        return(CM_E_BADUUS);

    if ( (uus->pkt_type != CM_PKT_TYPE) ||
         (uus->prot_desc != CM_PROT_DESC) ||
         (cm__calc_chksum(uus, CM_UUS_SIZE) != 0) )
        return(CM_E_BADUUS);

    /* channel must be atleast connected */
    if ( chan->ustate < 10 )
        return(CM_E_BADSTATE);

    /* if channel already accepted assoc, accept again (other side lost) */
    if ( chan->ustate == CM_US_UUS_OKED )
    {
     D_LOG(D_ALWAYS|DIGIQ931, ("cm__ans_data_ind: chan_num->ustate: %d\n", chan->ustate));
        accept:
        chan->ustate = CM_US_UUS_OKED;
        chan->timeout = ut_time_now();
        cm__tx_uus_pkt(chan, CM_ASSOC_ACK, 0);
        return(CM_E_SUCC);
    }

    /* record information from uus */
   NdisMoveMemory (chan->DstAddr, uus->src_addr, 6);

    chan->remote_conn_index = uus->conn;

   //
   // kill dead man timer for this channel
   //
   NdisZeroMemory(&msg1, sizeof(IDD_MSG));
   msg1.opcode = Q931_CAN_TU10_RQ;
   msg1.bufptr = ut_get_buf();
   msg1.buflen = 0;
   msg1.bufid = MAKELONG(0, chan->cid);

    /* send to idd */
    if (idd_send_msg(chan->idd, &msg1, (USHORT)CM_PORT(chan), (VOID*)cm__q931_cmpl_handler, NULL) != IDD_E_SUCC)
        ut_free_buf(msg1.bufptr);


    /* if not last channel, accept */
    chan_num = 0;
    cm__chan_foreach(cm__inc_chan_num, chan, &chan_num);
    if ( (UCHAR)chan_num < uus->channum )
   {
      D_LOG(D_ALWAYS|DIGIQ931, ("cm__ans_data_ind: chan_num: %d, uus->channum: %d\n", chan_num, uus->channum));
        goto accept;
   }

        
    /* last channel, find matching connection/profile */
    if ( !(cm = cm__find_listen_conn(uus->lname, uus->rname, chan->addr, chan->idd)) )
    {
        /* none found, reject */
        cause = CM_NO_PROF;
      D_LOG(D_ALWAYS|DIGIQ931, ("cm__ans_data_ind: rejected, cause: %d\n", cause));
        cm__tx_uus_pkt(chan, CM_ASSOC_NACK, cause);
        return(CM_E_NOSUCH);
    }    
    
    /* matching connection found!, fillin */
   D_LOG(D_ALWAYS|DIGIQ931, ("cm__ans_data_ind: matching connection: cm: 0x%lx\n", cm));

    cm->state = CM_ST_IN_ANS;
   cm->StateChangeFlag = TRUE;
    cm->was_listen = TRUE;
    cm->active_chan_num = chan_num;
    cm->remote_conn_index = chan->remote_conn_index;
   cm->ConnectionType = CM_DKF;
   NdisMoveMemory(cm->DstAddr, chan->DstAddr, 6);
   NdisMoveMemory (cm->remote_name, uus->rname, sizeof(cm->remote_name));

    cm->timeout = cm->rx_last_frame_time = cm->tx_last_frame_time =
                                            ut_time_now();

    /* accept channel here */                                            
    chan->ustate = CM_US_UUS_OKED;
    chan->timeout = ut_time_now();
    chan->cm = cm;
    cm__tx_uus_pkt(chan, CM_ASSOC_ACK, 0);

    
    /* collect channels info local vector */
    cm->dprof.chan_num = 0;
    cm__chan_foreach(cm__add_chan, chan, cm);
  
    /* init channel fields */
    for ( n = 0 ; n < cm->dprof.chan_num ; n++)
    {
        CM_CHAN     *chan = cm->dprof.chan_tbl + n;

        chan->ustate = CM_US_CONN;
        chan->timeout = ut_time_now();
        chan->num = (USHORT)n;
        chan->cm = cm;
        chan->active = TRUE;        
    }

    /* make connection active */
    cm->state = CM_ST_ACTIVE;
   cm->StateChangeFlag = TRUE;

   // Set compression Flag
   if (cm->dprof.HWCompression && (uus->option_0 & UUS_0_COMPRESSION))
      CompressionFlag = 1;
   else
      CompressionFlag = 0;

   D_LOG(D_ALWAYS|DIGIQ931, ("cm__ans_data_ind: Activating connection for cm: 0x%lx\n", cm));
    return(cm__activate_conn(cm, CompressionFlag));
}    
    
/* (org) new cid indicated on outgoing channel */
INT
cm__org_cid_ind(CM_CHAN *chan, IDD_MSG *msg)
{
    CM          *cm;
    USHORT      conn_num, chan_num, cid;
    
   D_LOG(D_ENTRY|DIGIQ931, ("cm__org_cid_ind: entry, chan: 0x%lx, msg: 0x%lx\n", \
                                   chan, msg));

    /* extract conn_num/chan_num out of param 3, get cid */
    conn_num = HIBYTE(LOWORD(msg->bufid));
    chan_num = LOBYTE(LOWORD(msg->bufid));
    cid = HIWORD(msg->bufid);
   D_LOG(D_ALWAYS|DIGIQ931, ("cm__org_cid_ind: conn_num: %d, chan_num: %d, cid: 0x%x\n", conn_num, chan_num, cid));

// DbgPrint("cid_ind: conn_num: %d, chan_num: %d, cid: 0x%x\n",
//                   conn_num, chan_num, cid);

    /* get related connection */
    if ( !(cm = cm__get_conn(conn_num)) )
   {
//    DbgPrint("cid_ind: cm__get_conn failed!\n");
        return(CM_E_BADPARAM);
   }
        
    /* get related channel */
    if ( chan_num >= cm->dprof.chan_num )
   {
//    DbgPrint("cid_ind: invalid chan_num!\n");
        return(CM_E_BADPARAM);
   }
    else
        chan = cm->dprof.chan_tbl + chan_num;

    /* check channel ustate */
    if ( chan->ustate != CM_US_WAIT_CID )
   {
//    DbgPrint("cid_ind: invalid ustate (%d)!\n", chan->ustate);
        return(CM_E_BADSTATE);
   }
    
    /* cid == 0, no free slots at idp, simulate state change to 0 */
    if ( !cid )
   {
      cm->NoActiveLine = 1;
        return(cm__org_state_ind(chan, NULL));
   }

    /* assign params */
    chan->ustate = CM_US_UNDEF;
    chan->cid = cid;
// DbgPrint("cid_ind: ustate: %d, cid: 0x%x assigned\n", chan->ustate, chan->cid);

    return(CM_E_SUCC);
}

/* (org) process state indications */
INT
cm__org_state_ind(CM_CHAN *chan, IDD_MSG *msg)
{
    CM     *cm;
    ULONG   n;
    USHORT  gave_up_num, chan_num;
   ULONG    CompressionFlag;
    
   D_LOG(D_ENTRY|DIGIQ931, ("cm__org_state_ind: entry, chan: 0x%lx, msg: 0x%lx\n", \
                                   chan, msg));

    /* check for change of state at protocol level */
    if ( !chan )
    {
        /* not used for now */
        return(CM_E_NOTIMPL);
    }

    /* log change */
    cm = chan->cm;
                    
    chan->ustate = msg ? LOWORD(msg->bufid) : 0;

   D_LOG(DIGIQ931,("cm__org_state_ind: cm 0x%lx, ustate: 0x%x\n", \
                  cm, chan->ustate));

    /* if changed to U0, has been released, may retry connection here */
    if ( !chan->ustate )
    {
      /* turn off bchannel */
      cm__bchan_ctrl(chan, 0);

        /* if not in activation, this is a fatal error, disconnect */
        if ( cm->state != CM_ST_IN_ACT )
        {
            disc_all:

            for ( n = 0 ; n < cm->dprof.chan_num ; n++ )
            {
                CM_CHAN     *chan1 = cm->dprof.chan_tbl + n;

                if ( chan1->ustate > 0 )
                    cm__disc_rq(chan1);
            }

            /* deactivate connection */
            cm__deactivate_conn(cm, 0);

            return(CM_E_SUCC);
        }

        /* attampt to retry */
        if ( !cm->dprof.fallback ||
         (cm->CauseValue == 0x11 || cm->SignalValue == 0x04) ||
         (cm__get_next_chan(chan) != CM_E_SUCC) )
        {
            chan->ustate = CM_US_GAVE_UP;
            chan->gave_up = 1;
        }
        else
        {
            /* if here, retrying */
            chan->cid = MAKEWORD(chan->num, cm->local_conn_index);
            chan->ustate = CM_US_WAIT_CID;
            chan->timeout = ut_time_now();

            cm__est_rq(chan);
        }

        /* find out how many channels gave up (or connected) */
        check_chan:
        for ( n = gave_up_num = 0 ; n < cm->dprof.chan_num ; n++ )
            if ( cm->dprof.chan_tbl[n].gave_up )
                gave_up_num++;
            else if ( cm->dprof.chan_tbl[n].ustate != CM_US_WAIT_CONN )
                break;

      /* if broke out of loop before hitting chan_num, some channels
         are still in progress */
      if ( n < cm->dprof.chan_num )
         return(CM_E_SUCC);

        /* if all gave up, give up conn */
        if ( gave_up_num >= cm->dprof.chan_num )
        {
            cm__deactivate_conn(cm, 0);
            return(CM_E_SUCC);
        }

        /* if here, some channels connected and some gave up, continue */
        chan_num = cm->dprof.chan_num - gave_up_num;

        /* if fallback set to no, must match */
        if ( !cm->dprof.fallback && (chan_num != cm->dprof.chan_num) )
            goto disc_all;

        /* connection enters in_sync state */
        cm->state = CM_ST_IN_SYNC;
      cm->StateChangeFlag = TRUE;
        cm->timeout = ut_time_now();

      /* compact channel table & renumber */
      for ( n = 0 ; n < cm->dprof.chan_num ; n++ )
      {
         CM_CHAN     *chan1 = cm->dprof.chan_tbl + n;

         if ( chan1->gave_up )
         {
            NdisMoveMemory(cm->dprof.chan_tbl + n,
                        cm->dprof.chan_tbl + n + 1,
                        sizeof(CM_CHAN) * (cm->dprof.chan_num - n - 1));
             cm->dprof.chan_num--;
            n--;
         }
      }
      for ( n = 0 ; n < cm->dprof.chan_num ; n++ )
         cm->dprof.chan_tbl[n].num = (USHORT)n;

      if (cm->ConnectionType == CM_DKF)
      {
         //
         // if this is a uus connnection tx uus frames
         //
         /* send initial uus_rq on all active channels */
         for ( n = 0 ; n < cm->dprof.chan_num ; n++ )
         {
            CM_CHAN     *chan1 = cm->dprof.chan_tbl + n;
   
            if ( chan1->gave_up )
               continue;
   
            chan1->timeout = ut_time_now();
            chan1->ustate = CM_US_UUS_SEND;
   
            cm__tx_uus_pkt(chan1, CM_ASSOC_RQ, 0);            
         }
      }
      else
      {
         //
         // if this is a ppp connection mark channels
         // as being connected and activate the connection
         //
         for ( n = 0 ; n < cm->dprof.chan_num ; n++ )
         {
            CM_CHAN     *chan1 = cm->dprof.chan_tbl + n;
   
            if ( chan1->gave_up )
               continue;

            chan1->ustate = CM_US_CONN;
            chan1->timeout = ut_time_now();
            chan1->remote_conn_index = 1;
         }
         NdisZeroMemory(cm->DstAddr, sizeof(cm->DstAddr));
         NdisZeroMemory(cm->remote_name, sizeof(cm->remote_name));
   
         /* make connection active now */
         cm->state = CM_ST_ACTIVE;
         cm->StateChangeFlag = TRUE;
         CompressionFlag = 0;

         return (cm__activate_conn(cm, CompressionFlag));
      }

        return(CM_E_SUCC);
    }

    /* if change state to U10 just connected */
    if ( chan->ustate == 10 )
    {
        /* start data transfer on channel */
        cm__bchan_ctrl(chan, 1);
        chan->ustate = CM_US_WAIT_CONN;
        chan->timeout = ut_time_now();

        /* see if all channels are connected, continue as a change to U0 */
        goto check_chan;
    }
}                                    

/* (org) process data indications */
INT
cm__org_data_ind(CM_CHAN *chan, IDD_MSG *msg)
{
    CM_UUS      *uus;
    CM          *cm = chan->cm;
    ULONG       n, first;
   ULONG    CompressionFlag;
    
   D_LOG(D_ENTRY|DIGIQ931, ("cm__org_data_ind: entry, chan: 0x%lx, msg: 0x%lx\n", \
                                   chan, msg));


   /* assign UUS pointer & do some basic checks */
    uus = (CM_UUS*)msg->bufptr;
    if ( msg->buflen < CM_UUS_SIZE )
        return(CM_E_BADUUS);
    if ( (uus->pkt_type != CM_PKT_TYPE) ||
         (uus->prot_desc != CM_PROT_DESC) ||
         (cm__calc_chksum(uus, CM_UUS_SIZE) != 0) )
        return(CM_E_BADUUS);

    /* channel must be atleast connected */
    if ( chan->ustate < 10 )
        return(CM_E_BADSTATE);

    /* if is a request, channel is part of a listening conn */
    if ( uus->opcode == CM_ASSOC_RQ )
    {
        cm__tx_uus_pkt(chan, CM_ASSOC_ACK, 0);
        return(CM_E_SUCC);
    }

    /* if nack detected, connection is torn down */
    if ( uus->opcode == CM_ASSOC_NACK )
    {
//        disc_all:
        for ( n = 0 ; n < cm->dprof.chan_num ; n++ )
        {
            CM_CHAN     *chan1 = cm->dprof.chan_tbl + n;

            if ( chan1->ustate > 0 )
                cm__disc_rq(chan1);
        }

        /* deactivate connection */
        cm__deactivate_conn(cm, 0);

        return(CM_E_SUCC);
    }

    /* if here must be an ack */
    if ( uus->opcode != CM_ASSOC_ACK )
        return(CM_E_BADUUS);

   /* if channel already connected and uus ack'ed - ignore */
   if ( chan->ustate > CM_US_UUS_OKED )
      return(CM_E_SUCC);

   //
   // if this flag is set then we originally had a PPP connection
   // this means that all of the connection stuff is taken care of and
   // we just need to satisfy the remote ends uus requirements.
   // there should be only one channel in this case!
   //
   if (cm->PPPToDKF)
   {
        chan->ustate = CM_US_CONN;
      NdisMoveMemory (chan->DstAddr, uus->src_addr, 6);
      NdisMoveMemory(cm->DstAddr, chan->DstAddr, 6);
      cm->remote_conn_index = cm->dprof.chan_tbl[0].remote_conn_index;
      NdisMoveMemory(cm->remote_name, uus->lname, sizeof(cm->remote_name));
      cm->PPPToDKF = 0;
      return(CM_E_SUCC);
   }

    /* if here, it is an ack */
    chan->ustate = CM_US_UUS_OKED;
    chan->timeout = ut_time_now();

   NdisMoveMemory (chan->DstAddr, uus->src_addr, 6);

    chan->remote_conn_index = uus->conn;

    /* proceed only if all channels ok'ed */
    for ( n = 0 ; n < cm->dprof.chan_num ; n++ )
        if ( !cm->dprof.chan_tbl[n].gave_up &&
             (cm->dprof.chan_tbl[n].ustate != CM_US_UUS_OKED) )
            return(CM_E_SUCC);

    /* verify all channel got connected to the same eaddr/conn */
    for ( first = 0 ; first < cm->dprof.chan_num ; first++ )
        if ( !cm->dprof.chan_tbl[n].gave_up )
            break;

    /* move all channels to connected state */            
    for ( n = 0 ; n < cm->dprof.chan_num ; n++ )
        if ( !cm->dprof.chan_tbl[n].gave_up )
        {
            cm->dprof.chan_tbl[n].ustate = CM_US_CONN;
            cm->dprof.chan_tbl[n].timeout = ut_time_now();
        }

// Hack to get around no cm for all channels < the last channel received
    NdisMoveMemory(cm->DstAddr, chan->DstAddr, 6);

    /* store some values on a connection level */
    cm->remote_conn_index = cm->dprof.chan_tbl[first].remote_conn_index;
    NdisMoveMemory(cm->remote_name, uus->lname, sizeof(cm->remote_name));
        
    /* make connection active now */
    cm->state = CM_ST_ACTIVE;
   cm->StateChangeFlag = TRUE;

   // Set compression Flag
   if (cm->dprof.HWCompression && (uus->option_0 & UUS_0_COMPRESSION))
      CompressionFlag = 1;
   else
      CompressionFlag = 0;

   return(cm__activate_conn(cm, CompressionFlag));
}

/* (org) process element indications */
INT
cm__org_elem_ind(CM_CHAN *chan, IDD_MSG *msg)
{
    USHORT      bchan;
    int         auto_disc = 0;
    CHAR        *elem;
    
   D_LOG(D_ENTRY|DIGIQ931, ("cm__org_elem_ind: entry, chan: 0x%lx, msg: 0x%lx\n", \
                                   chan, msg));

    /* must have a valid channel to proceed */
    if ( !chan )
        return(CM_E_SUCC);

    /* check if bchannel reported */
    if ( cm__get_bchan(msg, &bchan) == CM_E_SUCC )
    {
      D_LOG(D_ALWAYS|DIGIQ931, ("cm__org_elem_ind: bchan: %d\n", bchan));
        
        if ( !CM_BCHAN_ASSIGNED(chan->bchan) )
            auto_disc |= 1;
        else
            chan->bchan = bchan;
    }

    /* scan for cause */
    if ( (elem = cm__q931_elem(msg->bufptr, msg->buflen, 0x08)) &&
         (elem[1] >= 2) && !(elem[2] & 0x78) )
    {
        static CHAR disc_vals[] = { 0x01, 0x11, 0x12 };

      D_LOG(D_ALWAYS|DIGIQ931, ("cm__org_elem_ind: cause: 0x%x\n", elem[3] & 0x7F));
        
        if ( __memchr((PUCHAR)disc_vals,(CHAR) elem[3] & 0x7F, (ULONG) sizeof(disc_vals)) )
      {
         CM *cm = (CM*)chan->cm;

         cm->CauseValue = elem[3] & 0x7F;
            auto_disc |= 2;
      }
    }

    /* scan for signal */
    if ( (elem = cm__q931_elem(msg->bufptr, msg->buflen, 0x34)) &&
         (elem[1] == 1) )
    {
//        static CHAR signal_vals[] = { 0x00, 0x03, 0x04, 0x0C };
        static CHAR signal_vals[] = { 0x03, 0x04, 0x0C };

      D_LOG(D_ALWAYS|DIGIQ931, ("cm__org_elem_ind: signal: 0x%x\n", elem[2]));
        
        if ( __memchr(signal_vals, elem[2], sizeof(signal_vals)) )
      {
         CM *cm = (CM*)chan->cm;

         cm->SignalValue = elem[2];
            auto_disc |= 4;
      }
    }

    /* check if need to disconnect */
    if ( auto_disc )
    {
      D_LOG(D_ALWAYS|DIGIQ931, ("cm__org_elem_ind: auto_disc: 0x%x\n", auto_disc));
        cm__disc_rq(chan);
    }

    return(CM_E_SUCC);    
}                                    

/* calc a checksum for a buffer */
UCHAR
cm__calc_chksum(VOID *buf_1, INT len)
{
   UCHAR    *buf = (UCHAR *)buf_1;
    UCHAR   sum;

    for ( sum = 0 ; len ; len-- )
        sum += *buf++;

    return(sum);    
}

/* increment a channel count */
BOOL
cm__inc_chan_num(CM_CHAN *chan, CM_CHAN *ref_chan, ULONG *chan_num)
{
    /* find if this channel is part of same connection as ref_chan */
    if ( memcmp(chan->DstAddr, ref_chan->DstAddr, 6) ||
         (chan->remote_conn_index != ref_chan->remote_conn_index) )
        return(TRUE);

    /* inrement here */
    *chan_num += 1;
    return(TRUE);         
}

/* add a channel to a connection */
BOOL
cm__add_chan(CM_CHAN *chan, CM_CHAN *ref_chan, CM *cm)
{
    CM_CHAN     *chan1;
    
    /* if connection already full, stop here */
    if ( cm->dprof.chan_num >= cm->active_chan_num )
        return(FALSE);
        
    /* find if this channel is part of same connection as ref_chan */
    if ( memcmp(chan->DstAddr, ref_chan->DstAddr, 6) ||
         (chan->remote_conn_index != ref_chan->remote_conn_index) )
        return(TRUE);

    /* add this channel */
    chan1 = &cm->dprof.chan_tbl[cm->dprof.chan_num++];
    *chan1 = *chan;
    cm__chan_free(chan);
    return(TRUE);
}