#include <asm/types.h>
#include "lantronix.h"
#define NOT_FOUND ((unsigned short)-1)
int debug = 0;
int lx_error = LX_ERROR_NO_ERROR;
unsigned char read_queue[NQUEUE][QUEUELEN];
size_t queue_len[NQUEUE] = {0};
struct commstr {
__u16 _dummy;
__u16 len;
__u32 acc;
__u32 sid;
__u8 code;
__u8 d0B;
__u16 datalen;
__u16 d0E;
__u16 d10;
__u16 d12;
__u16 d14;
__u32 did;
__u32 d1A;
__u16 d1E;
__u16 d20;
__u8 data[];
};
struct devinfo {
__u16 len;
__u16 type;
__u16 vid;
__u16 pid;
__u32 port;
char client[0x40];
char name1[0x20];
__u8 ip[4];
__u16 d70;
__u8 d72;
__u8 d73;
__u8 d74[4];
__u8 d78[4];
__u8 d7C[2];
__u16 d7E;
__u8 d80[0x18];
char sn[0x20];
__u16 dB8;
char name2[0x20];
__u16 dDA;
};
struct cliinfo {
__u16 len;
__u16 type;
char name[0x60];
__u8 ip[4];
__u8 d68[6];
char d6E[0x20];
};
struct udppacket {
__u32 sn;
__u32 firm_ver;
__u32 firm_rev;
__u8 code1;
__u8 code2;
__u16 tcp_port;
__u16 d10;
__u16 d12;
__u16 d14;
__u16 ord;
__u32 d18;
__u16 vid;
__u16 pid;
__u32 usb_port;
};
int sock = 0;
struct commstr *salloc = NULL;
void freeall() { /* pro atexit() */
if(salloc) free(salloc);
salloc = NULL;
if(sock) close(sock);
sock = 0;
}
int initsock(char *ip) {
struct hostent *host;
struct sockaddr_in sin;
int s;
if((host = gethostbyname((void*)ip)) == NULL) return -1;
if((s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) return -1;
sin.sin_family = AF_INET;
sin.sin_port = htons(10010);
memcpy(&(sin.sin_addr), host->h_addr, host->h_length);
if((connect(s, (struct sockaddr*)&sin, sizeof(sin))) == -1) return -1;
return s;
}
void setupstr(struct commstr *str, unsigned char code, unsigned acc, unsigned short d0E,
unsigned short d10, unsigned short d12, unsigned short datalen) {
memset(str, 0, sizeof(struct commstr));
str->code = code;
str->acc = htonl(acc);
str->d0E = htons(d0E);
str->d10 = htons(d10);
str->d12 = htons(d12);
str->datalen = htons(datalen);
str->len = htons(datalen + 32);
memset(str->data, 0, datalen);
}
void sendstr(struct commstr *str) {
unsigned char *stream = (unsigned char*)str + 2;
if(debug > 1) {
int i;
for(i = 0; i < 34 + ntohs(str->datalen); i++)
printf("%02X ", (int)(stream[i]));
puts("");
}
if(send(sock, (void*)stream, 34 + ntohs(str->datalen), 0) < 0) exit(RETVAL_SEND);
}
void sendsimple(unsigned char code, unsigned acc, unsigned short d0E,
unsigned short d10, unsigned short d12) {
setupstr(salloc, code, acc, d0E, d10, d12, 0);
sendstr(salloc);
}
void sendpacket_va(unsigned char code, unsigned acc, unsigned short d0E,
unsigned short d10, unsigned short d12, unsigned short datalen, va_list ap) {
int i;
setupstr(salloc, code, acc, d0E, d10, d12, datalen);
for(i = 0; i < datalen; i++)
salloc->data[i] = (unsigned char)va_arg(ap, unsigned);
sendstr(salloc);
}
void sendpacket(unsigned char code, unsigned acc, unsigned short d0E,
unsigned short d10, unsigned short d12, unsigned short datalen, ...) {
va_list ap;
if(datalen) {
va_start(ap, datalen);
sendpacket_va(code, acc, d0E, d10, d12, datalen, ap);
va_end(ap);
} else {
sendsimple(code, acc, d0E, d10, d12);
}
}
void sendconfig(unsigned acc, unsigned short datalen, ...) {
va_list ap;
va_start(ap, datalen);
sendpacket_va(0x41, acc, 1,0,0, datalen, ap);
va_end(ap);
free(waitpacket(0x51));
}
struct commstr *readpacket(int sock) {
int r, len, o;
struct commstr *str;
unsigned char *buf;
unsigned short prebuf;
r = recv(sock, &prebuf, 2, 0);
if(r <= 0) exit(RETVAL_RECV);
len = ntohs(prebuf)+2;
o = 2;
str = malloc(len+2); /* Nezapomente uvolnit! */
if(!str) exit(RETVAL_MALLOC);
buf = (unsigned char*)str + 2;
memcpy(buf, &prebuf, 2);
do {
r = recv(sock, buf+o, len-o, 0);
if(r <= 0) { free(str); exit(RETVAL_RECV); }
else o += r;
} while(o < len);
if(debug > 1) {
int i;
for(i = 0; i < len; i++) {
printf("%02X ", (int)(buf[i]));
if(i == 1000) puts("");
}
puts("");
}
return str;
}
void dispatch(struct commstr *str) {
struct devinfo *di;
struct cliinfo *ci;
struct udppacket *udp;
int off, q;
switch(str->code) {
case 0x57:
case 0x12:
case 0x15:
/* ignore */
break;
case 0x52:
if(str->d12 == 0x0) {
q = ntohl(str->acc);
if(queue_len[q] + ntohs(str->datalen) > QUEUELEN) exit(RETVAL_QUEUE);
memcpy(read_queue[q]+queue_len[q], str->data, ntohs(str->datalen));
queue_len[q] += ntohs(str->datalen);
}
break;
case 0x18:
if(debug) {
printf("\n=== 0x18 ===\nPočet zařízení: %i\nPočet klientů: %i\n",
ntohs(str->d0E), ntohs(str->d10));
for(off = 0; ; off += ntohs(*(unsigned short*)(str->data+off))) {
switch(str->data[off+2]) {
case 0x04:
di = (struct devinfo*)(str->data+off);
printf("port %i: %04X/%04X %s\t%s",
ntohl(di->port)-1, ntohs(di->vid), ntohs(di->pid), di->name1, di->sn);
if(di->ip[0]) printf(" [%i.%i.%i.%i %s]",
di->ip[0], di->ip[1], di->ip[2], di->ip[3], di->client);
printf("\n");
break;
case 0x05:
ci = (struct cliinfo*)(str->data+off);
printf("%s\t%i.%i.%i.%i\n", ci->name, ci->ip[0], ci->ip[1], ci->ip[2], ci->ip[3]);
break;
case 0x00:
break;
}
if(str->data[off+2] == 0x00) {
off += 4;
break;
}
}
printf("\n");
}
break;
case 0x61:
udp = (struct udppacket*)(str->data);
if(debug) {
printf("\n=== 0x61: %02X%02X ===\n", udp->code1, udp->code2);
switch(udp->code1) {
case 0x01:
if(udp->d14 == 0)
sendsimple(0x05, 0,0,0,0);
else puts("Zbytečnost");
break;
case 0x02:
case 0x03:
printf("Zařízení %04X/%04X na portu %i: požadavek na %s\n",
ntohs(udp->vid), ntohs(udp->pid), ntohl(udp->usb_port),
udp->code1==2 ? "aktivaci":"deaktivaci");
break;
case 0x06:
printf("Zařízení %04X/%04X na portu %i ",
ntohs(udp->vid), ntohs(udp->pid), ntohl(udp->usb_port));
switch(udp->code2) {
case 0x00:
if(udp->d10) puts("připojeno");
else puts("odpojeno");
break;
case 0x01:
puts("připraveno");
break;
case 0x02:
puts("aktivováno");
}
break;
}
}
break;
default:
if(debug) printf("\n=== 0x%02X ===\n", str->code);
break;
}
free(str);
}
struct commstr *waitpacket(unsigned char code) {
struct commstr *ret;
time_t b = time(NULL);
for(ret = readpacket(sock); ret->code != code; ret = readpacket(sock)) {
dispatch(ret);
if(time(NULL)-b > MAXWAIT) exit(RETVAL_WAIT);
}
return ret;
}
struct commstr *waitpacket61(unsigned short code) {
struct commstr *ret;
struct udppacket *udp;
time_t b = time(NULL);
for(;;) {
for(ret = readpacket(sock); ret->code != 0x61; ret = readpacket(sock))
dispatch(ret);
udp = (struct udppacket*)(ret->data);
if(256 * udp->code1 + udp->code2 == code) break;
dispatch(ret);
if(time(NULL)-b > MAXWAIT) exit(RETVAL_WAIT);
}
return ret;
}
struct commstr *waitpacket_sid(unsigned sid) {
struct commstr *ret;
time_t b = time(NULL);
for(ret = readpacket(sock); ntohl(ret->sid) != sid; ret = readpacket(sock)) {
dispatch(ret);
if(time(NULL)-b > MAXWAIT) exit(RETVAL_WAIT);
}
return ret;
}
int write_lx(unsigned acc, void *buf, size_t count) {
struct commstr *ret;
setupstr(salloc, 0x43, acc, 1,count,1, count);
memcpy(salloc->data, buf, count);
salloc->sid = htonl(1);
sendstr(salloc);
ret = waitpacket_sid(1);
if((int)ntohl(ret->did) < 0) exit(RETVAL_WRITE);
dispatch(ret);
return ntohs(ret->d12);
}
int read_lx(unsigned acc, void *buf, size_t count) {
size_t len;
while(!queue_len[acc]) dispatch(waitpacket(0x52));
len = MIN(queue_len[acc], count);
memcpy(buf, read_queue[acc], len);
queue_len[acc] -= len;
memmove(read_queue[acc], read_queue[acc]+len, queue_len[acc]);
sendsimple(0x42, acc, 1,0x1000,0);
return len;
}
unsigned short finddev_lx(int addr) {
struct commstr *ret;
struct devinfo *di;
unsigned short ord;
int off, ex = 0;
sendsimple(0x08, 0, 2,3,0);
ret = waitpacket(0x18);
ord = 0;
for(off = 0; ; off += ntohs(*(unsigned short*)(ret->data+off))) {
switch(ret->data[off+2]) {
case 0x04:
di = (struct devinfo*)(ret->data+off);
if(ntohl(di->port) == addr+1) {
if(debug) {
printf("finddev - port %i: %04X/%04X %s\t%s",
ntohl(di->port), ntohs(di->vid), ntohs(di->pid), di->name1, di->sn);
if(di->ip[0]) printf(" [%i.%i.%i.%i %s]",
di->ip[0], di->ip[1], di->ip[2], di->ip[3], di->client);
printf("\n");
}
ex = 1;
break;
}
ord++;
break;
case 0x00:
if(debug) {
printf("finddev: na portu %i neni pripojeno zadne zarizeni!\n", addr);
}
ord = NOT_FOUND;
ex = 1;
break;
}
if(ex) break;
}
free(ret);
return ord;
}
int opendev_lx(int addr, int *acc) {
struct commstr *ret;
struct udppacket *udp;
unsigned short ord, port, vid, pid;
lx_error = LX_ERROR_NO_ERROR;
if(!acc) {
lx_error = LX_ERROR_MEMORY;
return 0;
}
if(!salloc) {
salloc = malloc(sizeof(struct commstr) + MAXDATA);
if(!salloc) {
lx_error = LX_ERROR_MEMORY;
return 0;
}
}
if(!sock) {
sock = initsock(LX_ADDRESS/*"10.3.4.72"*/);
if(sock == -1) {
lx_error = LX_ERROR_NETWORK;
return 0;
}
atexit(freeall);
}
setupstr(salloc, 0x01, 0, 2,1,0, 1+strlen(ID_COMPUTER)/*6*/);
salloc->did = htonl(LX_SERIAL/*0xA38A13A2*/);
strcpy((char*)salloc->data, ID_COMPUTER/*"VASEK"*/);
sendstr(salloc);
free(waitpacket(0x11));
ord = finddev_lx(addr);
if(ord == NOT_FOUND) {
lx_error = LX_ERROR_NOT_FOUND;
return 0;
}
if(debug) printf("Aktivuji zařízení s pořadím %i\n", ord);
sendsimple(0x09, 0, ord,0,0);
for(;;) {
for(ret = readpacket(sock); ret->code != 0x19 && ret->code != 0x61; ret = readpacket(sock))
dispatch(ret);
if(ret->code == 0x19) break;
udp = (struct udppacket*)(ret->data);
if(udp->code1 == 0x02 && udp->code2 == 0x02) {
vid = ntohs(udp->vid);
pid = ntohs(udp->pid);
port = ntohl(udp->usb_port);
}
dispatch(ret);
}
if(ret->did == 0) {
if(debug) printf("Aktivace proběhla úspěšně.\n");
} else {
fprintf(stderr, "Aktivace se nezdařila, chybový kód: %i.\n", (int)(ntohl(ret->did)));
free(ret);
lx_error = LX_ERROR_ACTIVATE;
return 0;
}
free(ret);
setupstr(salloc, 0x02, 0, vid, pid, 0, 0);
salloc->did = htonl(port);
sendstr(salloc);
ret = waitpacket(0x12);
*acc = ntohl(ret->acc);
if(debug) printf(" ord = %i: acc = %i\n", ord, *acc);
free(ret);
sendsimple(0x08, 0, 2,3,0);
dispatch(waitpacket(0x18));
if(debug) printf("Nastavuji parametry RS232\n");
sendconfig(*acc, 8, 0x41,0x11,0,0,0,0,0,0); /* Reset */
sendconfig(*acc, 8, 0x41,0,0x01,0,0,0,0,0); /* UART enable */
sendconfig(*acc, 24, 0x41,0x13,0,0,0,0,0x10,0,0x01,0,0,0,0x40,0,0,0,0,0,0,0,0,0,0,0); /* "set flow" */
sendconfig(*acc, 8, 0xC1,0x0F,0,0,0,0,0x40,0x02); /* "get props" */
sendconfig(*acc, 8, 0xC1,0x08,0,0,0,0,0x01,0); /* "get mdmsts" */
sendconfig(*acc, 8, 0x02,0x01,0,0,0x81,0,0,0); /* ??? */
sendsimple(0x47, *acc, 1,1,0);
sendconfig(*acc, 8, 0x41,0x01,0x04,0,0,0,0,0); /* Baud 921600 */
sendsimple(0x42, *acc, 1,0x1000,0);
sendconfig(*acc, 8, 0x41,0x07,0x02,0x02,0,0,0,0); /* RTS */
sendconfig(*acc, 8, 0x41,0x07,0x01,0x01,0,0,0,0); /* DTR */
sendconfig(*acc, 8, 0x41,0x03,0x00,0x08,0,0,0,0); /* 8 data bits, 1 stop bit, parity off */
sendconfig(*acc, 14, 0x41,0x19,0,0,0,0,0x06,0,0,0,0,0,0x11,0x13); /* "special chars" */
sendconfig(*acc, 24, 0x41,0x13,0,0,0,0,0x10,0,0x01,0,0,0,0x40,0,0,0,0,0x70,0,0,0,0x1C,0,0); /* "set flow" */
sendsimple(0x42, *acc, 1,0x1000,0);
sendsimple(0x42, *acc, 1,0x1000,0);
sendconfig(*acc, 8, 0x41,0x05,0x01,0,0,0,0,0); /* Break on */
sendconfig(*acc, 8, 0x41,0x05,0x01,0,0,0,0,0); /* Break on */
sendconfig(*acc, 8, 0x41,0x05,0x00,0,0,0,0,0); /* Break off */
queue_len[*acc] = 0;
return 1;
}
int closedev_lx(int addr) {
unsigned short ord;
ord = finddev_lx(addr);
if(ord == NOT_FOUND) return 1;
usleep(500000);
if(debug) printf("Deaktivuji zařízení s pořadím %i\n", ord);
sendsimple(0x0C, 0, ord,0,0);
free(waitpacket(0x1C));
dispatch(waitpacket61(0x0600));
dispatch(waitpacket61(0x0600));
sendsimple(0x08, 0, 2,3,0);
dispatch(waitpacket(0x18));
return 1;
}
char *deverror_lx(int addr) {
static char msg[200];
int off;
off = sprintf(msg, "Nepodarilo se pripojit k zarizeni na portu c. %i.\n", addr);
switch(lx_error) {
case LX_ERROR_MEMORY:
sprintf(msg+off, "Chyba pri inicializaci programu.\n");
break;
case LX_ERROR_NETWORK:
sprintf(msg+off, "Chyba sitove komunikace.\n");
break;
case LX_ERROR_NOT_FOUND:
sprintf(msg+off, "Zkontrolujte prosim, zda je zarizeni pripojeno na tomto portu.\n");
break;
case LX_ERROR_ACTIVATE:
sprintf(msg+off, "Zarizeni odmita pozadavek na aktivaci.\n");
break;
}
return msg;
}
