FifoTerm.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// $Id$
//
// Copyright 2008, 2009, 2010, 2011, 2012  Antonio Franchi and Paolo Stegagno    
//
// This file is part of MIP.
//
// MIP 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.
//
// MIP 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 MIP. If not, see <http://www.gnu.org/licenses/>.
//
// Contact info: antonio.franchi@tuebingen.mpg.de stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------




/* @{ */

#ifndef __FIFO_TERM_H
#define __FIFO_TERM_H

#ifdef MIP_HOST_APPLE
#include <applePatch.h>
#include <sys/types.h>
#include <sys/stat.h>
#endif

#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <assert.h>
#include <string>
#include <cstring>

using namespace std;


#define MAX_FIFO    1000        /*numero massimo di fifo apribili*/
#define DEF_BUFSIZE 10000       /*grandezza di default del buffer del server*/

#define MAX_STRING_LENGHT 200  /*lunghezza massima di una stringa inviabile via fifo con una sola print*/

typedef struct {
  long type;
 char fifo_response[MAX_STRING_LENGHT];
} request;

typedef enum{
 FIFO_CLEAR, 
  FIFO_FLUSH,  
 FIFO_LINE_ERASE,
  FIFO_CLOSE,
  FIFO_CMDS
} fifoCmds;

extern char startOfText;
extern char endOfText;
extern char formFeed;
extern char endOfTransmission;

extern char fifoCmdsChar[FIFO_CMDS];

fifoCmds fifoParse(char charCmd);

#define ESC_LINE_ERASE    "\033[2K"
#define ESC_CURS_TOP_LEFT "\033[0;0f"
#define ESC_SCREEN_CLEAR  "\033[2J"
#define ESC_FORW_SCREEN_CLEAR  "\033[0J"
#define ESC_BACK_SCREEN_CLEAR  "\033[1J"
#define ESC_HIDE_CURS     "?25l"
#define ESC_UNHIDE_CURS   "?25h"


class FifoServer{
 
  private:
    
 char *buffer; 
 unsigned int bufSize; 
 char fifoName[MAX_STRING_LENGHT];
 request r;
 bool active;
   
 void ffSetFifoName(char* name){
  strcpy(fifoName, name);
 }
 
 void ffCreateFifo(){
  if (mkfifo(fifoName, O_CREAT | 0666) == -1 )
   printf("Errore nella chiamata mkfifo \n");
  return;
 }
 
 void inline fifoAppend(const char* message){
  if(strlen(message) < bufSize){
   if(strlen(buffer) + strlen(message) < bufSize-1){
    strcat(buffer,message);
   }
   else{
    printf(ESC_CURS_TOP_LEFT);
    printf("%s", buffer);
    buffer[0] = '\0';
    strcat(buffer,message);
   }
  }
  else{
   printf("FifoServer: messaggio troppo lungo!\n");
  }
 }
 
  fifoCmds fifoParse(char charCmd){
    fifoCmds cmd;
    for(unsigned int i=0U;i<FIFO_CMDS;i++){
      cmd = (fifoCmds) i;
      if(fifoCmdsChar[cmd]==charCmd)
        return cmd; 
    }
    return FIFO_CMDS;
  }
 
 
 
 void inline fifoExec(char* message){
  switch(fifoParse(*message)){
   case FIFO_CLEAR:
     printf(ESC_SCREEN_CLEAR);
    printf(ESC_CURS_TOP_LEFT);
    break;
   case FIFO_FLUSH:
    printf(ESC_CURS_TOP_LEFT);
    printf("%s", buffer);
    buffer[0] = '\0';
    break;
   case FIFO_LINE_ERASE:
    fifoAppend(ESC_LINE_ERASE);
    break;    
   case FIFO_CLOSE:
    active = false;
    break;
   default:
    fifoAppend(message);
  } 
 }
 
 public:
  
 
 void inline ffReceive(int sleepTime = 1000000){
  active = true;
  int fd = open(fifoName,O_RDWR);
  while(active) {
   if (read(fd, &r, sizeof(request)) != 0) {
    fifoExec(r.fifo_response);
   }
   usleep(sleepTime);
  }
 }
   
 void ffUnlinkFifo(){
  unlink(fifoName);
 }
 
 FifoServer(char* name, unsigned int bufSize);
 
