/******************************************************************************** 
 *      Copyright:  (C) guowenxue <guowenxue@gmail.com>
 *                  All rights reserved.
 *
 *       Filename:  ppp.c
 *    Description:  This file is the ppp thread file,used to do PPP dial up
 *
 *        Version:  1.0.0(02/02/2012~)
 *         Author:  Guo Wenxue <guowenxue@gmail.com>
 *      ChangeLog:  1, Release initial version on "02/02/2012 11:33:33 AM"
 *                 
 ********************************************************************************/
#include <sys/ioctl.h>
#include <netinet/in.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <arpa/inet.h>
#include "cp_ppp.h"
#include "cp_string.h"
#include "cp_iniparser.h"
//#include "cp_network.h"
//#include "gsmd.h"

/*
 * Description: Check PPP10 device exist or not, and set the PPP context status
 *
 *
 * Return Value: 0: PPP10 device exist    -1:PPP10 device not exist
 *
 */
int check_ppp_interface(char *ppp_dev)
{
    int           fd = -1;
    int           retval = -1;
    char          buf[512];

    if ((fd = open("/proc/net/dev", O_RDONLY, 0666)) < 0)
    {
        return -1;      /* System error, take as PPP10 device not exist too */
    }

    while (read(fd, buf, sizeof(buf)) > 0)
    {
        if (NULL != strstr(buf, ppp_dev))
        {
            retval = 0;
            break;
        }
    }

    close(fd);
    return retval;
}

int check_ppp_ipaddr(pppd_info_t *pppd_info, char *ppp_dev)
{
    int                   fd;
    struct ifreq          ifr;
    struct sockaddr_in    *sin;  

    if(check_ppp_interface(ppp_dev))
        return -2;

    fd = socket(AF_INET, SOCK_DGRAM, 0);
    strcpy(ifr.ifr_name, ppp_dev);

    if ((ioctl(fd, SIOCGIFADDR, (caddr_t) & ifr, sizeof(struct ifreq))) < 0)
    {
        log_fatal("System call ioctl() with SIOCGIFADDR failure.\n", ppp_dev);
        return -1;
    }

    sin = (struct sockaddr_in *)&ifr.ifr_addr;
    strcpy(pppd_info->netaddr, (const char *)inet_ntoa(sin->sin_addr));
    log_nrml("Get %s local IP address: %s\n", ppp_dev, pppd_info->netaddr);

    if ((ioctl(fd, SIOCGIFDSTADDR, (caddr_t) & ifr, sizeof(struct ifreq))) < 0)
    {
        log_fatal("System call ioctl() with SIOCGIFDSTADDR failure.\n", ppp_dev);
        return -1;
    }
    sin = (struct sockaddr_in *)&ifr.ifr_dstaddr;
    strcpy(pppd_info->ptpaddr, (const char *)inet_ntoa(sin->sin_addr));
    log_nrml("Get %s remote IP address: %s\n", ppp_dev, pppd_info->ptpaddr);

    return 0;
}


/*  Description: Use ping do network test
 *   Input args: $from: : use which NIC(Network Interface Card: eth0, eth1) or 
 *               source IP address do ping test. if it's NULL, use default route
 *               $ping_ip:  The ping test destination IP address
 *  Output args: NONE
 * Return Value: >=0 ping test packet lost percent, <0: failure
 */
int network_ping_test(char *from, char *ping_ip)
{
    FILE                 *fp;
    char                 cmd[256];
    char                 buf[512];
    int                  lost_percent = 100;
    unsigned long        tx_packets = 0;
    unsigned long        rx_packets = 0;

    memset(cmd, 0, sizeof(cmd));
    if(from)
    {   
        snprintf(cmd, sizeof(cmd), "ping -W1 -c5 -s4 %s -I %s", ping_ip, from);
    }   
    else
    {   
        snprintf(cmd, sizeof(cmd), "ping -W1 -c5 -s4 %s", ping_ip);
    }   

    if (NULL == (fp = popen(cmd, "r")))
    {   
        return -2; 
    }   

    while (NULL != fgets(buf, sizeof(buf), fp))
    {   
        if (strstr(buf, "transmitted"))
        {   
            split_string_to_value(buf, "%l,%l,%d", &tx_packets, &rx_packets, &lost_percent);
            break;
        }   
    }   

    pclose(fp);
    return lost_percent;
}

