lemplug.c

Go to the documentation of this file.

/********************************************************************\

  Name:         lemplug.c
  Created by:   Andreas Suter

  Contents:     ePowerSwitch M8    Device Driver (firmware tag = 0), and
                ePowerSwitch M8+R2 Device Driver (firmware tag = 1)

\********************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <netdb.h>
#include <ctype.h>

#include "midas.h"

#define closesocket(s) close(s)

#define LEMPLUG_MAX_READ 5 

#define LEMPLUG_SUCCESS         0
#define LEMPLUG_NOSUCCESS      -1
#define LEMPLUG_STARTUP_ERROR  -2
#define LEMPLUG_NO_HOST_ERROR  -3
#define LEMPLUG_CONNECT_ERROR  -4

/*---- globals -----------------------------------------------------*/

typedef struct {
  int  enable_log;             
  char log[2*NAME_LENGTH];     
  DWORD read_time;             
  char host[NAME_LENGTH];      
  int  port;                   
  char user_name[NAME_LENGTH]; 
  char pwd[NAME_LENGTH];       
  int  firmware_tag;           
} LEMPLUG_SETTINGS;

#define LEMPLUG_SETTINGS_STR "\
Enable Log = INT : 0\n\
Log = STRING : [64]\n\
Read Time = DWORD : 5\n\
Host = STRING : [32]\n\
Port = INT : 23\n\
User Name = STRING : [32]\n\
Pwd = STRING : [32]\n\
Firmware Tag = INT : 0\n\
"

typedef struct {
  LEMPLUG_SETTINGS dd_settings;      
  float outlet_state[8];             
  char  outlet_name[8][NAME_LENGTH]; 
  INT num_channels;                  
  INT(*bd) (INT cmd, ...);           
  void *bd_info;                     
  HNDLE hkey;                        
  int   startup_error;               
  DWORD read_time_stamp;             
} LEMPLUG_INFO;


/*---- base64 encoding routines ------------------------------------------*/

char *map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
char request[10000], response[10000];

/***************************************************************************/
void lemplug_base64_encode(char *s, char *d)
{
   unsigned int t, pad;

   pad = 3 - strlen(s) % 3;
   if (pad == 3)
      pad = 0;
   while (*s) {
      t = (*s++) << 16;
      if (*s)
         t |= (*s++) << 8;
      if (*s)
         t |= (*s++) << 0;

      *(d + 3) = map[t & 63];
      t >>= 6;
      *(d + 2) = map[t & 63];
      t >>= 6;
      *(d + 1) = map[t & 63];
      t >>= 6;
      *(d + 0) = map[t & 63];

      d += 4;
   }
   *d = 0;
   while (pad--)
      *(--d) = '=';
}

/***************************************************************************/
INT lemplug_strip_whitespace(char *str)
{
  char *s;

  if (strlen(str) == 0)
    return 0;

  s=str+strlen(str)-1; // go to the end of the string
  for (;;) {
    if (isspace(*s)) { // remove whitespace
      *s='\0';
      s--;
    } else
      break;
  }

  return strlen(str);
}

/***************************************************************************/
void lemplug_write_log(LEMPLUG_INFO *info, char *log)
{
  int  fd;
  char tt[64];
  char str[10000];
  time_t err_time;

  fd = open(info->dd_settings.log, O_CREAT | O_WRONLY | O_APPEND, 0644);

  if (fd>0) { // valid file descriptor
    // get time
    time(&err_time);
    strcpy(tt, ctime(&err_time));
    tt[strlen(tt)-1]='\0';

    sprintf(str, "----------------------------------------------\n");
    write(fd, str, strlen(str));

    sprintf(str, "[%s]:\r\n%s\n", tt, log);
    write(fd, str, strlen(str));

    close(fd);
  }
}

