clients/nutclient.cpp

   1 /* nutclient.cpp - nutclient C++ library implementation
   2
   3    Copyright (C) 2012  Emilien Kia <emilien.kia@gmail.com>
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  18 */
  19
  20 #include "nutclient.h"
  21
  22 #include <sstream>
  23
  24 #include <errno.h>
  25 #include <string.h>
  26 #include <stdio.h>
  27
  28 /* Windows/Linux Socket compatibility layer: */
  29 /* Thanks to Benjamin Roux (http://broux.developpez.com/articles/c/sockets/) */
  30 #ifdef WIN32
  31 #  include <winsock2.h>
  32 #else
  33 #  include <sys/types.h>
  34 #  include <sys/socket.h>
  35 #  include <netinet/in.h>
  36 #  include <arpa/inet.h>
  37 #  include <unistd.h> /* close */
  38 #  include <netdb.h> /* gethostbyname */
  39 #  include <fcntl.h>
  40 #  define INVALID_SOCKET -1
  41 #  define SOCKET_ERROR -1
  42 #  define closesocket(s) close(s)
  43    typedef int SOCKET;
  44    typedef struct sockaddr_in SOCKADDR_IN;
  45    typedef struct sockaddr SOCKADDR;
  46    typedef struct in_addr IN_ADDR;
  47 #endif /* WIN32 */
  48 /* End of Windows/Linux Socket compatibility layer: */
  49
  50
  51 /* Include nut common utility functions or define simple ones if not */
  52 #ifdef HAVE_NUTCOMMON
  53 #include "common.h"
  54 #else /* HAVE_NUTCOMMON */
  55 #include <stdlib.h>
  56 #include <string.h>
  57 static inline void *xmalloc(size_t size){return malloc(size);}
  58 static inline void *xcalloc(size_t number, size_t size){return calloc(number, size);}
  59 static inline void *xrealloc(void *ptr, size_t size){return realloc(ptr, size);}
  60 static inline char *xstrdup(const char *string){return strdup(string);}
  61 #endif /* HAVE_NUTCOMMON */
  62
  63
  64 namespace nut
  65 {
  66
  67 SystemException::SystemException():
  68 NutException(err())
  69 {
  70 }
  71
  72 std::string SystemException::err()
  73 {
  74         if(errno==0)
  75                 return "Undefined system error";
  76         else
  77         {
  78                 std::stringstream str;
  79                 str << "System error " << errno << ": " << strerror(errno);
  80                 return str.str();
  81         }
  82 }
  83
  84
  85 namespace internal
  86 {
  87
  88 /**
  89  * Internal socket wrapper.
  90  * Provides only client socket functions.
  91  *
  92  * Implemented as separate internal class to easily hide plateform specificities.
  93  */
  94 class Socket
  95 {
  96 public:
  97         Socket();
  98
  99         void connect(const std::string& host, int port)throw(nut::IOException);
 100         void disconnect();
 101         bool isConnected()const;
 102
 103         void setTimeout(long timeout);
 104         bool hasTimeout()const{return _tv.tv_sec>=0;}
 105
 106         size_t read(void* buf, size_t sz)throw(nut::IOException);
 107         size_t write(const void* buf, size_t sz)throw(nut::IOException);
 108
 109         std::string read()throw(nut::IOException);
 110         void write(const std::string& str)throw(nut::IOException);
 111
 112
 113 private:
 114         SOCKET _sock;
 115         struct timeval  _tv;
 116         std::string _buffer; /* Received buffer, string because data should be text only. */
 117 };
 118
 119 Socket::Socket():
 120 _sock(INVALID_SOCKET),
 121 _tv()
 122 {
 123         _tv.tv_sec = -1;
 124         _tv.tv_usec = 0;
 125 }
 126
 127 void Socket::setTimeout(long timeout)
 128 {
 129         _tv.tv_sec = timeout;
 130 }
 131
 132 void Socket::connect(const std::string& host, int port)throw(nut::IOException)
 133 {
 134         int     sock_fd;
 135         struct addrinfo hints, *res, *ai;
 136         char                    sport[NI_MAXSERV];
 137         int                     v;
 138         fd_set                  wfds;
 139         int                     error;
 140         socklen_t               error_size;
 141         long                    fd_flags;
 142
 143         _sock = -1;
 144
 145         if (host.empty()) {
 146                 throw nut::UnknownHostException();
 147         }
 148
 149         snprintf(sport, sizeof(sport), "%hu", (unsigned short int)port);
 150
 151         memset(&hints, 0, sizeof(hints));
 152         hints.ai_family = AF_UNSPEC;
 153         hints.ai_socktype = SOCK_STREAM;
 154         hints.ai_protocol = IPPROTO_TCP;
 155
 156         while ((v = getaddrinfo(host.c_str(), sport, &hints, &res)) != 0) {
 157                 switch (v)
 158                 {
 159                 case EAI_AGAIN:
 160                         continue;
 161                 case EAI_NONAME:
 162                         throw nut::UnknownHostException();
 163                 case EAI_SYSTEM:
 164                         throw nut::SystemException();
 165                 case EAI_MEMORY:
 166                         throw nut::NutException("Out of memory");
 167                 default:
 168                         throw nut::NutException("Unknown error");
 169                 }
 170         }
 171
 172         for (ai = res; ai != NULL; ai = ai->ai_next) {
 173
 174                 sock_fd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
 175
 176                 if (sock_fd < 0) {
 177                         switch (errno)
 178                         {
 179                         case EAFNOSUPPORT:
 180                         case EINVAL:
 181                 break;
 182                         default:
 183                                 throw nut::SystemException();
 184                         }
 185                         continue;
 186                 }
 187
 188                 /* non blocking connect */
 189                 if(hasTimeout()) {
 190                         fd_flags = fcntl(sock_fd, F_GETFL);
 191                         fd_flags |= O_NONBLOCK;
 192                         fcntl(sock_fd, F_SETFL, fd_flags);
 193                 }
 194
 195                 while ((v = ::connect(sock_fd, ai->ai_addr, ai->ai_addrlen)) < 0) {
 196                         if(errno == EINPROGRESS) {
 197                                 FD_ZERO(&wfds);
 198                                 FD_SET(sock_fd, &wfds);
 199                                 select(sock_fd+1,NULL,&wfds,NULL, hasTimeout()?&_tv:NULL);
 200                                 if (FD_ISSET(sock_fd, &wfds)) {
 201                                         error_size = sizeof(error);
 202                                         getsockopt(sock_fd,SOL_SOCKET,SO_ERROR,
 203                                                         &error,&error_size);
 204                                         if( error == 0) {
 205                                                 /* connect successful */
 206                                                 v = 0;
 207                                                 break;
 208                                         }
 209                                         errno = error;
 210                                 }
 211                                 else {
 212                                         /* Timeout */
 213                                         v = -1;
 214                                         break;
 215                                 }
 216                         }
 217
 218                         switch (errno)
 219                         {
 220                         case EAFNOSUPPORT:
 221                                 break;
 222                         case EINTR:
 223                         case EAGAIN:
 224                                 continue;
 225                         default:
 226 //                              ups->upserror = UPSCLI_ERR_CONNFAILURE;
 227 //                              ups->syserrno = errno;
 228                                 break;
 229                         }
 230                         break;
 231                 }
 232
 233                 if (v < 0) {
 234                         close(sock_fd);
 235                         continue;
 236                 }
 237
 238                 /* switch back to blocking operation */
 239                 if(hasTimeout()) {
 240                         fd_flags = fcntl(sock_fd, F_GETFL);
 241                         fd_flags &= ~O_NONBLOCK;
 242                         fcntl(sock_fd, F_SETFL, fd_flags);
 243                 }
 244
 245                 _sock = sock_fd;
 246 //              ups->upserror = 0;
 247 //              ups->syserrno = 0;
 248                 break;
 249         }
 250
 251         freeaddrinfo(res);
 252
 253         if (_sock < 0) {
 254                 throw nut::IOException("Cannot connect to host");
 255         }
 256
 257
 258 #ifdef OLD
 259         struct hostent *hostinfo = NULL;
 260         SOCKADDR_IN sin = { 0 };
 261         hostinfo = ::gethostbyname(host.c_str());
 262         if(hostinfo == NULL) /* Host doesnt exist */
 263         {
 264                 throw nut::UnknownHostException();
 265         }
 266
 267         // Create socket
 268         _sock = ::socket(PF_INET, SOCK_STREAM, 0);
 269         if(_sock == INVALID_SOCKET)
 270         {
 271                 throw nut::IOException("Cannot create socket");
 272         }
 273
 274         // Connect
 275         sin.sin_addr = *(IN_ADDR *) hostinfo->h_addr;
 276         sin.sin_port = htons(port);
 277         sin.sin_family = AF_INET;
 278         if(::connect(_sock,(SOCKADDR *) &sin, sizeof(SOCKADDR)) == SOCKET_ERROR)
 279         {
 280                 _sock = INVALID_SOCKET;
 281                 throw nut::IOException("Cannot connect to host");
 282         }
 283 #endif // OLD
 284 }
 285
 286 void Socket::disconnect()
 287 {
 288         if(_sock != INVALID_SOCKET)
 289         {
 290                 ::closesocket(_sock);
 291                 _sock = INVALID_SOCKET;
 292         }
 293         _buffer.clear();
 294 }
 295
 296 bool Socket::isConnected()const
 297 {
 298         return _sock!=INVALID_SOCKET;
 299 }
 300
 301 size_t Socket::read(void* buf, size_t sz)throw(nut::IOException)
 302 {
 303         if(!isConnected())
 304         {
 305                 throw nut::NotConnectedException();
 306         }
 307
 308         if(_tv.tv_sec>=0)
 309         {
 310                 fd_set fds;
 311                 FD_ZERO(&fds);
 312                 FD_SET(_sock, &fds);
 313                 int ret = select(_sock+1, &fds, NULL, NULL, &_tv);
 314                 if (ret < 1) {
 315                         throw nut::TimeoutException();
 316                 }
 317         }
 318
 319         ssize_t res = ::read(_sock, buf, sz);
 320         if(res==-1)
 321         {
 322                 disconnect();
 323                 throw nut::IOException("Error while reading on socket");
 324         }
 325         return (size_t) res;
 326 }
 327
 328 size_t Socket::write(const void* buf, size_t sz)throw(nut::IOException)
 329 {
 330         if(!isConnected())
 331         {
 332                 throw nut::NotConnectedException();
 333         }
 334
 335         if(_tv.tv_sec>=0)
 336         {
 337                 fd_set fds;
 338                 FD_ZERO(&fds);
 339                 FD_SET(_sock, &fds);
 340                 int ret = select(_sock+1, NULL, &fds, NULL, &_tv);
 341                 if (ret < 1) {
 342                         throw nut::TimeoutException();
 343                 }
 344         }
 345
 346         ssize_t res = ::write(_sock, buf, sz);
 347         if(res==-1)
 348         {
 349                 disconnect();
 350                 throw nut::IOException("Error while writing on socket");
 351         }
 352         return (size_t) res;
 353 }
 354
 355 std::string Socket::read()throw(nut::IOException)
 356 {
 357         std::string res;
 358         char buff[256];
 359
 360         while(true)
 361         {
 362                 // Look at already read data in _buffer
 363                 if(!_buffer.empty())
 364                 {
 365                         size_t idx = _buffer.find('\n');
 366                         if(idx!=std::string::npos)
 367                         {
 368                                 res += _buffer.substr(0, idx);
 369                                 _buffer.erase(0, idx+1);
 370                                 return res;
 371                         }
 372                         res += _buffer;
 373                 }
 374
 375                 // Read new buffer
 376                 size_t sz = read(&buff, 256);
 377                 _buffer.assign(buff, sz);
 378         }
 379 }
 380
 381 void Socket::write(const std::string& str)throw(nut::IOException)
 382 {
 383 //      write(str.c_str(), str.size());
 384 //      write("\n", 1);
 385         std::string buff = str + "\n";
 386         write(buff.c_str(), buff.size());
 387 }
 388
 389 }/* namespace internal */
 390
 391
 392 /*
 393  *
 394  * Client implementation
 395  *
 396  */
 397
 398 Client::Client()
 399 {
 400 }
 401
 402 Client::~Client()
 403 {
 404 }
 405
 406 bool Client::hasDevice(const std::string& dev)throw(NutException)
 407 {
 408         std::set<std::string> devs = getDeviceNames();
 409         return devs.find(dev) != devs.end();
 410 }
 411
 412 Device Client::getDevice(const std::string& name)throw(NutException)
 413 {
 414         if(hasDevice(name))
 415                 return Device(this, name);
 416         else
 417                 return Device(NULL, "");
 418 }
 419
 420 std::set<Device> Client::getDevices()throw(NutException)
 421 {
 422         std::set<Device> res;
 423
 424         std::set<std::string> devs = getDeviceNames();
 425         for(std::set<std::string>::iterator it=devs.begin(); it!=devs.end(); ++it)
 426         {
 427           res.insert(Device(this, *it));
 428         }
 429
 430         return res;
 431 }
 432
 433 bool Client::hasDeviceVariable(const std::string& dev, const std::string& name)throw(NutException)
 434 {
 435         std::set<std::string> names = getDeviceVariableNames(dev);
 436         return names.find(name) != names.end();
 437 }
 438
 439 std::map<std::string,std::vector<std::string> > Client::getDeviceVariableValues(const std::string& dev)throw(NutException)
 440 {
 441   std::map<std::string,std::vector<std::string> > res;
 442
 443   std::set<std::string> names = getDeviceVariableNames(dev);
 444   for(std::set<std::string>::iterator it=names.begin(); it!=names.end(); ++it)
 445   {
 446     const std::string& name = *it;
 447     res[name] = getDeviceVariableValue(dev, name);
 448   }
 449
 450   return res;
 451 }
 452
 453 bool Client::hasDeviceCommand(const std::string& dev, const std::string& name)throw(NutException)
 454 {
 455   std::set<std::string> names = getDeviceCommandNames(dev);
 456   return names.find(name) != names.end();
 457 }
 458
 459
 460 /*
 461  *
 462  * TCP Client implementation
 463  *
 464  */
 465
 466 TcpClient::TcpClient():
 467 Client(),
 468 _host("localhost"),
 469 _port(3493),
 470 _socket(new internal::Socket)
 471 {
 472         // Do not connect now
 473 }
 474
 475 TcpClient::TcpClient(const std::string& host, int port)throw(IOException):
 476 Client(),
 477 _socket(new internal::Socket)
 478 {
 479         connect(host, port);
 480 }
 481
 482 TcpClient::~TcpClient()
 483 {
 484         delete _socket;
 485 }
 486
 487 void TcpClient::connect(const std::string& host, int port)throw(IOException)
 488 {
 489         _host = host;
 490         _port = port;
 491         connect();
 492 }
 493
 494 void TcpClient::connect()throw(nut::IOException)
 495 {
 496         _socket->connect(_host, _port);
 497 }
 498
 499 std::string TcpClient::getHost()const
 500 {
 501         return _host;
 502 }
 503
 504 int TcpClient::getPort()const
 505 {
 506         return _port;
 507 }
 508
 509 bool TcpClient::isConnected()const
 510 {
 511         return _socket->isConnected();
 512 }
 513
 514 void TcpClient::disconnect()
 515 {
 516         _socket->disconnect();
 517 }
 518
 519 void TcpClient::setTimeout(long timeout)
 520 {
 521         _timeout = timeout;
 522 }
 523
 524 long TcpClient::getTimeout()const
 525 {
 526         return _timeout;
 527 }
 528
 529 void TcpClient::authenticate(const std::string& user, const std::string& passwd)
 530         throw(NutException)
 531 {
 532         detectError(sendQuery("USERNAME " + user));
 533         detectError(sendQuery("PASSWORD " + passwd));
 534 }
 535
 536 void TcpClient::logout()throw(NutException)
 537 {
 538         detectError(sendQuery("LOGOUT"));
 539         _socket->disconnect();
 540 }
 541
 542 Device TcpClient::getDevice(const std::string& name)throw(NutException)
 543 {
 544         try
 545         {
 546                 get("UPSDESC", name);
 547         }
 548         catch(NutException& ex)
 549         {
 550                 if(ex.str()=="UNKNOWN-UPS")
 551                         return Device(NULL, "");
 552                 else
 553                         throw;
 554         }
 555         return Device(this, name);
 556 }
 557
 558 std::set<std::string> TcpClient::getDeviceNames()throw(NutException)
 559 {
 560         std::set<std::string> res;
 561
 562         std::vector<std::vector<std::string> > devs = list("UPS");
 563         for(std::vector<std::vector<std::string> >::iterator it=devs.begin();
 564                 it!=devs.end(); ++it)
 565         {
 566                 std::string id = (*it)[0];
 567                 if(!id.empty())
 568                         res.insert(id);
 569         }
 570
 571         return res;
 572 }
 573
 574 std::string TcpClient::getDeviceDescription(const std::string& name)throw(NutException)
 575 {
 576   return get("UPSDESC", name)[0];
 577 }
 578
 579 std::set<std::string> TcpClient::getDeviceVariableNames(const std::string& dev)throw(NutException)
 580 {
 581         std::set<std::string> set;
 582
 583         std::vector<std::vector<std::string> > res = list("VAR", dev);
 584         for(size_t n=0; n<res.size(); ++n)
 585         {
 586                 set.insert(res[n][0]);
 587         }
 588
 589         return set;
 590 }
 591
 592 std::set<std::string> TcpClient::getDeviceRWVariableNames(const std::string& dev)throw(NutException)
 593 {
 594         std::set<std::string> set;
 595
 596         std::vector<std::vector<std::string> > res = list("RW", dev);
 597         for(size_t n=0; n<res.size(); ++n)
 598         {
 599                 set.insert(res[n][0]);
 600         }
 601
 602         return set;
 603 }
 604
 605 std::string TcpClient::getDeviceVariableDescription(const std::string& dev, const std::string& name)throw(NutException)
 606 {
 607         return get("DESC", dev + " " + name)[0];
 608 }
 609
 610 std::vector<std::string> TcpClient::getDeviceVariableValue(const std::string& dev, const std::string& name)throw(NutException)
 611 {
 612         return get("VAR", dev + " " + name);
 613 }
 614
 615 std::map<std::string,std::vector<std::string> > TcpClient::getDeviceVariableValues(const std::string& dev)throw(NutException)
 616 {
 617
 618         std::map<std::string,std::vector<std::string> >  map;
 619
 620         std::vector<std::vector<std::string> > res = list("VAR", dev);
 621         for(size_t n=0; n<res.size(); ++n)
 622         {
 623                 std::vector<std::string>& vals = res[n];
 624                 std::string var = vals[0];
 625                 vals.erase(vals.begin());
 626                 map[var] = vals;
 627         }
 628
 629         return map;
 630 }
 631
 632 void TcpClient::setDeviceVariable(const std::string& dev, const std::string& name, const std::string& value)throw(NutException)
 633 {
 634         std::string query = "SET VAR " + dev + " " + name + " " + escape(value);
 635         detectError(sendQuery(query));
 636 }
 637
 638 void TcpClient::setDeviceVariable(const std::string& dev, const std::string& name, const std::vector<std::string>& values)throw(NutException)
 639 {
 640         std::string query = "SET VAR " + dev + " " + name;
 641         for(size_t n=0; n<values.size(); ++n)
 642         {
 643                 query += " " + escape(values[n]);
 644         }
 645         detectError(sendQuery(query));
 646 }
 647
 648 std::set<std::string> TcpClient::getDeviceCommandNames(const std::string& dev)throw(NutException)
 649 {
 650         std::set<std::string> cmds;
 651
 652         std::vector<std::vector<std::string> > res = list("CMD", dev);
 653         for(size_t n=0; n<res.size(); ++n)
 654         {
 655                 cmds.insert(res[n][0]);
 656         }
 657
 658         return cmds;
 659 }
 660
 661 std::string TcpClient::getDeviceCommandDescription(const std::string& dev, const std::string& name)throw(NutException)
 662 {
 663         return get("CMDDESC", dev + " " + name)[0];
 664 }
 665
 666 void TcpClient::executeDeviceCommand(const std::string& dev, const std::string& name)throw(NutException)
 667 {
 668         detectError(sendQuery("INSTCMD " + dev + " " + name));
 669 }
 670
 671 void TcpClient::deviceLogin(const std::string& dev)throw(NutException)
 672 {
 673         detectError(sendQuery("LOGIN " + dev));
 674 }
 675
 676 void TcpClient::deviceMaster(const std::string& dev)throw(NutException)
 677 {
 678         detectError(sendQuery("MASTER " + dev));
 679 }
 680
 681 void TcpClient::deviceForcedShutdown(const std::string& dev)throw(NutException)
 682 {
 683         detectError(sendQuery("FSD " + dev));
 684 }
 685
 686 int TcpClient::deviceGetNumLogins(const std::string& dev)throw(NutException)
 687 {
 688         std::string num = get("NUMLOGINS", dev)[0];
 689         return atoi(num.c_str());
 690 }
 691
 692
 693 std::vector<std::string> TcpClient::get
 694         (const std::string& subcmd, const std::string& params) throw(NutException)
 695 {
 696         std::string req = subcmd;
 697         if(!params.empty())
 698         {
 699                 req += " " + params;
 700         }
 701         std::string res = sendQuery("GET " + req);
 702         detectError(res);
 703         if(res.substr(0, req.size()) != req)
 704         {
 705                 throw NutException("Invalid response");
 706         }
 707
 708         return explode(res, req.size());
 709 }
 710
 711 std::vector<std::vector<std::string> > TcpClient::list
 712         (const std::string& subcmd, const std::string& params) throw(NutException)
 713 {
 714         std::string req = subcmd;
 715         if(!params.empty())
 716         {
 717                 req += " " + params;
 718         }
 719         std::string res = sendQuery("LIST " + req);
 720         detectError(res);
 721         if(res != ("BEGIN LIST " + req))
 722         {
 723                 throw NutException("Invalid response");
 724         }
 725
 726         std::vector<std::vector<std::string> > arr;
 727         while(true)
 728         {
 729                 res = _socket->read();
 730                 detectError(res);
 731                 if(res == ("END LIST " + req))
 732                 {
 733                         return arr;
 734                 }
 735                 if(res.substr(0, req.size()) == req)
 736                 {
 737                         arr.push_back(explode(res, req.size()));
 738                 }
 739                 else
 740                 {
 741                         throw NutException("Invalid response");
 742                 }
 743         }
 744 }
 745
 746 std::string TcpClient::sendQuery(const std::string& req)throw(IOException)
 747 {
 748         _socket->write(req);
 749         return _socket->read();
 750 }
 751
 752 void TcpClient::detectError(const std::string& req)throw(NutException)
 753 {
 754         if(req.substr(0,3)=="ERR")
 755         {
 756                 throw NutException(req.substr(4));
 757         }
 758 }
 759
 760 std::vector<std::string> TcpClient::explode(const std::string& str, size_t begin)
 761 {
 762         std::vector<std::string> res;
 763         std::string temp;
 764
 765         enum STATE {
 766                 INIT,
 767                 SIMPLE_STRING,
 768                 QUOTED_STRING,
 769                 SIMPLE_ESCAPE,
 770                 QUOTED_ESCAPE
 771         } state = INIT;
 772
 773         for(size_t idx=begin; idx<str.size(); ++idx)
 774         {
 775                 char c = str[idx];
 776                 switch(state)
 777                 {
 778                 case INIT:
 779                         if(c==' ' /* || c=='\t' */)
 780                         { /* Do nothing */ }
 781                         else if(c=='"')
 782                         {
 783                                 state = QUOTED_STRING;
 784                         }
 785                         else if(c=='\\')
 786                         {
 787                                 state = SIMPLE_ESCAPE;
 788                         }
 789                         /* What about bad characters ? */
 790                         else
 791                         {
 792                                 temp += c;
 793                                 state = SIMPLE_STRING;
 794                         }
 795                         break;
 796                 case SIMPLE_STRING:
 797                         if(c==' ' /* || c=='\t' */)
 798                         {
 799                                 /* if(!temp.empty()) : Must not occur */
 800                                         res.push_back(temp);
 801                                 temp.clear();
 802                                 state = INIT;
 803                         }
 804                         else if(c=='\\')
 805                         {
 806                                 state = SIMPLE_ESCAPE;
 807                         }
 808                         else if(c=='"')
 809                         {
 810                                 /* if(!temp.empty()) : Must not occur */
 811                                         res.push_back(temp);
 812                                 temp.clear();
 813                                 state = QUOTED_STRING;
 814                         }
 815                         /* What about bad characters ? */
 816                         else
 817                         {
 818                                 temp += c;
 819                         }
 820                         break;
 821                 case QUOTED_STRING:
 822                         if(c=='\\')
 823                         {
 824                                 state = QUOTED_ESCAPE;
 825                         }
 826                         else if(c=='"')
 827                         {
 828                                 res.push_back(temp);
 829                                 temp.clear();
 830                                 state = INIT;
 831                         }
 832                         /* What about bad characters ? */
 833                         else
 834                         {
 835                                 temp += c;
 836                         }
 837                         break;
 838                 case SIMPLE_ESCAPE:
 839                         if(c=='\\' || c=='"' || c==' ' /* || c=='\t'*/)
 840                         {
 841                                 temp += c;
 842                         }
 843                         else
 844                         {
 845                                 temp += '\\' + c; // Really do this ?
 846                         }
 847                         state = SIMPLE_STRING;
 848                         break;
 849                 case QUOTED_ESCAPE:
 850                         if(c=='\\' || c=='"')
 851                         {
 852                                 temp += c;
 853                         }
 854                         else
 855                         {
 856                                 temp += '\\' + c; // Really do this ?
 857                         }
 858                         state = QUOTED_STRING;
 859                         break;
 860                 }
 861         }
 862
 863         if(!temp.empty())
 864         {
 865                 res.push_back(temp);
 866         }
 867
 868         return res;
 869 }
 870
 871 std::string TcpClient::escape(const std::string& str)
 872 {
 873         std::string res = "\"";
 874
 875         for(size_t n=0; n<str.size(); n++)
 876         {
 877                 char c = str[n];
 878                 if(c=='"')
 879                         res += "\\\"";
 880                 else if(c=='\\')
 881                         res += "\\\\";
 882                 else
 883                         res += c;
 884         }
 885
 886         res += '"';
 887         return res;
 888 }
 889
 890 /*
 891  *
 892  * Device implementation
 893  *
 894  */
 895
 896 Device::Device(Client* client, const std::string& name):
 897 _client(client),
 898 _name(name)
 899 {
 900 }
 901
 902 Device::Device(const Device& dev):
 903 _client(dev._client),
 904 _name(dev._name)
 905 {
 906 }
 907
 908 Device::~Device()
 909 {
 910 }
 911
 912 std::string Device::getName()const
 913 {
 914         return _name;
 915 }
 916
 917 const Client* Device::getClient()const
 918 {
 919         return _client;
 920 }
 921
 922 Client* Device::getClient()
 923 {
 924         return _client;
 925 }
 926
 927 bool Device::isOk()const
 928 {
 929         return _client!=NULL && !_name.empty();
 930 }
 931
 932 Device::operator bool()const
 933 {
 934         return isOk();
 935 }
 936
 937 bool Device::operator!()const
 938 {
 939         return !isOk();
 940 }
 941
 942 bool Device::operator==(const Device& dev)const
 943 {
 944         return dev._client==_client && dev._name==_name;
 945 }
 946
 947 bool Device::operator<(const Device& dev)const
 948 {
 949   return getName()<dev.getName();
 950 }
 951
 952 std::string Device::getDescription()throw(NutException)
 953 {
 954         return getClient()->getDeviceDescription(getName());
 955 }
 956
 957 std::vector<std::string> Device::getVariableValue(const std::string& name)
 958         throw(NutException)
 959 {
 960         return getClient()->getDeviceVariableValue(getName(), name);
 961 }
 962
 963 std::map<std::string,std::vector<std::string> > Device::getVariableValues()
 964         throw(NutException)
 965 {
 966         return getClient()->getDeviceVariableValues(getName());
 967 }
 968
 969 std::set<std::string> Device::getVariableNames()throw(NutException)
 970 {
 971   return getClient()->getDeviceVariableNames(getName());
 972 }
 973
 974 std::set<std::string> Device::getRWVariableNames()throw(NutException)
 975 {
 976   return getClient()->getDeviceRWVariableNames(getName());
 977 }
 978
 979 void Device::setVariable(const std::string& name, const std::string& value)throw(NutException)
 980 {
 981   getClient()->setDeviceVariable(getName(), name, value);
 982 }
 983
 984 void Device::setVariable(const std::string& name, const std::vector<std::string>& values)
 985         throw(NutException)
 986 {
 987   getClient()->setDeviceVariable(getName(), name, values);
 988 }
 989
 990
 991
 992 Variable Device::getVariable(const std::string& name)throw(NutException)
 993 {
 994   if(getClient()->hasDeviceVariable(getName(), name))
 995         return Variable(this, name);
 996   else
 997     return Variable(NULL, "");
 998 }
 999
1000 std::set<Variable> Device::getVariables()throw(NutException)
1001 {
1002         std::set<Variable> set;
1003
1004   std::set<std::string> names = getClient()->getDeviceVariableNames(getName());
1005   for(std::set<std::string>::iterator it=names.begin(); it!=names.end(); ++it)
1006   {
1007                 set.insert(Variable(this, *it));
1008   }
1009
1010         return set;
1011 }
1012
1013 std::set<Variable> Device::getRWVariables()throw(NutException)
1014 {
1015         std::set<Variable> set;
1016
1017   std::set<std::string> names = getClient()->getDeviceRWVariableNames(getName());
1018   for(std::set<std::string>::iterator it=names.begin(); it!=names.end(); ++it)
1019   {
1020                 set.insert(Variable(this, *it));
1021   }
1022
1023         return set;
1024 }
1025
1026 std::set<std::string> Device::getCommandNames()throw(NutException)
1027 {
1028   return getClient()->getDeviceCommandNames(getName());
1029 }
1030
1031 std::set<Command> Device::getCommands()throw(NutException)
1032 {
1033         std::set<Command> cmds;
1034
1035         std::set<std::string> res = getCommandNames();
1036         for(std::set<std::string>::iterator it=res.begin(); it!=res.end(); ++it)
1037         {
1038                 cmds.insert(Command(this, *it));
1039         }
1040
1041         return cmds;
1042 }
1043
1044 Command Device::getCommand(const std::string& name)throw(NutException)
1045 {
1046   if(getClient()->hasDeviceCommand(getName(), name))
1047         return Command(this, name);
1048   else
1049     return Command(NULL, "");
1050 }
1051
1052 void Device::executeCommand(const std::string& name)throw(NutException)
1053 {
1054   getClient()->executeDeviceCommand(getName(), name);
1055 }
1056
1057 void Device::login()throw(NutException)
1058 {
1059   getClient()->deviceLogin(getName());
1060 }
1061
1062 void Device::master()throw(NutException)
1063 {
1064   getClient()->deviceMaster(getName());
1065 }
1066
1067 void Device::forcedShutdown()throw(NutException)
1068 {
1069 }
1070
1071 int Device::getNumLogins()throw(NutException)
1072 {
1073   return getClient()->deviceGetNumLogins(getName());
1074 }
1075
1076 /*
1077  *
1078  * Variable implementation
1079  *
1080  */
1081
1082 Variable::Variable(Device* dev, const std::string& name):
1083 _device(dev),
1084 _name(name)
1085 {
1086 }
1087
1088 Variable::Variable(const Variable& var):
1089 _device(var._device),
1090 _name(var._name)
1091 {
1092 }
1093
1094 Variable::~Variable()
1095 {
1096 }
1097
1098 std::string Variable::getName()const
1099 {
1100         return _name;
1101 }
1102
1103 const Device* Variable::getDevice()const
1104 {
1105         return _device;
1106 }
1107
1108 Device* Variable::getDevice()
1109 {
1110         return _device;
1111 }
1112
1113 bool Variable::isOk()const
1114 {
1115         return _device!=NULL && !_name.empty();
1116
1117 }
1118
1119 Variable::operator bool()const
1120 {
1121         return isOk();
1122 }
1123
1124 bool Variable::operator!()const
1125 {
1126         return !isOk();
1127 }
1128
1129 bool Variable::operator==(const Variable& var)const
1130 {
1131         return var._device==_device && var._name==_name;
1132 }
1133
1134 bool Variable::operator<(const Variable& var)const
1135 {
1136         return getName()<var.getName();
1137 }
1138
1139 std::vector<std::string> Variable::getValue()throw(NutException)
1140 {
1141   return getDevice()->getClient()->getDeviceVariableValue(getDevice()->getName(), getName());
1142 }
1143
1144 std::string Variable::getDescription()throw(NutException)
1145 {
1146   return getDevice()->getClient()->getDeviceVariableDescription(getDevice()->getName(), getName());
1147 }
1148
1149 void Variable::setValue(const std::string& value)throw(NutException)
1150 {
1151         getDevice()->setVariable(getName(), value);
1152 }
1153
1154 void Variable::setValues(const std::vector<std::string>& values)throw(NutException)
1155 {
1156         getDevice()->setVariable(getName(), values);
1157 }
1158
1159
1160 /*
1161  *
1162  * Command implementation
1163  *
1164  */
1165
1166 Command::Command(Device* dev, const std::string& name):
1167 _device(dev),
1168 _name(name)
1169 {
1170 }
1171
1172 Command::Command(const Command& cmd):
1173 _device(cmd._device),
1174 _name(cmd._name)
1175 {
1176 }
1177
1178 Command::~Command()
1179 {
1180 }
1181
1182 std::string Command::getName()const
1183 {
1184         return _name;
1185 }
1186
1187 const Device* Command::getDevice()const
1188 {
1189         return _device;
1190 }
1191
1192 Device* Command::getDevice()
1193 {
1194         return _device;
1195 }
1196
1197 bool Command::isOk()const
1198 {
1199         return _device!=NULL && !_name.empty();
1200
1201 }
1202
1203 Command::operator bool()const
1204 {
1205         return isOk();
1206 }
1207
1208 bool Command::operator!()const
1209 {
1210         return !isOk();
1211 }
1212
1213 bool Command::operator==(const Command& cmd)const
1214 {
1215         return cmd._device==_device && cmd._name==_name;
1216 }
1217
1218 bool Command::operator<(const Command& cmd)const
1219 {
1220         return getName()<cmd.getName();
1221 }
1222
1223 std::string Command::getDescription()throw(NutException)
1224 {
1225         return getDevice()->getClient()->getDeviceCommandDescription(getDevice()->getName(), getName());
1226 }
1227
1228 void Command::execute()throw(NutException)
1229 {
1230         getDevice()->executeCommand(getName());
1231 }
1232
1233 } /* namespace nut */
1234
1235
1236 /**
1237  * C nutclient API.
1238  */
1239 extern "C" {
1240
1241
1242 strarr strarr_alloc(unsigned short count)
1243 {
1244         strarr arr = (strarr)xcalloc(count+1, sizeof(char*));
1245         arr[count] = NULL;
1246         return arr;
1247 }
1248
1249 void strarr_free(strarr arr)
1250 {
1251         char** pstr = arr;
1252         while(*pstr!=NULL)
1253         {
1254                 free(*pstr);
1255                 ++pstr;
1256         }
1257         free(arr);
1258 }
1259
1260
1261 static strarr stringset_to_strarr(const std::set<std::string>& strset)
1262 {
1263         strarr arr = strarr_alloc(strset.size());
1264         strarr pstr = arr;
1265         for(std::set<std::string>::const_iterator it=strset.begin(); it!=strset.end(); ++it)
1266         {
1267                 *pstr = xstrdup(it->c_str());
1268         }
1269         return arr;
1270 }
1271
1272 static strarr stringvector_to_strarr(const std::vector<std::string>& strset)
1273 {
1274         strarr arr = strarr_alloc(strset.size());
1275         strarr pstr = arr;
1276         for(std::vector<std::string>::const_iterator it=strset.begin(); it!=strset.end(); ++it)
1277         {
1278                 *pstr = xstrdup(it->c_str());
1279         }
1280         return arr;
1281 }
1282
1283
1284 NUTCLIENT_TCP_t nutclient_tcp_create_client(const char* host, unsigned short port)
1285 {
1286         nut::TcpClient* client = new nut::TcpClient;
1287         try
1288         {
1289                 client->connect(host, port);
1290                 return (NUTCLIENT_TCP_t)client;
1291         }
1292         catch(nut::NutException& ex)
1293         {
1294                 // TODO really catch it
1295                 delete client;
1296                 return NULL;
1297         }
1298
1299 }
1300
1301 void nutclient_destroy(NUTCLIENT_t client)
1302 {
1303         if(client)
1304         {
1305                 delete (nut::Client*)client;
1306         }
1307 }
1308
1309 int nutclient_tcp_is_connected(NUTCLIENT_TCP_t client)
1310 {
1311         if(client)
1312         {
1313                 nut::TcpClient* cl = dynamic_cast<nut::TcpClient*>((nut::Client*)client);
1314                 if(cl)
1315                 {
1316                         return cl->isConnected() ? 1 : 0;
1317                 }
1318         }
1319         return 0;
1320 }
1321
1322 void nutclient_tcp_disconnect(NUTCLIENT_TCP_t client)
1323 {
1324         if(client)
1325         {
1326                 nut::TcpClient* cl = dynamic_cast<nut::TcpClient*>((nut::Client*)client);
1327                 if(cl)
1328                 {
1329                         cl->disconnect();
1330                 }
1331         }
1332 }
1333
1334
1335 int nutclient_tcp_reconnect(NUTCLIENT_TCP_t client)
1336 {
1337         if(client)
1338         {
1339                 nut::TcpClient* cl = dynamic_cast<nut::TcpClient*>((nut::Client*)client);
1340                 if(cl)
1341                 {
1342                         try
1343                         {
1344                                 cl->connect();
1345                                 return 0;
1346                         }
1347                         catch(...){}
1348                 }
1349         }
1350         return -1;
1351 }
1352
1353 void nutclient_tcp_set_timeout(NUTCLIENT_TCP_t client, long timeout)
1354 {
1355         if(client)
1356         {
1357                 nut::TcpClient* cl = dynamic_cast<nut::TcpClient*>((nut::Client*)client);
1358                 if(cl)
1359                 {
1360                         cl->setTimeout(timeout);
1361                 }
1362         }
1363 }
1364
1365 long nutclient_tcp_get_timeout(NUTCLIENT_TCP_t client)
1366 {
1367         if(client)
1368         {
1369                 nut::TcpClient* cl = dynamic_cast<nut::TcpClient*>((nut::Client*)client);
1370                 if(cl)
1371                 {
1372                         return cl->getTimeout();
1373                 }
1374         }
1375         return -1;
1376 }
1377
1378
1379 void nutclient_authenticate(NUTCLIENT_t client, const char* login, const char* passwd)
1380 {
1381         if(client)
1382         {
1383                 nut::Client* cl = (nut::Client*)client;
1384                 if(cl)
1385                 {
1386                         try
1387                         {
1388                                 cl->authenticate(login, passwd);
1389                         }
1390                         catch(...){}
1391                 }
1392         }
1393 }
1394
1395 void nutclient_logout(NUTCLIENT_t client)
1396 {
1397         if(client)
1398         {
1399                 nut::Client* cl = (nut::Client*)client;
1400                 if(cl)
1401                 {
1402                         try
1403                         {
1404                                 cl->logout();
1405                         }
1406                         catch(...){}
1407                 }
1408         }
1409 }
1410
1411 void nutclient_device_login(NUTCLIENT_t client, const char* dev)
1412 {
1413         if(client)
1414         {
1415                 nut::Client* cl = (nut::Client*)client;
1416                 if(cl)
1417                 {
1418                         try
1419                         {
1420                                 cl->deviceLogin(dev);
1421                         }
1422                         catch(...){}
1423                 }
1424         }
1425 }
1426
1427 int nutclient_get_device_num_logins(NUTCLIENT_t client, const char* dev)
1428 {
1429         if(client)
1430         {
1431                 nut::Client* cl = (nut::Client*)client;
1432                 if(cl)
1433                 {
1434                         try
1435                         {
1436                                 return cl->deviceGetNumLogins(dev);
1437                         }
1438                         catch(...){}
1439                 }
1440         }
1441         return -1;
1442 }
1443
1444
1445 void nutclient_device_master(NUTCLIENT_t client, const char* dev)
1446 {
1447         if(client)
1448         {
1449                 nut::Client* cl = (nut::Client*)client;
1450                 if(cl)
1451                 {
1452                         try
1453                         {
1454                                 cl->deviceMaster(dev);
1455                         }
1456                         catch(...){}
1457                 }
1458         }
1459 }
1460
1461 void nutclient_device_forced_shutdown(NUTCLIENT_t client, const char* dev)
1462 {
1463         if(client)
1464         {
1465                 nut::Client* cl = (nut::Client*)client;
1466                 if(cl)
1467                 {
1468                         try
1469                         {
1470                                 cl->deviceForcedShutdown(dev);
1471                         }
1472                         catch(...){}
1473                 }
1474         }
1475 }
1476
1477 strarr nutclient_get_devices(NUTCLIENT_t client)
1478 {
1479         if(client)
1480         {
1481                 nut::Client* cl = (nut::Client*)client;
1482                 if(cl)
1483                 {
1484                         try
1485                         {
1486                                 return stringset_to_strarr(cl->getDeviceNames());
1487                         }
1488                         catch(...){}
1489                 }
1490         }
1491         return NULL;
1492 }
1493
1494 int nutclient_has_device(NUTCLIENT_t client, const char* dev)
1495 {
1496         if(client)
1497         {
1498                 nut::Client* cl = (nut::Client*)client;
1499                 if(cl)
1500                 {
1501                         try
1502                         {
1503                                 return cl->hasDevice(dev)?1:0;
1504                         }
1505                         catch(...){}
1506                 }
1507         }
1508         return 0;
1509 }
1510
1511 char* nutclient_get_device_description(NUTCLIENT_t client, const char* dev)
1512 {
1513         if(client)
1514         {
1515                 nut::Client* cl = (nut::Client*)client;
1516                 if(cl)
1517                 {
1518                         try
1519                         {
1520                                 return xstrdup(cl->getDeviceDescription(dev).c_str());
1521                         }
1522                         catch(...){}
1523                 }
1524         }
1525         return NULL;
1526 }
1527
1528 strarr nutclient_get_device_variables(NUTCLIENT_t client, const char* dev)
1529 {
1530         if(client)
1531         {
1532                 nut::Client* cl = (nut::Client*)client;
1533                 if(cl)
1534                 {
1535                         try
1536                         {
1537                                 return stringset_to_strarr(cl->getDeviceVariableNames(dev));
1538                         }
1539                         catch(...){}
1540                 }
1541         }
1542         return NULL;
1543 }
1544
1545 strarr nutclient_get_device_rw_variables(NUTCLIENT_t client, const char* dev)
1546 {
1547         if(client)
1548         {
1549                 nut::Client* cl = (nut::Client*)client;
1550                 if(cl)
1551                 {
1552                         try
1553                         {
1554                                 return stringset_to_strarr(cl->getDeviceRWVariableNames(dev));
1555                         }
1556                         catch(...){}
1557                 }
1558         }
1559         return NULL;
1560 }
1561
1562 int nutclient_has_device_variable(NUTCLIENT_t client, const char* dev, const char* var)
1563 {
1564         if(client)
1565         {
1566                 nut::Client* cl = (nut::Client*)client;
1567                 if(cl)
1568                 {
1569                         try
1570                         {
1571                                 return cl->hasDeviceVariable(dev, var)?1:0;
1572                         }
1573                         catch(...){}
1574                 }
1575         }
1576         return 0;
1577 }
1578
1579 char* nutclient_get_device_variable_description(NUTCLIENT_t client, const char* dev, const char* var)
1580 {
1581         if(client)
1582         {
1583                 nut::Client* cl = (nut::Client*)client;
1584                 if(cl)
1585                 {
1586                         try
1587                         {
1588                                 return xstrdup(cl->getDeviceVariableDescription(dev, var).c_str());
1589                         }
1590                         catch(...){}
1591                 }
1592         }
1593         return NULL;
1594 }
1595
1596 strarr nutclient_get_device_variable_values(NUTCLIENT_t client, const char* dev, const char* var)
1597 {
1598         if(client)
1599         {
1600                 nut::Client* cl = (nut::Client*)client;
1601                 if(cl)
1602                 {
1603                         try
1604                         {
1605                                 return stringvector_to_strarr(cl->getDeviceVariableValue(dev, var));
1606                         }
1607                         catch(...){}
1608                 }
1609         }
1610         return NULL;
1611 }
1612
1613 void nutclient_set_device_variable_value(NUTCLIENT_t client, const char* dev, const char* var, const char* value)
1614 {
1615         if(client)
1616         {
1617                 nut::Client* cl = (nut::Client*)client;
1618                 if(cl)
1619                 {
1620                         try
1621                         {
1622                                 cl->setDeviceVariable(dev, var, value);
1623                         }
1624                         catch(...){}
1625                 }
1626         }
1627 }
1628
1629 void nutclient_set_device_variable_values(NUTCLIENT_t client, const char* dev, const char* var, const strarr values)
1630 {
1631         if(client)
1632         {
1633                 nut::Client* cl = (nut::Client*)client;
1634                 if(cl)
1635                 {
1636                         try
1637                         {
1638                                 std::vector<std::string> vals;
1639                                 strarr pstr = (strarr)values;
1640                                 while(*pstr)
1641                                 {
1642                                         vals.push_back(std::string(*pstr));
1643                                         ++pstr;
1644                                 }
1645
1646                                 cl->setDeviceVariable(dev, var, vals);
1647                         }
1648                         catch(...){}
1649                 }
1650         }
1651 }
1652
1653
1654
1655 strarr nutclient_get_device_commands(NUTCLIENT_t client, const char* dev)
1656 {
1657         if(client)
1658         {
1659                 nut::Client* cl = (nut::Client*)client;
1660                 if(cl)
1661                 {
1662                         try
1663                         {
1664                                 return stringset_to_strarr(cl->getDeviceCommandNames(dev));
1665                         }
1666                         catch(...){}
1667                 }
1668         }
1669         return NULL;
1670 }
1671
1672
1673 int nutclient_has_device_command(NUTCLIENT_t client, const char* dev, const char* cmd)
1674 {
1675         if(client)
1676         {
1677                 nut::Client* cl = (nut::Client*)client;
1678                 if(cl)
1679                 {
1680                         try
1681                         {
1682                                 return cl->hasDeviceCommand(dev, cmd)?1:0;
1683                         }
1684                         catch(...){}
1685                 }
1686         }
1687         return 0;
1688 }
1689
1690
1691 char* nutclient_get_device_command_description(NUTCLIENT_t client, const char* dev, const char* cmd)
1692 {
1693         if(client)
1694         {
1695                 nut::Client* cl = (nut::Client*)client;
1696                 if(cl)
1697                 {
1698                         try
1699                         {
1700                                 return xstrdup(cl->getDeviceCommandDescription(dev, cmd).c_str());
1701                         }
1702                         catch(...){}
1703                 }
1704         }
1705         return NULL;
1706 }
1707
1708 void nutclient_execute_device_command(NUTCLIENT_t client, const char* dev, const char* cmd)
1709 {
1710         if(client)
1711         {
1712                 nut::Client* cl = (nut::Client*)client;
1713                 if(cl)
1714                 {
1715                         try
1716                         {
1717                                 cl->executeDeviceCommand(dev, cmd);
1718                         }
1719                         catch(...){}
1720                 }
1721         }
1722 }
1723
1724 } /* extern "C" */
1725
1726