smcp-clpu.c

smcp报文处理,阅读您的文件包然后写出其具体功能

#include "smcp-message-factory.h"
#include "smcp-clpu.h"
#include "remote-proxy.h"
#include "communication-interface.h"
#include "smcp-timer.h"
#include "remote-proxy.h"

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
#include <syslog.h>
#include <sys/reboot.h>

udp_t Udp;
int Msgfd;
rack_t rack;
/***********************************************************
 * from MHPU
 **********************************************************/
static void transact_operation_start_request(smcp_msg *msg)
{
    //doing something in here
    unsigned char result;
    rack.mhpu.rack = msg->src_rack;    //record MHPU's rack,slot
    rack.mhpu.slot = msg->src_slot;

    operation_start_response(msg, result);

    if (result == OK)
    {
        rack.cswu.rack = msg->src_rack;
        rack.cswu.slot = msg->src_slot;
        boot_notify();

    }

}
static void transact_event_trap_response(smcp_msg *msg)
{
}
static void transact_alive_check_request(smcp_msg *msg) //from MHPU INFO
{
    //doing something in here

    alive_check_response(msg);
}
static void transact_operation_status_change_indicate(smcp_msg *msg)
{
    //do something in here
    rack.clpu.ser_status = msg->pdata[3];
    if (rack.clpu.ser_status == OUTS_STATUS)
    {
        //inform DSP to stop working
        ;
    }
    operation_status_chang_response(msg, OK);
}
static void transact_reset_indicate(smcp_msg *msg)
{
    //software reset in here...

    //response
    reset_indicate_response(msg, OK);
    printf("reset computer\n");
    //hardware reset...
   // reboot(RB_AUTOBOOT);
}
/***********************************************************
 * from CSWU
 **********************************************************/
static void transact_act_notify(smcp_msg *msg)
{
    //do something
    rack.cswu.rack = msg->src_rack;
    rack.cswu.slot = msg->src_slot;
    //response
    act_response(msg);

}
static void transact_boot_response(smcp_msg *msg)
{
    smcp_destroy_timer(SEND_BOOT_NOTIFY_TIMER);
}

static void transact_download_start_indicate(smcp_msg *msg)
{

    download_start_response(msg);

}
static void transact_download_complete_response(smcp_msg *msg)
{

}
static void download_file()
{
    printf("System is down load file\n");
}

/**********************************************************
 * from RRU
 ***********************************************************/
static void transact_alive_check_response(smcp_msg *msg)
{
    smcp_stop_timer(ALIVE_CHECK_RRU3_TIMER);
}
static void transact_act_response(smcp_msg *msg)
{

}
static void transact_boot_notify(smcp_msg *msg)
{
    int i;
    for(i=0;i<4;i++)
   {
       if(rru[i].rack ==msg->src_rack && rru[i].slot == msg->src_slot)
       {
           smcp_start__timer(60,i+5);
           break;
       }
   }

    boot_response(msg);

}

static void transact_reset_indicate_response(smcp_msg *msg)
{
}

/***************************************************
 *  system initial part
 ***************************************************/
static int init_rack()
{
    rack.clpu.type = CLPU;
    rack.clpu.rack = 4;
    rack.clpu.slot = 1;
    rack.clpu.boot_cause = REBOOT;
    rack.clpu.ser_status = INIT_STATUS;
    memcpy(rack.clpu.soft_ver, "00.00.000A", 10);
    memcpy(rack.clpu.param_ver, "00.00.001A", 10);

    rack.cswu.rack = 4;
    rack.cswu.slot = 5;


    return 0;

}
static int set_rru()
{
    rru[0].rack = rack.clpu.rack;
    rru[0].slot = rack.clpu.slot * 16 + 8;

    rru[1].rack = rack.clpu.rack;
    rru[1].slot = rack.clpu.slot * 16 + 9;

    rru[2].rack = rack.clpu.rack;
    rru[2].slot = rack.clpu.slot * 16 + 10;

    rru[3].rack =  rack.clpu.rack;
    rru[3].slot = rack.clpu.slot * 16 + 11;


    return 0;
}
static int system_setup_signal(void)
{
    if (signal(SIGTERM, download_file) < 0)
    {
        printf("SIGTERM setup failed\n");
        return -1;
    }
    if (signal(SIGINT, catch_control_c) < 0)
    {
        printf("SIGSEGV setup failed\n");
        return -1;
    }
    return 0;
}
static int create_receive_message_task(void)
{
    pthread_t pfd;
    if (pthread_create(&pfd, NULL, (void*) receive_message, NULL) < 0)
    {
        return -1;
    }
    return pfd;
}
static int create_proccess_message_task(void)
{
    pthread_t pfd;
    if (pthread_create(&pfd, NULL, (void*) proccess_message, NULL) < 0)
    {
        return -1;
    }
    return pfd;
}
/*********************************************************
 *
 ********************************************************/
