encode.c

/*
 * Copyright 2010-2011 Brian Uechi <buasst@gmail.com>
 *
 * This file is part of mochad.
 *
 * mochad is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * mochad is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with mochad.  If not, see <http://www.gnu.org/licenses/>.
 */


// bridge: Rx RF -> Tx PL
//  if equivalent command exists such as A1 ON, relay RF commands to PL.
//  RF remote keys such as ARM have no equivalent PL command. See RF
//  key map.
// bridge: Rx PL -> Tx RF
//  if equivalent command exists such as A1 ON, relay PL command to RF.
// relay : Rx RF -> Tx RF
//   for all RF commands
// relay : Rx PL -> Tx PL
//   for all PL commands
// echo  : Tx RF -> Rx RF (done)
//   Sending an RF command generetes a fake RF receive message. Consider 2
//   clients connected to cm15ad. Client 1 send RF A1 ON. If this option is
//   off, client 2 will not receive any indication this happened. The CM15A
//   does not receive its own transmissions. When this option is on, cm15ad
//   generates a fake Rx RF A1 ON for all clients except the client that sent
//   the command.
// echo  : Tx PL -> Rx PL (done)
//   See above.
// RF remote key translation
//   For backwards compatibility with systems that can only work with house/unit
//   commands, translation RF keys into HouseUnit ON/OFF. For example,
//   RF ARM MIN DELAY -> PL P1 ON
//   RF DISARM -> RF P1 OFF
//   RF ARM MAX DELAY -> RF P2 ON
//   RF DISARM -> PL P2 OFF
//
//   In the other direction,
//
//   PL P1 ON -> RF ARM MIN DELAY
//
//------------------------
//  Sent by CM15a for B3 Dim 49%, Dim 0%, Dim 100%
//  07 e7 02 1f  31     pl b3 extdim 49
//     H? ?U DA  TF
//     H = house code 'B"
//     U = unit code - 1
//     T  = Type 0..15
//          0 = shutters and sunshades
//          1 = sensors
//          2 = reserved for security
//          3 = control modules (dimmers and appliances)
//              F  = Function
//                  0 = 
//                  1 = Preset receiver output
//                  DA[5..0] = dim amount = 0..63a
//                      NZ=ON,Z=OFF,
//                  DA[7..6] = T1 T0
//                      T 0=3.7s,1=30s,2=60s,3=300s
//          4 = extended secure addressing
//          5 = extended secure addressing for groups
//
//
//  07 e7 02 01  31     pl b3 extdim 0
//  07 e7 02 3e  31     pl b3 extdim 100


#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdarg.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/socket.h>
#include "global.h"
#include "encode.h"
#include "decode.h"
#include "x10state.h"
#include "x10_write.h"

static void strupper(char *buf) {
    while (*buf) {
	if (islower(*buf)) *buf = toupper(*buf);
	buf++;
    }
}

static int gethexdata(unsigned char buf8[]) {
    char *parm;
    unsigned char *ptr = buf8;
    unsigned char *endbuf = buf8 + 8;

    while ((parm = strtok(NULL, " ")) && (ptr < endbuf)) {
	dbprintf("parm %s\n", parm);
	errno = 0;
	*ptr++ = (unsigned char) strtoul(parm, NULL, 16);
	if (errno) {
	    dbprintf("Hex digit conversion problem %d\n", errno);
	    return -1;
	}
    }
    return (ptr - buf8);
}


#define    FUNC_ALL_UNITS_OFF   (0)
#define    FUNC_ALL_LIGHTS_ON   (1)
#define    FUNC_ON              (2)
#define    FUNC_OFF             (3)
#define    FUNC_DIM             (4)
#define    FUNC_BRIGHT          (5)
#define    FUNC_ALL_LIGHTS_OFF  (6)
#define    FUNC_EXTENDED_CODE_1 (7)
#define    FUNC_HAIL_REQUEST    (8)
#define    FUNC_HAIL_ACK        (9)
#define    FUNC_EXTENDED_CODE_3 (10)
#define    FUNC_UNUSED          (11)
#define    FUNC_EXTENDED_CODE_2 (12)
#define    FUNC_STATUS_ON       (13)
#define    FUNC_STATUS_OFF      (14)
#define    FUNC_STATUS_REQUEST  (15)
#define    FUNC_EXTENDED_DIM    (16)