/***************************************************************************/
INT lemplug_cmd_0(LEMPLUG_INFO *info)
{
  struct hostent *phe;
  struct sockaddr_in bind_addr;
  int sock;
  int status;
  int done = 0;
  int err, i;

  err = 0;
  do {
    // open connection
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
       perror("cannot create socket");
       return LEMPLUG_NOSUCCESS;
    }

    // compose remote address
    memset(&bind_addr, 0, sizeof(bind_addr));
    bind_addr.sin_family = AF_INET;
    bind_addr.sin_addr.s_addr = 0;
    bind_addr.sin_port = htons((unsigned short) info->dd_settings.port);

    phe = gethostbyname(info->dd_settings.host);
    if (phe == NULL) {
       perror("cannot get host name");
       return LEMPLUG_NO_HOST_ERROR;
    }
    memcpy((char *) &(bind_addr.sin_addr), phe->h_addr, phe->h_length);

    // connect to server
    status = connect(sock, (void *) &bind_addr, sizeof(bind_addr));
    if (status != 0) {
       cm_msg(MINFO, "lemplug_cmd_0", "Cannot connect to host %s, port %d\n",
              info->dd_settings.host, info->dd_settings.port);
       return LEMPLUG_CONNECT_ERROR;
    }

    // send request
    send(sock, request, strlen(request), 0);
    // receive response
    memset(response, 0, sizeof(response));
    i = recv(sock, response, sizeof(response), 0);

    if (i < 0) {
      perror("Cannot receive response");
      return LEMPLUG_NOSUCCESS;
    }

    if (strstr(response, "303 See Other")) {
      done = 1;
    } else {
      usleep(100000);
      err++;
    }

    if (err > 5) {
      done = 1;
    }

    // close connection
    closesocket(sock);
  } while (!done);

  return strlen(response);
}

/***************************************************************************/
INT lemplug_read_0(LEMPLUG_INFO *info)
{
  struct hostent *phe;
  struct sockaddr_in bind_addr;
  int sock;
  int status;
  int i, state;
  int err;
  int done = 0;
  char *s, name[128];

  // open connection
  if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
     perror("cannot create socket");
     return LEMPLUG_NOSUCCESS;
  }

  // compose remote address
  memset(&bind_addr, 0, sizeof(bind_addr));
  bind_addr.sin_family = AF_INET;
  bind_addr.sin_addr.s_addr = 0;
  bind_addr.sin_port = htons((unsigned short) info->dd_settings.port);

  phe = gethostbyname(info->dd_settings.host);
  if (phe == NULL) {
     perror("cannot get host name");
     return LEMPLUG_NO_HOST_ERROR;
  }
  memcpy((char *) &(bind_addr.sin_addr), phe->h_addr, phe->h_length);

  // connect to server
  status = connect(sock, (void *) &bind_addr, sizeof(bind_addr));
  if (status != 0) {
     cm_msg(MINFO, "lemplug_read_0", "lemplug_read_0: Cannot connect to host %s, port %d\n",
            info->dd_settings.host, info->dd_settings.port);
     return LEMPLUG_CONNECT_ERROR;
  }

  err = 0;
  do {
    // send request
    send(sock, request, strlen(request), 0);
    // receive response
    memset(response, 0, sizeof(response));
    i = recv(sock, response, sizeof(response), 0);

    if (i < 0) {
      perror("Cannot receive response");
      return -1;
    }

    if (strstr(response, "cmd.js"))
      done = 1;
    else {
      usleep(100000);
      err++;
    }

    if (err > 5)
      done = 1;

  } while (!done);

  // close connection
  closesocket(sock);

  if (err>5)
    return LEMPLUG_NOSUCCESS;

  // extract names and status of the outlets (ugly code but it should work mostly ;-))
  s = strstr(response, "display(");
  if ((s == NULL) || strlen(response)<686)
    return LEMPLUG_NOSUCCESS;

  s += 9; // shift pointer to the 1st socket name
  for (i=0; i<8; i++) {
    memset(name, 0, sizeof(name));
    strncpy(name, s, 32);
    lemplug_strip_whitespace(name);
    snprintf(info->outlet_name[i], NAME_LENGTH, "lemplug%%%s", name);
    s += 34;
    sscanf(s, "%d", &state);
    info->outlet_state[i] = (float)state;
    s += 8;
  }

  return strlen(response);
}

