fbvncserver.c

Go to the documentation of this file.

#include "fbvncserver.h"

#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>

#include <fcntl.h>
#include <linux/fb.h>
#include <signal.h>

/* Project */
#include "keysym2scancode.h"  /* keysym to scancode conversion */

/* Types */
struct ClientData {
  rfbBool oldButton;
  int oldx,oldy;
};

typedef struct {
  long x;
  long y;
  long pressure;
} ARTIFICIAL_TS_EVENT;

// Variables
static int last_pen_down = 0;

struct kbd_layout_t *kbd_layout = NULL;
struct fb_var_screeninfo vscrinfo;

unsigned short int
    *fbbuf    = NULL,
    *cmpfbbuf = NULL,
    *rfbbuf   = NULL;

void emit_scancode (unsigned int s, rfbBool down) {
  unsigned short keycode = s;

  if (uinput_fd_kbd && uinput) {
    TRACE3("emitting keycode ... %d (%#x) [down: %d] \n", keycode, keycode, down);
    dev_uinput_key(uinput_fd_kbd,keycode,down);
  } else {
    TRACE2(" [W]: unable to emit keycode - uinput not ready ... (uinput: %d, fd: %d)", uinput, uinput_fd_kbd);
  } // end of [if]
} // end of [emit_scancode]


int emit_touchscreen_sequence(ARTIFICIAL_TS_EVENT *s) {
  int fd;
  int ret;
  ret = 0;

  if((fd=open("/dev/tssim",O_WRONLY))>=0) {
    while(s->x!=-1) {
      write(fd,s,sizeof(ARTIFICIAL_TS_EVENT));
      s++;
    }
    close(fd);
  } else {
    fprintf(stderr, " unable to open /dev/tssim for write-only access \n");
    ret=-1;
  }
  return(ret);
}

void ptrevent( int buttonMask, int x, int y, rfbClientPtr cl)
{

  ARTIFICIAL_TS_EVENT touchscreen_sequence[5];
  int i, buffer = 0;
  if ((x < 0 ) ||
      (y < 0 ) ||
      (x > cl -> screen -> width) ||
      (y > cl -> screen -> height)) {
    TRACE4(" [W] ptrevent() - invalid ts event (x: %d, y: %d [%3d,%3d]) \n",
            cl -> screen -> width,
            cl -> screen -> height,
            x,y);
    return;
  };

  switch (rotate) {
    case 0: break;
    case 1: break;
    case 2: break;
    case 3:
          buffer = x;
          x = -y + (cl -> screen -> height);
          y = buffer;
       break;
    default: ;
  }

  if(buttonMask!=0) {
    for(i=0;i<(last_pen_down?1:5);i++) {
      touchscreen_sequence[i].x=x;
      touchscreen_sequence[i].y=y;
      touchscreen_sequence[i].pressure=1;
    }
    touchscreen_sequence[i].x=-1;
    rfbLog ( " pointer event @ x: %d, y:%d (down) \n", x, y);
    if (uinput_fd_mouse && uinput) {
      ptr_abs(uinput_fd_mouse,x,y);
      button_click(uinput_fd_mouse,1);
      dev_uinput_sync(uinput_fd_mouse);
      rfbLog (" => sent to uinput. \n");

    } else {
      emit_touchscreen_sequence(touchscreen_sequence);
    };
  } else {
    if(last_pen_down) {
      touchscreen_sequence[0].x=x;
      touchscreen_sequence[0].y=y;
      touchscreen_sequence[0].pressure=0;
      touchscreen_sequence[1].x=-1;

      rfbLog (" pointer event @ x: %d, y:%d (up) \n", x, y);
      if (uinput_fd_mouse && uinput) {
        ptr_abs(uinput_fd_mouse,x,y);
        button_click(uinput_fd_mouse,0);
        dev_uinput_sync(uinput_fd_mouse);
        rfbLog (" => sent to uinput. \n");

      } else {
        emit_touchscreen_sequence(touchscreen_sequence);
      };
    };
  };
  last_pen_down=(buttonMask!=0);
  return;
}