int check_ppp_stat(ppp_stat_t  *ppp_stat, char *ppp_dev)
{
    int                 retval;
    FILE                *fp;
    char                *ptr;
    char                buf[512];

    if( NULL == (fp=fopen(PPP_PROC_NET_DEV, "r")) ) 
    {
        log_err("Can not open %s.\n", PPP_PROC_NET_DEV);
        return -1;
    }

    fgets(buf, sizeof(buf), fp);
    fgets(buf, sizeof(buf), fp);

    while (fgets(buf, sizeof(buf), fp))
    {
        ptr=strstr(buf, ppp_dev);
        if(NULL == ptr)
        {
            log_err("Can not find %s interface statistic data in %s\n", ppp_dev, PPP_PROC_NET_DEV);
            retval = -1;
            break;
        }
        else
        {
             ptr = strchr(ptr, ':');
             ptr++;
             sscanf(ptr, "%llu%llu%lu%lu%lu%lu%lu%lu%llu%llu%lu%lu%lu%lu%lu%lu",
                     &(ppp_stat->ullRx_Bytes),
                     &(ppp_stat->ullRx_Packets),
                     &(ppp_stat->ulRx_Errors),
                     &(ppp_stat->ulRx_Dropped),
                     &(ppp_stat->ulRx_FIFO_Errors),
                     &(ppp_stat->ulRx_Frame_Errors),
                     &(ppp_stat->ulRx_Compressed),
                     &(ppp_stat->ulRx_Multicast),
                     &(ppp_stat->ullTx_Bytes),
                     &(ppp_stat->ullTx_Packets),
                     &(ppp_stat->ulTx_Errors),
                     &(ppp_stat->ulTx_Dropped),
                     &(ppp_stat->ulTx_FIFO_Errors),
                     &(ppp_stat->ulCollisions),
                     &(ppp_stat->ulTx_Carrier_Errors),
                     &(ppp_stat->ulTx_Compressed)
                   );
             retval = 0;
             break;
        }
    }

    if(0 == retval )
        log_dbg("Check PPP network traffic: Tx %llu bytes, Rx %llu bytes.\n", ppp_stat->ullTx_Bytes, ppp_stat->ullRx_Bytes);
    fclose(fp);
    return retval;
}

int kill_pppd_process(comport_t *comport)
{
    int           pid = -1;

    while( (pid=check_pppd_pid(comport->dev_name)) > 0) 
    {
        log_nrml("Terminate pppd process [pid=%d]\n", pid);
        kill(pid, SIGTERM); 
        sleep(1); /* Wait pppd process exit */
    }

    return 0;
}

int stop_ppp_connect(ppp_ctx_t *ppp_ctx)
{
    log_warn("Stop PPP connection now.\n");

    if(check_ppp_interface(ppp_ctx->dev))
        return 0;

    kill_pppd_process(ppp_ctx->comport);

    if(ppp_ctx->comport)
    {
        free_gsm_dataport("stop_ppp_connect()", ppp_ctx->module, &(ppp_ctx->comport));
    }
    return 0;
}

