release/src/router/apcupsd/src/drivers/snmplite/snmp.cpp

   1 /*
   2  * snmp.cpp
   3  *
   4  * SNMP client interface
   5  */
   6
   7 /*
   8  * Copyright (C) 2009 Adam Kropelin
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of version 2 of the GNU General
  12  * Public License as published by the Free Software Foundation.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17  * General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public
  20  * License along with this program; if not, write to the Free
  21  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  22  * MA 02111-1307, USA.
  23  */
  24
  25 #include "apc.h"
  26 #include "snmp.h"
  27 #include "asn.h"
  28
  29 #ifdef __WIN32__
  30 #define close(x) closesocket(x)
  31 #endif
  32
  33 using namespace Snmp;
  34
  35 SnmpEngine::SnmpEngine() :
  36    _socket(-1),
  37    _trapsock(-1),
  38    _reqid(0)
  39 {
  40 }
  41
  42 SnmpEngine::~SnmpEngine()
  43 {
  44    close(_socket);
  45    close(_trapsock);
  46 }
  47
  48 bool SnmpEngine::Open(const char *host, unsigned short port, const char *comm, bool trap)
  49 {
  50    // In case we are already open
  51    close(_socket);
  52    close(_trapsock);
  53
  54    // Remember new community name
  55    _community = comm;
  56
  57    // Generate starting request id
  58    struct timeval now;
  59    gettimeofday(&now, NULL);
  60    _reqid = now.tv_usec;
  61
  62    // Look up destination address
  63    memset(&_destaddr, 0, sizeof(_destaddr));
  64    _destaddr.sin_family = AF_INET;
  65    _destaddr.sin_port = htons(port);
  66    _destaddr.sin_addr.s_addr = inet_addr(host);
  67    if (_destaddr.sin_addr.s_addr == INADDR_NONE)
  68    {
  69       struct hostent he;
  70       char *tmphstbuf = NULL;
  71       size_t hstbuflen = 0;
  72       struct hostent *hp = gethostname_re(host, &he, &tmphstbuf, &hstbuflen);
  73       if (!hp || hp->h_length != sizeof(_destaddr.sin_addr.s_addr) ||
  74           hp->h_addrtype != AF_INET)
  75       {
  76          free(tmphstbuf);
  77          return false;
  78       }
  79
  80       memcpy(&_destaddr.sin_addr.s_addr, hp->h_addr,
  81              sizeof(_destaddr.sin_addr.s_addr));
  82       free(tmphstbuf);
  83    }
  84
  85    // Get a UDP socket
  86    _socket = socket(PF_INET, SOCK_DGRAM, 0);
  87    if (_socket == -1)
  88    {
  89       perror("socket");
  90       return false;
  91    }
  92
  93    // Bind to rx on any interface
  94    struct sockaddr_in addr;
  95    memset(&addr, 0, sizeof(addr));
  96    addr.sin_family = AF_INET;
  97    addr.sin_port = 0;
  98    addr.sin_addr.s_addr = INADDR_ANY;
  99    int rc = bind(_socket, (struct sockaddr*)&addr, sizeof(addr));
 100    if (rc == -1)
 101    {
 102       perror("bind");
 103       return false;
 104    }
 105
 106    // Open socket for receiving traps, if clients wants one
 107    if (trap)
 108    {
 109       _trapsock = socket(PF_INET, SOCK_DGRAM, 0);
 110       if (_trapsock == -1)
 111       {
 112          perror("socket");
 113          return false;
 114       }
 115
 116       memset(&addr, 0, sizeof(addr));
 117       addr.sin_family = AF_INET;
 118       addr.sin_port = htons(SNMP_TRAP_PORT);
 119       addr.sin_addr.s_addr = INADDR_ANY;
 120       rc = bind(_trapsock, (struct sockaddr*)&addr, sizeof(addr));
 121       if (rc == -1)
 122       {
 123          perror("bind");
 124          return false;
 125       }
 126    }
 127
 128    return true;
 129 }
 130
 131 void SnmpEngine::Close()
 132 {
 133    close(_socket);
 134    _socket = -1;
 135    close(_trapsock);
 136    _trapsock = -1;
 137 }
 138
 139 bool SnmpEngine::Set(const int oid[], Variable *data)
 140 {
 141    // Send the request
 142    VbListMessage req(Asn::SET_REQ_PDU, _community, _reqid++);
 143    req.Append(oid, data);
 144    if (!issue(&req))
 145       return false;
 146
 147    // Wait for a response
 148    VbListMessage *rsp = (VbListMessage*)rspwait(1000);
 149    if (!rsp)
 150       return false;
 151
 152    // Check error status
 153    if (rsp->ErrorStatus())
 154    {
 155       delete rsp;
 156       return false;
 157    }
 158
 159    delete rsp;
 160    return true;
 161 }
 162
 163 bool SnmpEngine::Get(const int oid[], Variable *data)
 164 {
 165    OidVar oidvar;
 166    oidvar.oid = oid;
 167    oidvar.data = *data;
 168
 169    alist<OidVar> oids;
 170    oids.append(oidvar);
 171
 172    bool ret = Get(oids);
 173    if (ret)
 174       *data = (*oids.begin()).data;
 175
 176    return ret;
 177 }
 178
 179 bool SnmpEngine::Get(alist<OidVar> &oids)
 180 {
 181    // First, fetch all scalar (i.e. non-sequence) OIDs using a single
 182    // SNMP GETNEXT-REQUEST. Note we use GETNEXT instead of GET since all
 183    // OIDs omit the trailing 0.
 184
 185    // Start with a request with no varbinds
 186    VbListMessage getreq(Asn::GETNEXT_REQ_PDU, _community, _reqid++);
 187
 188    // Append one varbind for each oidvar from the caller
 189    alist<OidVar>::iterator iter;
 190    for (iter = oids.begin(); iter != oids.end(); ++iter)
 191       if (iter->data.type != Asn::SEQUENCE)
 192          getreq.Append(iter->oid);
 193
 194    // Perform request if we put at least one OID in it
 195    if (getreq.Size() > 0)
 196    {
 197       // Send request & await response
 198       VbListMessage *rsp = perform(&getreq);
 199       if (!rsp)
 200          return false;
 201
 202       // Verify response varbind size is same as request
 203       // (i.e. agent provided a response for each varbind we requested)
 204       if (rsp->Size() != getreq.Size())
 205       {
 206          delete rsp;
 207          return false;
 208       }
 209
 210       // Copy response data into caller's oidvars. Although I believe the SNMP
 211       // spec requires the GET-RESPONSE to give the var-bind-list in the same
 212       // order as the GET-REQUEST, we're not going to count on that. A little
 213       // CPU time spent searching is ok to ensure widest compatiblity in case
 214       // we encounter a weak SNMP agent implementation.
 215       VbListMessage &response = *rsp;
 216       for (unsigned int i = 0; i < response.Size(); i++)
 217       {
 218          for (iter = oids.begin(); iter != oids.end(); ++iter)
 219          {
 220             if (response[i].Oid().IsChildOf(iter->oid))
 221             {
 222                response[i].Extract(&iter->data);
 223                break;
 224             }
 225          }
 226       }
 227
 228       // Done with response
 229       delete rsp;
 230    }
 231
 232    // Now process sequences. For each sequence we issue a series of
 233    // SNMP GETNEXT-REQUESTs until we detect the end of the sequence.
 234    for (iter = oids.begin(); iter != oids.end(); ++iter)
 235    {
 236       if (iter->data.type == Asn::SEQUENCE)
 237       {
 238          Asn::ObjectId nextoid = iter->oid;
 239          while (1)
 240          {
 241             // Create a GET-NEXT request
 242             VbListMessage nextreq(Asn::GETNEXT_REQ_PDU, _community, _reqid++);
 243
 244             // Request a single OID
 245             nextreq.Append(nextoid);
 246
 247             // Perform the request
 248             VbListMessage *rspmsg = perform(&nextreq);
 249
 250             // If request failed, we're done (possibly at end of MIB so we
 251             // don't consider this an error)
 252             if (!rspmsg)
 253                break;
 254
 255             // If result OID is not a child of the top-level OID we're fetching
 256             // it means we've run off the end of the sequence so we're done
 257             VarBind &result = (*rspmsg)[0];
 258             if (!result.Oid().IsChildOf(iter->oid))
 259             {
 260                delete rspmsg;
 261                break;
 262             }
 263
 264             // Extract data and append to sequence
 265             Variable tmp;
 266             result.Extract(&tmp);
 267             iter->data.seq.append(tmp);
 268
 269             // Save returned OID for next iteration
 270             nextoid = result.Oid();
 271             delete rspmsg;
 272          }
 273       }
 274    }
 275
 276    return true;
 277 }
 278
 279 VbListMessage *SnmpEngine::perform(VbListMessage *req)
 280 {
 281    // Send the request
 282    if (!issue(req))
 283       return NULL;
 284
 285    // Wait for a response
 286    VbListMessage *rsp = (VbListMessage*)rspwait(2000);
 287    if (rsp && rsp->ErrorStatus())
 288    {
 289       delete rsp;
 290       return NULL;
 291    }
 292
 293    return rsp;
 294 }
 295
 296 TrapMessage *SnmpEngine::TrapWait(unsigned int msec)
 297 {
 298    if (_trapsock == -1)
 299       return NULL;
 300
 301    return (TrapMessage*)rspwait(msec, true);
 302 }
 303
 304 bool SnmpEngine::issue(Message *msg)
 305 {
 306    // Marshal the data
 307    unsigned char data[8192];
 308    unsigned int buflen = sizeof(data);
 309    unsigned char *buffer = data;
 310    if (!msg->Marshal(buffer, buflen))
 311       return false;
 312
 313    // Send data to destination
 314    int datalen = buffer - data;
 315    int rc = sendto(_socket, (char*)data, datalen, 0,
 316                    (struct sockaddr*)&_destaddr, sizeof(_destaddr));
 317    if (rc != datalen)
 318    {
 319       perror("sendto");
 320       return false;
 321    }
 322
 323    return true;
 324 }
 325
 326 Message *SnmpEngine::rspwait(unsigned int msec, bool trap)
 327 {
 328    static unsigned char data[8192];
 329    struct sockaddr_in fromaddr;
 330
 331    int sock = trap ? _trapsock : _socket;
 332
 333    // Calculate exit time
 334    struct timeval exittime;
 335    gettimeofday(&exittime, NULL);
 336    exittime.tv_usec += msec * 1000;
 337    while (exittime.tv_usec >= 1000000)
 338    {
 339       exittime.tv_usec -= 1000000;
 340       exittime.tv_sec++;
 341    }
 342
 343    while(1)
 344    {
 345       // See if we've run out of time
 346       struct timeval now;
 347       gettimeofday(&now, NULL);
 348       if (now.tv_sec > exittime.tv_sec ||
 349           (now.tv_sec == exittime.tv_sec &&
 350            now.tv_usec >= exittime.tv_usec))
 351          return NULL;
 352
 353       // Calculate new timeout
 354       struct timeval timeout;
 355       timeout.tv_sec = exittime.tv_sec - now.tv_sec;
 356       timeout.tv_usec = exittime.tv_usec - now.tv_usec;
 357       while (timeout.tv_usec < 0)
 358       {
 359          timeout.tv_usec += 1000000;
 360          timeout.tv_sec--;
 361       }
 362
 363       // Wait for a datagram to arrive
 364       fd_set fds;
 365       FD_ZERO(&fds);
 366       FD_SET(sock, &fds);
 367       int rc = select(sock+1, &fds, NULL, NULL, &timeout);
 368       if (rc == -1)
 369       {
 370          if (errno == EAGAIN || errno == EINTR)
 371             continue;
 372          return NULL;
 373       }
 374
 375       // Timeout
 376       if (rc == 0)
 377          return NULL;
 378
 379       // Read datagram
 380       socklen_t fromlen = sizeof(fromaddr);
 381       rc = recvfrom(sock, (char*)data, sizeof(data), 0,
 382                     (struct sockaddr*)&fromaddr, &fromlen);
 383       if (rc == -1)
 384       {
 385          if (errno == EAGAIN || errno == EINTR)
 386             continue;
 387          return NULL;
 388       }
 389
 390       // Ignore packet if it's not from our agent
 391       if (fromaddr.sin_addr.s_addr != _destaddr.sin_addr.s_addr)
 392          continue;
 393
 394       // Got a packet from our agent: decode it
 395       unsigned char *buffer = data;
 396       unsigned int buflen = rc;
 397       Message *msg = Message::Demarshal(buffer, buflen);
 398       if (!msg)
 399          continue;
 400
 401       // Check message type
 402       if (trap && msg->Type() == Asn::TRAP_PDU)
 403       {
 404          return msg;
 405       }
 406       else if (!trap && msg->Type() == Asn::GET_RSP_PDU &&
 407                ((VbListMessage *)msg)->RequestId() == _reqid-1)
 408       {
 409          return msg;
 410       }
 411       else
 412       {
 413          printf("Unhandled SNMP message type: %02x\n", msg->Type());
 414       }
 415
 416       // Throw it out and try again
 417       delete msg;
 418    }
 419 }
 420
 421 // *****************************************************************************
 422 // VarBind
 423 // *****************************************************************************
 424
 425 VarBind::VarBind(const Asn::ObjectId &oid, Variable *data)
 426 {
 427    _oid = new Asn::ObjectId(oid);
 428
 429    if (data)
 430    {
 431       switch (data->type)
 432       {
 433       case Asn::INTEGER:
 434          _data = new Asn::Integer(data->type);
 435          *(_data->AsInteger()) = data->i32;
 436          break;
 437       case Asn::TIMETICKS:
 438       case Asn::COUNTER:
 439       case Asn::GAUGE:
 440          _data = new Asn::Integer(data->type);
 441          *(_data->AsInteger()) = data->u32;
 442          break;
 443       case Asn::OCTETSTRING:
 444          _data = new Asn::OctetString(data->str);
 445          break;
 446       case Asn::NULLL:
 447       default:
 448          _data = new Asn::Null();
 449          break;
 450       }
 451    }
 452    else
 453    {
 454       _data = new Asn::Null();
 455    }
 456 }
 457
 458 VarBind::VarBind(Asn::Sequence &seq)
 459 {
 460    if (seq.Size() == 2 &&
 461        seq[0]->IsObjectId())
 462    {
 463       _oid = seq[0]->copy()->AsObjectId();
 464       _data = seq[1]->copy();
 465    }
 466    else
 467    {
 468       _oid = new Asn::ObjectId();
 469       _data = new Asn::Null();
 470    }
 471 }
 472
 473 VarBind::~VarBind()
 474 {
 475    delete _data;
 476    delete _oid;
 477 }
 478
 479 bool VarBind::Extract(Variable *out)
 480 {
 481    out->type = _data->Type();
 482    if (_data->IsInteger())
 483    {
 484       out->i32 = _data->AsInteger()->IntValue();
 485       out->u32 = _data->AsInteger()->UintValue();
 486    }
 487    else if (_data->IsOctetString())
 488    {
 489       out->str = *_data->AsOctetString();
 490    }
 491    else
 492    {
 493       printf("Unsupported Asn::Object::AsnType: %d\n", _data->Type());
 494       return false;
 495    }
 496    return true;
 497 }
 498
 499 Asn::Sequence *VarBind::GetAsn()
 500 {
 501    Asn::Sequence *seq = new Asn::Sequence();
 502    seq->Append(_oid->copy());
 503    seq->Append(_data->copy());
 504    return seq;
 505 }
 506
 507 // *****************************************************************************
 508 // VarBindList
 509 // *****************************************************************************
 510
 511 VarBindList::VarBindList(Asn::Sequence &seq)
 512 {
 513    for (unsigned int i = 0; i < seq.Size(); i++)
 514    {
 515       if (seq[i]->IsSequence())
 516          _vblist.append(new VarBind(*seq[i]->AsSequence()));
 517    }
 518 }
 519
 520 VarBindList::~VarBindList()
 521 {
 522    for (unsigned int i = 0; i < _vblist.size(); i++)
 523       delete _vblist[i];
 524 }
 525
 526 void VarBindList::Append(const Asn::ObjectId &oid, Variable *data)
 527 {
 528    _vblist.append(new VarBind(oid, data));
 529 }
 530
 531 Asn::Sequence *VarBindList::GetAsn()
 532 {
 533    Asn::Sequence *seq = new Asn::Sequence();
 534    for (unsigned int i = 0; i < _vblist.size(); i++)
 535       seq->Append(_vblist[i]->GetAsn());
 536    return seq;
 537 }
 538
 539 // *****************************************************************************
 540 // VbListMessage
 541 // *****************************************************************************
 542 VbListMessage *VbListMessage::CreateFromSequence(
 543    Asn::Identifier type, const char *community, Asn::Sequence &seq)
 544 {
 545    // Verify format: We should have 4 parts.
 546    if (seq.Size() != 4 ||
 547        !seq[0]->IsInteger() ||  // request-id
 548        !seq[1]->IsInteger() ||  // error-status
 549        !seq[2]->IsInteger() ||  // error-index
 550        !seq[3]->IsSequence())   // variable-bindings
 551       return NULL;
 552
 553    // Extract data
 554    return new VbListMessage(type, community, seq);
 555 }
 556
 557 VbListMessage::VbListMessage(
 558    Asn::Identifier type,
 559    const char *community,
 560    Asn::Sequence &seq) :
 561       Message(type, community)
 562 {
 563    // Format was already verified in CreateFromSequence()
 564    _reqid = seq[0]->AsInteger()->IntValue();
 565    _errstatus = seq[1]->AsInteger()->IntValue();
 566    _errindex = seq[2]->AsInteger()->IntValue();
 567    _vblist = new VarBindList(*seq[3]->AsSequence());
 568 }
 569
 570 VbListMessage::VbListMessage(
 571    Asn::Identifier type,
 572    const char *community,
 573    int reqid) :
 574       Message(type, community),
 575       _reqid(reqid),
 576       _errstatus(0),
 577       _errindex(0),
 578       _vblist(new VarBindList())
 579 {
 580 }
 581
 582 void VbListMessage::Append(const Asn::ObjectId &oid, Variable *data)
 583 {
 584    _vblist->Append(oid, data);
 585 }
 586
 587 Asn::Sequence *VbListMessage::GetAsn()
 588 {
 589    Asn::Sequence *seq = new Asn::Sequence(_type);
 590    seq->Append(new Asn::Integer(_reqid));
 591    seq->Append(new Asn::Integer(_errstatus));
 592    seq->Append(new Asn::Integer(_errindex));
 593    seq->Append(_vblist->GetAsn());
 594    return seq;
 595 }
 596
 597 // *****************************************************************************
 598 // Message
 599 // *****************************************************************************
 600 Message *Message::Demarshal(unsigned char *&buffer, unsigned int &buflen)
 601 {
 602    Message *ret = NULL;
 603    astring community;
 604    Asn::Identifier type;
 605
 606    Asn::Object *obj = Asn::Object::Demarshal(buffer, buflen);
 607    if (!obj)
 608       return NULL;
 609
 610    // Data demarshalled okay. Now walk the object tree to parse the message.
 611
 612    // Top-level object should be a sequence of length 3
 613    Asn::Sequence &seq = *(Asn::Sequence*)obj;
 614    if (!obj->IsSequence() || seq.Size() != 3)
 615       goto error;
 616
 617    // First item in sequence is an integer specifying SNMP version
 618    if (!seq[0]->IsInteger() ||
 619        seq[0]->AsInteger()->IntValue() != SNMP_VERSION_1)
 620       goto error;
 621
 622    // Second item is the community string
 623    if (!seq[1]->IsOctetString())
 624       goto error;
 625    community = *seq[1]->AsOctetString();
 626
 627    // Third is another sequence containing the PDU
 628    type = seq[2]->Type();
 629    switch (type)
 630    {
 631    case Asn::GET_REQ_PDU:
 632    case Asn::GETNEXT_REQ_PDU:
 633    case Asn::GET_RSP_PDU:
 634       ret = VbListMessage::CreateFromSequence(
 635          type, community, *seq[2]->AsSequence());
 636       break;
 637    case Asn::TRAP_PDU:
 638       ret = TrapMessage::CreateFromSequence(
 639          type, community, *seq[2]->AsSequence());
 640       break;
 641    default:
 642       break;
 643    }
 644
 645 error:
 646    delete obj;
 647    return ret;
 648 }
 649
 650 bool Message::Marshal(unsigned char *&buffer, unsigned int &buflen)
 651 {
 652    Asn::Sequence *seq = new Asn::Sequence();
 653    seq->Append(new Asn::Integer(SNMP_VERSION_1));
 654    seq->Append(new Asn::OctetString(_community));
 655    seq->Append(GetAsn());
 656
 657    bool ret = seq->Marshal(buffer, buflen);
 658    delete seq;
 659    return ret;
 660 }
 661
 662 // *****************************************************************************
 663 // TrapMessage
 664 // *****************************************************************************
 665 TrapMessage *TrapMessage::CreateFromSequence(
 666    Asn::Identifier type, const char *community, Asn::Sequence &seq)
 667 {
 668    // Verify format: We should have 6 parts.
 669    if (seq.Size() != 6 ||
 670        !seq[0]->IsObjectId() ||     // enterprise
 671        !seq[1]->IsOctetString() ||  // agent-addr
 672        !seq[2]->IsInteger() ||      // generic-trap
 673        !seq[3]->IsInteger() ||      // specific-trap
 674        !seq[4]->IsInteger() ||      // time-stamp
 675        !seq[5]->IsSequence())       // variable-bindings
 676       return NULL;
 677
 678    // Extract data
 679    return new TrapMessage(type, community, seq);
 680 }
 681
 682 TrapMessage::TrapMessage(
 683    Asn::Identifier type,
 684    const char *community,
 685    Asn::Sequence &seq) :
 686       Message(type, community)
 687 {
 688    // Format was already verified in CreateFromSequence()
 689    _enterprise = seq[0]->copy()->AsObjectId();
 690    _generic = seq[2]->AsInteger()->IntValue();
 691    _specific = seq[3]->AsInteger()->IntValue();
 692    _timestamp = seq[4]->AsInteger()->UintValue();
 693    _vblist = new VarBindList(*seq[5]->AsSequence());
 694 }