eibd/client/eibclient.c

   1 /*
   2     EIBD client library
   3     Copyright (C) 2005-2007 Martin Kögler <mkoegler@auto.tuwien.ac.at>
   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     In addition to the permissions in the GNU General Public License,
  11     you may link the compiled version of this file into combinations
  12     with other programs, and distribute those combinations without any
  13     restriction coming from the use of this file. (The General Public
  14     License restrictions do apply in other respects; for example, they
  15     cover modification of the file, and distribution when not linked into
  16     a combine executable.)
  17
  18     This program is distributed in the hope that it will be useful,
  19     but WITHOUT ANY WARRANTY; without even the implied warranty of
  20     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21     GNU General Public License for more details.
  22
  23     You should have received a copy of the GNU General Public License
  24     along with this program; if not, write to the Free Software
  25     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  26 */
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <unistd.h>
  30 #include <sys/socket.h>
  31 #include <sys/un.h>
  32 #include <netinet/in.h>
  33 #include <netdb.h>
  34 #include <errno.h>
  35
  36 #include "config.h"
  37
  38 #include "eibclient.h"
  39 #include "eibtypes.h"
  40
  41 /** unsigned char */
  42 typedef uint8_t uchar;
  43
  44 /** EIB Connection internal */
  45 struct _EIBConnection
  46 {
  47   int (*complete) (EIBConnection *);
  48   /** file descriptor */
  49   int fd;
  50   unsigned readlen;
  51   /** buffer */
  52   uchar *buf;
  53   /** buffer size */
  54   unsigned buflen;
  55   /** used buffer */
  56   unsigned size;
  57   struct
  58   {
  59     int len;
  60     uint8_t *buf;
  61     int16_t *ptr1;
  62     uint8_t *ptr2;
  63     uint8_t *ptr3;
  64     uint16_t *ptr4;
  65   } req;
  66 };
  67
  68 /** extracts TYPE code of an eibd packet */
  69 #define EIBTYPE(con) (((con)->buf[0]<<8)|((con)->buf[1]))
  70 /** sets TYPE code for an eibd packet*/
  71 #define EIBSETTYPE(buf,type) do{(buf)[0]=(type>>8)&0xff;(buf)[1]=(type)&0xff;}while(0)
  72
  73 /** set EIB address */
  74 #define EIBSETADDR(buf,type) do{(buf)[0]=(type>>8)&0xff;(buf)[1]=(type)&0xff;}while(0)
  75
  76 /** resolve host name */
  77 static int
  78 GetHostIP (struct sockaddr_in *sock, const char *Name)
  79 {
  80 #ifdef HAVE_GETHOSTBYNAME_R
  81   int len = 2000;
  82   struct hostent host;
  83   char *buf = (char *) malloc (len);
  84   int res;
  85   int err;
  86 #endif
  87   struct hostent *h;
  88   if (!Name)
  89     return 0;
  90   memset (sock, 0, sizeof (*sock));
  91 #ifdef HAVE_GETHOSTBYNAME_R
  92   do
  93     {
  94       res = gethostbyname_r (Name, &host, buf, len, &h, &err);
  95       if (res == ERANGE)
  96         {
  97           len += 2000;
  98           buf = (char *) realloc (buf, len);
  99         }
 100       if (!buf)
 101         return 0;
 102     }
 103   while (res == ERANGE);
 104
 105   if (res || !h)
 106     {
 107       free (buf);
 108       return 0;
 109     }
 110 #else
 111   h = gethostbyname (Name);
 112   if (!h)
 113     return 0;
 114 #endif
 115   sock->sin_family = h->h_addrtype;
 116   sock->sin_addr.s_addr = (*((unsigned long *) h->h_addr_list[0]));
 117 #ifdef HAVE_GETHOSTBYNAME_R
 118   if (buf)
 119     free (buf);
 120 #endif
 121   return 1;
 122 }
 123
 124 int
 125 EIBClose (EIBConnection * con)
 126 {
 127   if (!con)
 128     {
 129       errno = EINVAL;
 130       return -1;
 131     }
 132   close (con->fd);
 133   if (con->buf)
 134     free (con->buf);
 135   free (con);
 136   return 0;
 137 }
 138
 139 EIBConnection *
 140 EIBSocketLocal (const char *path)
 141 {
 142   EIBConnection *con = (EIBConnection *) malloc (sizeof (EIBConnection));
 143   struct sockaddr_un addr;
 144   if (!con)
 145     {
 146       errno = ENOMEM;
 147       return 0;
 148     }
 149   addr.sun_family = AF_LOCAL;
 150   strncpy (addr.sun_path, path, sizeof (addr.sun_path));
 151   addr.sun_path[sizeof (addr.sun_path) - 1] = 0;
 152
 153   con->fd = socket (AF_LOCAL, SOCK_STREAM, 0);
 154   if (con->fd == -1)
 155     {
 156       free (con);
 157       return 0;
 158     }
 159
 160   if (connect (con->fd, (struct sockaddr *) &addr, sizeof (addr)) == -1)
 161     {
 162       int saveerr = errno;
 163       close (con->fd);
 164       free (con);
 165       errno = saveerr;
 166       return 0;
 167     }
 168   con->buflen = 0;
 169   con->buf = 0;
 170   con->readlen = 0;
 171
 172   return con;
 173 }
 174
 175 EIBConnection *
 176 EIBSocketRemote (const char *host, int port)
 177 {
 178   EIBConnection *con = (EIBConnection *) malloc (sizeof (EIBConnection));
 179   struct sockaddr_in addr;
 180   if (!con)
 181     {
 182       errno = ENOMEM;
 183       return 0;
 184     }
 185
 186   if (!GetHostIP (&addr, host))
 187     {
 188       free (con);
 189       errno = ECONNREFUSED;
 190       return 0;
 191     }
 192   addr.sin_port = htons (port);
 193
 194   con->fd = socket (addr.sin_family, SOCK_STREAM, 0);
 195   if (con->fd == -1)
 196     {
 197       free (con);
 198       return 0;
 199     }
 200
 201   if (connect (con->fd, (struct sockaddr *) &addr, sizeof (addr)) == -1)
 202     {
 203       int saveerr = errno;
 204       close (con->fd);
 205       free (con);
 206       errno = saveerr;
 207       return 0;
 208     }
 209   con->buflen = 0;
 210   con->buf = 0;
 211   con->readlen = 0;
 212
 213   return con;
 214 }
 215
 216 EIBConnection *
 217 EIBSocketURL (const char *url)
 218 {
 219   if (!url)
 220     {
 221       errno = EINVAL;
 222       return 0;
 223     }
 224   if (!strncmp (url, "local:", 6))
 225     {
 226       return EIBSocketLocal (url + 6);
 227     }
 228   if (!strncmp (url, "ip:", 3))
 229     {
 230       char *a = strdup (url + 3);
 231       char *b;
 232       int port;
 233       EIBConnection *c;
 234       if (!a)
 235         {
 236           errno = ENOMEM;
 237           return 0;
 238         }
 239       for (b = a; *b; b++)
 240         if (*b == ':')
 241           break;
 242       if (*b == ':')
 243         {
 244           *b = 0;
 245           port = atoi (b + 1);
 246         }
 247       else
 248         port = 6720;
 249       c = EIBSocketRemote (a, port);
 250       free (a);
 251       return c;
 252     }
 253   errno = EINVAL;
 254   return 0;
 255 }
 256
 257 /** send a request to eibd */
 258 static int
 259 _EIB_SendRequest (EIBConnection * con, unsigned int size, uchar * data)
 260 {
 261   uchar head[2];
 262   int i, start;
 263
 264   if (size > 0xffff || size < 2)
 265     {
 266       errno = EINVAL;
 267       return -1;
 268     }
 269   head[0] = (size >> 8) & 0xff;
 270   head[1] = (size) & 0xff;
 271
 272 lp1:
 273   i = write (con->fd, &head, 2);
 274   if (i == -1 && errno == EINTR)
 275     goto lp1;
 276   if (i == -1)
 277     return -1;
 278   if (i != 2)
 279     {
 280       errno = ECONNRESET;
 281       return -1;
 282     }
 283   start = 0;
 284 lp2:
 285   i = write (con->fd, data + start, size - start);
 286   if (i == -1 && errno == EINTR)
 287     goto lp2;
 288   if (i == -1)
 289     return -1;
 290   if (i == 0)
 291     {
 292       errno = ECONNRESET;
 293       return -1;
 294     }
 295   start += i;
 296   if (start < size)
 297     goto lp2;
 298   return 0;
 299 }
 300
 301 static int
 302 _EIB_CheckRequest (EIBConnection * con, int block)
 303 {
 304   int i;
 305   struct timeval tv;
 306   fd_set readset;
 307
 308   if (!block)
 309     {
 310       tv.tv_sec = 0;
 311       tv.tv_usec = 0;
 312       FD_ZERO (&readset);
 313       FD_SET (con->fd, &readset);
 314       if (select (con->fd + 1, &readset, 0, 0, &tv) == -1)
 315         return -1;
 316
 317       if (!FD_ISSET (con->fd, &readset))
 318         return 0;
 319     }
 320
 321   if (con->readlen < 2)
 322     {
 323       uchar head[2];
 324       head[0] = (con->size >> 8) & 0xff;
 325       i = read (con->fd, &head + con->readlen, 2 - con->readlen);
 326       if (i == -1 && errno == EINTR)
 327         return 0;
 328       if (i == -1)
 329         return -1;
 330       if (i == 0)
 331         {
 332           errno = ECONNRESET;
 333           return -1;
 334         }
 335       con->readlen += i;
 336       con->size = (head[0] << 8) | (head[1]);
 337       if (con->size < 2)
 338         {
 339           errno = ECONNRESET;
 340           return -1;
 341         }
 342
 343       if (con->size > con->buflen)
 344         {
 345           con->buf = (uchar *) realloc (con->buf, con->size);
 346           if (con->buf == 0)
 347             {
 348               con->buflen = 0;
 349               errno = ENOMEM;
 350               return -1;
 351             }
 352           con->buflen = con->size;
 353         }
 354       return 0;
 355     }
 356
 357   if (con->readlen < con->size + 2)
 358     {
 359       i =
 360         read (con->fd, con->buf + (con->readlen - 2),
 361               con->size - (con->readlen - 2));
 362       if (i == -1 && errno == EINTR)
 363         return 0;
 364       if (i == -1)
 365         return -1;
 366       if (i == 0)
 367         {
 368           errno = ECONNRESET;
 369           return -1;
 370         }
 371       con->readlen += i;
 372     }
 373   return 0;
 374 }
 375
 376 /** receive packet from eibd */
 377 static int
 378 _EIB_GetRequest (EIBConnection * con)
 379 {
 380   do
 381     {
 382       if (_EIB_CheckRequest (con, 1) == -1)
 383         return -1;
 384     }
 385   while (con->readlen < 2
 386          || (con->readlen >= 2 && con->readlen < con->size + 2));
 387
 388   con->readlen = 0;
 389
 390   return 0;
 391 }
 392
 393 int
 394 EIB_Poll_Complete (EIBConnection * con)
 395 {
 396   if (!con)
 397     {
 398       errno = EINVAL;
 399       return -1;
 400     }
 401   if (_EIB_CheckRequest (con, 0) == -1)
 402     return -1;
 403   return (con->readlen >= 2 && con->readlen >= con->size + 2) ? 1 : 0;
 404 }
 405
 406 int
 407 EIB_Poll_FD (EIBConnection * con)
 408 {
 409   if (!con)
 410     {
 411       errno = EINVAL;
 412       return -1;
 413     }
 414   return con->fd;
 415 }
 416
 417 int
 418 EIBComplete (EIBConnection * con)
 419 {
 420   if (!con)
 421     {
 422       errno = EINVAL;
 423       return -1;
 424     }
 425   return con->complete (con);
 426 }
 427
 428 static int
 429 OpenBusmonitor_complete (EIBConnection * con)
 430 {
 431   int i;
 432   i = _EIB_GetRequest (con);
 433   if (i == -1)
 434     return -1;
 435
 436   if (EIBTYPE (con) == EIB_CONNECTION_INUSE)
 437     {
 438       errno = EBUSY;
 439       return -1;
 440     }
 441   if (EIBTYPE (con) != EIB_OPEN_BUSMONITOR)
 442     {
 443       errno = ECONNRESET;
 444       return -1;
 445     }
 446   return 0;
 447 }
 448
 449 int
 450 EIBOpenBusmonitor_async (EIBConnection * con)
 451 {
 452   uchar head[2];
 453   int i;
 454   if (!con)
 455     {
 456       errno = EINVAL;
 457       return -1;
 458     }
 459   EIBSETTYPE (head, EIB_OPEN_BUSMONITOR);
 460   i = _EIB_SendRequest (con, 2, head);
 461   if (i == -1)
 462     return -1;
 463
 464   con->complete = OpenBusmonitor_complete;
 465   return 0;
 466 }
 467
 468 int
 469 EIBOpenBusmonitor (EIBConnection * con)
 470 {
 471   if (EIBOpenBusmonitor_async (con) == -1)
 472     return -1;
 473   return EIBComplete (con);
 474 }
 475
 476 static int
 477 OpenBusmonitorText_complete (EIBConnection * con)
 478 {
 479   int i;
 480   i = _EIB_GetRequest (con);
 481   if (i == -1)
 482     return -1;
 483
 484   if (EIBTYPE (con) == EIB_CONNECTION_INUSE)
 485     {
 486       errno = EBUSY;
 487       return -1;
 488     }
 489   if (EIBTYPE (con) != EIB_OPEN_BUSMONITOR_TEXT)
 490     {
 491       errno = ECONNRESET;
 492       return -1;
 493     }
 494   return 0;
 495 }
 496
 497 int
 498 EIBOpenBusmonitorText_async (EIBConnection * con)
 499 {
 500   uchar head[2];
 501   int i;
 502   if (!con)
 503     {
 504       errno = EINVAL;
 505       return -1;
 506     }
 507   EIBSETTYPE (head, EIB_OPEN_BUSMONITOR_TEXT);
 508   i = _EIB_SendRequest (con, 2, head);
 509   if (i == -1)
 510     return -1;
 511   con->complete = OpenBusmonitorText_complete;
 512   return 0;
 513 }
 514
 515 int
 516 EIBOpenBusmonitorText (EIBConnection * con)
 517 {
 518   if (EIBOpenBusmonitorText_async (con) == -1)
 519     return -1;
 520   return EIBComplete (con);
 521 }
 522
 523 static int
 524 OpenVBusmonitor_complete (EIBConnection * con)
 525 {
 526   int i;
 527   i = _EIB_GetRequest (con);
 528   if (i == -1)
 529     return -1;
 530
 531   if (EIBTYPE (con) == EIB_CONNECTION_INUSE)
 532     {
 533       errno = EBUSY;
 534       return -1;
 535     }
 536   if (EIBTYPE (con) != EIB_OPEN_VBUSMONITOR)
 537     {
 538       errno = ECONNRESET;
 539       return -1;
 540     }
 541   return 0;
 542 }
 543
 544 int
 545 EIBOpenVBusmonitor_async (EIBConnection * con)
 546 {
 547   uchar head[2];
 548   int i;
 549   if (!con)
 550     {
 551       errno = EINVAL;
 552       return -1;
 553     }
 554   EIBSETTYPE (head, EIB_OPEN_VBUSMONITOR);
 555   i = _EIB_SendRequest (con, 2, head);
 556   if (i == -1)
 557     return -1;
 558   con->complete = OpenVBusmonitor_complete;
 559   return 0;
 560 }
 561
 562 int
 563 EIBOpenVBusmonitor (EIBConnection * con)
 564 {
 565   if (EIBOpenVBusmonitor_async (con) == -1)
 566     return -1;
 567   return EIBComplete (con);
 568 }
 569
 570 static int
 571 OpenVBusmonitorText_complete (EIBConnection * con)
 572 {
 573   int i;
 574   i = _EIB_GetRequest (con);
 575   if (i == -1)
 576     return -1;
 577
 578   if (EIBTYPE (con) == EIB_CONNECTION_INUSE)
 579     {
 580       errno = EBUSY;
 581       return -1;
 582     }
 583   if (EIBTYPE (con) != EIB_OPEN_VBUSMONITOR_TEXT)
 584     {
 585       errno = ECONNRESET;
 586       return -1;
 587     }
 588   return 0;
 589 }
 590
 591 int
 592 EIBOpenVBusmonitorText_async (EIBConnection * con)
 593 {
 594   uchar head[2];
 595   int i;
 596   if (!con)
 597     {
 598       errno = EINVAL;
 599       return -1;
 600     }
 601   EIBSETTYPE (head, EIB_OPEN_VBUSMONITOR_TEXT);
 602   i = _EIB_SendRequest (con, 2, head);
 603   if (i == -1)
 604     return -1;
 605   con->complete = OpenVBusmonitorText_complete;
 606   return 0;
 607 }
 608
 609 int
 610 EIBOpenVBusmonitorText (EIBConnection * con)
 611 {
 612   if (EIBOpenVBusmonitorText_async (con) == -1)
 613     return -1;
 614   return EIBComplete (con);
 615 }
 616
 617 int
 618 EIBGetBusmonitorPacket (EIBConnection * con, int maxlen, uint8_t * buf)
 619 {
 620   int i;
 621   if (!con || !buf)
 622     {
 623       errno = EINVAL;
 624       return -1;
 625     }
 626
 627   i = _EIB_GetRequest (con);
 628   if (i == -1)
 629     return -1;
 630
 631   if (EIBTYPE (con) != EIB_BUSMONITOR_PACKET)
 632     {
 633       errno = ECONNRESET;
 634       return -1;
 635     }
 636   i = con->size - 2;
 637   if (i > maxlen)
 638     i = maxlen;
 639   memcpy (buf, con->buf + 2, i);
 640   return i;
 641 }
 642
 643 static int
 644 OpenT_Connection_complete (EIBConnection * con)
 645 {
 646   int i;
 647   i = _EIB_GetRequest (con);
 648   if (i == -1)
 649     return -1;
 650
 651   if (EIBTYPE (con) != EIB_OPEN_T_CONNECTION)
 652     {
 653       errno = ECONNRESET;
 654       return -1;
 655     }
 656   return 0;
 657 }
 658
 659 int
 660 EIBOpenT_Connection_async (EIBConnection * con, eibaddr_t dest)
 661 {
 662   uchar head[5];
 663   int i;
 664   if (!con)
 665     {
 666       errno = EINVAL;
 667       return -1;
 668     }
 669   EIBSETTYPE (head, EIB_OPEN_T_CONNECTION);
 670   EIBSETADDR (head + 2, dest);
 671   i = _EIB_SendRequest (con, 5, head);
 672   if (i == -1)
 673     return -1;
 674   con->complete = OpenT_Connection_complete;
 675   return 0;
 676 }
 677
 678 int
 679 EIBOpenT_Connection (EIBConnection * con, eibaddr_t dest)
 680 {
 681   if (EIBOpenT_Connection_async (con, dest) == -1)
 682     return -1;
 683   return EIBComplete (con);
 684 }
 685
 686 static int
 687 OpenT_TPDU_complete (EIBConnection * con)
 688 {
 689   int i;
 690   i = _EIB_GetRequest (con);
 691   if (i == -1)
 692     return -1;
 693
 694   if (EIBTYPE (con) != EIB_OPEN_T_TPDU)
 695     {
 696       errno = ECONNRESET;
 697       return -1;
 698     }
 699   return 0;
 700 }
 701
 702 int
 703 EIBOpenT_TPDU_async (EIBConnection * con, eibaddr_t src)
 704 {
 705   uchar head[5];
 706   int i;
 707   if (!con)
 708     {
 709       errno = EINVAL;
 710       return -1;
 711     }
 712   EIBSETTYPE (head, EIB_OPEN_T_TPDU);
 713   EIBSETADDR (head + 2, src);
 714   i = _EIB_SendRequest (con, 5, head);
 715   if (i == -1)
 716     return -1;
 717   con->complete = OpenT_TPDU_complete;
 718   return 0;
 719 }
 720
 721 int
 722 EIBOpenT_TPDU (EIBConnection * con, eibaddr_t src)
 723 {
 724   if (EIBOpenT_TPDU_async (con, src) == -1)
 725     return -1;
 726   return EIBComplete (con);
 727 }
 728
 729 static int
 730 OpenT_Individual_complete (EIBConnection * con)
 731 {
 732   int i;
 733   i = _EIB_GetRequest (con);
 734   if (i == -1)
 735     return -1;
 736
 737   if (EIBTYPE (con) != EIB_OPEN_T_INDIVIDUAL)
 738     {
 739       errno = ECONNRESET;
 740       return -1;
 741     }
 742   return 0;
 743 }
 744
 745 int
 746 EIBOpenT_Individual_async (EIBConnection * con, eibaddr_t dest,
 747                            int write_only)
 748 {
 749   uchar head[5];
 750   int i;
 751   if (!con)
 752     {
 753       errno = EINVAL;
 754       return -1;
 755     }
 756   EIBSETTYPE (head, EIB_OPEN_T_INDIVIDUAL);
 757   EIBSETADDR (head + 2, dest);
 758   head[4] = (write_only ? 0xff : 0);
 759   i = _EIB_SendRequest (con, 5, head);
 760   if (i == -1)
 761     return -1;
 762   con->complete = OpenT_Individual_complete;
 763   return 0;
 764 }
 765
 766 int
 767 EIBOpenT_Individual (EIBConnection * con, eibaddr_t dest, int write_only)
 768 {
 769   if (EIBOpenT_Individual_async (con, dest, write_only) == -1)
 770     return -1;
 771   return EIBComplete (con);
 772 }
 773
 774 static int
 775 OpenT_Group_complete (EIBConnection * con)
 776 {
 777   int i;
 778   i = _EIB_GetRequest (con);
 779   if (i == -1)
 780     return -1;
 781
 782   if (EIBTYPE (con) != EIB_OPEN_T_GROUP)
 783     {
 784       errno = ECONNRESET;
 785       return -1;
 786     }
 787   return 0;
 788 }
 789
 790 int
 791 EIBOpenT_Group_async (EIBConnection * con, eibaddr_t dest, int write_only)
 792 {
 793   uchar head[5];
 794   int i;
 795   if (!con)
 796     {
 797       errno = EINVAL;
 798       return -1;
 799     }
 800   EIBSETTYPE (head, EIB_OPEN_T_GROUP);
 801   EIBSETADDR (head + 2, dest);
 802   head[4] = (write_only ? 0xff : 0);
 803   i = _EIB_SendRequest (con, 5, head);
 804   if (i == -1)
 805     return -1;
 806   con->complete = OpenT_Group_complete;
 807   return 0;
 808 }
 809
 810 int
 811 EIBOpenT_Group (EIBConnection * con, eibaddr_t dest, int write_only)
 812 {
 813   if (EIBOpenT_Group_async (con, dest, write_only) == -1)
 814     return -1;
 815   return EIBComplete (con);
 816 }
 817
 818 static int
 819 OpenT_Broadcast_complete (EIBConnection * con)
 820 {
 821   int i;
 822   i = _EIB_GetRequest (con);
 823   if (i == -1)
 824     return -1;
 825
 826   if (EIBTYPE (con) != EIB_OPEN_T_BROADCAST)
 827     {
 828       errno = ECONNRESET;
 829       return -1;
 830     }
 831   return 0;
 832 }
 833
 834 int
 835 EIBOpenT_Broadcast_async (EIBConnection * con, int write_only)
 836 {
 837   uchar head[5];
 838   int i;
 839   if (!con)
 840     {
 841       errno = EINVAL;
 842       return -1;
 843     }
 844   EIBSETTYPE (head, EIB_OPEN_T_BROADCAST);
 845   head[4] = (write_only ? 0xff : 0);
 846   i = _EIB_SendRequest (con, 5, head);
 847   if (i == -1)
 848     return -1;
 849   con->complete = OpenT_Broadcast_complete;
 850   return 0;
 851 }
 852
 853 int
 854 EIBOpenT_Broadcast (EIBConnection * con, int write_only)
 855 {
 856   if (EIBOpenT_Broadcast_async (con, write_only) == -1)
 857     return -1;
 858   return EIBComplete (con);
 859 }
 860
 861 int
 862 EIBSendTPDU (EIBConnection * con, eibaddr_t dest, int len, uint8_t * data)
 863 {
 864   uchar *ibuf;
 865   int i;
 866   if (!con)
 867     {
 868       errno = EINVAL;
 869       return -1;
 870     }
 871   if (len < 2 || !data)
 872     {
 873       errno = EINVAL;
 874       return -1;
 875     }
 876   ibuf = (uchar *) malloc (len + 4);
 877   if (!ibuf)
 878     {
 879       errno = ENOMEM;
 880       return -1;
 881     }
 882   EIBSETTYPE (ibuf, EIB_APDU_PACKET);
 883   EIBSETADDR (ibuf + 2, dest);
 884   memcpy (ibuf + 4, data, len);
 885   i = _EIB_SendRequest (con, len + 4, ibuf);
 886   free (ibuf);
 887   return i;
 888 }
 889
 890 int
 891 EIBSendAPDU (EIBConnection * con, int len, uint8_t * data)
 892 {
 893   uchar *ibuf;
 894   int i;
 895   if (!con)
 896     {
 897       errno = EINVAL;
 898       return -1;
 899     }
 900   if (len < 2 || !data)
 901     {
 902       errno = EINVAL;
 903       return -1;
 904     }
 905   ibuf = (uchar *) malloc (len + 2);
 906   if (!ibuf)
 907     {
 908       errno = ENOMEM;
 909       return -1;
 910     }
 911   EIBSETTYPE (ibuf, EIB_APDU_PACKET);
 912   memcpy (ibuf + 2, data, len);
 913   i = _EIB_SendRequest (con, len + 2, ibuf);
 914   free (ibuf);
 915   return i;
 916 }
 917
 918 int
 919 EIBGetAPDU (EIBConnection * con, int maxlen, uint8_t * buf)
 920 {
 921   int i;
 922   if (!con || !buf)
 923     {
 924       errno = EINVAL;
 925       return -1;
 926     }
 927
 928   i = _EIB_GetRequest (con);
 929   if (i == -1)
 930     return -1;
 931
 932   if (EIBTYPE (con) != EIB_APDU_PACKET)
 933     {
 934       errno = ECONNRESET;
 935       return -1;
 936     }
 937   i = con->size - 2;
 938   if (i > maxlen)
 939     i = maxlen;
 940   memcpy (buf, con->buf + 2, i);
 941   return i;
 942 }
 943
 944 int
 945 EIBGetAPDU_Src (EIBConnection * con, int maxlen, uint8_t * buf,
 946                 eibaddr_t * src)
 947 {
 948   int i;
 949   if (!con || !buf)
 950     {
 951       errno = EINVAL;
 952       return -1;
 953     }
 954
 955   i = _EIB_GetRequest (con);
 956   if (i == -1)
 957     return -1;
 958
 959   if (EIBTYPE (con) != EIB_APDU_PACKET || con->size < 4)
 960     {
 961       errno = ECONNRESET;
 962       return -1;
 963     }
 964   i = con->size - 4;
 965   if (i > maxlen)
 966     i = maxlen;
 967   memcpy (buf, con->buf + 4, i);
 968   if (src)
 969     *src = (con->buf[2] << 8) | (con->buf[3]);
 970   return i;
 971 }
 972
 973 static int
 974 Open_GroupSocket_complete (EIBConnection * con)
 975 {
 976   int i;
 977   i = _EIB_GetRequest (con);
 978   if (i == -1)
 979     return -1;
 980
 981   if (EIBTYPE (con) != EIB_OPEN_GROUPCON)
 982     {
 983       errno = ECONNRESET;
 984       return -1;
 985     }
 986   return 0;
 987 }
 988
 989 int
 990 EIBOpen_GroupSocket_async (EIBConnection * con, int write_only)
 991 {
 992   uchar head[5];
 993   int i;
 994   if (!con)
 995     {
 996       errno = EINVAL;
 997       return -1;
 998     }
 999   EIBSETTYPE (head, EIB_OPEN_GROUPCON);
1000   head[4] = (write_only ? 0xff : 0);
1001   i = _EIB_SendRequest (con, 5, head);
1002   if (i == -1)
1003     return -1;
1004   con->complete = Open_GroupSocket_complete;
1005   return 0;
1006 }
1007
1008 int
1009 EIBOpen_GroupSocket (EIBConnection * con, int write_only)
1010 {
1011   if (EIBOpen_GroupSocket_async (con, write_only) == -1)
1012     return -1;
1013   return EIBComplete (con);
1014 }
1015
1016 int
1017 EIBGetGroup_Src (EIBConnection * con, int maxlen, uint8_t * buf,
1018                  eibaddr_t * src, eibaddr_t * dest)
1019 {
1020   int i;
1021   if (!con || !buf)
1022     {
1023       errno = EINVAL;
1024       return -1;
1025     }
1026
1027   i = _EIB_GetRequest (con);
1028   if (i == -1)
1029     return -1;
1030
1031   if (EIBTYPE (con) != EIB_GROUP_PACKET || con->size < 6)
1032     {
1033       errno = ECONNRESET;
1034       return -1;
1035     }
1036   i = con->size - 6;
1037   if (i > maxlen)
1038     i = maxlen;
1039   memcpy (buf, con->buf + 6, i);
1040   if (src)
1041     *src = (con->buf[2] << 8) | (con->buf[3]);
1042   if (dest)
1043     *dest = (con->buf[4] << 8) | (con->buf[5]);
1044   return i;
1045 }
1046
1047 int
1048 EIBSendGroup (EIBConnection * con, eibaddr_t dest, int len, uint8_t * data)
1049 {
1050   uchar *ibuf;
1051   int i;
1052   if (!con)
1053     {
1054       errno = EINVAL;
1055       return -1;
1056     }
1057   if (len < 2 || !data)
1058     {
1059       errno = EINVAL;
1060       return -1;
1061     }
1062   ibuf = (uchar *) malloc (len + 4);
1063   if (!ibuf)
1064     {
1065       errno = ENOMEM;
1066       return -1;
1067     }
1068   EIBSETTYPE (ibuf, EIB_GROUP_PACKET);
1069   EIBSETADDR (ibuf + 2, dest);
1070   memcpy (ibuf + 4, data, len);
1071   i = _EIB_SendRequest (con, len + 4, ibuf);
1072   free (ibuf);
1073   return i;
1074 }
1075
1076 static int
1077 M_ReadIndividualAddresses_complete (EIBConnection * con)
1078 {
1079   int i;
1080   i = _EIB_GetRequest (con);
1081   if (i == -1)
1082     return -1;
1083   if (EIBTYPE (con) != EIB_M_INDIVIDUAL_ADDRESS_READ)
1084     {
1085       errno = ECONNRESET;
1086       return -1;
1087     }
1088   i = con->size - 2;
1089   if (i > con->req.len)
1090     i = con->req.len;
1091   memcpy (con->req.buf, con->buf + 2, i);
1092   return i;
1093 }
1094
1095 int
1096 EIB_M_ReadIndividualAddresses_async (EIBConnection * con, int maxlen,
1097                                      uint8_t * buf)
1098 {
1099   uchar head[2];
1100   if (!con)
1101     {
1102       errno = EINVAL;
1103       return -1;
1104     }
1105   con->req.len = maxlen;
1106   con->req.buf = buf;
1107   EIBSETTYPE (head, EIB_M_INDIVIDUAL_ADDRESS_READ);
1108   if (_EIB_SendRequest (con, 2, head) == -1)
1109     return -1;
1110   con->complete = M_ReadIndividualAddresses_complete;
1111   return 0;
1112 }
1113
1114 int
1115 EIB_M_ReadIndividualAddresses (EIBConnection * con, int maxlen, uint8_t * buf)
1116 {
1117   if (EIB_M_ReadIndividualAddresses_async (con, maxlen, buf) == -1)
1118     return -1;
1119   return EIBComplete (con);
1120 }
1121
1122 static int
1123 M_Progmode_On_complete (EIBConnection * con)
1124 {
1125   int i;
1126   i = _EIB_GetRequest (con);
1127   if (i == -1)
1128     return -1;
1129   if (EIBTYPE (con) != EIB_PROG_MODE)
1130     {
1131       errno = ECONNRESET;
1132       return -1;
1133     }
1134   return 0;
1135 }
1136
1137 int
1138 EIB_M_Progmode_On_async (EIBConnection * con, eibaddr_t dest)
1139 {
1140   uchar head[5];
1141   if (!con)
1142     {
1143       errno = EINVAL;
1144       return -1;
1145     }
1146   EIBSETTYPE (head, EIB_PROG_MODE);
1147   EIBSETADDR (head + 2, dest);
1148   head[4] = 1;
1149   if (_EIB_SendRequest (con, 5, head) == -1)
1150     return -1;
1151   con->complete = M_Progmode_On_complete;
1152   return 0;
1153 }
1154
1155 int
1156 EIB_M_Progmode_On (EIBConnection * con, eibaddr_t dest)
1157 {
1158   if (EIB_M_Progmode_On_async (con, dest) == -1)
1159     return -1;
1160   return EIBComplete (con);
1161 }
1162
1163 static int
1164 M_Progmode_Off_complete (EIBConnection * con)
1165 {
1166   int i;
1167   i = _EIB_GetRequest (con);
1168   if (i == -1)
1169     return -1;
1170   if (EIBTYPE (con) != EIB_PROG_MODE)
1171     {
1172       errno = ECONNRESET;
1173       return -1;
1174     }
1175   return 0;
1176 }
1177
1178 int
1179 EIB_M_Progmode_Off_async (EIBConnection * con, eibaddr_t dest)
1180 {
1181   uchar head[5];
1182   if (!con)
1183     {
1184       errno = EINVAL;
1185       return -1;
1186     }
1187   EIBSETTYPE (head, EIB_PROG_MODE);
1188   EIBSETADDR (head + 2, dest);
1189   head[4] = 0;
1190   if (_EIB_SendRequest (con, 5, head) == -1)
1191     return -1;
1192   con->complete = M_Progmode_Off_complete;
1193   return 0;
1194 }
1195
1196 int
1197 EIB_M_Progmode_Off (EIBConnection * con, eibaddr_t dest)
1198 {
1199   if (EIB_M_Progmode_Off_async (con, dest) == -1)
1200     return -1;
1201   return EIBComplete (con);
1202 }
1203
1204 static int
1205 M_Progmode_Toggle_complete (EIBConnection * con)
1206 {
1207   int i;
1208   i = _EIB_GetRequest (con);
1209   if (i == -1)
1210     return -1;
1211   if (EIBTYPE (con) != EIB_PROG_MODE)
1212     {
1213       errno = ECONNRESET;
1214       return -1;
1215     }
1216   return 0;
1217 }
1218
1219 int
1220 EIB_M_Progmode_Toggle_async (EIBConnection * con, eibaddr_t dest)
1221 {
1222   uchar head[5];
1223   if (!con)
1224     {
1225       errno = EINVAL;
1226       return -1;
1227     }
1228   EIBSETTYPE (head, EIB_PROG_MODE);
1229   EIBSETADDR (head + 2, dest);
1230   head[4] = 2;
1231   if (_EIB_SendRequest (con, 5, head) == -1)
1232     return -1;
1233   con->complete = M_Progmode_Toggle_complete;
1234   return 0;
1235 }
1236
1237 int
1238 EIB_M_Progmode_Toggle (EIBConnection * con, eibaddr_t dest)
1239 {
1240   if (EIB_M_Progmode_Toggle (con, dest) == -1)
1241     return -1;
1242   return EIBComplete (con);
1243 }
1244
1245 static int
1246 M_Progmode_Status_complete (EIBConnection * con)
1247 {
1248   int i;
1249   i = _EIB_GetRequest (con);
1250   if (i == -1)
1251     return -1;
1252   if (EIBTYPE (con) != EIB_PROG_MODE || con->size < 3)
1253     {
1254       errno = ECONNRESET;
1255       return -1;
1256     }
1257   return con->buf[2];
1258 }
1259
1260 int
1261 EIB_M_Progmode_Status_async (EIBConnection * con, eibaddr_t dest)
1262 {
1263   uchar head[5];
1264   if (!con)
1265     {
1266       errno = EINVAL;
1267       return -1;
1268     }
1269   EIBSETTYPE (head, EIB_PROG_MODE);
1270   EIBSETADDR (head + 2, dest);
1271   head[4] = 3;
1272   if (_EIB_SendRequest (con, 5, head) == -1)
1273     return -1;
1274   con->complete = M_Progmode_Status_complete;
1275   return 0;
1276 }
1277
1278 int
1279 EIB_M_Progmode_Status (EIBConnection * con, eibaddr_t dest)
1280 {
1281   if (EIB_M_Progmode_Status (con, dest) == -1)
1282     return -1;
1283   return EIBComplete (con);
1284 }
1285
1286 static int
1287 M_GetMaskVersion_complete (EIBConnection * con)
1288 {
1289   int i;
1290   i = _EIB_GetRequest (con);
1291   if (i == -1)
1292     return -1;
1293   if (EIBTYPE (con) != EIB_MASK_VERSION || con->size < 4)
1294     {
1295       errno = ECONNRESET;
1296       return -1;
1297     }
1298   return (con->buf[2] << 8) | (con->buf[3]);
1299 }
1300
1301 int
1302 EIB_M_GetMaskVersion_async (EIBConnection * con, eibaddr_t dest)
1303 {
1304   uchar head[4];
1305   if (!con)
1306     {
1307       errno = EINVAL;
1308       return -1;
1309     }
1310   EIBSETTYPE (head, EIB_MASK_VERSION);
1311   EIBSETADDR (head + 2, dest);
1312   if (_EIB_SendRequest (con, 4, head) == -1)
1313     return -1;
1314   con->complete = M_GetMaskVersion_complete;
1315   return 0;
1316 }
1317
1318 int
1319 EIB_M_GetMaskVersion (EIBConnection * con, eibaddr_t dest)
1320 {
1321   if (EIB_M_GetMaskVersion_async (con, dest) == -1)
1322     return -1;
1323   return EIBComplete (con);
1324 }
1325
1326 static int
1327 M_WriteIndividualAddress_complete (EIBConnection * con)
1328 {
1329   int i;
1330   i = _EIB_GetRequest (con);
1331   if (i == -1)
1332     return -1;
1333   if (EIBTYPE (con) == EIB_ERROR_ADDR_EXISTS)
1334     {
1335       errno = EADDRINUSE;
1336       return -1;
1337     }
1338   if (EIBTYPE (con) == EIB_M_INDIVIDUAL_ADDRESS_WRITE)
1339     {
1340       return 0;
1341     }
1342   if (EIBTYPE (con) == EIB_ERROR_TIMEOUT)
1343     {
1344       errno = ETIMEDOUT;
1345       return -1;
1346     }
1347   if (EIBTYPE (con) == EIB_ERROR_MORE_DEVICE)
1348     {
1349       errno = EADDRNOTAVAIL;
1350       return -1;
1351     }
1352   errno = ECONNRESET;
1353   return -1;
1354 }
1355
1356 int
1357 EIB_M_WriteIndividualAddress_async (EIBConnection * con, eibaddr_t dest)
1358 {
1359   uchar head[4];
1360   if (!con)
1361     {
1362       errno = EINVAL;
1363       return -1;
1364     }
1365   EIBSETTYPE (head, EIB_M_INDIVIDUAL_ADDRESS_WRITE);
1366   EIBSETADDR (head + 2, dest);
1367   if (_EIB_SendRequest (con, 4, head) == -1)
1368     return -1;
1369   con->complete = M_WriteIndividualAddress_complete;
1370   return 0;
1371 }
1372
1373 int
1374 EIB_M_WriteIndividualAddress (EIBConnection * con, eibaddr_t dest)
1375 {
1376   if (EIB_M_WriteIndividualAddress_async (con, dest) == -1)
1377     return -1;
1378   return EIBComplete (con);
1379 }
1380
1381 static int
1382 MC_Connect_complete (EIBConnection * con)
1383 {
1384   int i;
1385   i = _EIB_GetRequest (con);
1386   if (i == -1)
1387     return -1;
1388
1389   if (EIBTYPE (con) != EIB_MC_CONNECTION)
1390     {
1391       errno = ECONNRESET;
1392       return -1;
1393     }
1394   return 0;
1395 }
1396
1397 int
1398 EIB_MC_Connect_async (EIBConnection * con, eibaddr_t dest)
1399 {
1400   uchar head[4];
1401   int i;
1402   if (!con)
1403     {
1404       errno = EINVAL;
1405       return -1;
1406     }
1407   EIBSETTYPE (head, EIB_MC_CONNECTION);
1408   EIBSETADDR (head + 2, dest);
1409   i = _EIB_SendRequest (con, 4, head);
1410   if (i == -1)
1411     return -1;
1412
1413   con->complete = MC_Connect_complete;
1414   return 0;
1415 }
1416
1417 int
1418 EIB_MC_Connect (EIBConnection * con, eibaddr_t dest)
1419 {
1420   if (EIB_MC_Connect_async (con, dest) == -1)
1421     return -1;
1422   return EIBComplete (con);
1423 }
1424
1425 static int
1426 MC_Progmode_On_complete (EIBConnection * con)
1427 {
1428   int i;
1429   i = _EIB_GetRequest (con);
1430   if (i == -1)
1431     return -1;
1432   if (EIBTYPE (con) != EIB_MC_PROG_MODE)
1433     {
1434       errno = ECONNRESET;
1435       return -1;
1436     }
1437   return 0;
1438 }
1439
1440 int
1441 EIB_MC_Progmode_On_async (EIBConnection * con)
1442 {
1443   uchar head[3];
1444   if (!con)
1445     {
1446       errno = EINVAL;
1447       return -1;
1448     }
1449   EIBSETTYPE (head, EIB_MC_PROG_MODE);
1450   head[2] = 1;
1451   if (_EIB_SendRequest (con, 3, head) == -1)
1452     return -1;
1453   con->complete = MC_Progmode_On_complete;
1454   return 0;
1455 }
1456
1457 int
1458 EIB_MC_Progmode_On (EIBConnection * con)
1459 {
1460   if (EIB_MC_Progmode_On_async (con) == -1)
1461     return -1;
1462   return EIBComplete (con);
1463 }
1464
1465 static int
1466 MC_Progmode_Off_complete (EIBConnection * con)
1467 {
1468   int i;
1469   i = _EIB_GetRequest (con);
1470   if (i == -1)
1471     return -1;
1472   if (EIBTYPE (con) != EIB_MC_PROG_MODE)
1473     {
1474       errno = ECONNRESET;
1475       return -1;
1476     }
1477   return 0;
1478 }
1479
1480 int
1481 EIB_MC_Progmode_Off_async (EIBConnection * con)
1482 {
1483   uchar head[3];
1484   if (!con)
1485     {
1486       errno = EINVAL;
1487       return -1;
1488     }
1489   EIBSETTYPE (head, EIB_MC_PROG_MODE);
1490   head[2] = 0;
1491   if (_EIB_SendRequest (con, 3, head) == -1)
1492     return -1;
1493   con->complete = MC_Progmode_Off_complete;
1494   return 0;
1495 }
1496
1497 int
1498 EIB_MC_Progmode_Off (EIBConnection * con)
1499 {
1500   if (EIB_MC_Progmode_Off_async (con) == -1)
1501     return -1;
1502   return EIBComplete (con);
1503 }
1504
1505 static int
1506 MC_Progmode_Toggle_complete (EIBConnection * con)
1507 {
1508   int i;
1509   i = _EIB_GetRequest (con);
1510   if (i == -1)
1511     return -1;
1512   if (EIBTYPE (con) != EIB_MC_PROG_MODE)
1513     {
1514       errno = ECONNRESET;
1515       return -1;
1516     }
1517   return 0;
1518 }
1519
1520 int
1521 EIB_MC_Progmode_Toggle_async (EIBConnection * con)
1522 {
1523   uchar head[3];
1524   if (!con)
1525     {
1526       errno = EINVAL;
1527       return -1;
1528     }
1529   EIBSETTYPE (head, EIB_MC_PROG_MODE);
1530   head[2] = 2;
1531   if (_EIB_SendRequest (con, 3, head) == -1)
1532     return -1;
1533   con->complete = MC_Progmode_Toggle_complete;
1534   return 0;
1535 }
1536
1537 int
1538 EIB_MC_Progmode_Toggle (EIBConnection * con)
1539 {
1540   if (EIB_MC_Progmode_Toggle_async (con) == -1)
1541     return -1;
1542   return EIBComplete (con);
1543 }
1544
1545 static int
1546 MC_Progmode_Status_complete (EIBConnection * con)
1547 {
1548   int i;
1549   i = _EIB_GetRequest (con);
1550   if (i == -1)
1551     return -1;
1552   if (EIBTYPE (con) != EIB_MC_PROG_MODE || con->size < 3)
1553     {
1554       errno = ECONNRESET;
1555       return -1;
1556     }
1557   return con->buf[2];
1558 }
1559
1560 int
1561 EIB_MC_Progmode_Status_async (EIBConnection * con)
1562 {
1563   uchar head[3];
1564   if (!con)
1565     {
1566       errno = EINVAL;
1567       return -1;
1568     }
1569   EIBSETTYPE (head, EIB_MC_PROG_MODE);
1570   head[2] = 3;
1571   if (_EIB_SendRequest (con, 3, head) == -1)
1572     return -1;
1573   con->complete = MC_Progmode_Status_complete;
1574   return 0;
1575 }
1576
1577 int
1578 EIB_MC_Progmode_Status (EIBConnection * con)
1579 {
1580   if (EIB_MC_Progmode_Status_async (con) == -1)
1581     return -1;
1582   return EIBComplete (con);
1583 }
1584
1585 static int
1586 MC_GetMaskVersion_complete (EIBConnection * con)
1587 {
1588   int i;
1589   i = _EIB_GetRequest (con);
1590   if (i == -1)
1591     return -1;
1592   if (EIBTYPE (con) != EIB_MC_MASK_VERSION || con->size < 4)
1593     {
1594       errno = ECONNRESET;
1595       return -1;
1596     }
1597   return (con->buf[2] << 8) | (con->buf[3]);
1598 }
1599
1600 int
1601 EIB_MC_GetMaskVersion_async (EIBConnection * con)
1602 {
1603   uchar head[2];
1604   if (!con)
1605     {
1606       errno = EINVAL;
1607       return -1;
1608     }
1609   EIBSETTYPE (head, EIB_MC_MASK_VERSION);
1610   if (_EIB_SendRequest (con, 2, head) == -1)
1611     return -1;
1612   con->complete = MC_GetMaskVersion_complete;
1613   return 0;
1614 }
1615
1616 int
1617 EIB_MC_GetMaskVersion (EIBConnection * con)
1618 {
1619   if (EIB_MC_GetMaskVersion_async (con) == -1)
1620     return -1;
1621   return EIBComplete (con);
1622 }
1623
1624 static int
1625 MC_GetPEIType_complete (EIBConnection * con)
1626 {
1627   int i;
1628   i = _EIB_GetRequest (con);
1629   if (i == -1)
1630     return -1;
1631   if (EIBTYPE (con) != EIB_MC_PEI_TYPE || con->size < 4)
1632     {
1633       errno = ECONNRESET;
1634       return -1;
1635     }
1636   return (con->buf[2] << 8) | (con->buf[3]);
1637 }
1638
1639 int
1640 EIB_MC_GetPEIType_async (EIBConnection * con)
1641 {
1642   uchar head[2];
1643   if (!con)
1644     {
1645       errno = EINVAL;
1646       return -1;
1647     }
1648   EIBSETTYPE (head, EIB_MC_PEI_TYPE);
1649   if (_EIB_SendRequest (con, 2, head) == -1)
1650     return -1;
1651   con->complete = MC_GetPEIType_complete;
1652   return 0;
1653 }
1654
1655 int
1656 EIB_MC_GetPEIType (EIBConnection * con)
1657 {
1658   if (EIB_MC_GetPEIType_async (con) == -1)
1659     return -1;
1660   return EIBComplete (con);
1661 }
1662
1663 static int
1664 MC_ReadADC_complete (EIBConnection * con)
1665 {
1666   int i;
1667   i = _EIB_GetRequest (con);
1668   if (i == -1)
1669     return -1;
1670   if (EIBTYPE (con) != EIB_MC_ADC_READ || con->size < 4)
1671     {
1672       errno = ECONNRESET;
1673       return -1;
1674     }
1675   if (con->req.ptr1)
1676     *con->req.ptr1 = (con->buf[2] << 8) | (con->buf[3]);
1677   return 0;
1678 }
1679
1680 int
1681 EIB_MC_ReadADC_async (EIBConnection * con, uint8_t channel, uint8_t count,
1682                       int16_t * val)
1683 {
1684   uchar head[4];
1685   if (!con)
1686     {
1687       errno = EINVAL;
1688       return -1;
1689     }
1690   con->req.ptr1 = val;
1691   EIBSETTYPE (head, EIB_MC_ADC_READ);
1692   head[2] = channel;
1693   head[3] = count;
1694   if (_EIB_SendRequest (con, 4, head) == -1)
1695     return -1;
1696   con->complete = MC_ReadADC_complete;
1697   return 0;
1698 }
1699
1700 int
1701 EIB_MC_ReadADC (EIBConnection * con, uint8_t channel, uint8_t count,
1702                 int16_t * val)
1703 {
1704   if (EIB_MC_ReadADC_async (con, channel, count, val) == -1)
1705     return -1;
1706   return EIBComplete (con);
1707 }
1708
1709 static int
1710 MC_PropertyRead_complete (EIBConnection * con)
1711 {
1712   int i;
1713   i = _EIB_GetRequest (con);
1714   if (i == -1)
1715     return -1;
1716   if (EIBTYPE (con) != EIB_MC_PROP_READ)
1717     {
1718       errno = ECONNRESET;
1719       return -1;
1720     }
1721   i = con->size - 2;
1722   if (i > con->req.len)
1723     i = con->req.len;
1724   memcpy (con->req.buf, con->buf + 2, i);
1725   return i;
1726 }
1727
1728 int
1729 EIB_MC_PropertyRead_async (EIBConnection * con, uint8_t obj, uint8_t property,
1730                            uint16_t start, uint8_t nr_of_elem, int max_len,
1731                            uint8_t * buf)
1732 {
1733   uchar head[7];
1734   if (!con)
1735     {
1736       errno = EINVAL;
1737       return -1;
1738     }
1739   con->req.buf = buf;
1740   con->req.len = max_len;
1741   if (!buf)
1742     {
1743       errno = EINVAL;
1744       return -1;
1745     }
1746   EIBSETTYPE (head, EIB_MC_PROP_READ);
1747   head[2] = obj;
1748   head[3] = property;
1749   head[4] = (start >> 8) & 0xff;
1750   head[5] = (start) & 0xff;
1751   head[6] = nr_of_elem;
1752   if (_EIB_SendRequest (con, 7, head) == -1)
1753     return -1;
1754   con->complete = MC_PropertyRead_complete;
1755   return 0;
1756 }
1757
1758 int
1759 EIB_MC_PropertyRead (EIBConnection * con, uint8_t obj, uint8_t property,
1760                      uint16_t start, uint8_t nr_of_elem, int max_len,
1761                      uint8_t * buf)
1762 {
1763   if (EIB_MC_PropertyRead_async
1764       (con, obj, property, start, nr_of_elem, max_len, buf) == -1)
1765     return -1;
1766   return EIBComplete (con);
1767 }
1768
1769 static int
1770 MC_Read_complete (EIBConnection * con)
1771 {
1772   int i;
1773   i = _EIB_GetRequest (con);
1774   if (i == -1)
1775     return -1;
1776   if (EIBTYPE (con) != EIB_MC_READ)
1777     {
1778       errno = ECONNRESET;
1779       return -1;
1780     }
1781   i = con->size - 2;
1782   if (i > con->req.len)
1783     i = con->req.len;
1784   memcpy (con->req.buf, con->buf + 2, i);
1785   return i;
1786 }
1787
1788 int
1789 EIB_MC_Read_async (EIBConnection * con, uint16_t addr, int len, uint8_t * buf)
1790 {
1791   uchar head[6];
1792   if (!con)
1793     {
1794       errno = EINVAL;
1795       return -1;
1796     }
1797   if (!buf)
1798     {
1799       errno = EINVAL;
1800       return -1;
1801     }
1802   con->req.len = len;
1803   con->req.buf = buf;
1804   EIBSETTYPE (head, EIB_MC_READ);
1805   head[2] = (addr >> 8) & 0xff;
1806   head[3] = (addr) & 0xff;
1807   head[4] = (len >> 8) & 0xff;
1808   head[5] = (len) & 0xff;
1809   if (_EIB_SendRequest (con, 6, head) == -1)
1810     return -1;
1811   con->complete = MC_Read_complete;
1812   return 0;
1813 }
1814
1815 int
1816 EIB_MC_Read (EIBConnection * con, uint16_t addr, int len, uint8_t * buf)
1817 {
1818   if (EIB_MC_Read_async (con, addr, len, buf) == -1)
1819     return -1;
1820   return EIBComplete (con);
1821 }
1822
1823 static int
1824 MC_PropertyWrite_complete (EIBConnection * con)
1825 {
1826   int i;
1827   i = _EIB_GetRequest (con);
1828   if (i == -1)
1829     return -1;
1830   if (EIBTYPE (con) != EIB_MC_PROP_WRITE)
1831     {
1832       errno = ECONNRESET;
1833       return -1;
1834     }
1835   i = con->size - 2;
1836   if (i > con->req.len)
1837     i = con->req.len;
1838   memcpy (con->req.buf, con->buf + 2, i);
1839   return i;
1840 }
1841
1842 int
1843 EIB_MC_PropertyWrite_async (EIBConnection * con, uint8_t obj,
1844                             uint8_t property, uint16_t start,
1845                             uint8_t nr_of_elem, int len, const uint8_t * buf,
1846                             int max_len, uint8_t * res)
1847 {
1848   uchar *ibuf;
1849   int i;
1850   if (!con)
1851     {
1852       errno = EINVAL;
1853       return -1;
1854     }
1855   if (!buf || !res)
1856     {
1857       errno = EINVAL;
1858       return -1;
1859     }
1860   con->req.len = max_len;
1861   con->req.buf = res;
1862   ibuf = (uchar *) malloc (len + 7);
1863   if (!ibuf)
1864     {
1865       errno = ENOMEM;
1866       return -1;
1867     }
1868   EIBSETTYPE (ibuf, EIB_MC_PROP_WRITE);
1869   ibuf[2] = obj;
1870   ibuf[3] = property;
1871   ibuf[4] = (start >> 8) & 0xff;
1872   ibuf[5] = (start) & 0xff;
1873   ibuf[6] = nr_of_elem;
1874   memcpy (ibuf + 7, buf, len);
1875   i = _EIB_SendRequest (con, len + 7, ibuf);
1876   free (ibuf);
1877   if (i == -1)
1878     return -1;
1879   con->complete = MC_PropertyWrite_complete;
1880   return 0;
1881 }
1882
1883 int
1884 EIB_MC_PropertyWrite (EIBConnection * con, uint8_t obj, uint8_t property,
1885                       uint16_t start, uint8_t nr_of_elem, int len,
1886                       const uint8_t * buf, int max_len, uint8_t * res)
1887 {
1888   if (EIB_MC_PropertyWrite_async
1889       (con, obj, property, start, nr_of_elem, len, buf, max_len, res) == -1)
1890     return -1;
1891   return EIBComplete (con);
1892 }
1893 static int
1894 MC_Write_complete (EIBConnection * con)
1895 {
1896   int i;
1897   i = _EIB_GetRequest (con);
1898   if (i == -1)
1899     return -1;
1900   if (EIBTYPE (con) == EIB_ERROR_VERIFY)
1901     {
1902       errno = EIO;
1903       return -1;
1904     }
1905   if (EIBTYPE (con) != EIB_MC_WRITE)
1906     {
1907       errno = ECONNRESET;
1908       return -1;
1909     }
1910   return con->req.len;
1911 }
1912
1913 int
1914 EIB_MC_Write_async (EIBConnection * con, uint16_t addr, int len,
1915                     const uint8_t * buf)
1916 {
1917   uchar *ibuf;
1918   int i;
1919   if (!con)
1920     {
1921       errno = EINVAL;
1922       return -1;
1923     }
1924   con->req.len = len;
1925   if (!buf)
1926     {
1927       errno = EINVAL;
1928       return -1;
1929     }
1930   ibuf = (uchar *) malloc (len + 6);
1931   if (!ibuf)
1932     {
1933       errno = ENOMEM;
1934       return -1;
1935     }
1936   EIBSETTYPE (ibuf, EIB_MC_WRITE);
1937   ibuf[2] = (addr >> 8) & 0xff;
1938   ibuf[3] = (addr) & 0xff;
1939   ibuf[4] = (len >> 8) & 0xff;
1940   ibuf[5] = (len) & 0xff;
1941   memcpy (ibuf + 6, buf, len);
1942   i = _EIB_SendRequest (con, len + 6, ibuf);
1943   free (ibuf);
1944   if (i == -1)
1945     return -1;
1946   con->complete = MC_Write_complete;
1947   return 0;
1948 }
1949
1950 int
1951 EIB_MC_Write (EIBConnection * con, uint16_t addr, int len,
1952               const uint8_t * buf)
1953 {
1954   if (EIB_MC_Write_async (con, addr, len, buf) == -1)
1955     return -1;
1956   return EIBComplete (con);
1957 }
1958
1959 static int
1960 MC_PropertyDesc_complete (EIBConnection * con)
1961 {
1962   int i;
1963   i = _EIB_GetRequest (con);
1964   if (i == -1)
1965     return -1;
1966   if (EIBTYPE (con) != EIB_MC_PROP_DESC || con->size < 6)
1967     {
1968       errno = ECONNRESET;
1969       return -1;
1970     }
1971   /* Type */
1972   if (con->req.ptr2)
1973     *con->req.ptr2 = con->buf[2];
1974   /* max_nr_of_elem */
1975   if (con->req.ptr4)
1976     *con->req.ptr4 = (con->buf[3] << 8) | (con->buf[4]);
1977   /* access */
1978   if (con->req.ptr3)
1979     *con->req.ptr3 = con->buf[5];
1980   return 0;
1981 }
1982
1983 int
1984 EIB_MC_PropertyDesc_async (EIBConnection * con, uint8_t obj, uint8_t property,
1985                            uint8_t * type, uint16_t * max_nr_of_elem,
1986                            uint8_t * access)
1987 {
1988   uchar head[5];
1989   if (!con)
1990     {
1991       errno = EINVAL;
1992       return -1;
1993     }
1994   con->req.ptr2 = type;
1995   con->req.ptr4 = max_nr_of_elem;
1996   con->req.ptr3 = access;
1997   EIBSETTYPE (head, EIB_MC_PROP_DESC);
1998   head[2] = obj;
1999   head[3] = property;
2000   if (_EIB_SendRequest (con, 4, head) == -1)
2001     return -1;
2002   con->complete = MC_PropertyDesc_complete;
2003   return 0;
2004 }
2005
2006 int
2007 EIB_MC_PropertyDesc (EIBConnection * con, uint8_t obj, uint8_t property,
2008                      uint8_t * type, uint16_t * max_nr_of_elem,
2009                      uint8_t * access)
2010 {
2011   if (EIB_MC_PropertyDesc_async
2012       (con, obj, property, type, max_nr_of_elem, access) == -1)
2013     return -1;
2014   return EIBComplete (con);
2015 }
2016
2017 static int
2018 MC_Authorize_complete (EIBConnection * con)
2019 {
2020   int i;
2021   i = _EIB_GetRequest (con);
2022   if (i == -1)
2023     return -1;
2024   if (EIBTYPE (con) != EIB_MC_AUTHORIZE || con->size < 3)
2025     {
2026       errno = ECONNRESET;
2027       return -1;
2028     }
2029   return con->buf[2];
2030 }
2031
2032 int
2033 EIB_MC_Authorize_async (EIBConnection * con, uint8_t key[4])
2034 {
2035   uchar head[6];
2036   if (!con)
2037     {
2038       errno = EINVAL;
2039       return -1;
2040     }
2041   EIBSETTYPE (head, EIB_MC_AUTHORIZE);
2042   memcpy (head + 2, key, 4);
2043   if (_EIB_SendRequest (con, 6, head) == -1)
2044     return -1;
2045   con->complete = MC_Authorize_complete;
2046   return 0;
2047 }
2048
2049 int
2050 EIB_MC_Authorize (EIBConnection * con, uint8_t key[4])
2051 {
2052   if (EIB_MC_Authorize_async (con, key) == -1)
2053     return -1;
2054   return EIBComplete (con);
2055 }
2056
2057 static int
2058 MC_SetKey_complete (EIBConnection * con)
2059 {
2060   int i;
2061   i = _EIB_GetRequest (con);
2062   if (i == -1)
2063     return -1;
2064   if (EIBTYPE (con) == EIB_PROCESSING_ERROR)
2065     {
2066       errno = EPERM;
2067       return -1;
2068     }
2069   if (EIBTYPE (con) != EIB_MC_KEY_WRITE)
2070     {
2071       errno = ECONNRESET;
2072       return -1;
2073     }
2074   return 0;
2075 }
2076
2077 int
2078 EIB_MC_SetKey_async (EIBConnection * con, uint8_t key[4], uint8_t level)
2079 {
2080   uchar head[7];
2081   if (!con)
2082     {
2083       errno = EINVAL;
2084       return -1;
2085     }
2086   EIBSETTYPE (head, EIB_MC_KEY_WRITE);
2087   memcpy (head + 2, key, 4);
2088   head[6] = level;
2089   if (_EIB_SendRequest (con, 7, head) == -1)
2090     return -1;
2091   con->complete = MC_SetKey_complete;
2092   return 0;
2093 }
2094
2095 int
2096 EIB_MC_SetKey (EIBConnection * con, uint8_t key[4], uint8_t level)
2097 {
2098   if (EIB_MC_SetKey_async (con, key, level) == -1)
2099     return -1;
2100   return EIBComplete (con);
2101 }
2102
2103 static int
2104 MC_PropertyScan_complete (EIBConnection * con)
2105 {
2106   int i;
2107   i = _EIB_GetRequest (con);
2108   if (i == -1)
2109     return -1;
2110   if (EIBTYPE (con) != EIB_MC_PROP_SCAN)
2111     {
2112       errno = ECONNRESET;
2113       return -1;
2114     }
2115   i = con->size - 2;
2116   if (i > con->req.len)
2117     i = con->req.len;
2118   memcpy (con->req.buf, con->buf + 2, i);
2119   return i;
2120 }
2121
2122 int
2123 EIB_MC_PropertyScan_async (EIBConnection * con, int maxlen, uint8_t * buf)
2124 {
2125   uchar head[2];
2126   if (!con)
2127     {
2128       errno = EINVAL;
2129       return -1;
2130     }
2131   con->req.len = maxlen;
2132   con->req.buf = buf;
2133   EIBSETTYPE (head, EIB_MC_PROP_SCAN);
2134   if (_EIB_SendRequest (con, 2, head) == -1)
2135     return -1;
2136   con->complete = MC_PropertyScan_complete;
2137   return 0;
2138 }
2139
2140 int
2141 EIB_MC_PropertyScan (EIBConnection * con, int maxlen, uint8_t * buf)
2142 {
2143   if (EIB_MC_PropertyScan_async (con, maxlen, buf) == -1)
2144     return -1;
2145   return EIBComplete (con);
2146 }
2147
2148 static int
2149 LoadImage_complete (EIBConnection * con)
2150 {
2151   int i;
2152   i = _EIB_GetRequest (con);
2153   if (i == -1)
2154     return -1;
2155   if (EIBTYPE (con) != EIB_LOAD_IMAGE || con->size < 4)
2156     {
2157       errno = ECONNRESET;
2158       return IMG_UNKNOWN_ERROR;
2159     }
2160   return (con->buf[2] << 8) | con->buf[3];
2161 }
2162
2163 int
2164 EIB_LoadImage_async (EIBConnection * con, const uint8_t * image, int len)
2165 {
2166   uchar *ibuf;
2167   int i;
2168   if (!con)
2169     {
2170       errno = EINVAL;
2171       return -1;
2172     }
2173   if (!image)
2174     {
2175       errno = EINVAL;
2176       return -1;
2177     }
2178   ibuf = (uchar *) malloc (len + 2);
2179   if (!ibuf)
2180     {
2181       errno = ENOMEM;
2182       return -1;
2183     }
2184   EIBSETTYPE (ibuf, EIB_LOAD_IMAGE);
2185   memcpy (ibuf + 2, image, len);
2186   i = _EIB_SendRequest (con, len + 2, ibuf);
2187   free (ibuf);
2188   if (i == -1)
2189     return -1;
2190   con->complete = LoadImage_complete;
2191   return 0;
2192 }
2193
2194 BCU_LOAD_RESULT
2195 EIB_LoadImage (EIBConnection * con, const uint8_t * image, int len)
2196 {
2197   if (EIB_LoadImage_async (con, image, len) == -1)
2198     return -1;
2199   return EIBComplete (con);
2200 }