Beispiel #1
0
int
ppe_packet_init(ppe_packet_t* ppep, uint8_t* data, int size)
{
    PPE_MEMSET(ppep, 0, sizeof(*ppep));
    ppep->data = data;
    ppep->size = size;
    return 0;
}
Beispiel #2
0
static ucli_status_t
ppe_ucli_utm__rwall__(ucli_context_t* uc)
{
    ppe_packet_t ppep;  
    ppe_header_t header; 
    ppe_field_t f; 
    int rv = UCLI_STATUS_OK; 

    UCLI_COMMAND_INFO(uc, 
                      "rwall", 0, 
                      "Read and write all packet fields in all headers."); 

    ppe_packet_init(&ppep, NULL, 0);

    /**
     * Allocate and assign a header pointer for every header type. 
     * All bits will be initialized to 1. 
     */
    for(header = 0; header < PPE_HEADER_COUNT; header++) {
        uint8_t* hp = aim_zmalloc(1000); 
        PPE_MEMSET(hp, 0xFF, 1000); 
        ppe_header_set(&ppep, header, hp); 
    }

    /**
     * Check that every field reads back as all 1's, with the correct width
     */
    for(f = 0; f < PPE_FIELD_COUNT; f++) {
        const ppe_field_info_t* fi = ppe_field_info_get(f); 
        if(fi->size_bits == 0) { 
            continue; 
        }
        if(fi->size_bits <= 32) {
            uint32_t v;
            ppe_field_get(&ppep, f, &v); 
            if(fi->size_bits == 32) {
                if(v != 0xFFFFFFFF)  {
                    rv = ucli_error(uc, "first read: field %{ppe_field} is 0x%x, should be 0x%x", 
                                    f, v, -1); 
                }
            }
            else {
                if(v != ( (1U << fi->size_bits) - 1)) { 
                    rv = ucli_error(uc, "first read: field %{ppe_field} is 0x%x, should be 0x%x (%d bits)", 
                                    f, v, (1<<fi->size_bits) - 1, fi->size_bits); 
                }
            }
            /** clear field and re-read */
            ppe_field_set(&ppep, f, 0); 
            ppe_field_get(&ppep, f, &v); 
            if(v != 0) {
                rv = ucli_error(uc, "second read: field %{ppe_field} is 0x%x when it should be 0.", 
                                f, v); 
            }            
        }
        else {
            uint8_t vb[64];    
            int bytes = ppe_wide_field_get(&ppep, f, vb); 
            int i; 
            for(i = 0; i < bytes; i++) {
                if(vb[i] != 0xFF) { 
                    rv = ucli_error(uc, "first read: field %{ppe_field}[%d] is 0x%.2x, should be 0x%.2x", 
                                    f, i, vb[i], 0xFF); 
                }
            }
            PPE_MEMSET(vb, 0, sizeof(vb)); 
            /** clear field and re-read */
            ppe_wide_field_set(&ppep, f, vb); 
            PPE_MEMSET(vb, 0xFF, sizeof(vb)); 
            ppe_wide_field_get(&ppep, f, vb); 
            for(i = 0; i < bytes; i++) {
                if(vb[i] != 0) {
                    rv = ucli_error(uc, "second read: field %{ppe_field}[%d] is 0x%.2x, should be 0.", 
                                    f, i, vb[i]); 
                }
            }
        }

        /** continue reading other fields, making sure the field we just cleared
         * does not change the value of fields we have not yet visited. */

    }

    for(header = 0; header < PPE_HEADER_COUNT; header++) {
        aim_free(ppe_header_get(&ppep, header)); 
    }
    return rv; 
}