在家没事，写了个二进制数据替换函数

// BinReplace.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "string.h"
#include "stdlib.h"

#define OK 0
#define ERR 1

typedef unsigned char UCHAR ;
typedef char CHAR ;
typedef unsigned long ULONG;
typedef unsigned int UINT;

typedef struct tagLV{
    ULONG ullenth;
    UCHAR *pucValue;
}S_V_L;

void BinPrint(const UCHAR *pucBuf, ULONG ulLen)
{
    ULONG i;
    if (NULL == pucBuf && ulLen != 0)
    {
        printf("BinPrint error!\n");
        return;
    }
    printf("BinBuf:");

    for (i = 0; i < ulLen; i++)
    {
        printf("0x%x,", pucBuf[i]);
        if (0 == (i %16) && 0 != i)
        {
            printf("\r\n");
        }
    }
    printf("\r\n");

}

UCHAR *BinDup(UCHAR *pBuf, ULONG ulLength)
{
    UCHAR *pNew = NULL;

    if (NULL == pBuf)
    {
        return NULL;
    }

    pNew = (UCHAR *)malloc(ulLength);
    if (NULL == pNew)
    {
        printf("MyStrDum malloc error!\n");
        return NULL;
    }
    memset(pNew, 0x00, ulLength);
    memcpy(pNew, pBuf, ulLength);

    return pNew;
}


/* pstSource:原二进制数据。输入参数
    pstSub:要替换的二进制数据。输入参数
    pstRep:需替换对目的二进制数据。输入参数
    pstRtn:替换后返回的数据。为输出值,不需要外部开空间，本函数会自动分配空间，需外部手动释放空间
*/
ULONG BinReplace(S_V_L *pstSource,  S_V_L *pstSub,  S_V_L *pstRep, S_V_L **ppstRtn)
{
    ULONG ulNewStrLen = 0;
    ULONG ulNewTrueLen = 0;

    UCHAR *pucNewBin = NULL;
    UCHAR *p1,*p2,*p3; /* p1是pSource  指针，P2是pSub指针，P3是pRep指针 */
    UCHAR *p1_end,*p2_end,*p3_end; /* p1_end是pSource  指针最后，P2_end是pSub指针最后，P3_end是pRep指针最后 */
    UCHAR *p, *p_end, *pucNew;
     S_V_L *pstRtn = NULL;

    if (NULL == pstSource || NULL == ppstRtn)
    {
        printf("pSource is null!\r\n");
        return ERR;
    }

    pstRtn = (S_V_L *)malloc(sizeof(S_V_L));
    if (NULL == pstRtn)
    {
         printf("malloc error!\r\n");
        return ERR;
    }

    memset(pstRtn, 0x00, sizeof(S_V_L));
    *ppstRtn = pstRtn;


    /* 当字串为空/长度为0，或者替换字串为空/长度为0此替换都无意义，否则程序会异常 */
    if (NULL == pstSub || NULL == pstRep|| 0 == pstSub->ullenth || 0 == pstRep->ullenth)
    {
        printf("pstSub/pstRep is null!\r\n");
        pstRtn->ullenth = pstSource->ullenth;
        pstRtn->pucValue = BinDup(pstSource->pucValue, pstSource->ullenth);
        return OK;
    }

    /* 字串长度不能超过原字串长度，因为肯定匹配不上。 */
    if (pstSource->ullenth < pstSub->ullenth)
    {
        printf("ulSubStrLen is too long!\r\n");
        pstRtn->ullenth = pstSource->ullenth;
        pstRtn->pucValue = BinDup(pstSource->pucValue, pstSource->ullenth);
        return OK;
    }

    /* 计算被替换后的字符串最大长度 */
    ulNewStrLen = (pstSub->ullenth < pstRep->ullenth)?((pstSource->ullenth/pstSub->ullenth + 1) * pstRep->ullenth):pstSource->ullenth;


    pucNewBin = (UCHAR *)malloc(ulNewStrLen);
    if (NULL == pucNewBin)
    {
         printf("malloc error!\r\n");
        pstRtn->ullenth = pstSource->ullenth;
        pstRtn->pucValue = BinDup(pstSource->pucValue, pstSource->ullenth);
        return OK;
    }

    memset(pucNewBin, 0x00, ulNewStrLen);

    p = pstSource->pucValue;
    p_end = p + pstSource->ullenth;
    pucNew = pucNewBin;

    ulNewTrueLen = 0;
    while(p != p_end) /* 遍历原二进制数据 */
    {
        p1 = p;
        p1_end = p_end;

        p2 = pstSub->pucValue;
        p2_end = p2 + pstSub->ullenth;

        p3 = pstRep->pucValue;
        p3_end = p3 + pstRep->ullenth;

        while((p1 < p1_end) && (p2 < p2_end) && (*p1 == *p2))  /* 找到相等的二进制数据 */
        {
            p1++;
            p2++;
        }

        if (p2 == p2_end) /* 如果完全匹配 */
        {
            while(p3 != p3_end)/*复制替换二进制数据*/
            {
                *pucNew = *p3;
                p3++;
                pucNew++;
                ulNewTrueLen++;
            }
            p1--;/*匹配完了多走了一个位置，应该回来*/
            p = p1;
        }
        else
        {
            *pucNew = *p;
            pucNew++;
            ulNewTrueLen++;
        }
        p++;
    }

    pstRtn->pucValue = pucNewBin;
    pstRtn->ullenth = ulNewTrueLen;
    *ppstRtn = pstRtn;
    return OK;

}



int main(int argc, char* argv[])
{
    UCHAR pSource[] = {1,2,3,3,3,4,4,5,3,3,4};
    UCHAR pstSub[] = {3,3};
    UCHAR pstRep[] = {0x0a,0x0a,0x0b};
    S_V_L stSource;
    S_V_L stSub;
    S_V_L stRep;
    S_V_L *p = NULL;
    ULONG ulRtn = ERR;

    memset(&stSource, 0, sizeof(S_V_L));
    stSource.ullenth = 11;
    stSource.pucValue = pSource;

    memset(&stSub, 0, sizeof(S_V_L));
    stSub.ullenth = 2;
    stSub.pucValue = pstSub;

    memset(&stRep, 0, sizeof(S_V_L));
    stRep.ullenth = 3;
    stRep.pucValue = pstRep;


    ulRtn= BinReplace(&stSource, &stSub, &stRep, &p);
    if (ulRtn != OK)
    {
        printf("BinReplace error\n");
        return ERR;
    }
    printf("source=\n");
    BinPrint(stSource.pucValue, 11);

    printf("sub = \n");
    BinPrint(stSub.pucValue, 2);

    printf("pstRep = \n");
    BinPrint(stRep.pucValue, 3);

    printf("replaced len:%d,string = ",p->ullenth, p);
    BinPrint(p->pucValue, p->ullenth);

    if (NULL != p)
    {
        if (NULL != p->pucValue)
            free(p->pucValue);
        free(p);
    }
    else
    {
        printf("replace error!\n");
    }
    return 0;
}