臃肿的代码

最新推荐文章于 2022-11-04 19:45:15 发布
最新推荐文章于 2022-11-04 19:45:15 发布
阅读量1.2k 收藏
点赞数
文章标签： null winapi struct dll makefile api

 



// burn_ht2008.cpp : Defines the entry point for the DLL application.
//

#include "stdafx.h"
#include "burn_ht2008.h"
#include <iostream.h>
#include <winsock.h>
#include <windowsx.h>
#include <stdio.h>
#include "icmpdefs.h"
#include <windows.h>
#include <process.h>
#include "SocketRx.h"
#include "SocketDx.h"
#include "SocketTx.h"
#include <conio.h>
#include <assert.h>
#include <stdlib.h>

#include   "Iphlpapi.h"  
#pragma   comment(lib,"iphlpapi")  
#pragma   comment(lib,"ws2_32.lib")  
#define   winsock_version   0x0202

#define IPPORT_TELNET_MA 2323
#define IPPORT_DEFAULT_TELNET 23

char strIP[20] = "192.168.2.2";         <------------------------------ 问题1
char strIP2[20] = "192.168.2.19";
char strIP3[20] = "192.168.2.36";
char strIP4[20] = "192.168.2.53";
char strIP5[20] = "192.168.2.70";
char strIP6[20] = "192.168.2.87";
char strIP7[20] = "192.168.2.104";
char strIP8[20] = "192.168.2.121";
char strIP9[20] = "192.168.2.138";
char strIP10[20] = "192.168.2.155";
char strIP11[20] = "192.168.2.172";
char strIP12[20] = "192.168.2.189";
char strIP13[20] = "192.168.2.206";
char strIP14[20] = "192.168.2.223";
char strIP15[20] = "192.168.2.240";

int  nPort = IPPORT_TELNET_MA;    //port 2323
int     nDefaultPort = IPPORT_DEFAULT_TELNET;   //default 23

BOOL fOver1 = TRUE;
BOOL fMac = FALSE;
BOOL fFirstTime = TRUE;
extern bool flagAlready;
extern bool fConfig;
extern bool fError;

HANDLE hThreadPing[15];
WSAData wsaData;
DHCPUserInfo burninfo;
HINSTANCE hIcmp = LoadLibrary("ICMP.DLL");

typedef struct tagThreadData
{
    char    strIPTh[20];
    char*   mcid;
    PIP_ECHO_REPLY_PING perp;
}THREADDATA;

typedef struct  
{
    char mcid[9];
    char ip[16];
}STBINFO;
STBINFO stb_info[10];
int stb_num;

THREADDATA TD[15];

#define vsnprintf _vsnprintf
#define snprintf  _snprintf
static int getTimeStr (char *asctimeBuf)
{
#if 1
    struct tm *newtime;
    time_t aclock;
   
    time( &aclock );   // Get time in seconds
    newtime = localtime( &aclock );   // Convert time to struct tm form
   
    strcpy(asctimeBuf, asctime(newtime));
    asctimeBuf[strlen(asctimeBuf) - 1] = '/0';
#else
    slogToFile(asctimeBuf, "XXX");
#endif
    return 0;
}
static void do_log(const char *fmt, va_list args)
{
    char tStr[80];
    char *msgbuf;
    char *fmtbuf;
#define LOG_MSG_BUF 512
    fmtbuf = (char *)malloc(LOG_MSG_BUF * 2);
    msgbuf = fmtbuf + LOG_MSG_BUF;
    assert(msgbuf);
    assert(fmtbuf);
    getTimeStr(tStr);
    snprintf(fmtbuf, LOG_MSG_BUF, "[%s]: %s", tStr, fmt);
    vsnprintf(msgbuf, LOG_MSG_BUF, fmtbuf, args);
   
    FILE *fp = fopen(".//error.log", "a");
    if (fp == NULL)
    {
        fprintf(stderr, msgbuf);
    }
    else
    {
        fprintf(fp, msgbuf);
        fclose(fp);
    }
   
    free(fmtbuf);
}

void logToFile(char *fmt, ...)
{
    va_list args;
   
    va_start(args, fmt);
    do_log(fmt, args);
    va_end(args);
}