 ~FifoServer(){
  /*unset signal handler*/
  signal(SIGINT,SIG_DFL);
  ffUnlinkFifo();
  delete buffer;
  /*unhide the cursor position*/
  printf(ESC_UNHIDE_CURS);
  return;
 }  
};



class FifoClient {
 
 private:
 bool fifoSet;
 char fifoName[MAX_STRING_LENGHT];
 request r;
 
  public:
  
  void ffSetFifoName(char* name){
   strcpy(fifoName, name);
   fifoSet = true;
  }

  void ffSendMessage(char* message){
   if(fifoSet){
    int fd;
    if ((fd = open(fifoName,1)) == -1 ) {
     return;
    }
    strcpy(r.fifo_response, message);
    // Variable BOO not used
//     ssize_t boo = write(fd, &r, sizeof(request));
    close(fd);
   }
   else{
//     printf("FifoClient: fifo non set yet\n", fifoName);
    printf("FifoClient: fifo non set yet\n");
   }
  }
  
  void ffSendCmd(fifoCmds cmd){
   if(fifoSet){
    int fd;
    if ((fd = open(fifoName,1)) == -1 ) {
     return;
    }
    r.fifo_response[0] = fifoCmdsChar[cmd];
    r.fifo_response[1] = '\0';
    // Variable BOO not used
//     ssize_t boo = write(fd, &r, sizeof(request));
    close(fd);
   }
   else{
    printf("FifoClient: fifo non set yet\n");
   }
  }
  
  FifoClient(){
   fifoSet = false;
   return;
  }
};



class FifoTerm{
 private:
 
  FifoClient fifoclient;
  char       fifoName[10];
  pid_t      serverPid;
 
 public:
 
  void print(char* message){
   if (strlen(message) > MAX_STRING_LENGHT) printf("fifo: impossible to send the message, string lenght > %d", MAX_STRING_LENGHT);
   else                                     fifoclient.ffSendMessage(message);
  } 
  
  void print(string message){
   unsigned int size = strlen(message.c_str());
   if (size > MAX_STRING_LENGHT){
    printf("fifo: impos to send the message, string lenght %d > %d\n",size, MAX_STRING_LENGHT);
   }else{
     fifoclient.ffSendMessage((char*) message.c_str());
   }
  } 
  
  void lineErase(void){
   fifoclient.ffSendCmd(FIFO_LINE_ERASE);
  }  
    
  void clear(void){
   fifoclient.ffSendCmd(FIFO_CLEAR);
  } 
  
  void flush(void){
   fifoclient.ffSendCmd(FIFO_FLUSH);
  }  
   
  void close(void){
   fifoclient.ffSendCmd(FIFO_CLOSE);
  }  
  
  FifoTerm(char *title, unsigned int bufSize=DEF_BUFSIZE){
   /*find the first fifo avaiable*/
   struct stat sts;
   unsigned int i=0;
   for(i=0;i<MAX_FIFO;i++){
    sprintf(fifoName,"fifo%03d\0",i);
    if((stat (fifoName, &sts)) == -1) break;
 //    printf("%d\n",i);
   }
   if(i==MAX_FIFO){
    printf("fifo disponibili esaurite!!!\n");
   }    
      
   if ((serverPid = fork()) == 0){
    /*if child create the server terminal*/
    char bufS[10];
    char command[100]="\0";
//     strcat(command,". ../setlibpath && ./FifoServer "); 
    strcat(command,"./FifoServer "); 
    strcat(command,fifoName);    
    sprintf(bufS," %d\0",bufSize); 
    strcat(command,bufS); 
    printf("%s\n",command); 
    if ( (execl(
#ifdef MIP_HOST_APPLE
       "/usr/X11/bin/xterm", "/usr/X11/bin/xtermxterm",
#else
       "/usr/bin/xterm", "/usr/bin/xtermxterm",       
#endif
       "-l", "-lf", "FifoServer.log",  "-title", title, "-bg", "white", "-fs", "10", "-geometry", "100x30",
          "-e", command, (char *) 0)) < 0)  {
     printf("FifoServer execution error\n");
     sleep(10);
    }  
   }
   else{
    /*if parent initialize client*/
    fifoclient.ffSetFifoName(fifoName);
   } 
  }
  
  
//   FifoTerm(string title, unsigned int bufSize=DEF_BUFSIZE){
//    FifoTerm(title.c_str(), bufSize);
//   };
  
  ~FifoTerm(){
   close(); 
  }
};


#endif




/* @}*/