void HsQMLAutoListModel::updateModelByKey(bool reorder)
{
int srcLen = sourceLength();
// Build a map of element key's highest indices in the new source
typedef QHash<QString, int> SrcDict;
SrcDict srcDict;
if (reorder) {
for (int i=0; i<srcLen; i++) {
QJSValue srcVal = mSource.property(i);
srcDict.insert(keyFunction(srcVal), i);
}
}
// Build a map of element key's previous indices in the old model
typedef QMultiHash<QString, int> ModelDict;
ModelDict modelDict;
for (int idx = mOldModel.size()-1; idx >= 0; --idx) {
Element& e = mOldModel[idx];
if (mRehash) {
e.mKey = keyFunction(e.mValue);
}
modelDict.insert(e.mKey, idx);
}
mRehash = false;
// Rearrange and insert new elements
Q_ASSERT(!mNewModel.size() && !mOldOffset);
mNewModel.reserve(srcLen);
for (int i=0; i<srcLen; i++) {
QJSValue srcVal = mSource.property(i);
QString srcKey = keyFunction(srcVal);
ModelDict::iterator it = modelDict.find(srcKey);
if (it != modelDict.end()) {
const int elemIdx = *it;
Q_ASSERT(elemIdx >= mOldOffset);
Q_ASSERT(elemIdx < mOldModel.size());
modelDict.erase(it);
// Try removing elements before target
while (elemIdx > mOldOffset) {
const Element& nextElem = mOldModel[mOldOffset];
if (reorder) {
// Check if element will be used later
SrcDict::iterator srcIt = srcDict.find(nextElem.mKey);
if (srcIt != srcDict.end()) {
if (srcIt.value() >= i) {
// Old element is still needed by the new source
break;
}
}
}
// Remove element
HSQML_LOG(3, QString().sprintf(
"AutoListModel.ByKey: Removed element at %d.", i));
beginRemoveRows(QModelIndex(), i, i);
mOldOffset++;
endRemoveRows();
modelDict.erase(modelDict.find(nextElem.mKey));
}
// Move target element earlier in list if needed
if (elemIdx > mOldOffset) {
Q_ASSERT(reorder);
int srcIdx = fromOldIndex(elemIdx);
HSQML_LOG(3, QString().sprintf(
"AutoListModel.ByKey: Moved element at %d to %d.",
srcIdx, i));
beginMoveRows(QModelIndex(), srcIdx, srcIdx, QModelIndex(), i);
mNewModel.append(mOldModel[elemIdx]);
mOldModel.remove(elemIdx);
endMoveRows();
// Renumber remaining indices in the old model
for (ModelDict::iterator renumIt = modelDict.begin();
renumIt != modelDict.end();) {
ModelDict::iterator currIt = renumIt++;
Q_ASSERT(currIt.value() >= mOldOffset);
if (currIt.value() > elemIdx) {
currIt.value()--;
}
}
}
else {
// Transfer element from old to new model
mNewModel.append(mOldModel[elemIdx]);
mOldOffset++;
}
// Has value changed?
handleInequality(srcVal, mNewModel, i);
Q_ASSERT(mNewModel.size() == i+1);
}
else {
HSQML_LOG(3, QString().sprintf(
"AutoListModel.ByKey: Inserted element at %d.", i));
beginInsertRows(QModelIndex(), i, i);
mNewModel.append(Element(srcVal, srcKey));
endInsertRows();
}
}
// Move element to the old model, removing any excess elements from the end
bool excess = mOldOffset < mOldModel.size();
if (excess) {
HSQML_LOG(3, QString().sprintf(
"AutoListModel.ByKey: Removed %d excess elements at %d.",
mOldModel.size() - mOldOffset, srcLen));
beginRemoveRows(QModelIndex(), srcLen, rowCount(QModelIndex())-1);
}
mNewModel.swap(mOldModel);
mNewModel.clear();
mOldOffset = 0;
if (excess) {
endRemoveRows();
}
}
//===== Main encrypt function
int encrypt( FILE *ftable, FILE *fin, const char *key_str, const int decrypt_flag ) {
//==================== Get and check key
unsigned char *key_byte;
// Get size of key array
int key_byte_len;
key_byte_len = ( strlen(key_str) + 1 ) / 2;
key_byte = keyFunction( key_str, key_byte_len, VALID_KEY_LEN );
// Key error checking
if( key_byte == NULL ) {
fprintf(stderr, "hw5: ERROR: Key processing failure!\n");
return 1;
}
//==================== Get tablefile tables
//--- Check tablefiles
if ( tableCheck( ftable ) ) {
fprintf(stderr, "\nhw5: ERROR: Tablefile errors!\n");
free(key_byte);
return 1;
}
// DEBUG :
{
//printf( "\nTablefile check passes!\n" );
}
unsigned int *ip_table;
unsigned int *e_table;
unsigned int **s_table;
s_table = (unsigned int**) malloc( sizeof(unsigned int*) * S_TABLE_NUM );
unsigned int *p_table;
unsigned int *v_table;
unsigned int *pc1_table;
unsigned int *pc2_table;
unsigned int *fp_table;
//--- Call get table functions
{
ip_table = getTableValues( ftable, TOKEN_IP, IP_TABLE_LEN );
e_table = getTableValues( ftable, TOKEN_E, E_TABLE_LEN );
s_table[0] = getTableValues( ftable, TOKEN_S1, S_TABLE_LEN );
s_table[1] = getTableValues( ftable, TOKEN_S2, S_TABLE_LEN );
s_table[2] = getTableValues( ftable, TOKEN_S3, S_TABLE_LEN );
s_table[3] = getTableValues( ftable, TOKEN_S4, S_TABLE_LEN );
s_table[4] = getTableValues( ftable, TOKEN_S5, S_TABLE_LEN );
s_table[5] = getTableValues( ftable, TOKEN_S6, S_TABLE_LEN );
s_table[6] = getTableValues( ftable, TOKEN_S7, S_TABLE_LEN );
s_table[7] = getTableValues( ftable, TOKEN_S8, S_TABLE_LEN );
p_table = getTableValues( ftable, TOKEN_P, P_TABLE_LEN );
v_table = getTableValues( ftable, TOKEN_V, V_TABLE_LEN );
pc1_table = getTableValues( ftable, TOKEN_PC1, PC1_TABLE_LEN );
pc2_table = getTableValues( ftable, TOKEN_PC2, PC2_TABLE_LEN );
fp_table = computeFPTable( ip_table, IP_TABLE_LEN );
}
// DEBUG :
{
/*
int dti;
printf( "\nIP-Table:" );
for ( dti=0; dti<IP_TABLE_LEN; dti++ ) {
if ( dti % 8 == 0 ) {
printf( "\n" );
}
printf( "%02d ", ip_table[dti] );
}
printf( "\n" );
*/
/*
printf( "\nE-Table:" );
int dti;
for ( dti=0; dti<E_TABLE_LEN; dti++ ) {
if ( dti % 6 == 0 ) {
printf( "\n" );
}
printf( "%02d ", e_table[dti] );
}
printf( "\n" );
*/
/*
int dti;
int dtj;
for ( dtj=0; dtj<S_TABLE_NUM; dtj++ ) {
printf( "\nS%d-Table:", dtj );
for ( dti=0; dti<S_TABLE_LEN; dti++ ) {
if ( dti % 16 == 0 ) {
printf( "\n" );
}
printf( "%02d ", s_table[dtj][dti] );
}
printf( "\n" );
}
*/
/*
printf( "\nP-Table:" );
int dti;
for ( dti=0; dti<P_TABLE_LEN; dti++ ) {
if ( dti % 4 == 0 ) {
printf( "\n" );
}
printf( "%02d ", p_table[dti] );
}
printf( "\n" );
*/
/*
printf( "\nV-Table:\n" );
int dti;
for ( dti=0; dti<V_TABLE_LEN; dti++ ) {
printf( "%d ", v_table[dti] );
}
printf( "\n" );
*/
/*
int dti;
printf( "\nPC1-Table:\n" );
for ( dti=0; dti<PC1_TABLE_LEN; dti++ ) {
if ( dti % 7 == 0 ) {
printf( "\n" );
}
printf( "%02d ", pc1_table[dti] );
}
printf( "\n" );
*/
/*
printf( "\nPC2-Table:\n" );
int dti;
for ( dti=0; dti<PC2_TABLE_LEN; dti++ ) {
if ( dti % 7 == 0 ) {
printf( "\n" );
}
printf( "%02d ", pc2_table[dti] );
}
printf( "\n" );
*/
/*
printf( "\nFP-Table:\n" );
int dti;
for ( dti=0; dti<IP_TABLE_LEN; dti++ ) {
if ( dti % 8 == 0 ) {
printf( "\n" );
}
printf( "%02d ", fp_table[dti] );
}
printf( "\n" );
*/
}
//==================== Compute subkeys
unsigned char **subkey;
subkey = (unsigned char**) malloc( sizeof(unsigned char*) * FEISTEL_ROUNDS );
int subkey_len = PC2_TABLE_LEN / 8;
subkeyFunction( pc1_table, PC1_TABLE_LEN,
v_table, V_TABLE_LEN,
pc2_table, PC2_TABLE_LEN,
key_byte, key_byte_len,
FEISTEL_ROUNDS,
decrypt_flag,
subkey, subkey_len );
//==================== Encryption
int msg_block_bytes = 1;
int block_cnt = 0;
int block_len = BLOCK_BYTES;
// Initialize ciphter block
unsigned char *cipher_block;
//--- Get initial 8-byte block of message
unsigned char msg_block[block_len];
msg_block_bytes = getMsgBlock( fin, msg_block, block_len );
block_cnt++;
//--- Loop to process block and get next blocks
while ( msg_block_bytes > 0 ) {
// DEBUG :
{
/*
printf( "\nMessage block bytes: %d\n", msg_block_bytes );
printf( "Plaintext : " );
int i;
for ( i=0; i<BLOCK_BYTES; i++ ) {
printf( "%02x", msg_block[i] );
}
printf( "\n" );
*/
}
//--- Call get cipher block function
cipher_block = getCipherBlock( ip_table, IP_TABLE_LEN,
e_table, E_TABLE_LEN,
s_table, S_TABLE_NUM, S_TABLE_LEN,
p_table, P_TABLE_LEN,
fp_table, IP_TABLE_LEN,
subkey, FEISTEL_ROUNDS, subkey_len,
msg_block, block_len,
block_cnt );
//--- Write to stdout
fwrite( cipher_block, 1, block_len, stdout );
//--- Get next 8-byte block of message
msg_block_bytes = getMsgBlock( fin, msg_block, block_len );
if ( msg_block_bytes == 0 ) {
// Free heap memory
free(cipher_block);
break;
}
block_cnt++;
// Free heap memory
free(cipher_block);
}
//===== Free heap memory
{
free(key_byte);
free(v_table);
free(pc1_table);
free(pc2_table);
free(ip_table);
free(fp_table);
free(e_table);
free(p_table);
int fhi;
for ( fhi=0; fhi<S_TABLE_NUM; fhi++ ) {
free(s_table[fhi]);
}
free(s_table);
for ( fhi=0; fhi<FEISTEL_ROUNDS; fhi++ ) {
free(subkey[fhi]);
}
free(subkey);
}
return 0;
/*
SUBKEY_ERROR: {
free(key_byte);
free(ip_table);
free(e_table);
free(p_table);
free(v_table);
free(pc1_table);
free(pc2_table);
free(fp_table);
int fhi;
for ( fhi=0; fhi<S_TABLE_NUM; fhi++ ) {
free(s_table[fhi]);
}
free(s_table);
return 1;
}
*/
}
