Adjust the Scatter Gather List buffer Address and lengths - c++

Question

I have a original allocated SGL array of structures that contain buffer address and lengths. We need to prepare a temporary SGL array based off original SGL structure array meeting few requirements and later use the temporary SGL array for crypto operations.
Requirement: Ignore the first 8 bytes and last 10 bytes
// Buffer data structure
typedef struct
{
void *data_addr;
int data_len;
}T_BUF_DATA;
Final Array:
T_BUF_DATA final_array[100];
Case1:
Original array: T_BUF_DATA[0] = buf_addr = 0xabc, buf_len = 1
T_BUF_DATA[1] = buf_addr = 0xdef, buf_len = 10
T_BUF_DATA[2] = buf_addr = 0x123, buf_len = 23
final_array[0] = buf_addr =( 0xdef + 7 ), buf_len = ( 10 - 7 ) // since we need to ignore the first 8 bytes from original list, adjust the buf_Addr by offset of 7 bytes
final_array[1] = buf_addr = 0x123, buf_len = ( 23 - 10 ) .. since we need to ignore the last 10 bytes
Case2:
Original array: T_BUF_DATA[0] = buf_addr = 0xabc, buf_len = 100
final_array[0] = buf_addr = ( 0xabc + 8 ), buf_len = 100 - ( 8 + 10 );
We need to implement a generic solution that can handle all the varying buffer length original array structures while preparing the final array. Can someone please assist me here ? I am able to handle the case 2, but stuck on attempting case 1 and any few other unknown corner cases.
void adjust_my_original_buffer ( T_BUF_DATA *data, int num_bufs )
{
T_BUF_DATA final_array[100];
int idx = 0;
for ( int i = 0 ; i < num_bufs; i++ )
{
// prepare the final array
}
}

Answer 1

Something like the following should work. The idea is to skip whole SG entries at the start (keeping track of remaining initial bytes to be skipped in initial_skip) and skip whole SG entries at the end (keeping track of remaining final bytes to be skipped in final_skip) in order to simplify the problem.
After the simplification, there may be 0, 1 or more SG entries remaining, indicated by the adjusted num_bufs, and the adjusted orig points to the first remaining entry. If there is at least one remaining SG entry, the first entry's data_len will be greater than initial_skip and the last entry's data_len will be greater than final_skip. If there is exactly one remaining SG entry, an additional test is required to check that its data_len is greater than initial_skip + final_skip, reducing the number of remaining SG entries to zero if that is not the case.
A loop copies the remaining SG entries from orig to final and the if statements within the loop adjust the first and last SG entries (which might be a single SG entry).
Finally, the function returns the length of the final SG list, which could be 0 if everything was skipped.
int adjust_my_original_buffer ( const T_BUF_DATA * restrict orig, T_BUF_DATA * restrict final, int num_bufs )
{
int initial_skip;
int final_skip;
// Skip initial bytes.
initial_skip = 8;
while ( num_bufs && orig[0].data_len <= initial_skip )
{
initial_skip -= orig[0].data_len;
orig++;
num_bufs--;
}
// Skip final bytes.
final_skip = 10;
while ( num_bufs && orig[num_bufs - 1].data_len <= final_skip )
{
final_skip -= orig[num_bufs - 1].data_len;
num_bufs--;
}
// If single SG entry remaining, check its length.
if ( num_bufs == 1 && data[0].data_len <= initial_skip + final_skip )
{
// Singleton SG entry is too short.
num_bufs = 0;
}
// Copy SG entries to final list, adjusting first and last entry.
for ( int i = 0; i < num_bufs; i++ )
{
final[i] = orig[i]; // Copy SG entry.
if ( i == 0 )
{
// Adjust first SG entry.
final[i].data_addr = (char *)final[i].data_addr + initial_skip;
final[i].data_len -= initial_skip;
}
if ( i == num_bufs - 1 )
{
// Adjust last SG entry.
final[i].data_len -= final_skip;
}
}
return num_bufs;
}