static const char *funccommands[] = {
    "ALL_UNITS_OFF",
    "ALL_LIGHTS_ON",
    "ON",
    "OFF",
    "DIM",
    "BRIGHT",
    "ALL_LIGHTS_OFF",
    "EXTENDED_CODE_1",
    "HAIL_REQUEST",
    "HAIL_ACK",
    "EXTENDED_CODE_3",
    "UNUSED",
    "EXTENDED_CODE_2",
    "STATUS_ON",
    "STATUS_OFF",
    "STATUS_REQUEST",
    "XDIM"
};

static const unsigned char x10housecode[] = {
    0x06, /* House code A */
    0x0e, /* House code B */
    0x02, /* House code C */
    0x0a, /* House code D */
    0x01, /* House code E */
    0x09, /* House code F */
    0x05, /* House code G */
    0x0d, /* House code H */
    0x07, /* House code I */
    0x0f, /* House code J */
    0x03, /* House code K */
    0x0b, /* House code L */
    0x00, /* House code M */
    0x08, /* House code N */
    0x04, /* House code O */
    0x0c, /* House code P */
};

static const unsigned char x10housecoderf[] = {
    0x06, /* House code A */
    0x07, /* House code B */
    0x04, /* House code C */
    0x05, /* House code D */
    0x08, /* House code E */
    0x09, /* House code F */
    0x0a, /* House code G */
    0x0b, /* House code H */
    0x0e, /* House code I */
    0x0f, /* House code J */
    0x0c, /* House code K */
    0x0d, /* House code L */
    0x00, /* House code M */
    0x01, /* House code N */
    0x02, /* House code O */
    0x03, /* House code P */
};

static int getfunc(void) {
    char *command;
    int i;

    command = strtok(NULL, " ");
    if (!command) return -1;
    for (i = 0; i < (sizeof (funccommands) / sizeof (funccommands[0])); i++) {
	if (strcmp(command, funccommands[i]) == 0) {
	    return i;
	}
    }
    return -1;
}

static const struct SecEventRec SecEventNameslongaddr[] = {
    {0x0C, "MOTION_ALERT"},
    {0x8C, "MOTION_NORMAL"},
    {0x0D, "MOTION_ALERT_LOW"}, /* MS10 does not emit this */
    {0x8D, "MOTION_NORMAL_LOW"}, /* MS10 does not emit this */
    {0x04, "CONTACT_ALERT_MIN"},
    {0x84, "CONTACT_NORMAL_MIN"},
    {0x00, "CONTACT_ALERT_MAX"},
    {0x80, "CONTACT_NORMAL_MAX"},
    {0x01, "CONTACT_ALERT_MIN_LOW"}, /* _LOW = LOW battery */
    {0x81, "CONTACT_NORMAL_MIN_LOW"},
    {0x05, "CONTACT_ALERT_MAX_LOW"},
    {0x85, "CONTACT_NORMAL_MAX_LOW"},
    {0x06, "ARM"},
    {0x86, "DISARM"},
    {0x46, "LIGHTS_ON"},
    {0xC6, "LIGHTS_OFF"},
    {0x26, "PANIC"},
    {0x00, NULL},
};

static const struct SecEventRec SecRemoteKeyNames8bitaddr[] = {
    {0x06, "ARM"},
    {0x0E, "ARM_HOME_MIN"},
    {0x06, "ARM_AWAY_MIN"},
    {0x0A, "ARM_HOME_MAX"},
    {0x02, "ARM_AWAY_MAX"},
    {0x82, "DISARM"},
    {0x22, "PANIC"},
    {0x42, "LIGHTS_ON"},
    {0xC2, "LIGHTS_OFF"},
    {0x00, NULL},
};

static int getrffunc(int rf8bitaddr) {
    char *command;
    int i;

    command = strtok(NULL, " ");
    if (!command) return -1;

    if (rf8bitaddr == 1) {
	for (i = 0; SecRemoteKeyNames8bitaddr[i].name; i++) {
	    if (strcmp(command, SecRemoteKeyNames8bitaddr[i].name) == 0)
		return SecRemoteKeyNames8bitaddr[i].funct;
	}
	return -1;
    } else if (rf8bitaddr == 0) {
	for (i = 0; SecEventNameslongaddr[i].name; i++) {
	    if (strcmp(command, SecEventNameslongaddr[i].name) == 0)
		return SecEventNameslongaddr[i].funct;
	}
	return -1;
    } else
	return -1;
}