BOOL APIENTRY DllMain( HANDLE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{   
    return TRUE;
}

UINT macIP(char* IP, char *mac_buf)
{
    IPAddr   ipdest;  
    ipdest = inet_addr(IP);
    ULONG  umac = 0;
    ULONG  ulen = 8;  
    char   buf[256];  
    char   bufint[6][3];
    ZeroMemory(buf,256);
    ZeroMemory(bufint,18);
   
    //发送ARP查询包获得远程MAC地址
    if (NO_ERROR != SendARP(ipdest,0,(PULONG)buf,&ulen))  
    {  
        LPVOID   lpMsgBuf;  
        FormatMessage(   
            FORMAT_MESSAGE_ALLOCATE_BUFFER   |   
            FORMAT_MESSAGE_FROM_SYSTEM   |   
            FORMAT_MESSAGE_IGNORE_INSERTS,  
            NULL,  
            WSAGetLastError(),  
            MAKELANGID(LANG_NEUTRAL,   SUBLANG_DEFAULT),   //   Default   language  
            (LPTSTR)   &lpMsgBuf,  
            0,  
            NULL   
            );  
        logToFile("%s/n",(LPCTSTR)lpMsgBuf);
        logToFile("%s/n",(LPCTSTR)lpMsgBuf);
        LocalFree(lpMsgBuf);  
    }  
    else  
    {  
        ...
    }
    return 0;
}

/*ip分成4个数*/
unsigned long __fastcall InvertIp(unsigned long NormalIp)   
{   
    unsigned char b1,b2,b3,b4;   
   
    b1 = (unsigned char)NormalIp & 0x00FF;   
    b2 = (unsigned char)(NormalIp >> 8) & 0x00FF;   
    b3 = (unsigned char)(NormalIp >> 16) & 0x00FF;   
    b4 = (unsigned char)(NormalIp >> 24) & 0x00FF;   
    return (b1 <<24) | (b2 << 16) | (b3 << 8) | b4;   
}  


UINT ThreadPing(char* IP, PIP_ECHO_REPLY_PING pIpe, char* mac_buf)
{   
    // 装载ICMP.DLL连接库
    if (hIcmp == 0)
    {
        cerr << "Unable to locate ICMP.DLL!" << endl;
        return 1 ;
    }
   
    // 定义函数三个指针类型
    typedef HANDLE (WINAPI* pfnHV)(VOID);
    typedef BOOL (WINAPI* pfnBH)(HANDLE);
    typedef DWORD (WINAPI* pfnDHDPWPipPDD)(HANDLE, DWORD, LPVOID, WORD,PIP_OPTION_INFORMATION_PING, LPVOID, DWORD, DWORD); // evil, no?
   
    //定义三个指针函数
    pfnHV pIcmpCreateFile;
    pfnBH pIcmpCloseHandle;
    pfnDHDPWPipPDD pIcmpSendEcho;
   
    //从ICMP.DLL中得到函数入口地址
    pIcmpCreateFile = (pfnHV)GetProcAddress(hIcmp, "IcmpCreateFile");
    pIcmpCloseHandle = (pfnBH)GetProcAddress(hIcmp, "IcmpCloseHandle");
    pIcmpSendEcho = (pfnDHDPWPipPDD)GetProcAddress(hIcmp, "IcmpSendEcho");
   
    if ((pIcmpCreateFile == 0) || (pIcmpCloseHandle == 0) || (pIcmpSendEcho == 0))
    {
        cerr << "Failed to get proc addr for function." << endl;
        return 3 ;
    }
   
    // 打开ping服务
    HANDLE hIP = pIcmpCreateFile();
    if (hIP == INVALID_HANDLE_VALUE)   
    {
        cerr << "Unable to open ping service." << endl;
        return 4;
    }
   
    // 构造ping数据包
    char acPingBuffer[64];
    memset(acPingBuffer, '/xAA', sizeof(acPingBuffer));

    pIpe->Data = acPingBuffer;
    pIpe->DataSize = sizeof(acPingBuffer);
   
    // 发送ping数据包
    DWORD dwStatus = pIcmpSendEcho(hIP, inet_addr(IP), acPingBuffer, sizeof(acPingBuffer), NULL, pIpe, sizeof(IP_ECHO_REPLY_PING) + sizeof(acPingBuffer), 100);
    if (dwStatus != 0)
    {
        macIP(IP, mac_buf);
        fOver1 = FALSE;
    }
    else
    {
        return -1;
    }

    return 0;
}

//Multithreading ping
UINT ThreadPingStart1(LPVOID lpParam)                               <------------------------------ 问题2
{
    THREADDATA*    pData = (THREADDATA*)lpParam;
    char PingIP[16];
    strcpy(PingIP, pData->strIPTh);
    int i = 0;
    in_addr   ia;
    unsigned   long   FirstIp;
    while(1)
    {
        FirstIp = inet_addr(PingIP);
        FirstIp = InvertIp(FirstIp);
        ia.S_un.S_addr = InvertIp(++FirstIp);
        ThreadPing(PingIP, pData->perp, pData->mcid);
        for(;;)
        {
            if(fOver1)
            {
                break;
            }
            else
                Sleep(1000);
        }


        i++;
        if (i != 17)
            strcpy(PingIP ,inet_ntoa(ia));
        else
        {   
            i = 0;
            strcpy(PingIP, "192.168.2.2");
        }
    }
    return 0;
}

UINT ThreadPingStart2(LPVOID lpParam)
{
    THREADDATA*    pData = (THREADDATA*)lpParam;
    char PingIP[16];
    strcpy(PingIP, pData->strIPTh);
    int i = 0;
    in_addr   ia;
    unsigned   long   FirstIp;
    while(1)
    {
        FirstIp = inet_addr(PingIP);
        FirstIp = InvertIp(FirstIp);
        ia.S_un.S_addr = InvertIp(++FirstIp);
        ThreadPing(PingIP, pData->perp, pData->mcid);
        for(;;)
        {
            if(fOver1)
            {
                break;
            }
            else
                Sleep(1000);
        }
        i++;
        if (i != 17)
            strcpy(PingIP ,inet_ntoa(ia));
        else
        {   
            i = 0;
            strcpy(PingIP, "192.168.2.19");
        }
    }
    return 0;
}
UINT ThreadPingStart3(LPVOID lpParam)
{
    THREADDATA*    pData = (THREADDATA*)lpParam;
    char PingIP[16];
    strcpy(PingIP, pData->strIPTh);
    int i = 0;
    in_addr   ia;
    unsigned   long   FirstIp;

    while(1)
    {
        FirstIp = inet_addr(PingIP);
        FirstIp = InvertIp(FirstIp);
        ia.S_un.S_addr = InvertIp(++FirstIp);
        ThreadPing(PingIP, pData->perp, pData->mcid);
        for(;;)
        {
            if(fOver1)
            {
                break;
            }
            else
                Sleep(1000);
        }
        i++;
        if (i != 17)
            strcpy(PingIP ,inet_ntoa(ia));
        else
        {   
            i = 0;
            strcpy(PingIP, "192.168.2.36");
        }
    }
    return 0;
}
UINT ThreadPingStart4(LPVOID lpParam)
{
    THREADDATA*    pData = (THREADDATA*)lpParam;
    char PingIP[16];
    strcpy(PingIP, pData->strIPTh);
    int i = 0;
    in_addr   ia;
    unsigned   long   FirstIp;


    while(1)
    {
        FirstIp = inet_addr(PingIP);
        FirstIp = InvertIp(FirstIp);
        ia.S_un.S_addr = InvertIp(++FirstIp);
        ThreadPing(PingIP, pData->perp, pData->mcid);
        for(;;)
        {
            if(fOver1)
            {
                break;
            }
            else
                Sleep(1000);
        }
        i++;
        if (i != 17)
            strcpy(PingIP ,inet_ntoa(ia));
        else
        {   
            i = 0;
            strcpy(PingIP, "192.168.2.53");
        }
    }
    return 0;
}
UINT ThreadPingStart5(LPVOID lpParam)
{
    THREADDATA*    pData = (THREADDATA*)lpParam;
    char PingIP[16];
    strcpy(PingIP, pData->strIPTh);
    int i = 0;
    in_addr   ia;
    unsigned   long   FirstIp;


    while(1)
    {
        FirstIp = inet_addr(PingIP);
        FirstIp = InvertIp(FirstIp);
        ia.S_un.S_addr = InvertIp(++FirstIp);
        ThreadPing(PingIP, pData->perp, pData->mcid);
        for(;;)
        {
            if(fOver1)
            {
                break;
            }
            else
                Sleep(1000);
        }
        i++;
        if (i != 17)
            strcpy(PingIP ,inet_ntoa(ia));
        else
        {   
            i = 0;
            strcpy(PingIP, "192.168.2.70");
        }
    }
    return 0;
}
UINT ThreadPingStart6(LPVOID lpParam)
{
    THREADDATA*    pData = (THREADDATA*)lpParam;
    char PingIP[16];
    strcpy(PingIP, pData->strIPTh);
    int i = 0;
    in_addr   ia;
    unsigned   long   FirstIp;


    while(1)
    {
        FirstIp = inet_addr(PingIP);
        FirstIp = InvertIp(FirstIp);
        ia.S_un.S_addr = InvertIp(++FirstIp);
        ThreadPing(PingIP, pData->perp, pData->mcid);
        for(;;)
        {
            if(fOver1)
            {
                break;
            }
            else
                Sleep(1000);
        }
        i++;
        if (i != 17)
            strcpy(PingIP ,inet_ntoa(ia));
        else
        {   
            i = 0;
            strcpy(PingIP, "192.168.2.87");
        }
    }
    return 0;
}
UINT ThreadPingStart7(LPVOID lpParam)
{
    THREADDATA*    pData = (THREADDATA*)lpParam;
    char PingIP[16];
    strcpy(PingIP, pData->strIPTh);
    int i = 0;
    in_addr   ia;
    unsigned   long   FirstIp;


    while(1)
    {
        FirstIp = inet_addr(PingIP);
        FirstIp = InvertIp(FirstIp);
        ia.S_un.S_addr = InvertIp(++FirstIp);
        ThreadPing(PingIP, pData->perp, pData->mcid);
        for(;;)
        {
            if(fOver1)
            {
                break;
            }
            else
                Sleep(1000);
        }
        i++;
        if (i != 17)
            strcpy(PingIP ,inet_ntoa(ia));
        else
        {   
            i = 0;
            strcpy(PingIP, "192.168.2.104");
        }
    }
    return 0;
}
UINT ThreadPingStart8(LPVOID lpParam)
{
    THREADDATA*    pData = (THREADDATA*)lpParam;
    char PingIP[16];
    strcpy(PingIP, pData->strIPTh);
    int i = 0;
    in_addr   ia;
    unsigned   long   FirstIp;


    while(1)
    {
        FirstIp = inet_addr(PingIP);
        FirstIp = InvertIp(FirstIp);
        ia.S_un.S_addr = InvertIp(++FirstIp);
        ThreadPing(PingIP, pData->perp, pData->mcid);
        for(;;)
        {
            if(fOver1)
            {
                break;
            }
            else
                Sleep(1000);
        }
        i++;
        if (i != 17)
            strcpy(PingIP ,inet_ntoa(ia));
        else
        {   
            i = 0;
            strcpy(PingIP, "192.168.2.121");
        }
    }
    return 0;
}
UINT ThreadPingStart9(LPVOID lpParam)
{
    THREADDATA*    pData = (THREADDATA*)lpParam;
    char PingIP[16];
    strcpy(PingIP, pData->strIPTh);
    int i = 0;
    in_addr   ia;
    unsigned   long   FirstIp;


    while(1)
    {
        FirstIp = inet_addr(PingIP);
        FirstIp = InvertIp(FirstIp);
        ia.S_un.S_addr = InvertIp(++FirstIp);
        ThreadPing(PingIP, pData->perp, pData->mcid);
        for(;;)
        {
            if(fOver1)
            {
                break;
            }
            else
                Sleep(1000);
        }
        i++;
        if (i != 17)
            strcpy(PingIP ,inet_ntoa(ia));
        else
        {   
            i = 0;
            strcpy(PingIP, "192.168.2.138");
        }
    }
    return 0;
}
UINT ThreadPingStart10(LPVOID lpParam)
{
    THREADDATA*    pData = (THREADDATA*)lpParam;
    char PingIP[16];
    strcpy(PingIP, pData->strIPTh);
    int i = 0;
    in_addr   ia;
    unsigned   long   FirstIp;

    while(1)
    {
        FirstIp = inet_addr(PingIP);
        FirstIp = InvertIp(FirstIp);
        ia.S_un.S_addr = InvertIp(++FirstIp);
        ThreadPing(PingIP, pData->perp, pData->mcid);
        for(;;)
        {
            if(fOver1)
            {
                break;
            }
            else
                Sleep(1000);
        }
        i++;
        if (i != 17)
            strcpy(PingIP ,inet_ntoa(ia));
        else
        {   
            i = 0;
            strcpy(PingIP, "192.168.2.155");
        }
    }
    return 0;
}
UINT ThreadPingStart11(LPVOID lpParam)
{
    THREADDATA*    pData = (THREADDATA*)lpParam;
    char PingIP[16];
    strcpy(PingIP, pData->strIPTh);
    int i = 0;
    in_addr   ia;
    unsigned   long   FirstIp;

    while(1)
    {
        FirstIp = inet_addr(PingIP);
        FirstIp = InvertIp(FirstIp);
        ia.S_un.S_addr = InvertIp(++FirstIp);
        ThreadPing(PingIP, pData->perp, pData->mcid);
        for(;;)
        {
            if(fOver1)
            {
                break;
            }
            else
                Sleep(1000);
        }
        i++;
        if (i != 17)
            strcpy(PingIP ,inet_ntoa(ia));
        else
        {   
            i = 0;
            strcpy(PingIP, "192.168.2.172");
        }
    }
    return 0;
}
UINT ThreadPingStart12(LPVOID lpParam)
{
    THREADDATA*    pData = (THREADDATA*)lpParam;
    char PingIP[16];
    strcpy(PingIP, pData->strIPTh);
    int i = 0;
    in_addr   ia;
    unsigned   long   FirstIp;

    while(1)
    {
        FirstIp = inet_addr(PingIP);
        FirstIp = InvertIp(FirstIp);
        ia.S_un.S_addr = InvertIp(++FirstIp);
        ThreadPing(PingIP, pData->perp, pData->mcid);
        for(;;)
        {
            if(fOver1)
            {
                break;
            }
            else
            {
                Sleep(1000);
            }
        }
        i++;
        if (i != 17)
            strcpy(PingIP ,inet_ntoa(ia));
        else
        {   
            i = 0;
            strcpy(PingIP, "192.168.2.189");
        }
    }
    return 0;
}
UINT ThreadPingStart13(LPVOID lpParam)
{
    THREADDATA*    pData = (THREADDATA*)lpParam;
    char PingIP[16];
    strcpy(PingIP, pData->strIPTh);
    int i = 0;
    in_addr   ia;
    unsigned   long   FirstIp;


    while(1)
    {
        FirstIp = inet_addr(PingIP);
        FirstIp = InvertIp(FirstIp);
        ia.S_un.S_addr = InvertIp(++FirstIp);
        ThreadPing(PingIP, pData->perp, pData->mcid);
        for(;;)
        {
            if(fOver1)
            {
                break;
            }
            else
                Sleep(1000);
        }
        i++;
        if (i != 17)
            strcpy(PingIP ,inet_ntoa(ia));
        else
        {   
            i = 0;
            strcpy(PingIP, "192.168.2.206");
        }
    }


    return 0;
}
UINT ThreadPingStart14(LPVOID lpParam)
{
    THREADDATA*    pData = (THREADDATA*)lpParam;
    char PingIP[16];
    strcpy(PingIP, pData->strIPTh);
    int i = 0;
    in_addr   ia;
    unsigned   long   FirstIp;
//    logToFile("pData->mcid=%p/n", pData->mcid);
    while(1)
    {
        FirstIp = inet_addr(PingIP);
        FirstIp = InvertIp(FirstIp);
        ia.S_un.S_addr = InvertIp(++FirstIp);
        ThreadPing(PingIP, pData->perp, pData->mcid);
        for(;;)
        {
            if(fOver1)
            {
                break;
            }
            else
                Sleep(1000);
        }
        i++;
        if (i != 17)
            strcpy(PingIP ,inet_ntoa(ia));
        else
        {   
            i = 0;
            strcpy(PingIP, "192.168.2.223");
        }
    }
    return 0;
}
UINT ThreadPingStart15(LPVOID lpParam)
{
    THREADDATA*    pData = (THREADDATA*)lpParam;
    char PingIP[16];
    strcpy(PingIP, pData->strIPTh);
    int i = 0;
    in_addr   ia;
    unsigned   long   FirstIp;

    while(1)
    {
        FirstIp = inet_addr(PingIP);
        FirstIp = InvertIp(FirstIp);
        ia.S_un.S_addr = InvertIp(++FirstIp);
        ThreadPing(PingIP, pData->perp, pData->mcid);
        for(;;)
        {
            if(fOver1)
            {
                break;
            }
            else
                Sleep(1000);
        }
        i++;
        if (i != 15)
            strcpy(PingIP ,inet_ntoa(ia));
        else
        {   
            i = 0;
            strcpy(PingIP, "192.168.2.240");
        }
    }
    return 0;
}

BURN_DLL_API void HT_InitBurn()
{   
    unsigned int id1;               <------------------------------ 问题3
    unsigned int id2;
    unsigned int id3;
    unsigned int id4;
    unsigned int id5;
    unsigned int id6;
    unsigned int id7;
    unsigned int id8;
    unsigned int id9;
    unsigned int id10;
    unsigned int id11;
    unsigned int id12;
    unsigned int id13;
    unsigned int id14;
    unsigned int id15;
   
   
    if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0)
    {
        exit(0);
    }
    strcpy(TD[0].strIPTh, strIP);              <------------------------------ 问题4
    strcpy(TD[1].strIPTh, strIP2);
    strcpy(TD[2].strIPTh, strIP3);
    strcpy(TD[3].strIPTh, strIP4);
    strcpy(TD[4].strIPTh, strIP5);
    strcpy(TD[5].strIPTh, strIP6);
    strcpy(TD[6].strIPTh, strIP7);
    strcpy(TD[7].strIPTh, strIP8);
    strcpy(TD[8].strIPTh, strIP9);
    strcpy(TD[9].strIPTh, strIP10);
    strcpy(TD[10].strIPTh, strIP11);
    strcpy(TD[11].strIPTh, strIP12);
    strcpy(TD[12].strIPTh, strIP13);
    strcpy(TD[13].strIPTh, strIP14);
    strcpy(TD[14].strIPTh, strIP15);

<------------------------------ 问题5
    TD[0].perp = (PIP_ECHO_REPLY_PING)GlobalAlloc( GMEM_FIXED | GMEM_ZEROINIT,sizeof(PIP_ECHO_REPLY_PING) + 64);
    TD[1].perp = (PIP_ECHO_REPLY_PING)GlobalAlloc( GMEM_FIXED | GMEM_ZEROINIT,sizeof(PIP_ECHO_REPLY_PING) + 64);
    TD[2].perp = (PIP_ECHO_REPLY_PING)GlobalAlloc( GMEM_FIXED | GMEM_ZEROINIT,sizeof(PIP_ECHO_REPLY_PING) + 64);
    TD[3].perp = (PIP_ECHO_REPLY_PING)GlobalAlloc( GMEM_FIXED | GMEM_ZEROINIT,sizeof(PIP_ECHO_REPLY_PING) + 64);
    TD[4].perp = (PIP_ECHO_REPLY_PING)GlobalAlloc( GMEM_FIXED | GMEM_ZEROINIT,sizeof(PIP_ECHO_REPLY_PING) + 64);
    TD[5].perp = (PIP_ECHO_REPLY_PING)GlobalAlloc( GMEM_FIXED | GMEM_ZEROINIT,sizeof(PIP_ECHO_REPLY_PING) + 64);
    TD[6].perp = (PIP_ECHO_REPLY_PING)GlobalAlloc( GMEM_FIXED | GMEM_ZEROINIT,sizeof(PIP_ECHO_REPLY_PING) + 64);
    TD[7].perp = (PIP_ECHO_REPLY_PING)GlobalAlloc( GMEM_FIXED | GMEM_ZEROINIT,sizeof(PIP_ECHO_REPLY_PING) + 64);
    TD[8].perp = (PIP_ECHO_REPLY_PING)GlobalAlloc( GMEM_FIXED | GMEM_ZEROINIT,sizeof(PIP_ECHO_REPLY_PING) + 64);
    TD[9].perp = (PIP_ECHO_REPLY_PING)GlobalAlloc( GMEM_FIXED | GMEM_ZEROINIT,sizeof(PIP_ECHO_REPLY_PING) + 64);
    TD[10].perp = (PIP_ECHO_REPLY_PING)GlobalAlloc( GMEM_FIXED | GMEM_ZEROINIT,sizeof(PIP_ECHO_REPLY_PING) + 64);
    TD[11].perp = (PIP_ECHO_REPLY_PING)GlobalAlloc( GMEM_FIXED | GMEM_ZEROINIT,sizeof(PIP_ECHO_REPLY_PING) + 64);
    TD[12].perp = (PIP_ECHO_REPLY_PING)GlobalAlloc( GMEM_FIXED | GMEM_ZEROINIT,sizeof(PIP_ECHO_REPLY_PING) + 64);
    TD[13].perp = (PIP_ECHO_REPLY_PING)GlobalAlloc( GMEM_FIXED | GMEM_ZEROINIT,sizeof(PIP_ECHO_REPLY_PING) + 64);
    TD[14].perp = (PIP_ECHO_REPLY_PING)GlobalAlloc( GMEM_FIXED | GMEM_ZEROINIT,sizeof(PIP_ECHO_REPLY_PING) + 64);
   
<------------------------------ 问题6
   hThreadPing[0] = (HANDLE)_beginthreadex( NULL,   
        0,
        (unsigned int (__stdcall *)(void *))ThreadPingStart1,
        (void *)&TD[0],
        CREATE_SUSPENDED,
        &id1);
    hThreadPing[1] = (HANDLE)_beginthreadex( NULL,   
        0,
        (unsigned int (__stdcall *)(void *))ThreadPingStart2,
        (void *)&TD[1],
        CREATE_SUSPENDED,
        &id2);
    hThreadPing[2] = (HANDLE)_beginthreadex( NULL,   
        0,
        (unsigned int (__stdcall *)(void *))ThreadPingStart3,
        (void *)&TD[2],
        CREATE_SUSPENDED,
        &id3);
    hThreadPing[3] = (HANDLE)_beginthreadex( NULL,   
        0,
        (unsigned int (__stdcall *)(void *))ThreadPingStart4,
        (void *)&TD[3],
        CREATE_SUSPENDED,
        &id4);
    hThreadPing[4] = (HANDLE)_beginthreadex( NULL,   
        0,
        (unsigned int (__stdcall *)(void *))ThreadPingStart5,
        (void *)&TD[4],
        CREATE_SUSPENDED,
        &id5);
    hThreadPing[5] = (HANDLE)_beginthreadex( NULL,   
        0,
        (unsigned int (__stdcall *)(void *))ThreadPingStart6,
        (void *)&TD[5],
        CREATE_SUSPENDED,
        &id6);
    hThreadPing[6] = (HANDLE)_beginthreadex( NULL,   
        0,
        (unsigned int (__stdcall *)(void *))ThreadPingStart7,
        (void *)&TD[6],
        CREATE_SUSPENDED,
        &id7);
    hThreadPing[7] = (HANDLE)_beginthreadex( NULL,   
        0,
        (unsigned int (__stdcall *)(void *))ThreadPingStart8,
        (void *)&TD[7],
        CREATE_SUSPENDED,
        &id8);
    hThreadPing[8] = (HANDLE)_beginthreadex( NULL,   
        0,
        (unsigned int (__stdcall *)(void *))ThreadPingStart9,
        (void *)&TD[8],
        CREATE_SUSPENDED,
        &id9);
    hThreadPing[9] = (HANDLE)_beginthreadex( NULL,   
        0,
        (unsigned int (__stdcall *)(void *))ThreadPingStart10,
        (void *)&TD[9],
        CREATE_SUSPENDED,
        &id10);
    hThreadPing[10] = (HANDLE)_beginthreadex( NULL,   
        0,
        (unsigned int (__stdcall *)(void *))ThreadPingStart11,
        (void *)&TD[10],
        CREATE_SUSPENDED,
        &id11);
    hThreadPing[11] = (HANDLE)_beginthreadex( NULL,   
        0,
        (unsigned int (__stdcall *)(void *))ThreadPingStart12,
        (void *)&TD[11],
        CREATE_SUSPENDED,
        &id12);
    hThreadPing[12] = (HANDLE)_beginthreadex( NULL,   
        0,
        (unsigned int (__stdcall *)(void *))ThreadPingStart13,
        (void *)&TD[12],
        CREATE_SUSPENDED,
        &id13);
    hThreadPing[13] = (HANDLE)_beginthreadex( NULL,   
        0,
        (unsigned int (__stdcall *)(void *))ThreadPingStart14,
        (void *)&TD[13],
        CREATE_SUSPENDED,
        &id14);
    hThreadPing[14] = (HANDLE)_beginthreadex( NULL,   
        0,
        (unsigned int (__stdcall *)(void *))ThreadPingStart15,
        (void *)&TD[14],
        CREATE_SUSPENDED,
        &id15);
}