void proccess_message()
{
    unsigned char message[MAX_MSG_LENGTH];
    smcp_msg rev_msg;
    for (;;)
    {
        memset(message, 0, MAX_MSG_LENGTH);
        if (rcvfrm_msg_queue(Msgfd, message) > 0)
        {
            rev_msg = smcp_unpagage(message);
            show_message(&rev_msg);
            switch (rev_msg.msg_id)
            {
            case BOOT_RESPONSE: //from CSWU
                transact_boot_response(&rev_msg);
                break;
            case ACT_NOTIFY: //from CSWU
                transact_act_notify(&rev_msg);
                break;
            case DOWNLOAD_START_INDICATE: //from CSWU
                transact_download_start_indicate(&rev_msg);
                break;
            case DOWNLOAD_COMPLETE_RESPONSE: //from CSWU
                transact_download_complete_response(&rev_msg);
                break;

            case OPERATION_START_REQUEST: //from MHPU
                transact_operation_start_request(&rev_msg);
                break;
            case ALIVE_CHECK_REQUEST: //from MHPU
                transact_alive_check_request(&rev_msg);
                break;
            case OPERATION_STATUS_CHANGE_INDICATE: //from MHPU
                transact_operation_status_change_indicate(&rev_msg);
                break;
            case RESET_INDICATE:
                transact_reset_indicate(&rev_msg); //from MHPU
                break;
            case EVENT_TRAP_RESPONSE:
                transact_event_trap_response(&rev_msg); //from MHPU
                break;

            case ACT_RESPONSE:      //from RRU
                transact_act_response(&rev_msg);
            case BOOT_NOTIFY: //from RRU
                transact_boot_notify(&rev_msg);
                break;
            case ALIVE_CHECK_RESPONSE: //from RRU
                transact_alive_check_response(&rev_msg);
                break;
            case RESET_INDICATE_RESPONSE: //from RRU
                transact_reset_indicate_response(&rev_msg);
                break;
            }
        }
    }
}

void receive_message()
{
    int length;
    for (;;)
    {
        memset(Udp.recv_buff, 0, MAX_MSG_LENGTH);
        if ((length = udp_recv(&Udp, Udp.recv_buff)) > 0)
        {
            again: if (sndto_msg_queue(Msgfd, Udp.recv_buff, length) < 0)
            {
                printf("send message to MSGQ failed\n");
                sleep(1);
                goto again;
            }
        }
    }
}
void catch_control_c()
{
    if (delete_msg_queue(Msgfd) < 0)
        printf("free message queue failed\n");
    if (udp_close(&Udp) < 0)
        printf("close udp failed\n");
    int i;
    for(i=0;i<CURNET_TIMER_NUM;i++)
    {

        if(smcp_destroy_timer(i)<0)
            printf("delete timer %d failed\n",i);
    }
    exit(0);
}
/************************************************************
 * message send and list part
 *************************************************************/
smcp_msg smcp_unpagage(char *message)
{
    smcp_msg msg;
    msg.msg_id = message[0]*256 + message[1];
    msg.data_length = message[2] * 256 + message[3];
    if(msg.data_length+4 > MAX_MSG_LENGTH)
    {
        printf("message length is too big\n");
        return;
    }
    msg.src_slot = message[4] & 0x0f;
    msg.src_rack = message[4] >> 4;
    msg.pdata = (char*) malloc(msg.data_length * sizeof(char));
    memcpy(msg.pdata, message + 4, msg.data_length);
    return msg;
}
int smcp_msg_send(smcp_msg *msg)
{
    unsigned char *message = NULL;
    char recv_ip[17];
    char s_rack[4];
    char s_slot[4];
    memset(recv_ip, 0, 17);
    memset(s_rack, 0, 4);
    memset(s_slot, 0, 4);

    message = (char *) malloc((msg->data_length + 4) * sizeof(char));
    message[0] = 0x00;
    message[1] = msg->msg_id;

    message[2] = msg->data_length / 256;
    message[3] = msg->data_length % 256;

    message[4] = msg->src_rack * 16 + msg->src_slot;
    message[5] = 0xff;    //slot number
    if (msg->pdata)
        memcpy(message + 6, msg->pdata, msg->data_length);

    sprintf(s_rack, "%d", msg->des_rack);
    sprintf(s_slot, "%d", msg->des_slot);
    strcat(recv_ip, "10.4.");
    strcat(recv_ip, s_rack);
    strcat(recv_ip, ".");
    strcat(recv_ip, s_slot);
    udp_set_receiver_addr(&Udp, recv_ip, 0xD500);

    udp_send(&Udp, message, msg->data_length + 4);
    time_t t;
    char p[32];
    time(&t);
    strftime(p, sizeof(p), "%T", localtime(&t));

    printf("Time:%s  send to %s:\n", p, recv_ip);
    show_message(msg);
    free(message);
    return 0;
}

/**************************************************************
 * CLPU ENTRY
 ***************************************************************/
#if 1
int main(int argc, char **argv)
{
    pthread_t pfd, rfd;
    //  openlog("MySysLogTest", LOG_PID|LOG_CONS, LOG_USER);

    //  syslog(LOG_ERR, "XXXXXXXXXXXXXXXXXX\n");
    //  syslog(LOG_INFO, "****************\n");
    // closelog();
    if (init_rack() < 0)
    {
        printf("init crack failed\n");
        return -1;
    }

    if (create_udp(&Udp, 0xD500) < 0)
    {
        printf("UDP create failed\n");
        return -1;
    }
    if ((Msgfd = create_msg_queue(77786)) < 0)
    {
        printf("msg_queue create failed\n");
        return -1;
    }
    if ((pfd = create_receive_message_task()) < 0)
    {
        printf("Receive message task create failed\n");
        return -1;
    }
    if ((rfd = create_proccess_message_task()) < 0)
    {
        printf("Process message task create failed\n");
        return -1;
    }
    if (system_setup_signal() < 0)
    {
        printf("system setup signal failed\n");
        return -1;
    }
    if (smcp_create_timers() < 0)
    {
        printf("create timers failed\n");
        return -1;
    }
    if (set_rru() < 0)
    {
        printf("set RRU failed\n");
        return -1;
    }
    boot_notify();
    if(smcp_start__timer(1,SEND_BOOT_NOTIFY_TIMER)<0)
    {
        printf("start timer for sending BOOT_NOTIFY message failed\n");
        return -1;
    }
    pthread_join(pfd, NULL);
    pthread_join(rfd, NULL);
    return 0;
}
#endif