http.c

ucos移植到44b0

    {
        fileOffset++;
        for (i=0;filedata[fileOffset+i] != 0;i++)
        {//文件名后缀
           suffix[i] = filedata[fileOffset+i];
        }
        suffix[i] = 0;

        if (  !strncmp(suffix,"html",4)
            ||!strncmp(suffix,"HTML",4)
            ||!strncmp(suffix,"htm", 3)
            ||!strncmp(suffix,"HTM", 3) )
        {
            return (TEXT_HTML);
        }
        else if(  !strncmp(suffix,"class",5)
                ||!strncmp(suffix,"CLASS",5)
                ||!strncmp(suffix,"jar", 3)
                ||!strncmp(suffix,"JAR", 3) )
            {
                return (OCTET_STREAM);
            }
        else if(  !strncmp(suffix,"jpeg",4)
                ||!strncmp(suffix,"JPEG",4)
                ||!strncmp(suffix,"jpg", 3)
                ||!strncmp(suffix,"JPG", 3) )
            {
                return (JPEG_IMAGE);
            }
        else if(  !strncmp(suffix,"gif",3)
                ||!strncmp(suffix,"GIF", 3) )
            {
                return (GIF_IMAGE);
            }
        else if(  !strncmp(suffix,"hdml",4) 
                ||!strncmp(suffix,"HDML", 4) )
            {
                return (TEXT_HDML);
            }
        else
            {
                return (OCTET_STREAM);
            }
    }
}

void returnFileHeader(struct netconn * newconn,_UL ct)
{
    char line[MAX_LINE+1];
    
    netconn_write(newconn, success, strlen(success), NETCONN_COPY);	 

    sprintf(line,"Server: emhttp\n");
    netconn_write(newconn, line, strlen(line), NETCONN_COPY);
    //sprintf(line,"Connection: close\n");
    //netconn_write(newconn, line, strlen(line), NETCONN_COPY);
    sprintf(line,"Content-Type: %s\n\n",content_types[ct]);
    netconn_write(newconn, line, strlen(line), NETCONN_COPY);
}



void parseAndsendTTFile(struct netconn * newconn,struct fileSetStruct * file)
{
    _UL i,curr,count;
    char content[MAX_LINE+1];
    
    curr = 0;//缓冲区当前指针
    memset(sendFilebuf,0,(MAX_SENDBUF_SIZE));
    
    //Uart_Printf("***come into parseAndsendTTFile***\n");
    for (i=0;i<file->size;i++)
    {   
        //检查是否有动态数据标签存在
        if ('<' == file->pfileStart[i])
        {
            //查找标签
            if (!strncmp(&(file->pfileStart[i+1]),"DATA",4))
            {
                i+=6;//跳到变量起始位置<DATA x>
                memset(content,0,(MAX_LINE+1));
                getDynamicContent(&(file->pfileStart[i]),content);
                
                //拷贝变量内容
                strncpy(&(sendFilebuf[curr]),content,strlen(content));
                curr += strlen(content);

                //跳过标签及变量
                for (;file->pfileStart[i] != '>';i++)
                {
                    ;  
                }                
            }
            else
            {
                sendFilebuf[curr] = file->pfileStart[i];
                curr++;
            }
            continue;        
        }
        else
        {
            //继续搜索
            sendFilebuf[curr] = file->pfileStart[i];
            curr++;
            continue;
        }        
    }

    //处理完毕之后发送已经拷贝到缓冲区的数据
    count = (curr)/100;
    for (i=0;i<count;i++)
    {
       //netconn_write(newconn, (file->pfileStart+i*100), 100, NETCONN_COPY); 
       netconn_write(newconn, (sendFilebuf + i*100), 100, NETCONN_COPY); 
    }
    //netconn_write(newconn, (file->pfileStart+i*100), ((file->size)%100), NETCONN_COPY); 
    netconn_write(newconn, (sendFilebuf + i*100), (curr)%100, NETCONN_COPY);

}