BURN_DLL_API bool HT_GetMCID(char* mcid)
{
    int tTime = 0;
    if (stb_num == 9)
        stb_num = 0;
    fOver1 = TRUE;

   TD[0].mcid = mcid;                 <------------------------------ 问题7
    TD[1].mcid = mcid;
    TD[2].mcid = mcid;
    TD[3].mcid = mcid;
    TD[4].mcid = mcid;
    TD[5].mcid = mcid;
    TD[6].mcid = mcid;
    TD[7].mcid = mcid;
    TD[8].mcid = mcid;
    TD[9].mcid = mcid;
    TD[10].mcid = mcid;
    TD[11].mcid = mcid;
    TD[12].mcid = mcid;
    TD[13].mcid = mcid;
    TD[14].mcid = mcid;
//    logToFile("===burn %p/n", TD[13].mcid);
    if (fFirstTime)
    {
        ResumeThread(hThreadPing[0]);                   <------------------------------ 问题8
        ResumeThread(hThreadPing[1]);
        ResumeThread(hThreadPing[2]);
        ResumeThread(hThreadPing[3]);
        ResumeThread(hThreadPing[4]);
        ResumeThread(hThreadPing[5]);
        ResumeThread(hThreadPing[6]);
        ResumeThread(hThreadPing[7]);
        ResumeThread(hThreadPing[8]);
        ResumeThread(hThreadPing[9]);
        ResumeThread(hThreadPing[10]);
        ResumeThread(hThreadPing[11]);
        ResumeThread(hThreadPing[12]);
        ResumeThread(hThreadPing[13]);
        ResumeThread(hThreadPing[14]);
        fFirstTime = FALSE;
    }

    for(;;)
    {
        if (fMac)
        {
            fMac = FALSE;
            return TRUE;
        }
        else
        {
            tTime++;
            if (tTime == 25)
            {
                fOver1 = FALSE;
                return FALSE;
            }
            Sleep(1000);
        }
    }
}