static int getparam(void) {
    char *param;

    param = strtok(NULL, " ");
    if (!param) return -1;
    return strtol(param, NULL, 10);
}

static int ishouse(char h) {
    return ((h >= 'A') && (h <= 'P'));
}

/* House code: 'A'..'P', house value: 0..15
 * Unit  code: "1".."16", unit value: 0..15
 * Valid strings:
 * A            house=0, *unit=-1
 * A1           house=0  *unit=0
 * P15          house=15 *unit=14
 */
static int getdeviceaddr(int *unit) {
    char *parm, c;

    int house = -1;

    *unit = -1;

    parm = strtok(NULL, " ");
    if (!parm || (strlen(parm) > 3)) return house;

    dbprintf("deviceaddr %s\n", parm);

    c = *parm++;
    if (!ishouse(c)) return house;
    house = c - 'A';
    dbprintf("house %d\n", house);

    c = *parm++;
    if (!isdigit(c)) return house;
    *unit = c - '0';
    dbprintf("*unit %d\n", *unit);

    c = *parm++;
    if (!isdigit(c)) {
	(*unit)--;
	dbprintf("*unit %d\n", *unit);
	return house;
    }
    *unit = (*unit * 10) + (c - '0');
    if (*unit > 16) {
	*unit = -1;
	return house;
    }
    (*unit)--;
    return house;
}

static int getrfaddr(unsigned long *rfaddr) {
    char *parm;

    parm = strtok(NULL, " ");
    if (!parm) return -1;

    dbprintf("rfaddr %s\n", parm);

    if ((strncmp(parm, "0x", 2) == 0) || (strncmp(parm, "0X", 2) == 0)) {
	/* 8 bit RF address starts with 0x or 0X */
	*rfaddr = strtoul(parm + 2, NULL, 16);
	return 1;
    }

    /* Long RF address must be 6 hex digits */
    *rfaddr = strtoul(parm, NULL, 16);
    return 0;
}

static unsigned short gethousecodes(void) {
    char *parm;
    unsigned char house;
    unsigned short rc = 0;

    parm = strtok(NULL, " ");
    /* No parameter means turn off all house codes */
    if (!parm || *parm == '\0') return 0;

    /* parameter == "*" means turn on all house codes */
    if (strcmp(parm, "*") == 0) return 0xFFFF;

    while ((house = *parm++)) {
	dbprintf("house %c\n", house);
	if (ishouse(house)) {
	    house -= 'A';
	    dbprintf("house %d\n", house);
	    rc |= (1 << house);
	    dbprintf("rc %04X\n", rc);
	}
    }
    return rc;
}

/*
 * byte 0
 *   bits 7..3  Dim amount
 *   bit 2      always 1
 *   bit 1      following byte is 1=function,0=address
 *   bit 0      1=extended,0=standard
 * byte 1
 *   if function, byte 0:bit 1=1
 *     bits 7..4    house code
 *     bits 3..0    function code
 *   if address, byte 0:bit 1=0
 *     bits 7..4    house code
 *     bits 3..0    unit code
 */
static int pl_tx_houseunit(int fd, int house, int unit) {
    char unsigned buf[4];

    /* Make buffer as if received so decoder prints */
    buf[0] = 0x00;
    buf[1] = 0x02;
    buf[2] = 0x00;
    buf[3] = x10housecode[house] << 4 | x10housecode[unit];
    cm15a_decode_plc(-1, buf, sizeof (buf));

    /* Transmit only requires last 2 bytes and first byte must be 0x04 */
    buf[2] = 0x04;
    return x10_write(buf + 2, 2);
}

/* Extended code 1 */
static int pl_tx_extended_code_1(int fd, int house, int unit, int command,
	int subcmd, int param) {
    unsigned char buf[7];
    size_t nbuf;
    unsigned char *xmitptr;

    dbprintf("%s(%d,%d,%d,%d,%d,%d)\n", __func__, fd, house, unit, command,
	    subcmd, param);
    /* Make buffer as if received so decoder prints */
    buf[0] = 0x00;
    buf[1] = 0x05;
    buf[2] = 0x07;
    nbuf = 7; /* Decode 7 bytes */
    buf[3] = (x10housecode[house] << 4) | 0x7;
    buf[4] = x10housecode[unit]; /* unit code */
    buf[5] = param & 0xFF;
    buf[6] = ((command & 0x0F) << 4) | (subcmd & 0x0F);
    xmitptr = &buf[2];
    cm15a_decode_plc(-1, buf, nbuf);
    dbprintf("%d:", nbuf);
    hexdump(buf, nbuf);

    /* Transmit only requires last 5 bytes */
    hexdump(xmitptr, 5);
    return x10_write(xmitptr, 5);
}

