packet.c

打魔兽战网的都知道他是什么

    }
    
    switch (packet->class)
    {
    case packet_class_init:
        size = sizeof(t_client_initconn);
	break;
    case packet_class_bnet:
        size = (unsigned int)bn_short_get(packet->u.bnet.h.size);
	break;
    case packet_class_file:
        size = (unsigned int)bn_short_get(packet->u.file.h.size);
	break;
    case packet_class_udp:
	size = packet->len;
	break;
    case packet_class_raw:
	size = packet->len;
	break;
    case packet_class_d2game:
	size = packet->len; /* FIXME: does header not contain the size? */
	break;
    case packet_class_d2gs:
        size = (unsigned int)bn_short_get(packet->u.d2cs_d2gs.h.size);
        break;
    case packet_class_d2cs_bnetd:
        size = (unsigned int)bn_short_get(packet->u.d2cs_bnetd.h.size);
        break;
    case packet_class_d2cs:
        size = (unsigned int)bn_short_get(packet->u.d2cs_client.h.size);
        break;
    case packet_class_w3route:
	size = (unsigned int)bn_short_get(packet->u.w3route.h.size);
	break;
    default:
	eventlog(eventlog_level_error,__FUNCTION__,"packet has invalid class %d",(int)packet->class);
	return 0;
    }
    
    if (size>MAX_PACKET_SIZE)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"packet has bad size %u",size);
	return 0;
    }
    return size;
}


extern int packet_set_size(t_packet * packet, unsigned int size)
{
    if (!packet)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
	return -1;
    }
    if (size>MAX_PACKET_SIZE)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got bad size %u",size);
	return -1;
    }
    
    switch (packet->class)
    {
    case packet_class_init:
	if (size!=0 && size!=sizeof(t_client_initconn))
	{
	    eventlog(eventlog_level_error,__FUNCTION__,"invalid size %u for init packet",size);
	    return -1;
	}
	packet->len = size;
        return 0;
    case packet_class_bnet:
	if (size!=0 && size<sizeof(t_bnet_header))
	{
	    eventlog(eventlog_level_error,__FUNCTION__,"invalid size %u for bnet packet",size);
	    return -1;
	}
        bn_short_set(&packet->u.bnet.h.size,size);
        return 0;
    case packet_class_file:
	if (size!=0 && size<sizeof(t_file_header))
	{
	    eventlog(eventlog_level_error,__FUNCTION__,"invalid size %u for file packet",size);
	    return -1;
	}
        bn_short_set(&packet->u.file.h.size,size);
        return 0;
    case packet_class_udp:
	if (size!=0 && size<sizeof(t_udp_header))
	{
	    eventlog(eventlog_level_error,__FUNCTION__,"invalid size %u for udp packet",size);
	    return -1;
	}
	packet->len = size;
	return 0;
    case packet_class_raw:
	packet->len = size;
	return 0;
    case packet_class_d2game:
	packet->len = size; /* FIXME: does header not contain the size? */
	return 0;
    case packet_class_d2cs:
        bn_short_set(&packet->u.d2cs_client.h.size,size);
        return 0;
    case packet_class_d2gs:
        bn_short_set(&packet->u.d2cs_d2gs.h.size,size);
        return 0;
    case packet_class_d2cs_bnetd:
        bn_short_set(&packet->u.d2cs_bnetd.h.size,size);
        return 0;
    case packet_class_w3route:
	if (size!=0 && size<sizeof(t_w3route_header))
	{
	    eventlog(eventlog_level_error,__FUNCTION__,"invalid size %u for w3route packet",size);
	    return -1;
	}
        bn_short_set(&packet->u.w3route.h.size,size);
        return 0;
    default:
	eventlog(eventlog_level_error,__FUNCTION__,"packet has invalid class %d",(int)packet->class);
	return -1;
    }
}


extern unsigned int packet_get_header_size(t_packet const * packet)
{
    if (!packet)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
	return MAX_PACKET_SIZE;
    }
    
    switch (packet_get_class(packet))
    {
    case packet_class_init:
        return 0;
    case packet_class_bnet:
        return sizeof(t_bnet_header);
    case packet_class_file:
        return sizeof(t_file_header);
    case packet_class_udp:
        return sizeof(t_udp_header);
    case packet_class_raw:
        return 0;
    case packet_class_d2game:
        return 0; /* FIXME: is there no game packet header? */
    case packet_class_d2cs:
        return sizeof(t_d2cs_client_header);
    case packet_class_d2gs:
        return sizeof(t_d2cs_d2gs_header);
    case packet_class_d2cs_bnetd:
        return sizeof(t_d2cs_bnetd_header);
    case packet_class_w3route:
        return sizeof(t_w3route_header);
    default:
        eventlog(eventlog_level_error,__FUNCTION__,"packet has bad class %d",(int)packet_get_class(packet));
        return MAX_PACKET_SIZE;
    }
}


extern unsigned int packet_get_flags(t_packet const * packet)
{
    if (!packet)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
        return 0;
    }
    
    return packet->flags;
}


extern int packet_set_flags(t_packet * packet, unsigned int flags)
{
    if (!packet)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
        return -1;
    }
    
    packet->flags = flags;
    return 0;
}