BURN_DLL_API int HT_Burn(DHCPUserInfo *duserinfo)
{
    SOCKET hSocket;
    HANDLE hThread[2];
    int port;
    char telnetIP[16];

   
    strcpy(burninfo.userid, duserinfo->userid);
    strcpy(burninfo.userpin, duserinfo->userpin);
    burninfo.nettype = duserinfo->nettype;
    strcpy(burninfo.domain, duserinfo->domain);
    strcpy(burninfo.dns1, duserinfo->dns1);
    strcpy(burninfo.dns2, duserinfo->dns2);
    if (burninfo.nettype == 2)
    {
        strcpy(burninfo.pppoe_username, duserinfo->pppoe_username);
        strcpy(burninfo.pppoe_password, duserinfo->pppoe_password);
        if ((strlen(burninfo.pppoe_username) == 0) || (strlen(burninfo.pppoe_password) == 0))
        {   
            return 200;
        }
    }
    else if(burninfo.nettype == 3)
    {
        strcpy(burninfo.static_ip, duserinfo->static_ip);
        strcpy(burninfo.static_submark, duserinfo->static_submark);
        strcpy(burninfo.static_gateway, duserinfo->static_gateway);
        strcpy(burninfo.static_dns1, duserinfo->static_dns1);
        strcpy(burninfo.static_dns2, duserinfo->static_dns2);
        if ((strlen(burninfo.static_ip) == 0) ||
            (strlen(burninfo.static_submark) == 0) ||
            (strlen(burninfo.static_gateway) == 0) ||
            (strlen(burninfo.static_dns1) == 0) )
        {   
            return 200;
        }
    }
    fOver1 = FALSE;

    /*判断字段*/
    if ((strlen(burninfo.domain) == 0) || (strlen(burninfo.userid) == 0) ||
        (strlen(burninfo.userpin) == 0) || (burninfo.nettype == 0))
    {   
        return 200;
    }

    for (int i = 0; i < stb_num; i++)
    {
       ...
    }
    if (i == stb_num)
    {
        logToFile("find failed %d/n", stb_num);
        return 203;
    }
    for (int j = 0; j < 2; j++)
    {        
        if (flagAlready)
        {
            port = nDefaultPort;
        }
        else
        {
            port = nPort;
        }
        flagAlready = false;

        CSocketDx    SocketDx(telnetIP, port);

        hSocket = SocketDx.TelnetConnect();
        if (hSocket == NULL)
        {
            logToFile("Unable To Connect/n");
            return 201;
        }
        
        CSocketRx    SocketRx(hSocket, hThread[0]);
        CSocketTx    SocketTx(hSocket, hThread[1]);
        
        WaitForMultipleObjects(2, hThread, FALSE, INFINITE);
        Sleep(1000);
        if (fError)
        {
            fError = FALSE;
            return 205;
        }

        if (fConfig)
        {
            fConfig = FALSE;
            return 204;
        }
    }   
//    logToFile(" To Connect/n");
    return 205;
}

