userapps/opensource/net-snmp/agent/mibgroup/mibII/adsl/adslMibHelper.c

   1 /****************************************************************************
   2  *
   3  *     Copyright (c) 2003 Broadcom Corporation
   4  *           All Rights Reserved
   5  *
   6  *     No portions of this material may be reproduced in any form without the
   7  *     written permission of:
   8  *
   9  *           Broadcom Corporation
  10  *           16251 Laguna Canyon Road
  11  *           Irvine, California  92618
  12  *
  13  *     All information contained in this document is Broadcom Corporation
  14  *     company private, proprietary, and trade secret.
  15  *
  16  *****************************************************************************/
  17 /**
  18  *
  19  *  @file    adslMibHelper.c
  20  *
  21  *  @brief   Helper functions for the ADSL MIB
  22  *
  23  ****************************************************************************/
  24
  25 #include <stddef.h>
  26
  27 #include <net-snmp/net-snmp-config.h>
  28 #include <net-snmp/net-snmp-includes.h>
  29 #include <net-snmp/agent/net-snmp-agent-includes.h>
  30 #include <net-snmp/agent/auto_nlist.h>
  31
  32 #include "../interfaces.h"
  33 #include "adslMibHelper.h"
  34 #include <AdslMibDef.h>
  35
  36 static int adslMibCurrAdminStatus=IF_ADMIN_STATUS_UP;
  37
  38 int
  39 getAdslIfIndex(void)
  40 {
  41   int ifIndex;
  42
  43     /*
  44      * This should be the index for the ifType[index]=adsl in the ifTable
  45      */
  46   ifIndex = Interface_Index_By_Name(ADSL_MIB_IFNAME,strlen(ADSL_MIB_IFNAME));
  47   if (ifIndex == 0)
  48     return (1);
  49   else
  50     return (ifIndex);
  51 }
  52
  53 /* code copied from adslctl.c */
  54 unsigned long
  55 getAdslIfSpeed(void)
  56 {
  57     adslMibInfo data;
  58     long size = sizeof(adslMibInfo);
  59     unsigned long speed = 0;
  60     int xK, rK;
  61
  62     BcmAdsl_GetObjectValue((char*)NULL, 0,(char*)&data, &size);
  63
  64     if (kAdslTrainingConnected == data.adslTrainingState) {
  65       if (data.adslConnection.chType) {
  66         xK = data.adslConnection.xmtInfo.K;
  67         if (xK != 0)
  68           speed = (unsigned long)((xK-1)*8*4*1000);
  69       }
  70       else {
  71         rK = data.adslConnection.rcvInfo.K;
  72         if (rK != 0)
  73           speed = (unsigned long)((rK-1)*8*4*1000);
  74       }
  75     }
  76     return speed;
  77 }
  78
  79 int
  80 getAdslOperStatus(void)
  81 {
  82     adslMibInfo data;
  83     long size = sizeof(adslMibInfo);
  84
  85     BcmAdsl_GetObjectValue((char*)NULL, 0,(char*)&data, &size);
  86
  87     if (data.adslPhys.adslCurrStatus == ADSL_MIB_CURR_STATUS_NO_DEFECT)
  88       return (IF_OPER_STATUS_UP);
  89     else
  90       return (IF_OPER_STATUS_DOWN);
  91 }
  92
  93 int
  94 getAdslAdminStatus(void)
  95 {
  96   return (adslMibCurrAdminStatus);
  97 }
  98
  99 int
 100 setAdslAdminStatus(int status)
 101 {
 102   int ret=0;
 103
 104   if (status != adslMibCurrAdminStatus) {
 105     if (status == IF_ADMIN_STATUS_UP) {
 106       if (BcmAdsl_ConnectionStart() == 0)
 107         adslMibCurrAdminStatus = IF_ADMIN_STATUS_UP;
 108       else
 109         ret = -1;
 110     }
 111     else if (status == IF_ADMIN_STATUS_DOWN) {
 112       if (BcmAdsl_ConnectionStop() == 0)
 113         adslMibCurrAdminStatus = IF_ADMIN_STATUS_DOWN;
 114       else
 115         ret = -1;
 116     }
 117     else
 118       ret =  -1; /* not supporting anything else */
 119   }
 120   return (ret);
 121 }
 122
 123 #ifdef SNMP_ADSL_MIB
 124 int
 125 adslMibHelper_getIfCount()
 126 {
 127     return (1);
 128 }
 129
 130 /** free context of adslAturPhysTable table */
 131 #ifdef DO_ADSLATURPHYSTABLE
 132 /*
 133  * Fill out the ADSL adslAturPhysTable
 134  */
 135 void
 136 adslMibHelper_filladslAturPhysTable(pADSL_MIB_ADSLATURPHYSTABLE pTable)
 137 {
 138     adslVersionInfo adslVer;
 139     adslMibInfo data;
 140     long size = sizeof(adslMibInfo);
 141
 142     pADSL_MIB_ADSLATURPHYSTABLE p = pTable;
 143
 144     p->pTableBeginning = pTable;
 145     p->ifIndex = getAdslIfIndex();
 146
 147     /* need to get modulation type, LineCoding type */
 148     BcmAdsl_GetObjectValue((char*)NULL, 0,(char*)&data, &size);
 149
 150
 151     /* serial number */
 152     strncpy(p->adslAturInvSerialNumber, ADSL_MIB_INV_SERIAL_NUMBER,
 153             strlen(ADSL_MIB_INV_SERIAL_NUMBER));
 154
 155
 156     switch (data.adslConnection.modType)
 157       {
 158       case kAdslModGdmt:
 159         strncpy(p->adslAturInvVendorID, ADSL_MIB_VENDOR_ID_G_DMT,
 160                 sizeof(p->adslAturInvVendorID));
 161         break;
 162       case kAdslModT1413:
 163         strncpy(p->adslAturInvVendorID, ADSL_MIB_VENDOR_ID_T1_413,
 164                 sizeof(p->adslAturInvVendorID));
 165         break;
 166       case kAdslModGlite:
 167       default:
 168         strncpy(p->adslAturInvVendorID,"",sizeof(p->adslAturInvVendorID));
 169       }
 170
 171     /* get phy version number first */
 172     BcmAdsl_GetVersion(&adslVer);
 173     strncpy(p->adslAturInvVersionNumber,adslVer.phyVerStr,sizeof(p->adslAturInvVersionNumber));
 174     p->adslAturCurrSnrMgn = (int)data.adslPhys.adslCurrSnrMgn;
 175     p->adslAturCurrAtn = (unsigned long)data.adslPhys.adslCurrAtn;
 176     p->adslAturCurrStatus = (int)data.adslPhys.adslCurrStatus;
 177     p->adslAturCurrOutputPwr = (unsigned char)data.adslPhys.adslCurrOutputPwr;
 178     p->adslAturCurrAttainableRate = (unsigned long)data.adslPhys.adslCurrAttainableRate;
 179
 180     p->next = NULL;
 181 }
 182 #endif                          /* DO_ADSLATURPHYSTABLE */
 183 /** free context of adslLineConfProfileTable table */
 184 #ifdef DO_ADSLLINECONFPROFILETABLE
 185 /*
 186  * Fill out the ADSL adslLineConfProfileTable
 187  */
 188 void
 189 adslMibHelper_filladslLineConfProfileTable
 190     (pADSL_MIB_ADSLLINECONFPROFILETABLE pTable)
 191 {
 192     char            adslEntryOid[4];
 193     adslLineEntry   data;
 194     long            size = sizeof(adslLineEntry);
 195
 196     pADSL_MIB_ADSLLINECONFPROFILETABLE p = pTable;
 197
 198     p->pTableBeginning = pTable;
 199     p->ifIndex = getAdslIfIndex();
 200
 201    /***************************************/
 202    /***************************************/
 203
 204     p->next = NULL;
 205 }
 206 #endif                          /* DO_ADSLLINECONFPROFILETABLE */
 207 /** free context of adslAturChanTable table */
 208 #ifdef DO_ADSLATURCHANTABLE
 209 /*
 210  * Fill out the ADSL adslAturChanTable
 211  */
 212 void
 213 adslMibHelper_filladslAturChanTable(pADSL_MIB_ADSLATURCHANTABLE pTable)
 214 {
 215     adslMibInfo data;
 216     long size = sizeof(adslMibInfo);
 217     adslChanEntry   *pChanData;
 218     pADSL_MIB_ADSLATURCHANTABLE p = pTable;
 219
 220     p->pTableBeginning = pTable;
 221     p->ifIndex = getAdslIfIndex();
 222
 223    /***************************************/
 224     /* need to get modulation type, LineCoding type */
 225     BcmAdsl_GetObjectValue((char*)NULL, 0,(char*)&data, &size);
 226
 227     if (data.adslConnection.chType == kAdslIntlChannel)
 228       pChanData = &data.adslChanIntl;
 229     else
 230       pChanData = &data.adslChanFast;
 231
 232     p->adslAturChanInterleaveDelay = (unsigned long)pChanData->adslChanIntlDelay;
 233     p->adslAturChanCurrTxRate = (unsigned long) pChanData->adslChanCurrTxRate;
 234     p->adslAturChanPrevTxRate = (unsigned long) pChanData->adslChanPrevTxRate;
 235     p->adslAturChanCrcBlockLength= (unsigned long) pChanData->adslChanCrcBlockLength;
 236    /***************************************/
 237
 238     p->next = NULL;
 239 }
 240 #endif                          /* DO_ADSLATURCHANTABLE */
 241 /** free context of adslAtucPerfDataTable table */
 242 #ifdef DO_ADSLATUCPERFDATATABLE
 243 /*
 244  * Fill out the ADSL adslAtucPerfDataTable
 245  */
 246 void
 247 adslMibHelper_filladslAtucPerfDataTable(pADSL_MIB_ADSLATUCPERFDATATABLE
 248                                         pTable)
 249 {
 250     char            adslEntryOid[4];
 251     adslPerfDataEntry    data;
 252     long            size = sizeof(adslPerfDataEntry);
 253
 254     pADSL_MIB_ADSLATUCPERFDATATABLE p = pTable;
 255
 256     p->pTableBeginning = pTable;
 257     p->ifIndex = getAdslIfIndex();
 258
 259    /***************************************/
 260     /* this is also needs support from driver.  The following are ATUR data */
 261     adslEntryOid[0] = kOidAdsl;
 262     adslEntryOid[1] = kOidAdslLine;
 263     adslEntryOid[2] = kOidAdslMibObjects;
 264     adslEntryOid[3] = kOidAdslPerfDataEntry;
 265     BcmAdsl_GetObjectValue((char*)&adslEntryOid, (int)sizeof(adslEntryOid),
 266                            (char*)&data, &size);
 267
 268     p->adslAtucPerfLofs = (unsigned long) data.perfTotal.adslLofs;
 269     p->adslAtucPerfLoss = (unsigned long) data.perfTotal.adslLoss;
 270     p->adslAtucPerfLprs = (unsigned long) data.perfTotal.adslLprs;
 271     p->adslAtucPerfESs = (unsigned long) data.perfTotal.adslESs;
 272     p->adslAtucPerfValidIntervals = (int) data.adslPerfValidIntervals
 273     p->adslAtucPerfInvalidIntervals = (int) data.adslPerfInvalidIntervals;
 274     p->adslAtucPerfCurr15MinTimeElapsed = (unsigned long) data.adslPerfCurr15MinTimeElapsed;
 275     p->adslAtucPerfCurr15MinLofs = (unsigned long) data.perfCurr15Min.adslLofs;
 276     p->adslAtucPerfCurr15MinLoss = (unsigned long) data.perfCurr15Min.adslLoss;
 277     p->adslAtucPerfCurr15MinLprs = (unsigned long) data.perfCurr15Min.adslLprs;
 278     p->adslAtucPerfCurr15MinESs = (unsigned long) data.perfCurr15Min.adslESs;
 279     p->adslAtucPerfCurr1DayTimeElapsed = (unsigned long) data.adslPerfCurr1DayTimeElapsed;
 280     p->adslAtucPerfCurr1DayLofs = (unsigned long) data.perfCurr1Day.adslLofs;
 281     p->adslAtucPerfCurr1DayLoss = (unsigned long) data.perfCurr1Day.adslLoss;
 282     p->adslAtucPerfCurr1DayLprs = (unsigned long) data.perfCurr1Day.adslLprs;
 283     p->adslAtucPerfCurr1DayESs = (unsigned long) data.perfCurr1Day.adslESs;
 284     p->adslAtucPerfPrev1DayMoniSecs = (int) data.adslAtucPerfPrev1DayMoniSecs;
 285     p->adslAtucPerfPrev1DayLofs = (unsigned long) data.perfPrev1Day.adslLofs;
 286     p->adslAtucPerfPrev1DayLoss = (unsigned long) data.perfPrev1Day.adslLoss;
 287     p->adslAtucPerfPrev1DayLprs = (unsigned long) data.perfPrev1Day.adslLprs;
 288     p->adslAtucPerfPrev1DayESs = (unsigned long) data.perfPrev1Day.adslESs;
 289    /***************************************/
 290
 291     p->next = NULL;
 292 }
 293 #endif                          /* DO_ADSLATUCPERFDATATABLE */
 294 /** free context of adslAtucIntervalTable table */
 295 #ifdef DO_ADSLATUCINTERVALTABLE
 296 /*
 297  * Fill out the ADSL adslAtucIntervalTable
 298  */
 299 void
 300 adslMibHelper_filladslAtucIntervalTable(pADSL_MIB_ADSLATUCINTERVALTABLE
 301                                         pTable)
 302 {
 303     char            adslEntryOid[4];
 304     adslPerfCounters data[kAdslMibPerfIntervals];
 305     long            size=sizeof(data);
 306
 307     pADSL_MIB_ADSLATUCINTERVALTABLE p = pTable;
 308
 309     p->pTableBeginning = pTable;
 310     p->ifIndex = getAdslIfIndex();
 311
 312    /***************************************/
 313     /* this table needs support from ADSL driver; using aturIntervalTable's data now */
 314     adslEntryOid[0] = kOidAdsl;
 315     adslEntryOid[1] = kOidAdslLine;
 316     adslEntryOid[2] = kOidAdslMibObjects;
 317     adslEntryOid[3] = kOidAdslAturPerfIntervalTable;
 318     BcmAdsl_GetObjectValue((char*)&adslEntryOid, (int)sizeof(adslEntryOid),
 319                            (char*)&data, &size);
 320
 321     numOfInterval = size/sizeof(adslPerfCounters);
 322
 323     for (i=0; i<numOfInterval; i++) {
 324       p->pTableBeginning = pTable;
 325       p->ifIndex = index;
 326       p->adslAturIntervalNumber = i+1;
 327       memcpy(&p->adslAturIntervalLofs,&data[i],(sizeof(adslPerfCounters)));
 328       p->adslAturIntervalValidData = 1;
 329       if (i == (numOfInterval-1))
 330         p->next=NULL;
 331       else {
 332         p->next = (p+1);
 333         p++;
 334       }
 335     }
 336    /***************************************/
 337
 338     p->next = NULL;
 339 }
 340 #endif                          /* DO_ADSLATUCINTERVALTABLE */
 341 /** free context of adslAturPerfDataTable table */
 342 #ifdef DO_ADSLATURPERFDATATABLE
 343 /*
 344  * Fill out the ADSL adslAturPerfDataTable
 345  */
 346 void
 347 adslMibHelper_filladslAturPerfDataTable(pADSL_MIB_ADSLATURPERFDATATABLE
 348                                         pTable)
 349 {
 350     char            adslEntryOid[4];
 351     adslPerfDataEntry    data;
 352     long            size = sizeof(adslPerfDataEntry);
 353
 354     pADSL_MIB_ADSLATURPERFDATATABLE p = pTable;
 355
 356     p->pTableBeginning = pTable;
 357     p->ifIndex = getAdslIfIndex();
 358
 359    /***************************************/
 360     adslEntryOid[0] = kOidAdsl;
 361     adslEntryOid[1] = kOidAdslLine;
 362     adslEntryOid[2] = kOidAdslMibObjects;
 363     adslEntryOid[3] = kOidAdslAturPerfDataTable;
 364
 365     BcmAdsl_GetObjectValue((char*)&adslEntryOid, (int)sizeof(adslEntryOid),
 366                            (char*)&data, &size);
 367
 368     p->adslAturPerfLofs = (unsigned long) data.perfTotal.adslLofs;
 369     p->adslAturPerfLoss = (unsigned long) data.perfTotal.adslLoss;
 370     p->adslAturPerfLprs = (unsigned long) data.perfTotal.adslLprs;
 371     p->adslAturPerfESs = (unsigned long) data.perfTotal.adslESs;
 372     p->adslAturPerfValidIntervals = (int) data.adslPerfValidIntervals;
 373     p->adslAturPerfInvalidIntervals = (int) data.adslPerfInvalidIntervals;
 374     p->adslAturPerfCurr15MinTimeElapsed = (unsigned long) data.adslPerfCurr15MinTimeElapsed;
 375     p->adslAturPerfCurr15MinLofs = (unsigned long) data.perfCurr15Min.adslLofs;
 376     p->adslAturPerfCurr15MinLoss = (unsigned long) data.perfCurr15Min.adslLoss;
 377     p->adslAturPerfCurr15MinLprs = (unsigned long) data.perfCurr15Min.adslLprs;
 378     p->adslAturPerfCurr15MinESs = (unsigned long) data.perfCurr15Min.adslESs;
 379     p->adslAturPerfCurr1DayTimeElapsed = (unsigned long) data.adslPerfCurr1DayTimeElapsed;
 380     p->adslAturPerfCurr1DayLofs = (unsigned long) data.perfCurr1Day.adslLofs;
 381     p->adslAturPerfCurr1DayLoss = (unsigned long) data.perfCurr1Day.adslLoss;
 382     p->adslAturPerfCurr1DayLprs = (unsigned long) data.perfCurr1Day.adslLprs;
 383     p->adslAturPerfCurr1DayESs = (unsigned long) data.perfCurr1Day.adslESs;
 384     p->adslAturPerfPrev1DayMoniSecs = (int) data.adslAturPerfPrev1DayMoniSecs;
 385     p->adslAturPerfPrev1DayLofs = (unsigned long) data.perfPrev1Day.adslLofs;
 386     p->adslAturPerfPrev1DayLoss = (unsigned long) data.perfPrev1Day.adslLoss;
 387     p->adslAturPerfPrev1DayLprs = (unsigned long) data.perfPrev1Day.adslLprs;
 388     p->adslAturPerfPrev1DayESs = (unsigned long) data.perfPrev1Day.adslESs;
 389    /***************************************/
 390
 391     p->next = NULL;
 392 }
 393 #endif                          /* DO_ADSLATURPERFDATATABLE */
 394 /** free context of adslLineAlarmConfProfileTable table */
 395 #ifdef DO_ADSLLINEALARMCONFPROFILETABLE
 396 /*
 397  * Fill out the ADSL adslLineAlarmConfProfileTable
 398  */
 399 void
 400 adslMibHelper_filladslLineAlarmConfProfileTable
 401     (pADSL_MIB_ADSLLINEALARMCONFPROFILETABLE pTable)
 402 {
 403     char profileName[32];
 404
 405     pADSL_MIB_ADSLLINEALARMCONFPROFILETABLE p = pTable;
 406
 407     /* we are supposed to get these configurations from the adsl driver; howevever,
 408        it doesn't have this implemented yet.  We are just going to hardcode them
 409        to 0 which means disabled */
 410     memset(p,0,sizeof(p));
 411
 412     p->pTableBeginning = pTable;
 413     p->ifIndex = getAdslIfIndex();
 414
 415     /***************************************/
 416     sprintf(profileName,"%d",p->ifIndex);
 417     strncpy(p->adslLineAlarmConfProfileName,profileName,sizeof(p->adslLineAlarmConfProfileName));
 418     p->adslAtucInitFailureTrapEnable = ADSL_MIB_ALARM_ATUC_INIT_FAIL_DISABLE;
 419     p->adslLineAlarmConfProfileRowStatus = ADSL_MIB_ALARM_ROW_ACTIVE;
 420     /***************************************/
 421
 422     p->next = NULL;
 423 }
 424 #endif                          /* DO_ADSLLINEALARMCONFPROFILETABLE */
 425 /** free context of adslAturChanPerfDataTable table */
 426 #ifdef DO_ADSLATURCHANPERFDATATABLE
 427 /*
 428  * Fill out the ADSL adslAturChanPerfDataTable
 429  */
 430 void
 431 adslMibHelper_filladslAturChanPerfDataTable
 432     (pADSL_MIB_ADSLATURCHANPERFDATATABLE pTable)
 433 {
 434     adslMibInfo data;
 435     long size = sizeof(adslMibInfo);
 436     adslChanPerfDataEntry  *pChanData;
 437
 438     pADSL_MIB_ADSLATURCHANPERFDATATABLE p = pTable;
 439
 440     p->pTableBeginning = pTable;
 441     p->ifIndex = getAdslIfIndex();
 442
 443    /***************************************/
 444     BcmAdsl_GetObjectValue((char*)NULL,0,(char*)&data, &size);
 445     if (data.adslConnection.chType == kAdslIntlChannel)
 446       pChanData = &data.adslChanIntlPerfData;
 447     else
 448       pChanData = &data.adslChanFastPerfData;
 449     memcpy((void *)&p->adslAturChanReceivedBlks,(void *)&pChanData->perfTotal,sizeof(adslChanCounters));
 450     p->adslAturChanPerfValidIntervals = pChanData->adslChanPerfValidIntervals;
 451     p->adslAturChanPerfInvalidIntervals = pChanData->adslChanPerfInvalidIntervals;
 452     p->adslAturChanPerfCurr15MinTimeElapsed = pChanData->adslPerfCurr15MinTimeElapsed;
 453     memcpy((void *)&p->adslAturChanPerfCurr15MinReceivedBlks,(void *)&pChanData->perfCurr15Min,sizeof(adslChanCounters));
 454     p->adslAturChanPerfCurr1DayTimeElapsed = pChanData->adslPerfCurr1DayTimeElapsed;
 455     memcpy((void *)&p->adslAturChanPerfCurr1DayReceivedBlks,(void *)&pChanData->perfCurr1Day,sizeof(adslChanCounters));
 456     p->adslAturChanPerfPrev1DayMoniSecs = pChanData->adslAturPerfPrev1DayMoniSecs;
 457     memcpy((void *)&p->adslAturChanPerfPrev1DayReceivedBlks,(void *)&pChanData->perfPrev1Day,sizeof(adslChanCounters));
 458    /***************************************/
 459
 460     p->next = NULL;
 461 }
 462 #endif                          /* DO_ADSLATURCHANPERFDATATABLE */
 463 /** free context of adslAturIntervalTable table */
 464 #ifdef DO_ADSLATURINTERVALTABLE
 465 /*
 466  * Fill out the ADSL adslAturIntervalTable
 467  */
 468 void
 469 adslMibHelper_filladslAturIntervalTable(pADSL_MIB_ADSLATURINTERVALTABLE
 470                                         pTable)
 471 {
 472     adslMibInfo data;
 473     long size;
 474     adslPerfCounters *pChanData;
 475     int numOfInterval, i;
 476     int index;
 477     int validInterval;
 478     pADSL_MIB_ADSLATURINTERVALTABLE p = pTable;
 479
 480     size = sizeof(adslMibInfo);
 481     index = getAdslIfIndex();
 482
 483    /***************************************/
 484     BcmAdsl_GetObjectValue((char*)NULL,0,(char*)&data, &size);
 485     pChanData = data.adslPerfIntervals;
 486     validInterval = data.adslPerfData.adslPerfValidIntervals;
 487
 488     /* the max interval we support */
 489     numOfInterval = kAdslMibPerfIntervals;
 490     for (i=0; i<numOfInterval; i++) {
 491       p->pTableBeginning = pTable;
 492       p->ifIndex = index;
 493       p->adslAturIntervalNumber = i+1;
 494       memcpy(&p->adslAturIntervalLofs,&pChanData[i],(sizeof(adslPerfCounters)));
 495       if (validInterval > i)
 496         p->adslAturIntervalValidData = 1;
 497       else
 498         p->adslAturIntervalValidData = 0;
 499
 500         p->next=NULL;
 501     }
 502    /***************************************/
 503 }
 504 #endif                          /* DO_ADSLATURINTERVALTABLE */
 505 /** free context of adslAtucPhysTable table */
 506 #ifdef DO_ADSLATUCPHYSTABLE
 507 /*
 508  * Fill out the ADSL adslAtucPhysTable
 509  */
 510 void
 511 adslMibHelper_filladslAtucPhysTable(pADSL_MIB_ADSLATUCPHYSTABLE pTable)
 512 {
 513     adslMibInfo data;
 514     long size = sizeof(adslMibInfo);
 515     adslFullPhysEntry *pPhysEntry;
 516
 517     pADSL_MIB_ADSLATUCPHYSTABLE p = pTable;
 518
 519     p->pTableBeginning = pTable;
 520     p->ifIndex = getAdslIfIndex();
 521
 522    /***************************************/
 523     BcmAdsl_GetObjectValue((char*)NULL,0,(char*)&data, &size);
 524
 525     pPhysEntry = &data.adslAtucPhys;
 526     strncpy(p->adslAtucInvSerialNumber,pPhysEntry->adslSerialNumber,
 527             sizeof(p->adslAtucInvSerialNumber));
 528     strncpy(p->adslAtucInvVendorID,pPhysEntry->adslVendorID,sizeof(p->adslAtucInvVendorID));
 529     strncpy(p->adslAtucInvVersionNumber,pPhysEntry->adslVersionNumber,
 530             sizeof(p->adslAtucInvVersionNumber));
 531     p->adslAtucCurrSnrMgn = (int)pPhysEntry->adslCurrSnrMgn;
 532     p->adslAtucCurrAtn = (unsigned long)pPhysEntry->adslCurrAtn;
 533     p->adslAtucCurrStatus = (int)pPhysEntry->adslCurrStatus;
 534     p->adslAtucCurrOutputPwr = (int)pPhysEntry->adslCurrOutputPwr;
 535     p->adslAtucCurrAttainableRate = (unsigned long)pPhysEntry->adslCurrAttainableRate;
 536    /***************************************/
 537
 538     p->next = NULL;
 539 }
 540 #endif                          /* DO_ADSLATUCPHYSTABLE */
 541 /** free context of adslAtucChanPerfDataTable table */
 542 #ifdef DO_ADSLATUCCHANPERFDATATABLE
 543 /*
 544  * Fill out the ADSL adslAtucChanPerfDataTable
 545  */
 546 void
 547 adslMibHelper_filladslAtucChanPerfDataTable
 548     (pADSL_MIB_ADSLATUCCHANPERFDATATABLE pTable)
 549 {
 550     adslMibInfo data;
 551     long size = sizeof(adslMibInfo);
 552     adslChanPerfDataEntry  *pChanData;
 553
 554     pADSL_MIB_ADSLATUCCHANPERFDATATABLE p = pTable;
 555
 556     p->pTableBeginning = pTable;
 557     p->ifIndex = getAdslIfIndex();
 558
 559    /***************************************/
 560     BcmAdsl_GetObjectValue((char*)NULL,0,(char*)&data, &size);
 561     /* this table needs support from ADSL driver; using aturChanPerf's data now */
 562     if (data.adslConnection.chType == kAdslIntlChannel)
 563       pChanData = &data.adslChanIntlPerfData;
 564     else
 565       pChanData = &data.adslChanFastPerfData;
 566     memcpy((void *)&p->adslAtucChanReceivedBlks,(void *)&pChanData->perfTotal,sizeof(adslChanCounters));
 567     p->adslAtucChanPerfValidIntervals = pChanData->adslChanPerfValidIntervals;
 568     p->adslAtucChanPerfInvalidIntervals = pChanData->adslChanPerfInvalidIntervals;
 569     p->adslAtucChanPerfCurr15MinTimeElapsed = pChanData->adslPerfCurr15MinTimeElapsed;
 570     memcpy((void *)&p->adslAtucChanPerfCurr15MinReceivedBlks,(void *)&pChanData->perfCurr15Min,sizeof(adslChanCounters));
 571     p->adslAtucChanPerfCurr1DayTimeElapsed = pChanData->adslPerfCurr1DayTimeElapsed;
 572     memcpy((void *)&p->adslAtucChanPerfCurr1DayReceivedBlks,(void *)&pChanData->perfCurr1Day,sizeof(adslChanCounters));
 573     p->adslAtucChanPerfPrev1DayMoniSecs = pChanData->adslAtucPerfPrev1DayMoniSecs;
 574     memcpy((void *)&p->adslAtucChanPerfPrev1DayReceivedBlks,(void *)&pChanData->perfPrev1Day,sizeof(adslChanCounters));
 575    /***************************************/
 576
 577     p->next = NULL;
 578 }
 579 #endif                          /* DO_ADSLATUCCHANPERFDATATABLE */
 580 /** free context of adslAturChanIntervalTable table */
 581 #ifdef DO_ADSLATURCHANINTERVALTABLE
 582 /*
 583  * Fill out the ADSL adslAturChanIntervalTable
 584  */
 585 void
 586 adslMibHelper_filladslAturChanIntervalTable
 587     (pADSL_MIB_ADSLATURCHANINTERVALTABLE pTable)
 588 {
 589     adslMibInfo data;
 590     long size = sizeof(adslMibInfo);
 591     adslChanCounters *pChanData;
 592     int numOfInterval, i;
 593     int index;
 594     int validInterval;
 595
 596     pADSL_MIB_ADSLATURCHANINTERVALTABLE p = pTable;
 597
 598     index = getAdslIfIndex();
 599
 600    /***************************************/
 601     BcmAdsl_GetObjectValue((char*)NULL,0,(char*)&data, &size);
 602     if (data.adslConnection.chType == kAdslIntlChannel) {
 603       pChanData = data.adslChanIntlPerfIntervals;
 604       validInterval = data.adslChanIntlPerfData.adslChanPerfValidIntervals;
 605     }
 606     else {
 607       pChanData = data.adslChanFastPerfIntervals;
 608       validInterval = data.adslChanFastPerfData.adslChanPerfValidIntervals;
 609     }
 610
 611     /* the max interval we support */
 612     numOfInterval = kAdslMibChanPerfIntervals;
 613     for (i=0; i<numOfInterval; i++) {
 614       p->pTableBeginning = pTable;
 615       p->ifIndex = index;
 616       p->adslAturChanIntervalNumber = i+1;
 617       memcpy(&p->adslAturChanIntervalReceivedBlks,&pChanData[i],sizeof(adslChanCounters));
 618       if (validInterval > i)
 619         p->adslAturChanIntervalValidData = 1;
 620       else
 621         p->adslAturChanIntervalValidData = 0;
 622       if (i == (numOfInterval-1))
 623         p->next=NULL;
 624       else {
 625         p->next = (p+1);
 626         p++;
 627       }
 628     }
 629    /***************************************/
 630
 631     p->next = NULL;
 632 }
 633 #endif                          /* DO_ADSLATURCHANINTERVALTABLE */
 634 /** free context of adslAtucChanIntervalTable table */
 635 #ifdef DO_ADSLATUCCHANINTERVALTABLE
 636 /*
 637  * Fill out the ADSL adslAtucChanIntervalTable
 638  */
 639 void
 640 adslMibHelper_filladslAtucChanIntervalTable
 641     (pADSL_MIB_ADSLATUCCHANINTERVALTABLE pTable)
 642 {
 643     adslMibInfo data;
 644     long size = sizeof(adslMibInfo);
 645     adslChanCounters *pChanData;
 646     int numOfInterval, i;
 647     int index;
 648     int validInterval;
 649
 650     pADSL_MIB_ADSLATUCCHANINTERVALTABLE p = pTable;
 651
 652     p->pTableBeginning = pTable;
 653     index = getAdslIfIndex();
 654
 655    /***************************************/
 656     BcmAdsl_GetObjectValue((char*)NULL,0,(char*)&data, &size);
 657     if (data.adslConnection.chType == kAdslIntlChannel) {
 658       pChanData = data.adslChanIntlPerfIntervals;
 659       validInterval = data.adslChanIntlPerfData.adslChanPerfValidIntervals;
 660     }
 661     else {
 662       pChanData = data.adslChanFastPerfIntervals;
 663       validInterval = data.adslChanFastPerfData.adslChanPerfValidIntervals;
 664     }
 665
 666     /* the max interval we support */
 667     numOfInterval = kAdslMibChanPerfIntervals;
 668     for (i=0; i<numOfInterval; i++) {
 669       p->pTableBeginning = pTable;
 670       p->ifIndex = index;
 671       p->adslAtucChanIntervalNumber = i+1;
 672       memcpy(&p->adslAtucChanIntervalReceivedBlks,&pChanData[i],sizeof(adslChanCounters));
 673       if (validInterval > i)
 674         p->adslAtucChanIntervalValidData = 1;
 675       else
 676         p->adslAtucChanIntervalValidData = 0;
 677       if (i == (numOfInterval-1))
 678         p->next=NULL;
 679       else {
 680         p->next = (p+1);
 681         p++;
 682       }
 683     }
 684    /***************************************/
 685
 686     p->next = NULL;
 687 }
 688 #endif                          /* DO_ADSLATUCCHANINTERVALTABLE */
 689 /** free context of adslLineTable table */
 690 #ifdef DO_ADSLLINETABLE
 691 /*
 692  * Fill out the ADSL adslLineTable
 693  */
 694 void
 695 adslMibHelper_filladslLineTable(pADSL_MIB_ADSLLINETABLE pTable)
 696 {
 697     char profileName[32];
 698     char            adslEntryOid[4];
 699     adslLineEntry   data;
 700     long            size = sizeof(adslLineEntry);
 701
 702     pADSL_MIB_ADSLLINETABLE p = pTable;
 703
 704     p->pTableBeginning = pTable;
 705     p->ifIndex = getAdslIfIndex();
 706
 707    /***************************************/
 708     adslEntryOid[0] = kOidAdsl;
 709     adslEntryOid[1] = kOidAdslLine;
 710     adslEntryOid[2] = kOidAdslMibObjects;
 711     adslEntryOid[3] = kOidAdslLineTable;
 712     BcmAdsl_GetObjectValue((char*)&adslEntryOid, (int)sizeof(adslEntryOid),
 713                            (char*)&data, &size);
 714
 715     p->adslLineCoding = (int) data.adslLineCoding;
 716     p->adslLineType = (int) data.adslLineType;
 717     strncpy((char*)p->adslLineSpecific, "", strlen(""));
 718     strncpy((char*)p->adslLineConfProfile, ADSL_MIB_CONFIG_PROFILE_NAME,
 719             sizeof(p->adslLineConfProfile));
 720     sprintf(profileName,"%d",p->ifIndex);
 721     strncpy(p->adslLineAlarmConfProfile, profileName,
 722             sizeof(p->adslLineAlarmConfProfile));
 723    /***************************************/
 724
 725     p->next = NULL;
 726 }
 727 #endif                          /* DO_ADSLLINETABLE */
 728 /** free context of adslAtucChanTable table */
 729 #ifdef DO_ADSLATUCCHANTABLE
 730 /*
 731  * Fill out the ADSL adslAtucChanTable
 732  */
 733 void
 734 adslMibHelper_filladslAtucChanTable(pADSL_MIB_ADSLATUCCHANTABLE pTable)
 735 {
 736     adslMibInfo data;
 737     long size = sizeof(adslMibInfo);
 738     adslChanEntry   *pChanData;
 739     pADSL_MIB_ADSLATUCCHANTABLE p = pTable;
 740
 741     p->pTableBeginning = pTable;
 742     p->ifIndex = getAdslIfIndex();
 743
 744    /***************************************/
 745     BcmAdsl_GetObjectValue((char*)NULL, 0,(char*)&data, &size);
 746
 747     /* driver support needed, atuc chan table; this one is atur table */
 748     if (data.adslConnection.chType == kAdslIntlChannel)
 749       pChanData = &data.adslChanIntl;
 750     else
 751       pChanData = &data.adslChanFast;
 752
 753     p->adslAturChanInterleaveDelay = (unsigned long)pChanData->adslChanIntlDelay;
 754     p->adslAturChanCurrTxRate = (unsigned long) pChanData->adslChanCurrTxRate;
 755     p->adslAturChanPrevTxRate = (unsigned long) pChanData->adslChanPrevTxRate;
 756     p->adslAturChanCrcBlockLength= (unsigned long) pChanData->adslChanCrcBlockLength;
 757    /***************************************/
 758
 759     p->next = NULL;
 760 }
 761 #endif                          /* DO_ADSLATUCCHANTABLE */
 762
 763 #endif /* SNMP_ADSL_MIB */