void keyevent(rfbBool down,rfbKeySym key,rfbClientPtr cl)
{
  unsigned int scancode;

  scancode = keysym2scancode(kbd_layout, key);
  TRACE2 (" [I]: KeyEvent: Key %#x - %d \n",key,down);
  TRACE1 ("       => Scancode: %#x \n",scancode);
  emit_scancode(scancode, down);
  return;
}

void clientleft(rfbClientPtr cl) { free(cl->clientData); }

static enum rfbNewClientAction newclient(rfbClientPtr cl) {
  cl->clientData = (void*)calloc(sizeof(struct ClientData),1);
  cl->clientGoneHook = clientleft;

  return RFB_CLIENT_ACCEPT;
}
 static int getFileTransferPermission (rfbClientPtr cl) { return TRUE; }

void print_usage(char *arg0) {
  printf("Usage: %s [options] \n", arg0);
#ifdef DEBUG
  printf(" -debug\n");
#endif
  printf("\n");
  printf(" -cw                    rotate  90 \n");
  printf(" -cw -cw                rotate 180 \n");
  printf(" -cw -cw -cw | -ccw     rotate 270 \n");
  printf("\n");
  printf(" -keymap <map>          name of the keymap to be used for event \n");
  printf("                        translation (default: %s) \n", DEFAULT_KBD_LAYOUT);
  printf("\n");
  printf("# ***  \n");
  printf("# * libVNCServer options (excerpt) \n");
  printf("# **** \n");
  printf(" -rfbport port          TCP port for RFB protocol\n");
  printf(" -rfbwait time          max time in ms to wait for RFB client\n");
  printf(" -rfbauth passwd-file   use authentication on RFB protocol\n");
  printf("                        (use 'storepasswd' to create a password file)\n");
//  printf(" -rfbversion 3.x        Set the version of the RFB we choose to advertise\n");
#ifndef HAVE_STRUCT_RFBSCREEN_PERMITFILETRANSFER
//  printf(" -permitfiletransfer    permit file transfer support\n");
#endif
  printf(" -passwd plain-password use authentication\n");
  printf("                        (use plain-password as password, USE AT YOUR RISK)\n");
  printf(" -deferupdate time      time in ms to defer updates (default 40)\n");
  printf(" -deferptrupdate time   time in ms to defer pointer updates (default none)\n");
//  printf(" -desktop name          VNC desktop name\n");
//  printf(" -alwaysshared          always treat new clients as shared\n");
//  printf(" -nevershared           never treat new clients as shared\n");
//  printf(" -dontdisconnect        don't disconnect existing clients when a new non-shared\n");
//  printf("                        connection comes in (refuse new connection instead)\n");
//  printf(" -httpdir dir-path      enable http server using dir-path home\n");
//  printf(" -httpport portnum      use portnum for http connection\n");
//  printf(" -enablehttpproxy       enable http proxy support\n");
  printf(" -progressive height    enable progressive updating for slow links\n");
  printf("\n");
#ifndef HAVE_STRUCT_RFBSCREEN_PERMITFILETRANSFER
  printf(" -disablefiletransfer   disable file transfer (tight)\n");
  printf(" -ftproot string        set ftp root (tight)\n");
  printf("\n");
#endif
  printf("# ***  \n");
  printf("# * additional info (build option(s) used) \n");
  printf("# **** \n");
#ifndef DEBUG
  printf(" [I]: release build (-debug not supported)\n");
#endif
#ifdef HTTP
  printf(" [I]: http connections to port 5800 supported\n");
#else
  printf(" [I]: http connections NOT supported \n");
#endif

#ifndef HAVE_STRUCT_RFBSCREEN_PERMITFILETRANSFER
  printf(" [I]: ultra-file transfer NOT supported \n");
#else
  printf(" [I]: ultra-file transfer supported \n");
#endif

#ifndef HAVE_RFBREGISTERTIGHTVNCFILETRANSFEREXTENSION
  printf(" [I]: tight-file transfer NOT supported \n ");
#else
  printf(" [I]: tight-file transfer supported \n ");
#endif
  printf("\n");
} // end of [print_usage]

