/* Guochun Shi: gshi@ncsa.uiuc.edu*/

#include <stddef.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/un.h>
#include "msg.h"
#include <unistd.h>
#include <fcntl.h>
#include <unistd.h>

#define MAXBUF 1024
static const char* sockfile = SOCKFILE;
static int sockfd = -1;

static void
set_socket_file(const char* s_fname)
{
    sockfile = s_fname;
    return;
}


static int
make_named_socket (const char *filename)
{
    struct sockaddr_un name;
    size_t size;
    int on = 1;
    int sock;
    
    unlink(filename);
    /* Create the socket. */
    sock = socket (PF_LOCAL, SOCK_STREAM, 0);
    if (sock < 0)
        {
            perror ("socket");
            exit (EXIT_FAILURE);
        }
    
    
    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on))< 0){
        perror("setsockopt");
        return -1;
    }


    /* Bind a name to the socket. */
    name.sun_family = AF_LOCAL;
    strncpy (name.sun_path, filename, sizeof (name.sun_path));
    
       /* The size of the address is
          the offset of the start of the filename,
          plus its length,
          plus one for the terminating null byte.
          Alternatively you can just do:
          size = SUN_LEN (&name);
      */
    size = (offsetof (struct sockaddr_un, sun_path)
            + strlen (name.sun_path) + 1);
    
    if (bind (sock, (struct sockaddr *) &name, size) < 0)
        {
            perror ("bind");
            exit (EXIT_FAILURE);
        }
    
    return sock;
}


int
vf_server_init()
{
    int rc;
    int sock;
    static int inited = 0;

    if (inited ){
	return 0;
    }
    sock= make_named_socket(sockfile);    
    rc = listen(sock, 5);
    if(rc){
        perror("listen");
        return -1;
    }
    
    sockfd = accept(sock, NULL, NULL);
    if (sockfd < 0){
	perror("accept");
	return -1;
    }
    
    inited =1;
    return 0;
}



static processdata_t processdata = NULL;

void
set_processdata_func(processdata_t func)
{
    processdata = func;
}

int
vf_server_recv(int blockflag)
{
    char buf[MAXBUF];
    int size;
    int flags;
    vf_msg_head_t head;
    
    memset(buf, 0, MAXBUF);
    flags = fcntl(sockfd, F_GETFL);
    if (flags == -1){
	perror("fcntl,F_GETFL");
	return -1;
    }
    if (blockflag ==0){
	flags &= ~O_NONBLOCK;
    }else{
	flags |= O_NONBLOCK;
    }
    if (fcntl(sockfd, F_SETFL, flags) < 0){
	perror("fcntl, F_SETFL");
	return -1;
    }
    
    size = recv(sockfd, &head, sizeof(head), 0);
    if (size <= 0){
	return 0;
    }
    if (size != sizeof(head)){
	perror("partial msg head recved\n");
	return -1;
    }
    
    
    size = recv(sockfd, buf, head.size, 0);
    
    if (size != head.size){
	perror("partial msg data recved\n");
	return -1;
    }
    //printf("one msg recved for (%d %d )\n", head.i, head.j);
    processdata(&head, buf, size);
    
    
    return 0;
}

static int
set_fd_flag(int blockflag){
    int flags;
    flags = fcntl(sockfd, F_GETFL);
    if (flags == -1){
	perror("fcntl,F_GETFL");
	return -1;
    }
    if (blockflag ==0){
	flags &= ~O_NONBLOCK;
    }else{
	flags |= O_NONBLOCK;
    }
    if (fcntl(sockfd, F_SETFL, flags) < 0){
	perror("fcntl, F_SETFL");
	return -1;
    }

    return 0;
}

int
vf_server_sync(void)
{
    int tmp = ITER_SYNC;
    
    vf_reset_data();
    set_fd_flag(0);
    
    send(sockfd, &tmp, sizeof(tmp), 0);
    return 0;
}