BURN_DLL_API void HT_ExitBurn()
{
    CloseHandle(hThreadPing[0]);                <------------------------------ 问题9
    CloseHandle(hThreadPing[1]);
    CloseHandle(hThreadPing[2]);
    CloseHandle(hThreadPing[3]);
    CloseHandle(hThreadPing[4]);
    CloseHandle(hThreadPing[5]);
    CloseHandle(hThreadPing[6]);
    CloseHandle(hThreadPing[7]);
    CloseHandle(hThreadPing[8]);
    CloseHandle(hThreadPing[9]);
    CloseHandle(hThreadPing[10]);
    CloseHandle(hThreadPing[11]);
    CloseHandle(hThreadPing[12]);
    CloseHandle(hThreadPing[13]);
    CloseHandle(hThreadPing[14]);

    FreeLibrary(hIcmp);
}


臃肿的代码在我们的软件里面比比皆是，上面的例子是比较突出的一个。
这种代码是在多次的修订过程中通过简单的copy and paste产生的。浪费存贮空间（SDRAM、磁盘、flash）还只是小事情，最大的问题是难读，难维护，难扩展。

如上例：
程序的目标其实很简单，通过扫描一段IP地址（192.168.2.1~192.168.2.255）来发现局域网中正在运行的STB，然后试图连接并配置参数。为了提高扫描的效率，开启多个线程来并行工作。

