server.c

实现图片手工播放或者是自动播放的后台文件

#include<fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<sys/socket.h>
#include<sys/wait.h>
#include "spcaframe.h"
#define  PORT 7069                     /********服务器监听端口号********/
#define  BACKLOG 10                    /*******最大同时连接请求数*******/

int       thread_num = 0;
int       playtype;                    /***********播放方式*************/
int       play;                        /***********是否播放*************/
int       auto_play;                   /*******是否自动播放开始*********/
int       auto_pause;                  /*******是否自动播放暂停*********/
int       auto_stop;                   /*******是否自动播放停止*********/
int       thread_play = 0;             /*******是否有线程在播放中*******/ 
int       pic_no = 0;                  /*********播放图片序号***********/
int       pic_total;                   /***********图片总数*************/
int       prj;

char      *str1="image";
char      *str2=".png";
char      filename[20];
char      picfilename[20];

struct    picparam picparam_message;   /*******播放状态信息*************/
struct    fileinfo
    {
         int    id;                    /***保存图片文件序号同下载顺序***/
         int    nextpic;               /*******保存图片播放的序号*******/
         int    delaytime;             /*****保存图片播放的时间延迟*****/
         char   file_title[50];        /***保存图片文件序号的图片标题***/
    }files[20];

int       j;                           /****手工下一幅播放的图片序号****/
int       manual_history[200];         /**足够大的数组保存下幅播放顺序**/
int       manual_next_total = 0;       /****手工下一幅播放的图片总数****/
int       manual_prio_temp = 0;        /******手工上一幅播放的图片******/

void      service (void *ir);
void      servicepic (int);
void      picplayinit();               /*********设置开机图片***********/
void      handleprj();

main()
{
    int ret, sin_size;
    int serverport = 7069;
    int sockfd, new_fd;           /*监听socket: sock_fd,数据传输socket:new_fd*/
    struct sockaddr_in my_addr;   /*本机地址信息*/
    struct sockaddr_in their_addr;/*客户地址信息*/
    pthread_t   server_th;
 
    picplayinit();                    /*****设置开机图片******/

    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    { 
        /*错误检测*/
        perror("Create socket error!!\n"); 
        exit(1);
    }

    my_addr.sin_family=AF_INET;
    my_addr.sin_port=htons(PORT);
    my_addr.sin_addr.s_addr = INADDR_ANY;
    bzero(&(my_addr.sin_zero),8);

    if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1)
    {
        /*错误检测*/
        perror("Bind socket error!!!\n");   
        exit(1);
    }

    if (listen(sockfd, BACKLOG) == -1)
    {
        /*错误检测*/
        perror("Listen socket error!!!\n"); 
        exit(1);
    }

    prj = 0;
    play  = 0;

    /***如果有工程文件则分析***/
    handleprj();

    printf("Waiting .... for connection. CTrl_c to stop !!!! \n");

    while (1) 
    { 
        sin_size = sizeof(struct sockaddr_in);
        printf("00000 after Creat pthread!!!\n");
        if ((new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size)) == -1) 
        {
            perror("Accept socket Error!!!\n"); 
            continue; 
        }

        printf("server: got connection from %s\n",inet_ntoa(their_addr.sin_addr));

        ret = pthread_create(&server_th, NULL, (void *)service, &new_fd);
        if (ret ==-1)
        {
            printf("bbbb after Creat pthread!!!\n");
            printf("Creat pthread error!!!\n");
            continue;
        }
        thread_num++;
        printf("1111111111 right Creat pthread Succ id = [%d] new_fd = [%d]!!!\n", thread_num, new_fd);
        //pthread_join(server_th, NULL);
    }
    close(sockfd);
    return 0;
}