void parseAndEmitFile(struct netconn * newconn,struct fileHdrStruct * filehdr)
{
    _UL i;
    char content[MAX_LINE+1];

    for (i=0;i<filehdr->size;i++)
    {//检查是否有动态数据标签存在
        if (filedata[filehdr->fileStart+i] == '<')
        {
            if (!strncmp(&filedata[filehdr->fileStart+i+1],"DATA",4))
            {
                i+=6;//跳到变量起始位置<DATA x>
                memset(content,0,(MAX_LINE+1));
                getDynamicContent(&filedata[filehdr->fileStart+i],content);
                netconn_write(newconn, content, strlen(content), NETCONN_COPY);
                for (;filedata[filehdr->fileStart+i] != '>';i++)
                {
                    ;  
                }                    
            }
            else
            {
                netconn_write(newconn,&filedata[filehdr->fileStart+i], 1, NETCONN_COPY);
            }
        }
        else
        {
            netconn_write(newconn,&filedata[filehdr->fileStart+i], 1, NETCONN_COPY);
        }
    }
}

void getDynamicContent(char * name,char * content)
{
    _UL i,j;
#if 0
    if (!init)
    {
        initContent();
        init = 1;
    }
#endif
    for (j=0;j<MAX_DYNAMIC_CONTENT;j++)
    {
        for (i=0;name[i] != '>';i++)
        {
            if ( dynamicContent[j].variableName[i] != name[i] )
            {
                break;
            }
        }
        if (name[i] == '>')
        {
            strcpy(content,dynamicContent[j].pfunc());
            return;
        }
    }

    strcpy(content,defultFunction());
    return;
}

_UL callDynamicHander(char * name,char *content)
{
    return 0;
}
#if 0
_UL callDynamicHander(char * name,char *content)
{
    _UL j,found=0xFFFFFFFF;

    if (!init)
    {
        initContent();
        init = 1;
    }

    for (j=0;j<MAX_DYNAMIC_HANDLERS;j++)
    {
        if (!strncmp(name,dynamichandler[j].fileName))
        {
            dynamichandler[j].pfunc(content);
            found = 0;
            break;
        }
    }

    return found;
}

#endif
_UL lookupFilename(char * filename,struct fileHdrStruct *filehdr)
{
    _UL offset = 0;
    _UL size,i,found,ret;

    while(filedata[offset] != 0)
    {
        ret = offset;
        found = 1;

        if (  (filedata[offset]   == 0xFA)
            &&(filedata[offset+1] == 0xF3) )
        {//找到文件报头
        
            offset+=2;//跳转到文件名称
            for (i=0;filedata[offset+i] != 0;i++)
            {
                if (filename[i] != filedata[offset+i] )
                {
                    found = 0;
                }
            }
            
            offset += (i+1);
            size = (filedata[offset] << 24)
                  |(filedata[offset+1] << 16)
                  |(filedata[offset+2] << 8)
                  |(filedata[offset+3]);

            if (found)
            {
                filehdr->hdrStart = ret;
                filehdr->size     = size;
                filehdr->fileStart = (offset+4);
                emitByte(PREFIX_BYTE);
                emitByte(NOMAL_REQUEST);
                emitString(filename);
                emitByte(SUFFIX_BYTE);                
                return 1;                
            }

            offset += (size+4);
        }  
        else
        {
            offset++;
        }
    }

    return 0;
}

_UL addDynamicContent(char * name,char *(*function)())
{
    _UL i;

    #if 0
    if (!init)
    {
        initContent();
        init = 1;
    }
    #endif
    
    for (i=0;i<MAX_DYNAMIC_CONTENT;i++)
    {
        if ( dynamicContent[i].variableName[0] != 0)
        {
            if (!strcmp(name,dynamicContent[i].variableName))
            {
                return 0XFFFFFFFF;
            }
        }        
    }

    for (i=0;i<MAX_DYNAMIC_CONTENT;i++)
    {
        if ( dynamicContent[i].variableName[0] == 0)
        {
            strncpy(dynamicContent[i].variableName,name,80);
            dynamicContent[i].pfunc = function;
            break;
        }        
    }

    return 0;
}