1）为了细分为15个网络段，用了15个字符串变量。
为什么不能用一个大小为15的字符指针数组或2维数组呢？

同时也可以看出作者在手动分网段的时候，颇费思量，其实则完全没有必要，为什么不能通过程序自动计算得到呢？
for (n = 0; n < 15; n++)
    IP[n] <= 192.168.2.{2+ (255/15)*n};

2）为了实现15个相同功能的线程，结果写了15个一样样的函数体。（仅少量参数的取值不同而已）
为什么不能用一个函数，通过传递不同的参数值来区别呢？

3~9）完全可以用数组+for循环的方式实现的，结果却写成简单的重复15条语句而已。

试想一下：
a）如果在运行了一段时间后，发现15个线程的效果还不是很理想，需要再调高，作者又将copy & paste多少代码？
另：我们怎么证明15是一个最优解，或是如何找到这个值？大幅度的调整代码怕是很不现实。
b）如果要把网络从192.168.2.1 ~ 192.168.2.255扩展20倍到192.168.1.1~192.168.20.255，作者又将copy & paste多少代码？
c）如果在ThreadPingStart1这个线程里面发现了一个bug，作者是不是要改另外14个地方？

d）如果要大幅度修改ThreadPingStart1的功能，作者copy & paste的同时恐怕很难保证在其他14个地方的没有遗漏——将参数也跟着调整过来。
e）如果有多个客户，每个客户的网段大小不一样，是不是应该提供多个不同的版本？针对这样的需求，作者该如何做呢？在现有的模式下，恐怕只有copy成多个文件然后在每个文件中定制修改来实现。这个工作量不仅仅是惊人，而且相当枯燥无趣。
反之，如果通过宏来控制可变的参数，则只需要修改宏重新编译就可。甚至连文件都不用修改，直接在Makefile里面批量改变CC命令行宏参数即可。或者不用宏，用变量，通过main(int argc, char *argv[])从执行码的命令行参数来初始化变量。