/*****************************************************************************/
/*                            Main program                                   */
/*****************************************************************************/
int main(int argc,char **argv) {
  int
    i,fbfd;

  rfbScreenInfoPtr
    rfbScreen;

  unsigned long int
    compareBufferSize = 0,
    remoteBufferSize  = 0,
    bytesPerPixel     = 0;

  char
    keyboard_layout[10] = DEFAULT_KBD_LAYOUT;

  div_t
    divresult;

  printf("%s (%s %s) \n",PACKAGE_STRING,__DATE__, __TIME__ );
 // ... process commandline arguments.
  for(i=1;i<argc;i++) {
    if (   !strcmp(argv[i],"-h")
        || !strcmp(argv[i],"-help")
        || !strcmp(argv[i],"--help")
        || !strcmp(argv[i],"-?") ) {
      print_usage(argv[0]);
      exit(1);
    } else if(!strcmp(argv[i],"-debug"))  debug  = 1;
      else if(!strcmp(argv[i],"-keymap")) {
        if (argc > i++) {
          if ( strlen(argv[i]) < sizeof(keyboard_layout) ) {
            strcpy(&keyboard_layout[0], argv[i]);
          } else {
            printf(" [W] invalid argument for -keymap: %s => I will use [%s] \n",argv[i], keyboard_layout[0]);
          } // end of [if]
        } // end of [if]
      } // end of [if]
      else if(!strcmp(argv[i],"-ccw"))    rotate = 3;
      else if(!strcmp(argv[i],"-cw")) {
        if (++rotate > 3) {
          fprintf(stderr," [F]: only 0,90,180 & 270 rotations are supported\n");
          fprintf(stderr,"      => 0 will be used. \n ");
          rotate = 0;
        }
    }
} // end of [for]

#ifdef DEBUG
  if (debug) rfbLogEnable(1);
    else rfbLogEnable(0);
#else
  rfbLogEnable(0);
#endif

// open framebuffer
  TRACE(" [I]: open framebuffer (/dev/fb0) ... \n");

  if((fbfd=open("/dev/fb0",O_RDONLY))<0) {
    perror("Opening /dev/fb0");
    return(-1);
  }

   TRACE(" [I]: requesting fb info via ioctl ...\n");

// Request the framebuffer's screen info
  if (ioctl(fbfd,FBIOGET_VSCREENINFO,&vscrinfo) <0 ) {
    close(fbfd);
    perror("ioctl(FBIOGET_VSCREENINFO)");
    return(-1);
  }

  TRACE1(" visible resolution [x]: %d px \n", vscrinfo.xres );
  TRACE1("                    [y]: %d px \n", vscrinfo.yres );
  TRACE1(" virtual resolution [x]: %d px \n", vscrinfo.xres_virtual);
  TRACE1("                    [y]: %d px \n", vscrinfo.yres_virtual);
  TRACE (" offset from virtual to visible resolution \n");
  TRACE1("                    [x]: %d px \n", vscrinfo.xoffset);
  TRACE1("                    [y]: %d px \n", vscrinfo.yoffset);
  TRACE1(" grayscale (0 = false) : %d \n", vscrinfo.grayscale);
  TRACE1(" bits per pixel        : %d \n", vscrinfo.bits_per_pixel);
  if (!vscrinfo.grayscale) {
    TRACE2 (" color offsets     red : %2d length : %d \n", vscrinfo.red.offset, vscrinfo.red.length);
    TRACE2 ("                 green : %2d length : %d \n", vscrinfo.green.offset, vscrinfo.green.length);
    TRACE2 ("                  blue : %2d length : %d \n", vscrinfo.blue.offset, vscrinfo.blue.length);
  }
  if (!vscrinfo.nonstd) {
    TRACE (" standard pixel format \n");
  } else {
    TRACE (" [W]: using non standard pixel format \n");
  };

  if (vscrinfo.height > 0) TRACE1 (" height of picture     : %d mm\n", vscrinfo.height);
  if (vscrinfo.width  > 0) TRACE1 (" width                 : %d mm\n", vscrinfo.width);

// adjust fb-dimensions accordnig to our needs
  if ((rotate == 1) ||  // for 90 & 270 degree we have to swap
      (rotate == 3)) {
      vscrinfo.xres = vscrinfo.xres + vscrinfo.yres;  // two reason for doing it "in place"
      vscrinfo.yres = vscrinfo.xres - vscrinfo.yres;  //  1. just for the fun of it
      vscrinfo.xres = vscrinfo.xres - vscrinfo.yres;  //  2. I do not care about the type/size of the vars
      TRACE (" [I]: swap'ed width vs. height to adjust dimensions \n");
  };

// ... allocate memory for compare-buffer
  divresult = div(vscrinfo.bits_per_pixel,8); // note: bytesPerPixel = ceil(vscrinfo.bits_per_pixel/8); <= soemtimes this doesn't work (don't know why)

  if (divresult.rem != 0) bytesPerPixel = divresult.quot + 1;
    else bytesPerPixel = divresult.quot;

  compareBufferSize = vscrinfo.xres * vscrinfo.yres * bytesPerPixel;
  TRACE2(" [I]: %d bytes per pixel => I will allocate %d bytes \n", bytesPerPixel, compareBufferSize);
  TRACE (" [I]: allocate memory for compare-buffer ... \n");

  if((cmpfbbuf=(unsigned short int *)malloc(compareBufferSize)) == NULL) {
    close(fbfd);
    perror("malloc");
    return(-1);
  }
  memset(cmpfbbuf,0x00,compareBufferSize);

// ... allocate and initialize the remote framebuffer
  TRACE (" [I]: allocate and initialize the remote framebuffer ... \n");

  remoteBufferSize = vscrinfo.xres * vscrinfo.yres * bytesPerPixel;
  if((rfbbuf=(unsigned short int *)malloc(remoteBufferSize))==NULL) {
    close(fbfd);
    free(cmpfbbuf);
    perror("malloc");
    return(-1);
  }
// ... mmap the fb
  TRACE (" [I]: mapping fb to memory ... \n");
  if((fbbuf=(unsigned short int *)mmap(0,                 /* */
                                       compareBufferSize, /* */
                                       PROT_READ,         /* Data can be read          */
                                       MAP_SHARED,        /* changes are shared        */
                                       fbfd,              /* file handle (framebuffer) */
                                       0)                 /* offset                    */
/*
 * WARNING: ... it might be that we need to specify/calculate an offset in case
 *              virtual resolution != visible resolution.
 */
      ) <0
    ) {
    close(fbfd);
    free(cmpfbbuf);
    free(rfbbuf);
    perror("mmap");
    return(-1);
  }

/*
 * check if we can use uinput for Keyboard-Events
 */
  if (uinput) {
    TRACE (" [I]: check if we have uinput device nodes ... \n");
    uinput_fd_kbd   = dev_uinput_init_kbd(UINPUT_KBD_NAME);
    uinput_fd_mouse = dev_uinput_init_mouse(UINPUT_TS_NAME);

    if ((uinput_fd_kbd > 0) &
        (uinput_fd_mouse > 0)) {
      TRACE1("    => Keyboard OK (fd=%d). \n",uinput_fd_kbd);
      TRACE1("    => Mouse OK    (fd=%d). \n",uinput_fd_mouse);

      kbd_layout = init_keyboard_layout(keyboard_layout);
      if (kbd_layout) {
        TRACE1(" [I]: keyboard [%s] loaded \n", keyboard_layout);
      } else {
        TRACE1(" [W]: keyboard layout [%s] NOT loaded \n", keyboard_layout);
        dev_uinput_close(uinput_fd_kbd);
        uinput_fd_kbd = 0;
        TRACE (" [W]: ... => keyboard event source released. \n")
      } // end of [if]
    } else {
      uinput = 0;
      TRACE(" [W]: => unable to initialize uinput \n ");
    }
  }

/*
 * initialize remote fb screen structure
 */
  rfbScreen = rfbGetScreen(&argc,    // &argc
              argv,                  // argv
              vscrinfo.xres,         // width
              vscrinfo.yres,         // height
              5,                     // bits per sample
              2,                     // samles per pixel
              bytesPerPixel);        // bytes per pixel

#ifdef HAVE_RFBSETPROTOCOLVERSION
#ifdef HAVE_STRUCT_RFBSCREEN_PERMITFILETRANSFER
/*
 * UltraVNC 1.0.2 win32
 * uses the rfb version to identify that it is talking
 * to an UltraVNC compatible server.
 * This is technically wrong to assume this as the rfb
 * version identifies the rfb handshake and not the
 * supported messages ...
 */
rfbSetProtocolVersion(rfbScreen, 3, 6);
#endif
#endif

  rfbScreen -> desktopName     = DESKTOP_NAME;
  rfbScreen -> frameBuffer     = (char *)rfbbuf;
  rfbScreen -> alwaysShared    = TRUE;
  rfbScreen -> serverFormat.bitsPerPixel  = vscrinfo.bits_per_pixel;

// set callback functions
  rfbScreen -> ptrAddEvent     = ptrevent;  // pointer
  rfbScreen -> kbdAddEvent     = keyevent;  // keyboard
  rfbScreen -> newClientHook   = newclient; // new client
// file transfer permission
#ifdef HAVE_STRUCT_RFBSCREEN_GETFILETRANSFERPERMISSION
  rfbScreen -> getFileTransferPermission = getFileTransferPermission;
#endif
#ifdef HAVE_STRUCT_RFBSCREEN_PERMITFILETRANSFER
  rfbScreen -> permitFileTransfer = TRUE;
#endif
#ifdef HAVE_RFBREGISTERTIGHTVNCFILETRANSFEREXTENSION
  rfbRegisterTightVNCFileTransferExtension();   // register TightVNC file transfer protocol extension(s)
#endif
/* if TRUE, an ignoring signal handler is installed for SIGPIPE  */
  rfbScreen -> ignoreSIGPIPE   = TRUE;
/* if not zero, only a slice of this height is processed every time
 * an update should be sent. This should make working on a slow
 * link more interactive. */
  rfbScreen -> progressiveSliceHeight = 0;

  if (!vscrinfo.grayscale) {
    rfbScreen -> serverFormat.redMax      = pow(2,vscrinfo.red.length)  -1;
    rfbScreen -> serverFormat.greenMax    = pow(2,vscrinfo.green.length)-1;
    rfbScreen -> serverFormat.blueMax     = pow(2,vscrinfo.blue.length) -1;
    rfbScreen -> serverFormat.redShift    = vscrinfo.red.offset;
    rfbScreen -> serverFormat.greenShift  = vscrinfo.green.offset;
    rfbScreen -> serverFormat.blueShift   = vscrinfo.blue.offset;

  } // end of [if]
#ifdef HTTP
  rfbScreen->httpDir         = HTTP;
#endif

  rfbInitServer(rfbScreen);           // initialize the remote framebuffer & start VNC-Server
  rfbRunEventLoop(rfbScreen,-1,TRUE); // non-blocking event loop; a background thread is started

  while (1) {
    if (rfbScreen -> clientHead != NULL) { // only update the fb if there are connected clients
      if (notEqual(fbbuf,cmpfbbuf,compareBufferSize) == 1) { // check if the screen has changed
        if (rotate == 0) { rotate0  (rfbScreen,fbbuf,cmpfbbuf); }; // end of [if]
        if (rotate == 1) { rotate90 (rfbScreen,fbbuf,cmpfbbuf); }; // end of [if]
        if (rotate == 2) { rotate180(rfbScreen,fbbuf,cmpfbbuf); }; // end of [if]
        if (rotate == 3) { rotate270(rfbScreen,fbbuf,cmpfbbuf); }; // end of [if]
        usleep(5000);
      } else { // no screen changes => no update needed
        usleep(50000);
      }; // end of [if]
    } else { // no clients connected @ the moment
      sleep(1);
    };
  }; // end of [while]

  rfbScreenCleanup(rfbScreen);

  free(fbbuf);
  free(cmpfbbuf);

  if (uinput_fd_kbd) dev_uinput_close(uinput_fd_kbd);
  if (uinput_fd_mouse) dev_uinput_close(uinput_fd_mouse);

  exit (0);
}

---