void
service (void *ir)
{
    int         i=0, k, ret;
    int         *id = (int*) ir;
    int         fd;               
    int         sock;
    int         receivesize;
    unsigned    int retfgets;
    unsigned    int retwrite;
    FILE        *fdppj;
    char        *buf;
    char        *picbuf;

    pthread_t   thread_auto;
    struct  cmd      cmdmessage;
    struct  pichead  picheadmessage;
    struct  pic      picmessage;

    sock = *id;

    sprintf(filename, "%s", "test.txt");

    for (;;)
    {   
        memset(&cmdmessage, 0, sizeof(struct cmd));

        ret = read(sock, (unsigned char*)&cmdmessage, sizeof(struct cmd));
	if (ret < 0) 
        {
        printf("22222  wrong pthread new_fd = [%d]!!!\n", sock);
            printf("Get date from client error!! \n");
            sleep(3);
            picplayinit();                    /*****回到开机图片******/
            pthread_exit(NULL);
	}
        printf("33333333  right pthread Succ id = [%d] new_fd = [%d]!!!\n", thread_num, sock);
        printf("\tCMD flag = [%0x] cmdtype [%d%d%d%d]\n\tnextdatalength = [%d] reserved = [%d]\n", cmdmessage.flag, cmdmessage.cmdtype[0],cmdmessage.cmdtype[1],cmdmessage.cmdtype[2], cmdmessage.cmdtype[3], cmdmessage.nextdatalength, cmdmessage.reserved);
         
        if (cmdmessage.cmdtype[0] == 1)               /*传播放图片状态*/
        {
        printf("4444444  right pthread Succ id = [%d] new_fd = [%d]!!!\n", thread_num, sock);
            /****取得正在播放图片的序号*****/
            picparam_message.header = 0x01020304;
            picparam_message.state[0] = prj;  
            picparam_message.state[1] = play;
            if(auto_pause == 1 && play == 1)
            {
                picparam_message.state[2] = 1;
            }
            else
            {
                picparam_message.state[2] = 0;
            }
            picparam_message.state[3] = files[pic_no].id;   /***为下载顺序****/ 
            picparam_message.reserved = playtype;  
            strcpy(picparam_message.title, files[pic_no].file_title);

            printf("state = %d%d%d%d\n", picparam_message.state[0], picparam_message.state[1], picparam_message.state[2], picparam_message.state[3]);

            ret = write(sock, (unsigned char *)&picparam_message, sizeof(struct picparam));
            if ( ret < 0 )
            {
        printf("555555 wrong pthread Succ id = [%d] new_fd = [%d]!!!\n", thread_num, sock);
            	printf("Write socket Error! in 3001 !!\n");
                sleep(3);
                picplayinit();                    /*****回到开机图片******/
                pthread_exit(NULL);
            }
            printf("Write socket succ! in 3001 !!\n");
        }
        else if (cmdmessage.cmdtype[0] == 2)             /***图片下载****/
        {
	    receivesize = cmdmessage.nextdatalength;

	    buf = (char *)malloc(receivesize);
	    if(buf == NULL)
            {
	        printf("malloc buf error!\n");
                sleep(5);
                picplayinit();                    /*****回到开机图片******/
                pthread_exit(NULL);
            }
       	    ret = read_sock(sock,(unsigned char *)buf, receivesize);
	    if(ret < 0)
            {
                printf("socket read file error!\n");
                sleep(5);
                picplayinit();                    /*****回到开机图片******/
                pthread_exit(NULL);
            }

       	    if((fd = open("temp.ppj", O_RDWR|O_CREAT|O_TRUNC)) < 0)
            {
            	printf("Creat ppj Error!\n");
                sleep(5);
                picplayinit();                    /*****回到开机图片******/
                pthread_exit(NULL);
            }

       	    if(write(fd, buf, receivesize) != receivesize)
            {
             	printf("Write Error!\n");
                sleep(5);
                picplayinit();                    /*****回到开机图片******/
                pthread_exit(NULL);
            }
       	    free(buf);
	    close(fd);

       	    if((fdppj = fopen("temp.ppj", "r")) < 0)
            {
		printf("Open ppj file Error!\n");
                sleep(5);
                picplayinit();                    /*****回到开机图片******/
                pthread_exit(NULL);
            }

	    retfgets = fread((unsigned char*)&picheadmessage, 1, sizeof(struct pichead), fdppj);

	    /**设置播放方式***/
	    playtype  = picheadmessage.playtype;
            /**回传成功信息***/
            cmdmessage.cmdtype[0] = 0;
            cmdmessage.cmdtype[1] = 0;
            cmdmessage.cmdtype[2] = 0;
            cmdmessage.cmdtype[3] = 3;

            ret = write(sock, (unsigned char*)&cmdmessage, sizeof(struct cmd));
            if (ret < 0)
            {
                printf("Send Ackcmd Error!! \n");
                sleep(5);
                picplayinit();                    /*****回到开机图片******/
                pthread_exit(NULL);
            }

            /****取得图片文件总数*****/
            pic_total = picheadmessage.piccount;
           
	    for (i=0; i<picheadmessage.piccount; i++)
            {
                memset(&cmdmessage, 0, sizeof(struct cmd));
                /*****读取下个图片文件的信息 包括图片的大小******/
       	        ret = read(sock, (unsigned char*)&cmdmessage, sizeof(struct cmd));
	        if (ret < 0) 
                {
                    printf("Get Clinet Infomation Error!! \n");
                    sleep(5);
                    picplayinit();                    /*****回到开机图片******/
                    pthread_exit(NULL);
                }

		memset(&picmessage, 0, sizeof(struct pic));

                /***从工程文件中读取下个图片文件的信息 包括图片的大小******/
	        retfgets = fread((unsigned char*)&picmessage, 1, sizeof(struct pic), fdppj);

		receivesize = picmessage.size;	
		buf = (char *)malloc(receivesize);
               	if(buf == NULL)
                {
                    printf("malloc buf error!\n");
                    sleep(5);
                    picplayinit();                    /*****回到开机图片******/
                    pthread_exit(NULL);
                }

                /*******接收一副图片****/
		ret = read_sock(sock, (unsigned char *)buf, receivesize);
                if(ret < 0)
                {
                    printf("socket read file error!\n");
                    sleep(5);
                    picplayinit();                    /*****回到开机图片******/
                    pthread_exit(NULL);
                }

                /***命名新图片名称   建立返回图片与播放图片间的关系***/ 
                sprintf(picfilename, "%s%d%s", str1, i, str2);

       		if((fd = open(picfilename, O_RDWR|O_CREAT|O_TRUNC)) < 0)
                {
                    printf("Creat pic %d Error!\n",i);
                    sleep(5);
                    picplayinit();                    /*****回到开机图片******/
		}
                if((retwrite = write(fd, (unsigned char *)buf, receivesize)) != receivesize)
                {
                    printf("Write Error!\n");
                    sleep(5);
                    picplayinit();                    /*****回到开机图片******/
                    pthread_exit(NULL);
                }
                free(buf);
                close(fd);

                /****建立返回图片与播放图片间的关系****/
                files[i].id = i;
                files[i].nextpic = picmessage.nextpic;
                files[i].delaytime = picmessage.delay;
                memset(files[i].file_title, 0, sizeof(char)*50);
	        strcpy(files[i].file_title, picmessage.title);

                /**回传成功信息***/
                cmdmessage.cmdtype[0] = 0;
                cmdmessage.cmdtype[1] = 0;
                cmdmessage.cmdtype[2] = 0;
                cmdmessage.cmdtype[3] = 3;
                ret = write(sock, (unsigned char *)&cmdmessage, sizeof(struct cmd)) ;
                if ( ret < 0 )
                {
                    printf("Write socket Error! in 3002 !!\n");
                    sleep(5);
                    picplayinit();                    /*****回到开机图片******/
                    pthread_exit(NULL);
                }
	    }
	    close(fdppj);
	    for (i=0; i<pic_total; i++)
	    {
		 printf("\tid = [%d], nextpic = [%d]\n\tdelaytime = [%d] title = [%s]\n", files[i].id, files[i].nextpic, files[i].delaytime, files[i].file_title);
	    }
            /***下载结束工程文件存在***/
            prj = 1;
        }
        else if (cmdmessage.cmdtype[0] == 4)             /***图片播放****/
        {
            printf("Start play picture!\n");
            /****处理工程文件****/
            if (prj == 0)
            {
                handleprj();
            }
            if ( prj != 1)
            {
                /***打开工程文件失败***/
                cmdmessage.cmdtype[0] = 0x10;
                cmdmessage.cmdtype[1] = 0;
                cmdmessage.cmdtype[2] = 0;
                cmdmessage.cmdtype[3] = 3;

                ret = write(sock, (unsigned char *)&cmdmessage, sizeof(struct cmd)) ;
                if ( ret < 0 )
                {
            	    printf("Write socket Error! in 3004 !!\n");
                    sleep(5);
                    picplayinit();                    /*****回到开机图片******/
                    pthread_exit(NULL);
                }
            	printf("Has no picproject!!\n");
                sleep(5);
                picplayinit();                    /*****回到开机图片******/
                pthread_exit(NULL);
            }

            play = 1;
            if (playtype == 0)         /**自动播放**/
            {
                /*****告诉线程自动播放******/
                auto_play = 1;
                auto_pause = 0;
                auto_stop  = 0;     /***如果原来有线程运行则停止原来线程****/

                /*****调用线程播放图片*****/
	        /**pic_no为图片自动播放时候的开始位置**/
		if (thread_play == 0)
		{
		    ret = pthread_create(&thread_auto, NULL, (void *)servicepic, pic_no);
		    if (ret != 0)
		    {
		        printf("Creat pthread error!!!\n");
                        sleep(5);
                        picplayinit();                /*****回到开机图片******/
                        pthread_exit(NULL);
		    }
		    thread_play = 1;
	        }
                printf("pause play succ!!\n");
            }
            else if (playtype == 1)    /**手工播放**/
            {
		/***设置播放历史为第一幅图片***/
		manual_history[0] = 0;
		/****播放第一幅图片总数为一****/
		manual_next_total = 1;
                manual_prio_temp = manual_next_total; 
                /***查找需要播放图片的保存文件名称****/
                sprintf(picfilename, "%s%d%s", str1, pic_no, str2);

                /****将要播放的图片名称写文件****/
	        if((fd=open(filename, O_CREAT||O_TRUNC))==-1)
	        {
	            fprintf(stderr,"Open %s Error:%s\n",filename, strerror(errno));
                    sleep(5);
                    picplayinit();                /*****回到开机图片******/
                    pthread_exit(NULL);
	        }