总结：
1）机械的copy & paste代码并不能增加软件的价值，相反，软件变的更加糟糕，臃肿，难读，难以维护；最终更没有价值。
2）在计算机软件设计里面，二和无穷大具有同样的属性：重复。故应该遵循同样的处理方式。一旦你发现需要有2个函数实现大致相同的功能的时候，应该考虑（以后）是否还会有第三个或者更多这样的需求，这个时候应停下来思考一下，如何总结、归纳、找到共性： 将变化的量作为参数拎出来，而将不变的架构、流程作为函数体实现。

pizicai105
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
臃肿代码的简化：C++
cat_want_fly的博客
01-16 714
 最近学习C++，试着写C++的基本例题，发现一个问题，虽然代码磕磕绊绊的写出来了，也实现了函数功能，但是十分的臃肿，相似的功能需要重新写一遍，不仅重复，可读性差，而且也不便于管理，如下面这个例子， 是对两个日期进行比较大小，重载日期与天数的加减以及两日期的加计算差值，重载的符号有 ++，--（前置），++，--（后置），+=，-=，&lt;,&gt;,== , != ,&lt;=, &gt;...
Java简化臃肿代码之Lombok
04-21
Java编程语言以其强大的功能和广泛的应用而闻名，但随着项目的扩展，代码的冗余问题也随之增加，尤其是在处理数据对象（POJOs）时。为了解决这个问题，Lombok库应运而生，它通过注解的方式帮助开发者简化代码，减少...
代码坏味道之代码臃肿
weixin_33729196的博客
03-07 502
:notebook: 本文已归档到：「blog」 翻译自：sourcemaking.com/refactoring… 代码臃肿(Bloated)这组坏味道意味着：代码中的类、函数、字段没有经过合理的组织，只是简单的堆砌起来。这一类型的问题通常在代码的初期并不明显，但是随着代码规模的增长而逐渐积累（特别是当没有人努力去根除它们时）。 基本类型偏执 基本类型偏执(Primitive Obse...
代码臃肿优化
AlbenXie的博客
06-26 1152
代码臃肿的表现是代码耦合比较严重： ①业务代码与技术代码耦合 ②业务代码与增值业务代码耦合 ③多余的依赖关系 业务代码中不能耦合技术代码。 因为业务代码中耦合技术代码，例如下面业务代码BusninessService中耦合技术代码CacheService和LoggerService，此时如果技术出现问题则业务代码就会影响并且会影响业务代码执行时间。 //启动类 @SpringBootAppl...
【代码重构（Refectoring）系列教程】代码臃肿（Bloaters）--臃肿类（Large Class）
weixin_41937380的博客
11-04 256
代码重构（Refactoring) 臃肿类的特征，如何解决，重构臃肿类的好处。
【代码重构（Refectoring）系列教程】代码臃肿（Bloaters）--Long Method
weixin_41937380的博客
11-01 206
代码重构(Refectoring), 常见的Code Smells之Bloater--Long Mehtod。
Android代码-ComponentDemo
08-06
在项目的开发过程中，随着开发人员的增多及功能的增加，如果提前没有使用合理的开发架构，那么代码会越来臃肿，功能间代码耦合也会越来越严重，这时候为了保证项目代码的质量，我们就必须进行重构。 比较简单的开发...
冗余代码检测与分析
01-27
冗余代码会产生一系列的影响，包括源代码臃肿、可靠性及可维护性降低。在某些情况下，死代码也会影响性能； 为了检测冗余代码，作者开发了一个工具，使用Roslyn创建C#源码抽象语法树。作者使用包括Roslyn和MSBuild...
Android代码-BaseOkHttpV3
08-06
提供统一返回监听器ResponseListener处理返回数据，避免代码反复臃肿。 强大的全局方法和事件让您的请求得心应手。 Maven仓库或Gradle的引用方式 Maven仓库： com.kongzue.baseokhttp_v3 baseokhttp_v3 3.0.8 ...
JS复杂判断的更优雅写法代码详解
12-12
我们编写js代码时经常遇到复杂逻辑判的情况，通常大家可以用if/else或者switch来实现多个条件判断，但这样会有个问题，随着逻辑复杂度的增加，代码中的if/else/switch会变得越来越臃肿，越来越看不懂，那么如何更...
装饰类(解决extends)代码臃肿问题
小屁孩的博客
03-29 160
> 装饰类方法，将以前类在初始化装饰类时带入，在装饰类中加入新方法，以前方法用到时用以前类。 public class Zhuangshi {//装饰类 private File file;//以前类 Zhuangshi(File file){ this.file=file; } public void xin(){ System.ou
论精简代码和臃肿代码的区别
<sdffdsfsdfdfs>sfsfsfsdfsdffds</sdfsDS>Fsd
10-08 1072
：）
解救臃肿的代码，代码封装利器自定义注解深入剖析
Java高级部落
12-12 666
点击上面蓝字进行关注的都是靓仔和仙女部分自定义注解内容元注解：　　元注解的作用就是负责注解其他注解。    Java5.0定义了4个标准的meta-annotation类型，它们被用来提供对其它 annotation类型作说明。    Java5.0定义的元注解：　　　　1.@Target　　　　2.@Retention　　　　3.@Documented　　　　4.@Inherited　　这些类型
你写的代码，是别人的噩梦吗？
阿里技术
12-15 3908
阿里妹导读：Frank，是来自阿里国际技术事业部的高级技术专家，从业十年，也是一位英语说到飞起的型男。今天他将与大家聊聊关于企业应用架构实践的话题。阿里高级技术专家Frank从业这么多年，接触过银行的应用，Apple的应用，eBay的应用和现在阿里的应用，虽然分属于不同的公司，使用了不同的架构，但有一个共同点就是都很复杂。导致复杂性的原因有很多，如果从架构的层面看，主要有两点，一个是架构设计过于复
趣图丨前端后端接口联调的时候……
程序人生的博客
09-20 2128
是不是感觉数据永远都对不上！看完此文，你有什么想法或观点呢？欢迎在留言区留言评论。更多精彩“程序员被逼死丨王小波程序员丨我会编程丨七夕表白丨程序员最高殊荣丨程序猿（媛）CP丨祭天丨Python歌词丨特斯拉丨程序媛丨直播丨鄙视链丨敲代码丨404丨结婚丨Facebook丨怎么进BAT丨女友日记丨高逼格指南丨计算机专业丨技能干货丨九寨沟地震丨编程习惯丨陆奇演讲丨自救指南丨周鸿祎谈创业丨”公众号ID：co
android调用python代码
最新发布
06-07
Android可以通过JNI技术调用C/C++...需要注意的是，这种方法可能会导致应用程序变得复杂和臃肿，因此需要仔细权衡利弊。此外，还需要确保Python代码不会占用过多的CPU和内存资源，以避免影响应用程序的性能和稳定性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值