_UL addDynamicHandler(char * name, char (* function)())
{
    _UL i;
    #if 0
    if (!init)
    {
        initContent();
        init = 1;
    }
    #endif
    for (i=0;i<MAX_DYNAMIC_HANDLERS;i++)
    {
        if ( dynamichandler[i].fileName[0] != 0)
        {
            if (!strcmp(name,dynamichandler[i].fileName))
            {
                return 0XFFFFFFFF;
            }
        }        
    }

    for (i=0;i<MAX_DYNAMIC_HANDLERS;i++)
    {
        if ( dynamichandler[i].fileName[0] == 0)
        {
            strncpy(dynamichandler[i].fileName,name,80);
            dynamichandler[i].pfunc = function;
        }   
        break;
    }

    return 0;
}

void emitByte(char byte)
{
    log[curWrite++] = byte;
    if (curWrite == MAX_LOG)
    {
        curWrite = 0;
    }    
}

void emitString(char * string)
{
    _UL i,len = strlen(string)+1;
    for (i=0;i<len;i++)
    {
        emitByte(string[i]);
    }
}

#if 0
void sendLog(struct netconn * newconn)
{
    _UL count = MAX_LOG;
    _UL i = curWrite;
    _UL state = HUNTING_PREFIX_HEADER;
    char curByte;
    char *logLine;

    const char *HTML_HDR1 ={"<HTML><HEAD><TITLE>log</TITLE></HEAD>"};
    const char *HTML_HDR2 ={"<BODY><H3>"};
    const char *HTML_HDR3 ={"</H3></BODY></HTML>\n"};

    i = curWrite;

    while(count > 0)
    {
        if (peekByte(&i) == PREFIX_BYTE)
        {
            break;
        }
        (void)getByte(&i;&count);
    }

    returnFileHeader(newconn,TEXT_HTML);

    netconn_write(newconn,HTML_HDR1, strlen(HTML_HDR1), NETCONN_COPY);
    netconn_write(newconn,HTML_HDR2, strlen(HTML_HDR2), NETCONN_COPY);

    while(count > 0)
    {
        if (state == HUNTING_PREFIX_HEADER)
        {
            if (getByte(&i;&count) == PREFIX_BYTE)
            {
                curByte = getByte(&i;&count);
                logLine = logStrings[(curByte & LOG_TYPE_MASK)].string;
                state   = EMIT_STRING;
                netconn_write(newconn,"\n",1, NETCONN_COPY);
            }
            else
            {
                break;
            }
        }
        else if (state == EMIT_STRING)
        {
            curByte = *logLine++;
            if (curByte == 0)
            {
                state = HUNTING_SUFFIX_HEADER;
            }
            else if(curByte == '^')
                {
                    state = EMIT_ARGUMENT;
                }
                else
                {
                    netconn_write(newconn,&curByte,1, NETCONN_COPY);
                }
        }
        else if (state == EMIT_ARGUMENT)
        {
            curByte = getByte(&i;&count);
            if (curByte == 0)
            {
                state = EMIT_STRING;
            }
            else
            {
                netconn_write(newconn,&curByte,1, NETCONN_COPY);
            }
        }
        else if (state == HUNTING_SUFFIX_HEADER)
        {
            if (getByte(&i;&count) == SUFFIX_BYTE)
            { 
                state = HUNTING_PREFIX_HEADER;
            }
            else
            {
                break;
            }
        }
    }
    
    netconn_write(newconn,HTML_HDR3, strlen(HTML_HDR3), NETCONN_COPY);
}
#endif
void sendLog(struct netconn * newconn)
{
   return;
}

_UL parseVariable(char * msgbody,char * variable,char * value)
{
    _UL i = 0;
    char * temmsgbody;

    temmsgbody = msgbody;
    //Uart_Printf("come into parseVariable /login\n");
     //Uart_Printf("come into %s /login\n",msgbody);
    temmsgbody = strstr(temmsgbody,variable);
    
    if (temmsgbody == NULL)
    {
        return 0xFFFFFFFF;
    }

    temmsgbody += strlen(variable)+1;
   //Uart_Printf("come into while /login\n");
  
    while((temmsgbody[i] != '&')&&(temmsgbody[i] != 0))
    {
         value[i] = temmsgbody[i];
         i++;
    }
    //Uart_Printf("cvalue %s\n",value);
    value[i] = 0;
    return 0;    
}
#endif