AREXPORT ArMapId &ArMapId::operator=(const ArMapId &other)
{
if (&other != this) {
mySourceName = other.mySourceName;
myFileName = other.myFileName;
delete [] myChecksum;
myChecksum = NULL;
myChecksumLength = 0;
delete [] myDisplayChecksum;
myDisplayChecksum = NULL;
myDisplayChecksumLength = 0;
if (other.myChecksumLength > 0) {
setChecksum(other.myChecksum,
other.myChecksumLength);
}
mySize = other.mySize;
myTimestamp = other.myTimestamp;
}
return *this;
}
void GREv0Layer::computeCalculateFields()
{
computeCalculateFieldsInner();
if (getGreHeader()->checksumBit == 0)
return;
// calculate checksum
setChecksum(0);
ScalarBuffer<uint16_t> buffer;
buffer.buffer = (uint16_t*)m_Data;
buffer.len = m_DataLen;
size_t checksum = compute_checksum(&buffer, 1);
setChecksum(checksum);
}
String MessageBuilder::getMessage(){
String output = String('>') + m_flags +
m_address_from + m_address_to +
m_message_type + m_message_sub_type +
m_data + "00;";
setChecksum(output);
return output;
}
/**
* set the given state and updates the codes
* @param _value the new state {STATE_on,STATE_off}
*/
void Tadiran::setState(uint8_t _value)
{
state=_value;
if (state & 1) codes[9] = CODE_high;
else codes[9] = CODE_low;
setChecksum();
}
/**
* set the given fan and updates the codes
* @param _value the new fan speed {FAN_auto, FAN_1, FAN_2, FAN_3}
*/
void Tadiran::setFan(uint8_t _value)
{
fan=_value;
if (fan & 2) codes[13]=CODE_high;
else codes[13]=CODE_low;
if (fan & 1) codes[11]=CODE_high;
else codes[11]=CODE_low;
setChecksum();
}
/**
* set the given mode and updates the codes
* @param _value the new mode {MODE_auto,MODE_cold,MODE_dry,MODE_fan,MODE_heat}
*/
void Tadiran::setMode(uint8_t _value)
{
mode=_value;
if (mode & 4) codes[7]=CODE_high;
else codes[7]=CODE_low;
if (mode & 2) codes[5]=CODE_high;
else codes[5]=CODE_low;
if (mode & 1) codes[3]=CODE_high;
else codes[3]=CODE_low;
setChecksum();
}
AREXPORT ArMapId::ArMapId(const ArMapId &other) :
mySourceName(other.mySourceName),
myFileName(other.myFileName),
myChecksum(NULL),
myChecksumLength(0),
myDisplayChecksum(NULL),
myDisplayChecksumLength(0),
mySize(other.mySize),
myTimestamp(other.myTimestamp)
{
if (other.myChecksumLength > 0) {
setChecksum(other.myChecksum,
other.myChecksumLength);
}
}
/**
* set the given temperature and updates the codes
* @param _value the new value [16..30]
*/
void Tadiran::setTemeprature(uint8_t _value)
{
temperature=_value;
if (temperature & 8) codes[25]=CODE_high;
else codes[25]=CODE_low;
if (temperature & 4) codes[23]=CODE_high;
else codes[23]=CODE_low;
if (temperature & 2) codes[21]=CODE_high;
else codes[21]=CODE_low;
if (temperature & 1) codes[19]=CODE_high;
else codes[19]=CODE_low;
setChecksum();
}
AREXPORT ArMapId::ArMapId(const char *sourceName,
const char *fileName,
const unsigned char *checksum,
size_t checksumLength,
long int size,
const time_t timestamp) :
mySourceName((sourceName != NULL) ? sourceName : ""),
myFileName((fileName != NULL) ? fileName : ""),
myChecksum(NULL),
myChecksumLength(0),
myDisplayChecksum(NULL),
myDisplayChecksumLength(0),
mySize(size),
myTimestamp(timestamp)
{
if (checksumLength > 0) {
setChecksum(checksum,
checksumLength);
}
}
static int fill(CharBuff* toBeFilled, PckDescr* descr, char* payload) {
int offset;
if((toBeFilled == NULL) || (payload == NULL && descr->payloadSize > 0)) {
return -1;
}
toBeFilled-> size = descr->totSize;
toBeFilled-> content[0] = descr->header;
toBeFilled-> content[fLength_header] = descr->payloadSize;
//Copies the bytes of the command, after the header and the payload size:
offset = fLength_header + fLength_payloadSize;
memcpy(toBeFilled->content + offset, descr->command, descr->commandSize);
if(descr->payloadSize > 0) {
//Copies the actual content (payload):
offset += descr->commandSize;
memcpy(toBeFilled->content + offset, payload, descr->payloadSize);
setChecksum(toBeFilled);
}
return 0;
}
int
insertFileIdentDesc(Directory *dir, struct fileIdentDesc* fid)
{
uint32_t lenFid;
lenFid = (sizeof(struct fileIdentDesc) + fid->lengthOfImpUse + fid->lengthFileIdent + 3) & ~3;
fid->descTag.descCRCLength = lenFid - sizeof(tag);
setChecksum(fid);
if( dir->fe.informationLength + lenFid > dir->dataSize ) {
if( !(dir->data = realloc(dir->data, dir->dataSize + 2048)) ) {
fail("Realloc directory data failed\n");
}
dir->dataSize += 2048;
}
memcpy(dir->data + dir->fe.informationLength, fid, lenFid);
dir->fe.informationLength += lenFid;
dir->dirDirty = 1;
return CMND_OK;
}
/* deleteFID()
*
* Remove an FID from the directory
* If fileLinkCount now zero, deallocate FileEntry and any data extents
*/
int
deleteFID(Directory * dir, struct fileIdentDesc * fid)
{
int rv;
struct fileEntry *fe;
rv = CMND_OK;
// if( fid->icb.extLocation.partitionReferenceNum != pd->partitionNumber )
// return NOT_IN_RW_PARTITION;
fe = readTaggedBlock(fid->icb.extLocation.logicalBlockNum, fid->icb.extLocation.partitionReferenceNum);
/* check permission */
freeBlock(fid->icb.extLocation.logicalBlockNum, fid->icb.extLocation.partitionReferenceNum);
if( fe->fileLinkCount > 1 ) {
fe->fileLinkCount--;
setChecksum(fe);
if( medium == CDRW )
dirtyBlock(fid->icb.extLocation.logicalBlockNum, fid->icb.extLocation.partitionReferenceNum);
else
vat[fid->icb.extLocation.logicalBlockNum] = writeCDR(fe);
} else {
if( medium == CDR ) {
if( fe->icbTag.fileType == ICBTAG_FILE_TYPE_DIRECTORY )
dir->fe.fileLinkCount--;
vat[fid->icb.extLocation.logicalBlockNum] = 0xFFFFFFFF;
} else {
if( fe->icbTag.fileType == ICBTAG_FILE_TYPE_DIRECTORY ) {
dir->fe.fileLinkCount--;
((struct logicalVolIntegrityDescImpUse*)
(lvid->impUse + 2 * sizeof(uint32_t) * lvid->numOfPartitions))->numDirs--;
} else {
((struct logicalVolIntegrityDescImpUse*)
(lvid->impUse + 2 * sizeof(uint32_t) * lvid->numOfPartitions))->numFiles--;
}
/* free file data */
switch( fe->icbTag.flags & ICBTAG_FLAG_AD_MASK ) {
case ICBTAG_FLAG_AD_IN_ICB:
break;
case ICBTAG_FLAG_AD_SHORT:
freeShortExtents((short_ad*)(fe->allocDescs + fe->lengthExtendedAttr));
break;
case ICBTAG_FLAG_AD_LONG:
freeLongExtents((long_ad*)(fe->allocDescs + fe->lengthExtendedAttr));
break;
default:
printf("UDF does not use Extended Alloc Descs\n");
rv = CMND_FAILED;
}
/* free the File Entry itself */
markBlock(FREE, fid->icb.extLocation.logicalBlockNum);
}
}
removeFID(dir, fid);
dir->dirDirty = 1;
return rv;
}
bool
Dbtup::scanNext(Signal* signal, ScanOpPtr scanPtr)
{
ScanOp& scan = *scanPtr.p;
ScanPos& pos = scan.m_scanPos;
Local_key& key = pos.m_key;
const Uint32 bits = scan.m_bits;
// table
TablerecPtr tablePtr;
tablePtr.i = scan.m_tableId;
ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
Tablerec& table = *tablePtr.p;
// fragment
FragrecordPtr fragPtr;
fragPtr.i = scan.m_fragPtrI;
ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
Fragrecord& frag = *fragPtr.p;
// tuple found
Tuple_header* th = 0;
Uint32 thbits = 0;
Uint32 loop_count = 0;
Uint32 scanGCI = scanPtr.p->m_scanGCI;
Uint32 foundGCI;
const bool mm = (bits & ScanOp::SCAN_DD);
const bool lcp = (bits & ScanOp::SCAN_LCP);
Uint32 lcp_list = fragPtr.p->m_lcp_keep_list;
Uint32 size = table.m_offsets[mm].m_fix_header_size;
if (lcp && lcp_list != RNIL)
goto found_lcp_keep;
switch(pos.m_get){
case ScanPos::Get_next_tuple:
case ScanPos::Get_next_tuple_fs:
jam();
key.m_page_idx += size;
// fall through
case ScanPos::Get_tuple:
case ScanPos::Get_tuple_fs:
jam();
/**
* We need to refetch page after timeslice
*/
pos.m_get = ScanPos::Get_page;
break;
default:
break;
}
while (true) {
switch (pos.m_get) {
case ScanPos::Get_next_page:
// move to next page
jam();
{
if (! (bits & ScanOp::SCAN_DD))
pos.m_get = ScanPos::Get_next_page_mm;
else
pos.m_get = ScanPos::Get_next_page_dd;
}
continue;
case ScanPos::Get_page:
// get real page
jam();
{
if (! (bits & ScanOp::SCAN_DD))
pos.m_get = ScanPos::Get_page_mm;
else
pos.m_get = ScanPos::Get_page_dd;
}
continue;
case ScanPos::Get_next_page_mm:
// move to next logical TUP page
jam();
{
key.m_page_no++;
if (key.m_page_no >= frag.noOfPages) {
jam();
if ((bits & ScanOp::SCAN_NR) && (scan.m_endPage != RNIL))
{
jam();
if (key.m_page_no < scan.m_endPage)
{
jam();
ndbout_c("scanning page %u", key.m_page_no);
goto cont;
}
}
// no more pages, scan ends
pos.m_get = ScanPos::Get_undef;
scan.m_state = ScanOp::Last;
return true;
}
cont:
key.m_page_idx = 0;
pos.m_get = ScanPos::Get_page_mm;
// clear cached value
pos.m_realpid_mm = RNIL;
}
/*FALLTHRU*/
case ScanPos::Get_page_mm:
// get TUP real page
jam();
{
if (pos.m_realpid_mm == RNIL) {
jam();
if (key.m_page_no < frag.noOfPages)
pos.m_realpid_mm = getRealpid(fragPtr.p, key.m_page_no);
else
{
ndbassert(bits & ScanOp::SCAN_NR);
goto nopage;
}
}
PagePtr pagePtr;
c_page_pool.getPtr(pagePtr, pos.m_realpid_mm);
if (pagePtr.p->page_state == ZEMPTY_MM) {
// skip empty page
jam();
if (! (bits & ScanOp::SCAN_NR))
{
pos.m_get = ScanPos::Get_next_page_mm;
break; // incr loop count
}
else
{
jam();
pos.m_realpid_mm = RNIL;
}
}
nopage:
pos.m_page = pagePtr.p;
pos.m_get = ScanPos::Get_tuple;
}
continue;
case ScanPos::Get_next_page_dd:
// move to next disk page
jam();
{
Disk_alloc_info& alloc = frag.m_disk_alloc_info;
Local_fragment_extent_list list(c_extent_pool, alloc.m_extent_list);
Ptr<Extent_info> ext_ptr;
c_extent_pool.getPtr(ext_ptr, pos.m_extent_info_ptr_i);
Extent_info* ext = ext_ptr.p;
key.m_page_no++;
if (key.m_page_no >= ext->m_first_page_no + alloc.m_extent_size) {
// no more pages in this extent
jam();
if (! list.next(ext_ptr)) {
// no more extents, scan ends
jam();
pos.m_get = ScanPos::Get_undef;
scan.m_state = ScanOp::Last;
return true;
} else {
// move to next extent
jam();
pos.m_extent_info_ptr_i = ext_ptr.i;
ext = c_extent_pool.getPtr(pos.m_extent_info_ptr_i);
key.m_file_no = ext->m_key.m_file_no;
key.m_page_no = ext->m_first_page_no;
}
}
key.m_page_idx = 0;
pos.m_get = ScanPos::Get_page_dd;
/*
read ahead for scan in disk order
do read ahead every 8:th page
*/
if ((bits & ScanOp::SCAN_DD) &&
(((key.m_page_no - ext->m_first_page_no) & 7) == 0))
{
jam();
// initialize PGMAN request
Page_cache_client::Request preq;
preq.m_page = pos.m_key;
preq.m_callback = TheNULLCallback;
// set maximum read ahead
Uint32 read_ahead = m_max_page_read_ahead;
while (true)
{
// prepare page read ahead in current extent
Uint32 page_no = preq.m_page.m_page_no;
Uint32 page_no_limit = page_no + read_ahead;
Uint32 limit = ext->m_first_page_no + alloc.m_extent_size;
if (page_no_limit > limit)
{
jam();
// read ahead crosses extent, set limit for this extent
read_ahead = page_no_limit - limit;
page_no_limit = limit;
// and make sure we only read one extra extent next time around
if (read_ahead > alloc.m_extent_size)
read_ahead = alloc.m_extent_size;
}
else
{
jam();
read_ahead = 0; // no more to read ahead after this
}
// do read ahead pages for this extent
while (page_no < page_no_limit)
{
// page request to PGMAN
jam();
preq.m_page.m_page_no = page_no;
int flags = 0;
// ignore result
m_pgman.get_page(signal, preq, flags);
jamEntry();
page_no++;
}
if (!read_ahead || !list.next(ext_ptr))
{
// no more extents after this or read ahead done
jam();
break;
}
// move to next extent and initialize PGMAN request accordingly
Extent_info* ext = c_extent_pool.getPtr(ext_ptr.i);
preq.m_page.m_file_no = ext->m_key.m_file_no;
preq.m_page.m_page_no = ext->m_first_page_no;
}
} // if ScanOp::SCAN_DD read ahead
}
/*FALLTHRU*/
case ScanPos::Get_page_dd:
// get global page in PGMAN cache
jam();
{
// check if page is un-allocated or empty
if (likely(! (bits & ScanOp::SCAN_NR)))
{
Tablespace_client tsman(signal, c_tsman,
frag.fragTableId,
frag.fragmentId,
frag.m_tablespace_id);
unsigned uncommitted, committed;
uncommitted = committed = ~(unsigned)0;
int ret = tsman.get_page_free_bits(&key, &uncommitted, &committed);
ndbrequire(ret == 0);
if (committed == 0 && uncommitted == 0) {
// skip empty page
jam();
pos.m_get = ScanPos::Get_next_page_dd;
break; // incr loop count
}
}
// page request to PGMAN
Page_cache_client::Request preq;
preq.m_page = pos.m_key;
preq.m_callback.m_callbackData = scanPtr.i;
preq.m_callback.m_callbackFunction =
safe_cast(&Dbtup::disk_page_tup_scan_callback);
int flags = 0;
int res = m_pgman.get_page(signal, preq, flags);
jamEntry();
if (res == 0) {
jam();
// request queued
pos.m_get = ScanPos::Get_tuple;
return false;
}
ndbrequire(res > 0);
pos.m_page = (Page*)m_pgman.m_ptr.p;
}
pos.m_get = ScanPos::Get_tuple;
continue;
// get tuple
// move to next tuple
case ScanPos::Get_next_tuple:
case ScanPos::Get_next_tuple_fs:
// move to next fixed size tuple
jam();
{
key.m_page_idx += size;
pos.m_get = ScanPos::Get_tuple_fs;
}
/*FALLTHRU*/
case ScanPos::Get_tuple:
case ScanPos::Get_tuple_fs:
// get fixed size tuple
jam();
{
Fix_page* page = (Fix_page*)pos.m_page;
if (key.m_page_idx + size <= Fix_page::DATA_WORDS)
{
pos.m_get = ScanPos::Get_next_tuple_fs;
th = (Tuple_header*)&page->m_data[key.m_page_idx];
if (likely(! (bits & ScanOp::SCAN_NR)))
{
jam();
thbits = th->m_header_bits;
if (! (thbits & Tuple_header::FREE))
{
goto found_tuple;
}
}
else
{
if (pos.m_realpid_mm == RNIL)
{
jam();
foundGCI = 0;
goto found_deleted_rowid;
}
thbits = th->m_header_bits;
if ((foundGCI = *th->get_mm_gci(tablePtr.p)) > scanGCI ||
foundGCI == 0)
{
if (! (thbits & Tuple_header::FREE))
{
jam();
goto found_tuple;
}
else
{
goto found_deleted_rowid;
}
}
else if (thbits != Fix_page::FREE_RECORD &&
th->m_operation_ptr_i != RNIL)
{
jam();
goto found_tuple; // Locked tuple...
// skip free tuple
}
}
} else {
jam();
// no more tuples on this page
pos.m_get = ScanPos::Get_next_page;
}
}
break; // incr loop count
found_tuple:
// found possible tuple to return
jam();
{
// caller has already set pos.m_get to next tuple
if (! (bits & ScanOp::SCAN_LCP && thbits & Tuple_header::LCP_SKIP)) {
Local_key& key_mm = pos.m_key_mm;
if (! (bits & ScanOp::SCAN_DD)) {
key_mm = pos.m_key;
// real page id is already set
} else {
key_mm.assref(th->m_base_record_ref);
// recompute for each disk tuple
pos.m_realpid_mm = getRealpid(fragPtr.p, key_mm.m_page_no);
}
// TUPKEYREQ handles savepoint stuff
scan.m_state = ScanOp::Current;
return true;
} else {
jam();
// clear it so that it will show up in next LCP
th->m_header_bits = thbits & ~(Uint32)Tuple_header::LCP_SKIP;
if (tablePtr.p->m_bits & Tablerec::TR_Checksum) {
jam();
setChecksum(th, tablePtr.p);
}
}
}
break;
found_deleted_rowid:
jam();
{
ndbassert(bits & ScanOp::SCAN_NR);
Local_key& key_mm = pos.m_key_mm;
if (! (bits & ScanOp::SCAN_DD)) {
key_mm = pos.m_key;
// caller has already set pos.m_get to next tuple
// real page id is already set
} else {
key_mm.assref(th->m_base_record_ref);
// recompute for each disk tuple
pos.m_realpid_mm = getRealpid(fragPtr.p, key_mm.m_page_no);
Fix_page *mmpage = (Fix_page*)c_page_pool.getPtr(pos.m_realpid_mm);
th = (Tuple_header*)(mmpage->m_data + key_mm.m_page_idx);
if ((foundGCI = *th->get_mm_gci(tablePtr.p)) > scanGCI ||
foundGCI == 0)
{
if (! (thbits & Tuple_header::FREE))
break;
}
}
NextScanConf* const conf = (NextScanConf*)signal->getDataPtrSend();
conf->scanPtr = scan.m_userPtr;
conf->accOperationPtr = RNIL;
conf->fragId = frag.fragmentId;
conf->localKey[0] = pos.m_key_mm.ref();
conf->localKey[1] = 0;
conf->localKeyLength = 1;
conf->gci = foundGCI;
Uint32 blockNo = refToBlock(scan.m_userRef);
EXECUTE_DIRECT(blockNo, GSN_NEXT_SCANCONF, signal, 7);
jamEntry();
// TUPKEYREQ handles savepoint stuff
loop_count = 32;
scan.m_state = ScanOp::Next;
return false;
}
break; // incr loop count
default:
ndbrequire(false);
break;
}
if (++loop_count >= 32)
break;
}
// TODO: at drop table we have to flush and terminate these
jam();
signal->theData[0] = ZTUP_SCAN;
signal->theData[1] = scanPtr.i;
sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB);
return false;
found_lcp_keep:
Local_key tmp;
tmp.assref(lcp_list);
tmp.m_page_no = getRealpid(fragPtr.p, tmp.m_page_no);
Ptr<Page> pagePtr;
c_page_pool.getPtr(pagePtr, tmp.m_page_no);
Tuple_header* ptr = (Tuple_header*)
((Fix_page*)pagePtr.p)->get_ptr(tmp.m_page_idx, 0);
Uint32 headerbits = ptr->m_header_bits;
ndbrequire(headerbits & Tuple_header::LCP_KEEP);
Uint32 next = ptr->m_operation_ptr_i;
ptr->m_operation_ptr_i = RNIL;
ptr->m_header_bits = headerbits & ~(Uint32)Tuple_header::FREE;
if (tablePtr.p->m_bits & Tablerec::TR_Checksum) {
jam();
setChecksum(ptr, tablePtr.p);
}
NextScanConf* const conf = (NextScanConf*)signal->getDataPtrSend();
conf->scanPtr = scan.m_userPtr;
conf->accOperationPtr = (Uint32)-1;
conf->fragId = frag.fragmentId;
conf->localKey[0] = lcp_list;
conf->localKey[1] = 0;
conf->localKeyLength = 1;
conf->gci = 0;
Uint32 blockNo = refToBlock(scan.m_userRef);
EXECUTE_DIRECT(blockNo, GSN_NEXT_SCANCONF, signal, 7);
fragPtr.p->m_lcp_keep_list = next;
ptr->m_header_bits |= Tuple_header::FREED; // RESTORE free flag
if (headerbits & Tuple_header::FREED)
{
if (tablePtr.p->m_attributes[MM].m_no_of_varsize)
{
jam();
free_var_rec(fragPtr.p, tablePtr.p, &tmp, pagePtr);
} else {
jam();
free_fix_rec(fragPtr.p, tablePtr.p, &tmp, (Fix_page*)pagePtr.p);
}
}
return false;
}
void TestItem::setData(const QVariant & value, int role){
switch(role) {
case DurationRole:
setDuration(value.toDouble());
break;
case ChecksumRole:
setChecksum(value.toString());
break;
case DependsRole:
setDepends(value.toString());
break;
case TestNameRole:
setTestname(value.toString());
break;
case RequiresRole:
setRequires(value.toString());
break;
case DescriptionRole:
setDescription(value.toString());
break;
case CommandRole:
setCommand(value.toString());
break;
case EnvironRole:
setEnviron(value.toString());
break;
case PluginRole:
setPlugin(value.toString());
break;
case TypeRole:
setType(value.toString());
break;
case UserRole:
setUser(value.toString());
break;
case ViaRole:
setVia(value.toString());
break;
case GroupRole:
setGroup(value.toString());
break;
case CheckRole:
setCheck(value.toBool());
break;
case ObjectPathRole:
setObjectpath(value.toString());
break;
case RunstatusRole:
setRunstatus(value.toInt());
break;
case ElapsedtimeRole:
setElapsedtime(value.toInt());
break;
case GroupstatusRole:
setGroupstatus(value.toInt());
break;
case ParentNameRole:
//setGroupstatus(value.toStringList()));
break;
case ParentIdRole:
//setGroupstatus(value.toStringList());
break;
case DepthRole:
setDepth(value.toInt());
break;
case BranchRole:
setBranch(value.toBool());
break;
case IOLogRole:
setIo_log(value.toString());
break;
case CommentsRole:
setComments(value.toString());
break;
case OutcomeRole:
setOutcome(value.toString());
break;
case RerunRole:
setRerun(value.toBool());
break;
}
}
void TcpPacket::assemblePacket()
{
if (nextPacket != NULL)
nextPacket->assemblePacket ();
int thissize = sizeof (TCP_HEADER) + options.size;
int nextsize = nextPacket != NULL ? nextPacket->getSize() : 0;
setSize (thissize + nextsize);
if (nextPacket != NULL)
memcpy (buffer + thissize, nextPacket->getBuffer(), nextsize);
//
// correct header length
//
setHeaderlength (thissize);
//
// correct endianess for output buffer
//
header.acknum = swap32(header.acknum );
header.checksum = swap16(header.checksum );
header.destport = swap16(header.destport );
header.headerlen_flags = swap16(header.headerlen_flags );
header.sequencenum = swap32(header.sequencenum );
header.sourceport = swap16(header.sourceport );
header.urgentpointer = swap16(header.urgentpointer );
header.windowsize = swap16(header.windowsize );
//
// calculate new checksum
// therefore we need the PayloadPacket
//
setChecksum (0);
if (Configuration::instance()->getReCalcChecksums ()) {
if (Configuration::instance()->getSetBadChecksumsToBad () && !checksumgood) {
setChecksum (RandomNumberGenerator::generate ());
} else {
uint8_t* data = NULL;
uint32_t datalen = 0;
if (nextProtocol != Packet::PROTO_NONE && nextPacket != NULL) {
data = nextPacket->getBuffer ();
datalen = nextPacket->getSize ();
}
void* pipsource = (ipProtocol == Packet::PROTO_IP ? (void*)&sourceip : (void*)&sourceip6);
void* pipdest = (ipProtocol == Packet::PROTO_IP ? (void*)&destip : (void*)&destip6 );
setChecksum (checksum (&header, pipsource, pipdest, ipProtocol, options.buf, options.size, data, datalen));
} // if (Configuration::instance()->getSetBadChecksumsToBad () && !checksumgood) {
} // if (Configuration::instance()->getReCalcChecksums ())
//
// copy into out buffer
// header, options, data
//
memcpy (buffer, &header, sizeof (TCP_HEADER));
memcpy (buffer + sizeof (TCP_HEADER), options.buf, options.size);
//
// convert endianess back
//
header.acknum = swap32(header.acknum );
header.checksum = swap16(header.checksum );
header.destport = swap16(header.destport );
header.headerlen_flags = swap16(header.headerlen_flags );
header.sequencenum = swap32(header.sequencenum );
header.sourceport = swap16(header.sourceport );
header.urgentpointer = swap16(header.urgentpointer );
header.windowsize = swap16(header.windowsize );
}
void
Dbtup::commit_operation(Signal* signal,
Uint32 gci_hi,
Uint32 gci_lo,
Tuple_header* tuple_ptr,
PagePtr pagePtr,
Operationrec* regOperPtr,
Fragrecord* regFragPtr,
Tablerec* regTabPtr)
{
ndbassert(regOperPtr->op_type != ZDELETE);
Uint32 lcpScan_ptr_i= regFragPtr->m_lcp_scan_op;
Uint32 save= tuple_ptr->m_operation_ptr_i;
Uint32 bits= tuple_ptr->m_header_bits;
Tuple_header *disk_ptr= 0;
Tuple_header *copy= get_copy_tuple(®OperPtr->m_copy_tuple_location);
Uint32 copy_bits= copy->m_header_bits;
Uint32 fixsize= regTabPtr->m_offsets[MM].m_fix_header_size;
Uint32 mm_vars= regTabPtr->m_attributes[MM].m_no_of_varsize;
Uint32 mm_dyns= regTabPtr->m_attributes[MM].m_no_of_dynamic;
bool update_gci_at_commit = ! regOperPtr->op_struct.bit_field.m_gci_written;
if((mm_vars+mm_dyns) == 0)
{
jam();
memcpy(tuple_ptr, copy, 4*fixsize);
disk_ptr= (Tuple_header*)(((Uint32*)copy)+fixsize);
}
else
{
jam();
/**
* Var_part_ref is only stored in *allocated* tuple
* so memcpy from copy, will over write it...
* hence subtle copyout/assign...
*/
Local_key tmp;
Var_part_ref *ref= tuple_ptr->get_var_part_ref_ptr(regTabPtr);
ref->copyout(&tmp);
memcpy(tuple_ptr, copy, 4*fixsize);
ref->assign(&tmp);
PagePtr vpagePtr;
if (copy_bits & Tuple_header::VAR_PART)
{
jam();
ndbassert(bits & Tuple_header::VAR_PART);
ndbassert(tmp.m_page_no != RNIL);
ndbassert(copy_bits & Tuple_header::COPY_TUPLE);
Uint32 *dst= get_ptr(&vpagePtr, *ref);
Var_page* vpagePtrP = (Var_page*)vpagePtr.p;
Varpart_copy*vp =(Varpart_copy*)copy->get_end_of_fix_part_ptr(regTabPtr);
/* The first word of shrunken tuple holds the lenght in words. */
Uint32 len = vp->m_len;
memcpy(dst, vp->m_data, 4*len);
if(copy_bits & Tuple_header::MM_SHRINK)
{
jam();
ndbassert(vpagePtrP->get_entry_len(tmp.m_page_idx) >= len);
if (len)
{
jam();
ndbassert(regFragPtr->m_varWordsFree >= vpagePtrP->free_space);
regFragPtr->m_varWordsFree -= vpagePtrP->free_space;
vpagePtrP->shrink_entry(tmp.m_page_idx, len);
// Adds the new free space value for the page to the fragment total.
update_free_page_list(regFragPtr, vpagePtr);
}
else
{
jam();
free_var_part(regFragPtr, vpagePtr, tmp.m_page_idx);
tmp.m_page_no = RNIL;
ref->assign(&tmp);
copy_bits &= ~(Uint32)Tuple_header::VAR_PART;
}
}
else
{
jam();
ndbassert(vpagePtrP->get_entry_len(tmp.m_page_idx) == len);
}
/**
* Find disk part after
* header + fixed MM part + length word + varsize part.
*/
disk_ptr = (Tuple_header*)(vp->m_data + len);
}
else
{
jam();
ndbassert(tmp.m_page_no == RNIL);
disk_ptr = (Tuple_header*)copy->get_end_of_fix_part_ptr(regTabPtr);
}
}
if (regTabPtr->m_no_of_disk_attributes &&
(copy_bits & Tuple_header::DISK_INLINE))
{
jam();
Local_key key;
memcpy(&key, copy->get_disk_ref_ptr(regTabPtr), sizeof(Local_key));
Uint32 logfile_group_id= regFragPtr->m_logfile_group_id;
PagePtr diskPagePtr((Tup_page*)m_pgman_ptr.p, m_pgman_ptr.i);
ndbassert(diskPagePtr.p->m_page_no == key.m_page_no);
ndbassert(diskPagePtr.p->m_file_no == key.m_file_no);
Uint32 sz, *dst;
if(copy_bits & Tuple_header::DISK_ALLOC)
{
jam();
disk_page_alloc(signal, regTabPtr, regFragPtr, &key, diskPagePtr, gci_hi);
}
if(regTabPtr->m_attributes[DD].m_no_of_varsize == 0)
{
jam();
sz= regTabPtr->m_offsets[DD].m_fix_header_size;
dst= ((Fix_page*)diskPagePtr.p)->get_ptr(key.m_page_idx, sz);
}
else
{
jam();
dst= ((Var_page*)diskPagePtr.p)->get_ptr(key.m_page_idx);
sz= ((Var_page*)diskPagePtr.p)->get_entry_len(key.m_page_idx);
}
if(! (copy_bits & Tuple_header::DISK_ALLOC))
{
jam();
disk_page_undo_update(diskPagePtr.p,
&key, dst, sz, gci_hi, logfile_group_id);
}
memcpy(dst, disk_ptr, 4*sz);
memcpy(tuple_ptr->get_disk_ref_ptr(regTabPtr), &key, sizeof(Local_key));
ndbassert(! (disk_ptr->m_header_bits & Tuple_header::FREE));
copy_bits |= Tuple_header::DISK_PART;
}
if(lcpScan_ptr_i != RNIL && (bits & Tuple_header::ALLOC))
{
jam();
ScanOpPtr scanOp;
c_scanOpPool.getPtr(scanOp, lcpScan_ptr_i);
Local_key rowid = regOperPtr->m_tuple_location;
rowid.m_page_no = pagePtr.p->frag_page_id;
if (!is_rowid_lcp_scanned(rowid, *scanOp.p))
{
jam();
copy_bits |= Tuple_header::LCP_SKIP;
}
}
Uint32 clear=
Tuple_header::ALLOC | Tuple_header::FREE | Tuple_header::COPY_TUPLE |
Tuple_header::DISK_ALLOC | Tuple_header::DISK_INLINE |
Tuple_header::MM_SHRINK | Tuple_header::MM_GROWN;
copy_bits &= ~(Uint32)clear;
tuple_ptr->m_header_bits= copy_bits;
tuple_ptr->m_operation_ptr_i= save;
if (regTabPtr->m_bits & Tablerec::TR_RowGCI &&
update_gci_at_commit)
{
jam();
* tuple_ptr->get_mm_gci(regTabPtr) = gci_hi;
if (regTabPtr->m_bits & Tablerec::TR_ExtraRowGCIBits)
{
Uint32 attrId = regTabPtr->getExtraAttrId<Tablerec::TR_ExtraRowGCIBits>();
store_extra_row_bits(attrId, regTabPtr, tuple_ptr, gci_lo,
/* truncate */true);
}
}
if (regTabPtr->m_bits & Tablerec::TR_Checksum) {
jam();
setChecksum(tuple_ptr, regTabPtr);
}
}