/***************************************************************************/
INT lemplug_cmd_1(LEMPLUG_INFO *info)
{
  struct hostent *phe;
  struct sockaddr_in bind_addr;
  int sock;
  int status;
  int i,j;
  int err;
  int done = 0;
  char str[1024], *s;

  // open connection
  if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
     perror("cannot create socket");
     return LEMPLUG_NOSUCCESS;
  }

  // compose remote address
  memset(&bind_addr, 0, sizeof(bind_addr));
  bind_addr.sin_family = AF_INET;
  bind_addr.sin_addr.s_addr = 0;
  bind_addr.sin_port = htons((unsigned short) info->dd_settings.port);

  phe = gethostbyname(info->dd_settings.host);
  if (phe == NULL) {
     perror("cannot get host name");
     return LEMPLUG_NO_HOST_ERROR;
  }
  memcpy((char *) &(bind_addr.sin_addr), phe->h_addr, phe->h_length);

  // connect to server
  status = connect(sock, (void *) &bind_addr, sizeof(bind_addr));
  if (status != 0) {
     cm_msg(MINFO, "lemplug_cmd_1", "lemplug_cmd_1: Cannot connect to host %s, port %d\n",
            info->dd_settings.host, info->dd_settings.port);
     return LEMPLUG_CONNECT_ERROR;
  }

  err = 0;
  memset(response, 0, sizeof(response));
  do {
    // send request
    send(sock, request, strlen(request), 0);
    // receive response
    memset(str, 0, sizeof(str));
    i = recv(sock, str, sizeof(str), 0);

    if (i < 0) {
      perror("Cannot receive response");
      return -1;
    }

    strcat(response, str);

    if (strstr(response, "</html>"))
      done = 1;
    else {
      usleep(100000);
      err++;
    }

    if (err > 5)
      done = 1;

  } while (!done);

  // close connection
  closesocket(sock);

  if (err>5)
    return LEMPLUG_NOSUCCESS;

  // everything looks fine, hence filter the content
  for (i=1; i<=8; i++) {
    sprintf(str, "M0:O%d=", i);
    s = strstr(response, str);
    if (s != 0) {
      memset(str, 0, sizeof(str));
      for (j=0; j<10; j++) {
        if (*(s+j) == '\r')
          break;
        str[j] = *(s+j);
      }
      if (strstr(str, "Off"))
        info->outlet_state[i-1] = 0.0;
      else if (strstr(str, "On"))
        info->outlet_state[i-1] = 1.0;
      else
        info->outlet_state[i-1] = 0.5;
    }
  }

  return strlen(response);
}

/***************************************************************************/
INT lemplug_cmd_2(LEMPLUG_INFO *info)
{
  struct hostent *phe;
  struct sockaddr_in bind_addr;
  int sock;
  int status;
  int i,j;
  int err;
  int done = 0;
  char str[1024], *s;

  // open connection
  if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
     perror("cannot create socket");
     return LEMPLUG_NOSUCCESS;
  }

  // compose remote address
  memset(&bind_addr, 0, sizeof(bind_addr));
  bind_addr.sin_family = AF_INET;
  bind_addr.sin_addr.s_addr = 0;
  bind_addr.sin_port = htons((unsigned short) info->dd_settings.port);

  phe = gethostbyname(info->dd_settings.host);
  if (phe == NULL) {
     perror("cannot get host name");
     return LEMPLUG_NO_HOST_ERROR;
  }
  memcpy((char *) &(bind_addr.sin_addr), phe->h_addr, phe->h_length);

  // connect to server
  status = connect(sock, (void *) &bind_addr, sizeof(bind_addr));
  if (status != 0) {
     cm_msg(MINFO, "lemplug_cmd_2", "lemplug_cmd_2: Cannot connect to host %s, port %d\n",
            info->dd_settings.host, info->dd_settings.port);
     return LEMPLUG_CONNECT_ERROR;
  }

  err = 0;
  memset(response, 0, sizeof(response));
  do {
    // send request
    send(sock, request, strlen(request), 0);
    // receive response
    memset(str, 0, sizeof(str));
    i = recv(sock, str, sizeof(str), 0);

    if (i < 0) {
      perror("Cannot receive response");
      return -1;
    }

    strcat(response, str);

    if (strstr(response, "</html>"))
      done = 1;
    else {
      usleep(100000);
      err++;
    }

    if (err > 5)
      done = 1;

  } while (!done);

  // close connection
  closesocket(sock);

  if (err>5)
    return LEMPLUG_NOSUCCESS;

  // everything looks fine, hence filter the content
  for (i=1; i<=8; i++) {
    sprintf(str, "P0%d=", i);
    s = strstr(response, str);
    if (s != 0) {
      memset(str, 0, sizeof(str));
      for (j=0; j<10; j++) {
        if (*(s+j) == '\r')
          break;
        str[j] = *(s+j);
      }
      if (strstr(str, "=0"))
        info->outlet_state[i-1] = 0.0;
      else if (strstr(str, "=1"))
        info->outlet_state[i-1] = 1.0;
      else
        info->outlet_state[i-1] = 0.5;
    }
  }

  return strlen(response);
}

