/*************************************************************************
    > File Name: pipe.c
    > Author: likeyi
    > Mail: likeyiyy@sina.com 
    > Created Time: Thu 17 Apr 2014 03:53:25 PM CST
 ************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
typedef struct buffer
{
    unsigned char * buffer;
    unsigned long length;
}buffer_t;
typedef struct stage_tag
{
    pthread_mutex_t mutex;
    pthread_cond_t avail;
    pthread_cond_t ready;
    int busy;
    int data_ready;
    buffer_t * data;
    pthread_t thread;
    long total;     /* 这个用来计数，看一个线程被调用多少次，当没有空闲的线程时，就用这个来比较。*/
}stage_t;
static stage_t * get_tcp_thread();
static stage_t * get_ip_thread();
static stage_t * get_eth_thread();
static stage_t * tcp_thread_t,* ip_thread_t,*eth_thread_t;

static unsigned char * tcp_hdr = "tcp header";
static unsigned char * ip_hdr = "ip header";
static unsigned char * eth_hdr = "eth header";

void * pipe_add_tcp_header(void * arg)
{
    /* 每次读取文件的一行，作为数据，发出去。*/
    pthread_detach(pthread_self());
    FILE * fp;
    unsigned char data[4096];
    stage_t * ip_thread = get_ip_thread();
    if((fp = fopen("data","r")) == NULL)
    {
        printf("Error When open data file\n");
        pthread_exit(NULL); /*NOTICE: pthread_exit 不应该是局部变量。*/
    }
    int i = 0;
    int size = strlen(tcp_hdr);
    while(1)
    {
        pthread_mutex_lock(&ip_thread->mutex);
        /*
        * 什么IP 正忙？哈哈，那么我只有等了。
        * 是的data_ready的状态说明正忙。
        * */
        while(ip_thread->data_ready)
        {
            pthread_cond_wait(&ip_thread->ready,&ip_thread->mutex); 
        }

        /*
        * 开始准备数据。
        * */
        if(fgets(data,sizeof(data),fp) == NULL)
        {
            break;
        }
        int size2 = strlen(data);
        unsigned char * next_data = malloc(size + size2 + 1);
        strcpy(next_data,tcp_hdr);
        strcpy(next_data + size,data);
        /* 数据封装完毕 */
        ip_thread->data->buffer = next_data;
        ip_thread->data->length = size + size2;

        
        ip_thread->data_ready = 1; 

        pthread_cond_signal(&ip_thread->avail);
        /*
        * 呵呵，某种意义上，我这个时候是不是也应该告诉我的上级，我也做好准备了？
        * 但是，我没有上级，哈哈哈。
        * */
        pthread_mutex_unlock(&ip_thread->mutex);
        
    }
    printf("tcp_thread stoped\n");
    
}
void * pipe_add_ip_header(void * arg)
{
    stage_t * ip_stage = get_ip_thread();
    pthread_mutex_lock(&ip_stage->mutex);
    
    int size = strlen(ip_hdr);
    while(1)
    {
        /* 数据没准备好 
        *  看起来用data_ready来表示是否busy很科学的样子，我这样做反而不好了。
        * */
        while(ip_stage->data_ready != 1)
        {
            pthread_cond_wait(&ip_stage->avail,&ip_stage->mutex);
        }
        /*
        * 
        * */

        int size2 = ip_stage->data->length;
        unsigned char * next_data = malloc(size + size2 + 2);
        strcpy(next_data,ip_hdr);
        *(next_data + size) = ‘ ‘;
        strcpy(next_data + size + 1,ip_stage->data->buffer);
        /* 数据封装完毕 */
/*********************************************************************/
        stage_t * eth_thread = get_eth_thread();
        pthread_mutex_lock(&eth_thread->mutex);
        while(eth_thread->data_ready)
        {
            pthread_cond_wait(&eth_thread->ready,&eth_thread->mutex);
        }
        eth_thread->data->buffer = next_data;
        eth_thread->data->length = size + size2;

        eth_thread->data_ready = 1;
        pthread_cond_signal(&eth_thread->avail);
        pthread_mutex_unlock(&eth_thread->mutex);

/*********************************************************************/

        /*
        * 我自己呢？data_ready = 0，并且释放信号。
        * */
        ip_stage->data_ready = 0;
        pthread_cond_signal(&ip_stage->ready);
    }

}
void * pipe_add_ethdr(void * arg)
{
    pthread_detach(pthread_self());
    stage_t * eth_stage = get_eth_thread();
    pthread_mutex_lock(&eth_stage->mutex);
    while(1)
    {
        while(eth_stage->data_ready != 1)
        {
            pthread_cond_wait(&eth_stage->avail,&eth_stage->mutex);
        }
        printf("Data is :%s\n",eth_stage->data->buffer);
        eth_stage->data_ready = 0;
        pthread_cond_signal(&eth_stage->ready);
    }
}
static stage_t * get_tcp_thread()
{
    return tcp_thread_t; 
}
static stage_t * get_ip_thread()
{
    return ip_thread_t;
}
static stage_t * get_eth_thread()
{
    return eth_thread_t;
}
int main(int argc, char ** argv)
{
    eth_thread_t = malloc(sizeof(stage_t));
    ip_thread_t = malloc(sizeof(stage_t));
    tcp_thread_t = malloc(sizeof(stage_t));

    eth_thread_t->data = malloc(sizeof(buffer_t));
    ip_thread_t->data = malloc(sizeof(buffer_t));
    tcp_thread_t->data = malloc(sizeof(buffer_t));

    pthread_mutex_init(&eth_thread_t->mutex,NULL);
    pthread_mutex_init(&ip_thread_t->mutex,NULL);
    pthread_mutex_init(&tcp_thread_t->mutex,NULL);

    pthread_cond_init(&eth_thread_t->avail,NULL);
    pthread_cond_init(&ip_thread_t->avail,NULL);
    pthread_cond_init(&tcp_thread_t->avail,NULL);

    pthread_cond_init(&eth_thread_t->ready,NULL);
    pthread_cond_init(&ip_thread_t->ready,NULL);
    pthread_cond_init(&tcp_thread_t->ready,NULL);

    pthread_create(&eth_thread_t->thread,NULL,pipe_add_ethdr,NULL);
    pthread_create(&ip_thread_t->thread,NULL,pipe_add_ip_header,NULL);
    pthread_create(&tcp_thread_t->thread,NULL,pipe_add_tcp_header,NULL);

    pthread_exit(NULL);
    
    
}