int get_apn_conf(char *ini_name, char *ini_key, apn_account_t *apn, unsigned char type)
{
    dictionary       *ini ;
    char             tmp[64];
    char             *str;
            
    if(NULL==ini_name || NULL==ini_key || NULL==apn)
    {       
        return -1;
    }       
        
    ini = iniparser_load(ini_name);
    if (ini==NULL)
    {   
        log_err("cannot load default APN configure file: %s\n", ini_name);
        return -2 ;
    }       
    log_dbg("Parser default APN configure file %s\n", ini_name);
            
    /* Parser APN configure */
    snprintf(tmp, 64, "%s:%s", ini_key, APN_3G==type?"3g_apn":"apn");
    if( !(str=iniparser_getstring(ini, tmp, NULL)) )
    {       
        log_err("cannot find APN setting for SIM [%s] in file: %s\n", ini_key, ini_name);
        memset(apn, 0, sizeof(apn_account_t));
        return -1;
    }           
    else        
    {       
        strncpy(apn->apn, str, APN_LEN);
    }
    
    /* Paser APN username information  */
    snprintf(tmp, 64, "%s:%s", ini_key, APN_3G==type?"3g_uid":"uid");
    str = iniparser_getstring(ini, tmp, NULL);
    strncpy(apn->uid, str, UID_LEN);


    /* Paser APN password information  */
    snprintf(tmp, 64, "%s:%s", ini_key, APN_3G==type?"3g_pwd":"pwd");
    str = iniparser_getstring(ini, tmp, NULL);
    strncpy(apn->pwd, str, PWD_LEN);

    iniparser_freedict(ini);
    return 0;
}


int select_apn(ppp_ctx_t *ppp_ctx, char *key)
{
    int                 retval;
    unsigned char       type = APN_2G;

    log_nrml("GPRS module work on GPRS mode, select APN now.\n"); 

    retval = get_apn_conf(APN_DEF_CONF_FILE, key, &(ppp_ctx->apn), type);
    if(!retval)
    {
        log_err("Get default APN [%s] from %s ok\n", ppp_ctx->apn.apn, APN_DEF_CONF_FILE);
        return 0;
    }

    return -1;
}

#define PPPD_CMD_LEN  512
int start_ppp_dial_cmd(comport_t  *comport, apn_account_t *apn, char *ppp_dev)
{
    char                tmp[64];
    char                pppd_cmd[PPPD_CMD_LEN];
    pid_t               pid;

    if( !comport || !comport->is_connted )
    {
        log_err("GPRS module data port %s is not opened.\n", comport->dev_name);
        return -1;
    }

    if( !apn || strlen(apn->apn)<=0 )
    {
        log_err("No valid APN was set.\n");
        return -1;
    }

    log_nrml("Start PPP connection with APN \"%s\" now.\n", apn->apn);

    memset(pppd_cmd, 0, PPPD_CMD_LEN);
    snprintf(pppd_cmd, PPPD_CMD_LEN, "%s -d %s ", PPPD_DIAL_SCRIPTS, comport->dev_name);

    snprintf(tmp, sizeof(tmp), " -a %s ", apn->apn);
    strncat(pppd_cmd, tmp, PPPD_CMD_LEN);

    if( strlen(apn->uid) > 0 )
    {
        snprintf(tmp, sizeof(tmp), " -u %s ", apn->uid);
        strncat(pppd_cmd, tmp, PPPD_CMD_LEN);
    }
    
    if( strlen(apn->pwd) > 0 )
    {
        snprintf(tmp, sizeof(tmp), " -p %s ", apn->pwd); 
        strncat(pppd_cmd, tmp, PPPD_CMD_LEN);
    }

    if( strlen(apn->auth) > 0 )
    {
        snprintf(tmp, sizeof(tmp), " -v %s ", apn->auth);
        strncat(pppd_cmd, tmp, PPPD_CMD_LEN);
    }

    strncat(pppd_cmd, ppp_dev, PPPD_CMD_LEN);

    log_nrml("ppp dial up command: %s\n", pppd_cmd);

    pid = fork();
    if( 0 == pid ) /* Child process */
    {
        system(pppd_cmd); 
        exit(0);
    }
    else if (pid < 0)
    {
        log_err("Create new process failure.\n"); 
        return -1;
    }
    else
    {
        log_dbg("pppd program already running.\n");
        micro_second_sleep(1000);  
    }

    return 0;
}