extern int packet_append_string(t_packet * packet, char const * str)
{
    unsigned int   len;
    unsigned short addlen;
    unsigned short size;
    
    if (!packet)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
        return -1;
    }
    if (!str)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL string");
        return -1;
    }
    
    len = strlen(str)+1;
    size = packet_get_size(packet);
    if (size>=MAX_PACKET_SIZE)
        return -1;
    
    if (MAX_PACKET_SIZE-(unsigned int)size>len)
	    addlen = len;
    else
	    addlen = MAX_PACKET_SIZE-size;
    if (addlen<1)
	return -1;
    
    memcpy(packet->u.data+size,str,addlen-1);
    packet->u.data[size+addlen-1] = '\0';
    packet_set_size(packet,size+addlen);
    
    return (int)addlen;
}


extern int packet_append_ntstring(t_packet * packet, char const * str)
{
    unsigned int   len;
    unsigned short addlen;
    unsigned short size;
    
    if (!packet)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
        return -1;
    }
    if (!str)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL string");
        return -1;
    }
    
    len = strlen(str);
    size = packet_get_size(packet);
    if (size>=MAX_PACKET_SIZE)
        return -1;
    
    if (MAX_PACKET_SIZE-(unsigned int)size>len)
	    addlen = len;
    else
	    addlen = MAX_PACKET_SIZE-size;
    if (addlen<1)
	return -1;
    
    memcpy(packet->u.data+size,str,addlen);
    packet_set_size(packet,size+addlen);
    
    return (int)addlen;
}


extern int packet_append_lstr(t_packet * packet, t_lstr *lstr)
{
    unsigned short addlen;
    unsigned short size;
    
    if (!packet)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
        return -1;
    }
    if (!lstr || !lstr_get_str(lstr))
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL string");
        return -1;
    }

    size = packet_get_size(packet);
    if (size>=MAX_PACKET_SIZE)
        return -1;
    
    if (MAX_PACKET_SIZE-(unsigned int)size>lstr_get_len(lstr))
	    addlen = lstr_get_len(lstr);
    else
	    addlen = MAX_PACKET_SIZE-size;
    if (addlen<1)
	return -1;
    
    memcpy(packet->u.data+size,lstr_get_str(lstr),addlen-1);
    packet->u.data[size+addlen-1] = '\0';
    packet_set_size(packet,size+addlen);
    
    return (int)addlen;
}


extern int packet_append_data(t_packet * packet, void const * data, unsigned int len)
{
    unsigned short addlen;
    unsigned short size;
    
    if (!packet)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
        return -1;
    }
    if (!data)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL data");
        return -1;
    }
    
    size = packet_get_size(packet);
    if (size>=MAX_PACKET_SIZE)
        return -1;
    
    if (MAX_PACKET_SIZE-(unsigned int)size>len)
	    addlen = len;
    else
	    addlen = MAX_PACKET_SIZE-size;
    if (addlen<1)
	return -1;
    
    memcpy(packet->u.data+size,data,addlen);
    packet_set_size(packet,size+addlen);
    
    return (int)addlen;
}


extern void const * packet_get_raw_data_const(t_packet const * packet, unsigned int offset)
{
    unsigned int size;
    
    if (!packet)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
        return NULL;
    }
    size = (unsigned int)packet_get_size(packet);
    if (offset>=size || offset>=MAX_PACKET_SIZE)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got bad offset %u for packet size %u",offset,size);
        return NULL;
    }
    
    return packet->u.data+offset;
}


extern void * packet_get_raw_data(t_packet * packet, unsigned int offset)
{
    unsigned int size;
    
    if (!packet)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
        return NULL;
    }
    size = (unsigned int)packet_get_size(packet);
    if (offset>=size || offset>=MAX_PACKET_SIZE)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got bad offset %u for packet size %u",offset,size);
        return NULL;
    }
    
    return packet->u.data+offset;
}


extern void * packet_get_raw_data_build(t_packet * packet, unsigned int offset)
{
    if (!packet)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
        return NULL;
    }
    
    if (offset>=MAX_PACKET_SIZE)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got bad offset %u for packet",offset);
        return NULL;
    }
    
    return packet->u.data+offset;
}


/* maxlen includes room for NUL char */
extern char const * packet_get_str_const(t_packet const * packet, unsigned int offset, unsigned int maxlen)
{
    unsigned int size;
    unsigned int pos;
    
    if (!packet)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
        return NULL;
    }
    size = (unsigned int)packet_get_size(packet);
    if (offset>=size)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got bad offset %u for packet size %u",offset,size);
        return NULL;
    }
    
    for (pos=offset; packet->u.data[pos]!='\0'; pos++)
	if (pos>=size || pos-offset>=maxlen)
	    return NULL;
    if (pos>=size || pos-offset>=maxlen) /* NUL must be inside too */
	return NULL;
    return packet->u.data+offset;
}


extern void const * packet_get_data_const(t_packet const * packet, unsigned int offset, unsigned int len)
{
    unsigned int size;
    
    if (!packet)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
        return NULL;
    }
    if (len<1)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got zero length");
	return NULL;
    }
    size = (unsigned int)packet_get_size(packet);
    if (offset+len>size)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got bad offset %u and length %u for packet size %u",offset,len,size);
        return NULL;
    }
    
    return packet->u.data+offset;
}


extern t_packet * packet_duplicate(t_packet const * src)
{
    t_packet * p;
    
    if (!(p = packet_create(packet_get_class(src))))
    {
	eventlog(eventlog_level_error,__FUNCTION__,"could not create packet");
	return NULL;
    }
    packet_append_data(p,src->u.data,packet_get_size(src));
    packet_set_flags(p,packet_get_flags(src));
    
    return p;
}