/*---- device driver routines --------------------------------------*/

INT lemplug_init(HNDLE hkey, void **pinfo, INT channels, INT(*bd) (INT cmd, ...))
{
  int status, size;
  HNDLE hDB, hkeydd;
  LEMPLUG_INFO *info;
  char str[256];
  char pwd[256];

  // allocate info structure
  info = calloc(1, sizeof(LEMPLUG_INFO));
  *pinfo = info;

  cm_get_experiment_database(&hDB, NULL);

  // create lemplug dd settings record
  status = db_create_record(hDB, hkey, "DD", LEMPLUG_SETTINGS_STR);
  if ((status != DB_SUCCESS) && (status != DB_OPEN_RECORD)) {
    cm_msg(MERROR, "lemplug_init", "lemplug_init: Error creating Bruker DD record in ODB, status=%d", status);
    cm_yield(0);
    return FE_ERR_ODB;
  }
    
  db_find_key(hDB, hkey, "DD", &hkeydd);
  size = sizeof(info->dd_settings);
  db_get_record(hDB, hkeydd, &info->dd_settings, &size, 0);

  // initialize driver
  info->num_channels = channels;
  info->bd = bd;
  info->hkey = hkey;
  info->startup_error = FALSE;
  info->read_time_stamp = ss_time()-info->dd_settings.read_time;

  if (!bd)
    return FE_ERR_ODB;

  // initialize bus driver
  status = info->bd(CMD_INIT, info->hkey, &info->bd_info);

  if (status != SUCCESS) {
    return status;
  }

  // initialization of device
  if (info->dd_settings.firmware_tag == 0) {
    strcpy(request, "GET / HTTP/1.0\r\n");
    strcat(request, "Host: lemplug\r\n");
    strcat(request, "User-Agent: lemPlug/0.1\r\n");
    strcat(request, "Accept: text/html, */*\r\n");
    sprintf(str, "%s:%s", info->dd_settings.user_name, info->dd_settings.pwd);
    lemplug_base64_encode(str, pwd);
    sprintf(str, "Authorization: Basic %s\r\n", pwd);
    strcat(request, str);
    strcat(request, "\r\n");
  } else if ((info->dd_settings.firmware_tag == 1) ||
             (info->dd_settings.firmware_tag == 2)) {
    // nothing to be done as long as the MD5 is not in place
    cm_msg(MINFO, "lemplug_init", "lemplug_init: initialized ...");
    cm_yield(0);

    return FE_SUCCESS;
  } else {
    cm_msg(MERROR, "lemplug_init", "lemplug_init: **ERROR** found unkown firmware tag: %d", info->dd_settings.firmware_tag);
    info->startup_error = TRUE;
    return FE_SUCCESS;
  }

  if (info->dd_settings.enable_log)
    lemplug_write_log(info, request);

  memset(response, 0, sizeof(response));

  status = lemplug_cmd_0(info);

  if (!status) {
    cm_msg(MINFO, "lemplug_init", "lemplug_init: no response from lemplug");
    cm_yield(0);
    info->startup_error = TRUE;
    return FE_SUCCESS;
  }

  if (info->dd_settings.enable_log)
    lemplug_write_log(info, response);

  cm_msg(MINFO, "lemplug_init", "lemplug_init: initialized ...");
  cm_yield(0);

  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------*/
INT lemplug_exit(LEMPLUG_INFO * info)
{
  // call EXIT function of bus driver, usually closes device
  info->bd(CMD_EXIT, info->bd_info);

  // free local variables
  free(info);

  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------*/
INT lemplug_set(LEMPLUG_INFO *info, INT channel, float value)
{
  char cmd[16];
  char str[256];
  char pwd[256];
  int  status;

  if (info->startup_error)
    return FE_SUCCESS;

  if (info->dd_settings.firmware_tag == 0) {
    // ePowerSwitch M8 switching command
    sprintf(cmd, "P1%d=%d", channel+1, (int)value);

    // http command
    strcpy(request, "POST /rack1.html HTTP/1.0\r\n");
    strcat(request, "Host: lemplug\r\n");
    strcat(request, "User-Agent: lemPlug/0.1\r\n");
    strcat(request, "Accept: text/html, */*\r\n");
    sprintf(str, "Content-Length: %d\r\n", (int)strlen(cmd));
    strcat(request, str);
    sprintf(str, "%s:%s", info->dd_settings.user_name, info->dd_settings.pwd);
    lemplug_base64_encode(str, pwd);
    sprintf(str, "Authorization: Basic %s\r\n", pwd);
    strcat(request, str);
    strcat(request, "\r\n");
    strcat(request, cmd);

    if (info->dd_settings.enable_log)
      lemplug_write_log(info, request);

    memset(response, 0, sizeof(response));

    status = lemplug_cmd_0(info);
  } else if (info->dd_settings.firmware_tag == 1) {
    if (value == 0.0) { // Off
      sprintf(request, "GET /hidden.htm?M0:O%d=OFF HTTP/1.0\r\n", channel+1);
    } else if (value == 1.0) { // On
      sprintf(request, "GET /hidden.htm?M0:O%d=ON HTTP/1.0\r\n", channel+1);
    } else {
      cm_msg(MERROR, "lemplug_set", "lemplug_set: only values 0.0 and 1.0 are allowed, found %f", value);
      return FE_SUCCESS;
    }
    strcat(request, "Host: lemplug\r\n");
    strcat(request, "User-Agent: lemPlug/0.1\r\n");
    strcat(request, "Accept: text/html, */*\r\n");
    strcat(request, "\r\n");

    status = lemplug_cmd_1(info);
  } else if (info->dd_settings.firmware_tag == 2) {
      if (value == 0.0) { // Off
        sprintf(request, "GET /hidden.htm?P0%d=0 HTTP/1.0\r\n", channel+1);
      } else if (value == 1.0) { // On
        sprintf(request, "GET /hidden.htm?P0%d=1 HTTP/1.0\r\n", channel+1);
      } else {
        cm_msg(MERROR, "lemplug_set", "lemplug_set: only values 0.0 and 1.0 are allowed, found %f", value);
        return FE_SUCCESS;
      }
      strcat(request, "Host: lemplug\r\n");
      strcat(request, "User-Agent: lemPlug/0.1\r\n");
      strcat(request, "Accept: text/html, */*\r\n");
      strcat(request, "\r\n");

      status = lemplug_cmd_2(info);
  } else {
    cm_msg(MERROR, "lemplug_get", "lemplug_get: **ERROR** found unkown firmware tag = %d", info->dd_settings.firmware_tag);
    return FE_SUCCESS;
  }

  if (info->dd_settings.enable_log)
    lemplug_write_log(info, response);

  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------*/
INT lemplug_get(LEMPLUG_INFO *info, INT channel, float *pvalue)
{
  int  status;
  char str[256];
  char pwd[256];
  char cmd[16];

  if (info->startup_error) {
    *pvalue = LEMPLUG_STARTUP_ERROR;
    return FE_SUCCESS;
  }

  if ((channel == 0) && (ss_time()-info->read_time_stamp > info->dd_settings.read_time)) { // read state

    if (info->dd_settings.firmware_tag == 0) { // ePowerSwitch 8M
      // construct command
      strcpy(cmd, "R");

      strcpy(request, "GET /rack1.html HTTP/1.0\r\n");
      strcat(request, "Host: lemplug\r\n");
      strcat(request, "User-Agent: lemPlug/0.1\r\n");
      strcat(request, "Accept: text/html, */*\r\n");
      sprintf(str, "Content-Length: %d\r\n", (int)strlen(cmd));
      strcat(request, str);
      sprintf(str, "%s:%s", info->dd_settings.user_name, info->dd_settings.pwd);
      lemplug_base64_encode(str, pwd);
      sprintf(str, "Authorization: Basic %s\r\n", pwd);
      strcat(request, str);
      strcat(request, "\r\n");
      strcat(request, cmd);

      status = lemplug_read_0(info);
    } else if (info->dd_settings.firmware_tag == 1) { // ePowerSwitch 8M+ R2
      strcpy(request, "GET /hidden.htm HTTP/1.0\r\n");
      strcat(request, "Host: lemplug\r\n");
      strcat(request, "User-Agent: lemPlug/0.1\r\n");
      strcat(request, "Accept: text/html, */*\r\n");
      strcat(request, "\r\n");

      status = lemplug_cmd_1(info);
    } else if (info->dd_settings.firmware_tag == 2) { // ePowerSwitch 8M+ R1
        strcpy(request, "GET /hidden.htm HTTP/1.0\r\n");
        strcat(request, "Host: lemplug\r\n");
        strcat(request, "User-Agent: lemPlug/0.1\r\n");
        strcat(request, "Accept: text/html, */*\r\n");
        strcat(request, "\r\n");

        status = lemplug_cmd_2(info);
    } else {
      cm_msg(MERROR, "lemplug_get", "lemplug_get: **ERROR** found unkown firmware tag = %d", info->dd_settings.firmware_tag);
      return FE_SUCCESS;
    }

    if (info->dd_settings.enable_log)
      lemplug_write_log(info, response);

    info->read_time_stamp = ss_time();

  }

  ss_sleep(10);
  *pvalue = info->outlet_state[channel];

  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------*/
INT lemplug_get_label(LEMPLUG_INFO *info, INT channel, char *name)
{
  return FE_SUCCESS;
}

/*---- device driver entry point -----------------------------------*/

INT lemplug(INT cmd, ...)
{
  va_list argptr;
  HNDLE hKey;
  INT channel, status;
  DWORD flags;
  float value, *pvalue;
  char *name;
  void *info, *bd;

  va_start(argptr, cmd);
  status = FE_SUCCESS;

  switch (cmd) {
  case CMD_INIT:
    hKey = va_arg(argptr, HNDLE);
    info = va_arg(argptr, void *);
    channel = va_arg(argptr, INT);
    flags = va_arg(argptr, DWORD);
    bd = va_arg(argptr, void *);
    status = lemplug_init(hKey, info, channel, bd);
    break;

  case CMD_EXIT:
    info = va_arg(argptr, void *);
    status = lemplug_exit(info);
    break;

  case CMD_SET:
    info = va_arg(argptr, void *);
    channel = va_arg(argptr, INT);
    value = (float) va_arg(argptr, double);   // floats are passed as double
    status = lemplug_set(info, channel, value);
    break;

  case CMD_GET:
    info = va_arg(argptr, void *);
    channel = va_arg(argptr, INT);
    pvalue = va_arg(argptr, float *);
    status = lemplug_get(info, channel, pvalue);
    break;

  case CMD_GET_LABEL:
    info    = va_arg(argptr, void *);
    channel = va_arg(argptr, INT);
    name    = va_arg(argptr, char *);
    status  = lemplug_get_label(info, channel, name);
    break;

  default:
    break;
  }

  va_end(argptr);

  return status;
}

/*------------------------------------------------------------------*/