int check_pppd_pid(char *find_key)
{
    char       buf[10];
    char       cmd[128];
    FILE       *fp = NULL;
    int        pid = -1;

    snprintf(cmd, sizeof(cmd), "ps | grep -v grep | grep pppd | grep %s | awk '{print $1}'", find_key); 

    fp = popen(cmd, "r");
    if(NULL == fp)
    {
        log_fatal("popen() to check the pppd process ID failure.\n");
        return -1;
    }

    memset(buf, 0, sizeof(buf));
    fgets(buf, sizeof(buf), fp);

    pid = atoi(buf); 

    if(pid <= 1)
    {
        log_err("Get pppd program running pid failure\n");
        pid = -1;
    }
#if 0
    else
    {
        log_trace("pppd program running pid is [%d]\n", pid);
    }
#endif

    pclose(fp);
    return pid;
}

void set_ppp_disconnect(ppp_ctx_t *ppp_ctx)
{
    ppp_ctx->status = DISCONNECT; 
    ppp_ctx->pppd_info.start_time = 0; 
    
    memset(&(ppp_ctx->pppd_info), 0, sizeof(pppd_info_t)); 
    memset(&(ppp_ctx->ppp_stat), 0, sizeof(ppp_stat_t)); 
    ppp_ctx->network = PPP_STOP;
}


int ppp_context_init(ppp_ctx_t *ppp_ctx, modinfo_t *module)
{
    memset(ppp_ctx, 0, sizeof(*ppp_ctx));

    ppp_ctx->thread_id = pthread_self();
    ppp_ctx->module = module;
    strncpy(ppp_ctx->dev, PPP_INTERFACE_NAME, sizeof(ppp_ctx->dev));
    strncpy(ppp_ctx->ping_ip, DEF_PING_DST, sizeof(ppp_ctx->ping_ip));
    ppp_ctx->ping_interval  = PING_INTERVAL_TIME;
    set_ppp_disconnect(ppp_ctx);

    log_nrml("Initialize PPP thread context ok\n"); 
    return 0;
}

void ppp_context_term(ppp_ctx_t *ppp_ctx)
{
    stop_ppp_connect(ppp_ctx);
    set_ppp_disconnect(ppp_ctx);

    log_nrml("Terminate PPP thread context ok\n"); 
}

int start_ppp_connect(ppp_ctx_t *ppp_ctx)
{
    int                 retval;
    modinfo_t          *module = ppp_ctx->module; 

    if( !ppp_ctx->comport ) 
    {
        ppp_ctx->comport=alloc_gsm_dataport("start_ppp_connect()", ppp_ctx->module);
        if(!ppp_ctx->comport)
            return -1;

        log_dbg("PPP thread alloc GPRS dataport %s=>[fd:%d]\n", ppp_ctx->comport->dev_name, ppp_ctx->comport->fd);
    }

    
    switch(ppp_ctx->status)
    { 
        case DISCONNECT: /*  Select the APN now */
            set_ppp_disconnect(ppp_ctx);
            retval = select_apn(ppp_ctx, module->reg.loc.mcc_mnc);
            if(!retval)
            {
                log_nrml("Select APN successfully, go to next stage.\n");
                ppp_ctx->fail_cnt = 0; 
                ppp_ctx->status++;
            }
            else
            {
                log_warn("Select APN failure, request to reset GPRS module\n");
                ppp_ctx->fail_cnt ++; 
                set_module_event(module, REQ_POWER_RESET);
                break;
            }

        case SELECTED_APN: /*  Select the APN now */
            log_warn("Run pppd program to start PPP connection now\n"); 
            ppp_ctx->network = PPP_CONN;
            start_ppp_dial_cmd(ppp_ctx->comport, &(ppp_ctx->apn), ppp_ctx->dev);
            ppp_ctx->status++; 
            break;
    } 
    
    return 0;
}