static int pl_tx_housefunc(int fd, int house, int func, int param) {
    unsigned char buf[7];
    int dims;
    size_t nbuf;
    unsigned char *xmitptr;

    dbprintf("%s(%d,%d,%d,%d)\n", __func__, fd, house, func, param);
    /* Make buffer as if received so decoder prints */
    buf[0] = 0x00;
    switch (func) {
	case FUNC_DIM:
	case FUNC_BRIGHT:
	    buf[1] = 0x03;
	    nbuf = 5; /* Decode 5 bytes */
	    buf[2] = 0x02;
	    dims = ((param & 0x1F) << 3);
	    buf[3] = dims | 0x01;
	    buf[4] = x10housecode[house] << 4 | func;
	    xmitptr = &buf[2];
	    cm15a_decode_plc(-1, buf, nbuf);
	    dbprintf("%d:", nbuf);
	    hexdump(buf, nbuf);

	    /* Transmit using the 0x06 prefix just like AHP */
	    /* The remaining two bytes are reversed */
	    *xmitptr++ = 0x06;
	    *xmitptr = *(xmitptr + 1);
	    xmitptr++;
	    *xmitptr = 0x06 | dims;
	    hexdump(xmitptr - 2, 3);
	    return x10_write(xmitptr - 2, 3);
	case FUNC_EXTENDED_DIM:
	    buf[1] = 0x05;
	    buf[2] = 0x07;
	    nbuf = 7; /* Decode 7 bytes */
	    buf[3] = x10housecode[house] << 4 | 0x7;
	    buf[4] = 0x02; /* 2 data bytes follow */
	    dims = param & 0xFF;
	    buf[5] = dims;
	    buf[6] = 0x31; /* Dim/Bright */
	    xmitptr = &buf[2];
	    cm15a_decode_plc(-1, buf, nbuf);
	    dbprintf("%d:", nbuf);
	    hexdump(buf, nbuf);

	    /* Transmit only requires last 5 bytes */
	    hexdump(xmitptr, 5);
	    return x10_write(xmitptr, 5);
	default:
	    buf[1] = 0x02;
	    nbuf = 4; /* Decode 4 bytes */
	    buf[2] = 0x01;
	    buf[3] = x10housecode[house] << 4 | func;
	    xmitptr = &buf[2];
	    cm15a_decode_plc(-1, buf, nbuf);
	    dbprintf("%d:", nbuf);
	    hexdump(buf, nbuf);

	    /* Transmit only requires last 2 bytes */
	    *xmitptr = 0x06;
	    hexdump(xmitptr, 2);
	    return x10_write(xmitptr, 2);
    }
}

/*
 * EB 20 E2 ED 0A F5 from SH624 8 bit RF address
 *        |  |  |  | 
 *        |  |  |  XOR with prev byte==0xff
 *        |  |  key code
 *        |  XOR with prev byte==0x0f
 *        8 bit security code change by pressing CODE button
 *
 * EB 29 7F 70 8C 73 CA 00 from MS10,DS10,KR10 17(?) bit RF address 
 *        |  |  |  |  |  |
 *        |  |  |  |  |  addr3 (even parity bit for previous byte)
 *        |  |  |  |  addr2
 *        |  |  |  XOR with prev byte=0xff
 *        |  |  function/key
 *        |  XOR with prev byte==0x0f
 *        addr1
 */

static int rfsec_tx(int fd, int rf8bitaddr, unsigned long rfaddr, int func) {
    unsigned char buf[8];
    unsigned char *p = buf;
    unsigned char addr1;

    *p++ = 0xEB;
    if (rf8bitaddr) {
	*p++ = 0x20;
	*p++ = rfaddr;
	*p++ = rfaddr ^ 0x0f;
	*p++ = func;
	*p = ~func;
	cm15a_decode_rf(-1, buf, 6);
	if (Cm19a)
	    return x10_write(buf + 1, 5);
	else
	    return x10_write(buf, 6);
    } else {
	*p++ = 0x29;
	addr1 = rfaddr >> 16;
	*p++ = addr1;
	*p++ = addr1 ^ 0x0f;
	*p++ = func;
	*p++ = ~func;
	*p++ = rfaddr >> 8;
	*p = rfaddr;
	cm15a_decode_rf(-1, buf, 8);
	if (Cm19a)
	    return x10_write(buf + 1, 7);
	else
	    return x10_write(buf, 8);
    }
}