int inspect_network_status(ppp_ctx_t *ppp_ctx)
{
    pppd_info_t            *pppd_info = &(ppp_ctx->pppd_info);
    ppp_stat_t             *ppp_stat = &(ppp_ctx->ppp_stat);
    int                    lost_percent;
    unsigned long long     last_tx_bytes= ppp_stat->ullTx_Bytes;
    unsigned long long     last_rx_bytes= ppp_stat->ullRx_Bytes;

    if( CONNECTED != ppp_ctx->status)
    {
        ppp_ctx->pppd_info.ping_time = 0;
        memset(ppp_stat, 0, sizeof(*ppp_stat));

        pppd_info->pid = check_pppd_pid(ppp_ctx->comport->dev_name);
        if(pppd_info->pid <= 0)
        {
            /*  pppd can not connect in 30s, then set it to DISCONNECT status */
            if(time_elapsed(pppd_info->start_time) >= PPPD_DIAL_TIMEOUT)
            {
                /* Sleep for 2 seconds, make sure the exit pppd process release the TTY device */
                micro_second_sleep(2000);
                log_err("pppd process exit when do ppp dialing, set status to DISCONNECT.\n");
                set_ppp_disconnect(ppp_ctx);
            }
        }
        else
        {
            if(strlen(pppd_info->netaddr) <=0 )
            {
                check_ppp_ipaddr(pppd_info, ppp_ctx->dev);
                log_dbg("pppd running process ID [%d].\n", pppd_info->pid);
            }
        }
    }

    if(  time_elapsed(pppd_info->ping_time) >= ppp_ctx->ping_interval*1000  )
    {
        if(ppp_ctx->fail_cnt >= MAX_PPP_FAIL_CNT)
        {
            /* Sleep for 2 seconds, make sure the exit pppd process release the TTY device */
            micro_second_sleep(2000);
            log_warn("PPP network inspect status failure, set status to DISCONNECT.\n");
            set_ppp_disconnect(ppp_ctx);
            return 0;
        }

        lost_percent = network_ping_test(ppp_ctx->dev, ppp_ctx->ping_ip);
        ppp_ctx->network = lost_percent<=60 ? PPP_GOOD : PPP_BAD;

        if(lost_percent <= 80)
        {
            check_ppp_stat(ppp_stat, ppp_ctx->dev);
            if(last_tx_bytes==ppp_stat->ullTx_Bytes || last_rx_bytes==ppp_stat->ullRx_Bytes)
            {
                log_warn("PPP interface traffic not increased, maybe ppp disconnected?\n");
                ppp_ctx->fail_cnt++;
            }
            else
            {
                log_nrml("Set PPP connection status to CONNECTED.\n");
                set_ppp_disconnect(ppp_ctx);
                ppp_ctx->fail_cnt=0;
            }
        }
        else
        {
            ppp_ctx->fail_cnt++;
        }
        ppp_ctx->pppd_info.ping_time = time_now();
    }

    return 0;
}


void *ppp_thread_workbody(void *thread_arg)
{
    ppp_ctx_t          ppp_ctx; 
    modinfo_t         *module;

    module = (modinfo_t *)thread_arg;
    ppp_context_init(&ppp_ctx, module);

    log_nrml("GPRS PPP thread start running\n");

    while( !g_cp_signal.stop )
    {
        if(ALL_READY != module->ready)
        {
            if(ppp_ctx.status>=CONNECTING)
            {
                log_nrml("Stop exist PPP connection and free TTY data port\n");
                stop_ppp_connect(&ppp_ctx);
            }

            /*  GPRS not ready, sleep for 200ms and check again */
            micro_second_sleep(200);
            continue;
        }
        else
        {
            if(ppp_ctx.status>=CONNECTING)
            {
                inspect_network_status(&ppp_ctx);
            }
            else
            {
                start_ppp_connect(&ppp_ctx);
            }
        }

        sleep(1);
    }

    ppp_context_term(&ppp_ctx);
    pthread_exit(0);
    return NULL;
}

int start_thread_ppp(modinfo_t *module)
{
    pthread_t           tid;

    return thread_start(&tid, ppp_thread_workbody, module);
}