/* EB 20 60 9F 00 FF
 *        |  |  |
 *        |  |  unit/function
 *        |  XOR with prev byte=0xff
 *        house code/unit
 */
static int rf_tx_houseunitfunc(int fd, int house, int unit, int func) {
    unsigned char buf[6];
    unsigned char unit8, unit4, unit2, unit1;

    if (house < 0) return -1;
    unit8 = unit & 0x08;
    unit4 = unit & 0x04;
    unit2 = unit & 0x02;
    unit1 = unit & 0x01;

    buf[0] = 0xeb;
    buf[1] = 0x20;
    buf[2] = (x10housecoderf[house] << 4) | (unit8 >> 1);

    buf[4] = 0;
    switch (func) {
	    /* X10 standard RF */
	case FUNC_OFF:
	    buf[4] = 1 << 5; // 1=OFF, 0=ON
	    /* fall through */
	case FUNC_ON:
	    if (unit < 0) return -1;
	    buf[4] |= (unit4 << 4) | (unit2 << 2) | (unit1 << 4);
	    break;
	case FUNC_DIM:
	    buf[4] = 0x98;
	    break;
	case FUNC_BRIGHT:
	    buf[4] = 0x88;
	    break;
	    /* X10 SECURITY RF */
	default:
	    dbprintf("Invalid function\n");
	    return -1;
    }
    buf[3] = ~buf[2]; // add check bytes
    buf[5] = ~buf[4];

    cm15a_decode_rf(-1, buf, sizeof (buf));
    if (Cm19a)
	return x10_write(buf + 1, sizeof (buf) - 1);
    else
	return x10_write(buf, sizeof (buf));
}

static const char DOMAINPOLICY[] =
	"<?xml version=\"1.0\"?>"
	"<!DOCTYPE cross-domain-policy SYSTEM \"http://www.adobe.com/xml/dtds/cross-domain-policy.dtd\">"
	"<cross-domain-policy>"
	"<allow-access-from domain=\"*.chumby.com\" to-ports=\"1100\" />"
	"</cross-domain-policy>";

/* aLine looks something like the following
 * pl a1 on
 * rf a1 on
 * getstatus a1
 */
int processcommandline(int fd, char *aLine) {
    printf("%s\n", aLine);
    char *command, *arg1;
    int house, unit, func, param;
    unsigned char x10bytes8[8];
    size_t len;
    unsigned long rfaddr;
    int rf8bitaddr, rfcamkey;

    strupper(aLine);
    printf("%s\n", aLine);
    dbprintf("%lu:%s\n", (unsigned long) strlen(aLine), aLine);
    if (strcmp(aLine, "<POLICY-FILE-REQUEST/>") == 0) {
	/* Yes, this sends the '\0' terminator which is required. */
	send(fd, DOMAINPOLICY, sizeof (DOMAINPOLICY), MSG_NOSIGNAL);
	return 0;
    }
    command = strtok(aLine, " ");
    if (command) {
	if (strcmp(command, "PL") == 0) {
	    if (or20client(fd)) statusprintf(fd, "ok\n");
	    house = getdeviceaddr(&unit);
	    dbprintf("house %d unit %d\n", house, unit);
	    if (house < 0) return -1;
	    if (unit < 0) {
		/* Unit code is 0 but house code != 0 */
		func = getfunc();
		if (func < 0 || func == FUNC_EXTENDED_DIM) return -1;
		if (func == FUNC_DIM || func == FUNC_BRIGHT) {
		    param = getparam();
		    if (param == -1) param = 1;
		    pl_tx_housefunc(fd, house, func, param);
		} else
		    pl_tx_housefunc(fd, house, func, 0);
	    } else {
		func = getfunc();
		if (func < 0) {
		    pl_tx_houseunit(fd, house, unit);
		    return -1;
		}
		dbprintf("func %d\n", func);
		if (func == FUNC_EXTENDED_DIM) {
		    param = getparam();
		    if (param == -1) param = 1; /* default is 1 dim */
		    pl_tx_extended_code_1(fd, house, unit, 3, 1, param);
		} else if (func == FUNC_DIM || func == FUNC_BRIGHT) {
		    param = getparam();
		    if (param == -1) param = 1;
		    pl_tx_houseunit(fd, house, unit);
		    pl_tx_housefunc(fd, house, func, param);
		} else if (func == FUNC_EXTENDED_CODE_1) {
		    int command, subcmd, data;
		    command = getparam();
		    if (command == -1) command = 0;
		    subcmd = getparam();
		    if (subcmd == -1) subcmd = 0;
		    data = getparam();
		    if (data == -1) data = 0;
		    pl_tx_extended_code_1(fd, house, unit, command, subcmd, data);
		} else {
		    pl_tx_houseunit(fd, house, unit);
		    pl_tx_housefunc(fd, house, func, 0);
		}
	    }
	} else if (strcmp(command, "RF") == 0) {
	    printf("rf!\n");
	    if (or20client(fd)) statusprintf(fd, "ok\n");
	    printf("blah\n");
	    house = getdeviceaddr(&unit);
	    dbprintf("house %d unit %d\n", house, unit);
	    if (house < 0) return -1;
	    func = getfunc();
	    dbprintf("house %d unit %d %d\n", house, unit, func);
	    if (func < 0) return -1;
	    printf("blah!\n");
	    rf_tx_houseunitfunc(fd, house, unit, func);
	} else if (strcmp(command, "RFSEC") == 0) {
	    if (or20client(fd)) statusprintf(fd, "ok\n");
	    rfaddr = 0;
	    rf8bitaddr = getrfaddr(&rfaddr);
	    dbprintf("rfaddr 8bit: %d %X\n", rf8bitaddr, rfaddr);
	    if (rf8bitaddr < 0) return -1;
	    func = getrffunc(rf8bitaddr);
	    dbprintf("rf func %X\n", func);
	    if (func < 0) return -1;
	    rfsec_tx(fd, rf8bitaddr, rfaddr, func);
	} else if (strcmp(command, "RFCAM") == 0) {
	    if (or20client(fd)) statusprintf(fd, "ok\n");
	    /* Unit number is ignored */
	    house = getdeviceaddr(&unit);
	    if (house < 0) return -1;
	    arg1 = strtok(NULL, " ");
	    if (arg1 == NULL || *arg1 == '\0') return -1;
	    dbprintf("rfcam house keyname %d %s\n", house, arg1);

	    rfcamkey = findCamRemoteCommand(arg1);
	    if (rfcamkey > 0) {
		house = x10housecoderf[house] << 4;
		x10bytes8[0] = 0xeb;
		x10bytes8[1] = 0x14;
		x10bytes8[2] = (house + (rfcamkey - 0x2B)) & 0xFF;
		x10bytes8[3] = rfcamkey;
		x10bytes8[4] = house;
		hexdump(x10bytes8, 5);
		cm15a_decode_rf(-1, x10bytes8, 5);
		if (Cm19a)
		    x10_write(x10bytes8 + 1, 4);
		else
		    x10_write(x10bytes8, 5);
	    } else {
		sockprintf(fd, "Invalid command %s\n", arg1);
	    }
	} else if (strcmp(command, "PT") == 0) {
	    if (or20client(fd)) statusprintf(fd, "ok\n");
	    len = gethexdata(x10bytes8);
	    hexdump(x10bytes8, len);
	    if (len > 0) x10_write(x10bytes8, len);
	}
#if 0
	    /* Enable/disable the internal RFTOPL repeater */
	    /* This seems to make the device lockup after a while */
	    /* bb 40 51 05  00 14 20 28 */
	else if (strcmp(command, "RFTOPL") == 0) {
	    unsigned short bitmap16;
	    bitmap16 = gethousecodes();
	    x10_write("\xdb\x1f\xf0", 3);
	    x10_write("\xfb\x20\x00\x02", 4);
	    memcpy(x10bytes8, "\xbb\x00\x00\x05\x00\x14\x20\x28", 8);
	    memcpy(x10bytes8 + 1, &bitmap16, sizeof (bitmap16));
	    x10_write(x10bytes8, 8);
	} else if (strcmp(command, "CMINIT") == 0) {
	    dbprintf("Disabling internal RF to PL repeater\n");
	    x10_write((unsigned char *) "\x9b\x00\x09\x07\x43\x04\xe0\x03", 8);
	    x10_write((unsigned char *) "\x8b", 1);
	    x10_write((unsigned char *) "\xdb\x1f\xf0", 3);
	    x10_write((unsigned char *) "\xfb\x20\x00\x02", 4);
	    x10_write((unsigned char *) "\xbb\x00\x00\x05\x00\x14\x20\x28", 8);
	}
#endif
	else if (strcmp(command, "RFTOPL") == 0) {
	    if (or20client(fd)) statusprintf(fd, "ok\n");
	    RfToPl16 = gethousecodes();
	    sockprintf(fd, "RfToPl %04X\n", RfToPl16);
	} else if (strcmp(command, "RFTORF") == 0) {
	    if (or20client(fd)) statusprintf(fd, "ok\n");
	    arg1 = strtok(NULL, " ");
	    if (arg1) RfToRf16 = (unsigned short) strtoul(arg1, NULL, 10);
	    sockprintf(fd, "RfToRf %04X\n", RfToRf16);
	} else if (strcmp(command, "ST") == 0) {
	    arg1 = strtok(NULL, " ");
	    dbprintf("st arg1 %s\n", arg1);
	    if (arg1 && (strcmp(arg1, "0") == 0))
		hua_sec_init();
	    else
		hua_show(fd);
	} else if (strcmp(command, "GETSTATUS") == 0) {
	    house = getdeviceaddr(&unit);
	    if ((house >= 0) && (unit >= 0)) {
		arg1 = strtok(NULL, " ");
		if (arg1) {
		    if (strcmp(arg1, "XDIM") == 0) { /* getstatus a1 xdim */
			int status = hua_getstatus_xdim(house, unit);
			statusprintf(fd, "%d\n", status);
			char sensoflare_message[10];
			sprintf(sensoflare_message, "%c%d %d\n", 65 + house, 1 + unit, status);
			sendMessage(sensoflare_message);
		    } else { /* getstatus a1 ? */
			statusprintf(fd, "-1\n");
			char sensoflare_message[10];
			sprintf(sensoflare_message, "%c%d -1\n", 65 + house, 1 + unit);
			sendMessage(sensoflare_message);
		    }
		} else { /* getstatus a1 */
		    statusprintf(fd, "%s\n",
			    (hua_getstatus(house, unit) == '1') ? "on" : "off");
		    char sensoflare_message[10];
		    sprintf(sensoflare_message, "%c%d %s\n", 65 + house, 1 + unit, (hua_getstatus(house, unit) == '1') ? "on" : "off");
		    sendMessage(sensoflare_message);
		}
	    } else
		return -1;
	} else if (strcmp(command, "GETSTATUSSEC") == 0) {
	    rfaddr = 0;
	    rf8bitaddr = getrfaddr(&rfaddr);
	    if (rf8bitaddr < 0) return -1;
	    statusprintf(fd, "%s\n",
		    (hua_getstatus_sec(rf8bitaddr, rfaddr) == 1) ? "on" : "off");
	} else {
	    dbprintf("Unknown command: %s\n", command);
	    return -1;
	}
    }
    return 0;
}

/*
 * Parse human readable commands and convert to binary X10 protocol.
 * Send to CM15A.
 */
void cm15a_encode(int fd, unsigned char * buf, size_t buflen) {
    static char remainder[80]; // Any leftover, not seen \n yet.
    static size_t remlen = 0;
    char *remptr;

    dbprintf("buflen %lu\n", (unsigned long) buflen);
    hexdump(buf, buflen);
    dbprintf("remlen %lu\n", (unsigned long) remlen);
    hexdump(remainder, remlen);

    /* Break the input stream into \n or \r terminated lines. The stream is not
     * guaranteed to end on a line boundary so there may be left over input
     * which must be processed the next time around.
     */
    remptr = remainder + remlen;
    while (buflen--) {
	*remptr = *buf;
	if ((*remptr == '\n') || (*remptr == '\r') || (*remptr == '\0')) {
	    *remptr = '\0';
	    if (strlen(remainder)) {
		processcommandline(fd, remainder);
		if (or20client(fd)) del_client(fd);
	    }
	    remptr = remainder;
	} else
	    remptr++;
	buf++;
    }
    remlen = remptr - remainder;
}