void aesEncrypt(std::string filename, std::string key) {
if (!(key.length() == 16 || key.length() == 24 || key.length() == 32)) {
std::cout << "Key is not a valid length\n";
return;
}
auto RoundKeys = rijindaelKeySchedule(key); //todo fix 192bit and 256bit keys in schedule.
std::ifstream input(filename, std::ios::binary);
if (input.fail()) {
std::cerr << "Failed to open file\n";
return;
}
std::vector<BYTE> plaintext((std::istreambuf_iterator<char>(input)), std::istreambuf_iterator<char>());
input.close();
addPadding(plaintext);
std::ofstream out(filename + "_aes_enc", std::ios::binary);
for (auto it = plaintext.begin(); it != plaintext.end(); it += 16) {
StateBlock state(it);
cipher(state, RoundKeys);
state.writeToFile(out);
}
out.close();
}
void ImageOverlayRegionFinder::findRegions(bool optimizeForPowersOf2)
{
m_regions.clear();
if (!m_overlay.isValid())
{
return;
}
int rows = m_overlay.getRows();
int columns = m_overlay.getColumns();
unsigned char *data = m_overlay.getData();
// Màscara que indica els píxels visitats
QBitArray mask(rows * columns);
for (int row = 0, i = 0; row < rows; row++)
{
for (int column = 0; column < columns; column++, i++)
{
// Si trobem un objecte no tractat
if (data[i] > 0 && !mask.testBit(i))
{
QRect region = growRegion(row, column, mask);
addPadding(region);
addRegion(region, optimizeForPowersOf2);
removePadding(region);
fillMaskForRegion(mask, region);
}
}
}
}
/**
* Encrypts data based on ciper text, cipher key and IV
* @param b_input Plaintext
* @param p_key Cipher key
* @param p_iv Initialization vector
* @return Encrypted data
*/
QByteArray AES::encrypt(QByteArray b_input, QByteArray p_key, QByteArray p_iv)
{
if (b_input.isEmpty()) {
qDebug() << "Error while encryption: Cannot encrypt empty input";
return QByteArray();
}
addPadding(&b_input);
QByteArray result;
int keySize = p_key.size();
int ivSize = p_iv.size();
if (keySize != 16 && keySize != 24 && keySize != 32) {
qDebug() << "Error while encryption: Invalid keysize";
return QByteArray();
}
if (ivSize != 16) {
qDebug() << "Error while encryption: Invalid keysize";
return QByteArray();
}
// Chunks have to stay < 1MB (1.050MB to be exactly)
qint64 chunksCount = (b_input.size()/500000) + 1;
for (int part = 0; part < chunksCount; part++) {
// Out of range checks
if (part*500000 > b_input.size()) {
qDebug() << "Error while encryption: Skipped: Buffer overflow";
continue;
}
QByteArray p_chunk = b_input.mid(part*500000, 500000);
int inputSize = p_chunk.size();
unsigned char key[keySize];
qByteArrayToUCharArray(p_key, key);
unsigned char iv[ivSize];
qByteArrayToUCharArray(p_iv, iv);
unsigned char decrypted[inputSize];
qByteArrayToUCharArray(p_chunk, decrypted);
unsigned char encrypted[inputSize]; // Encrypted text
aes_context context;
aes_set_key(key, keySize * 8, &context);
aes_cbc_encrypt(decrypted, encrypted, inputSize, iv, &context);
result.append( uCharArrayToQByteArray(encrypted, inputSize));
}
result.prepend(p_iv);
return result;
}
void AtlasPresentationBridge::listMapItem()
{
//Check if we've already printed a map for this list, and if so print a separator
int items = mMapsInList.top();
if (items) {
mStream << mPadding << "---" << std::endl;
}
mMapsInList.pop();
mMapsInList.push(items + 1);
addPadding();
}
NvTweakVarBase* NvTweakBar::addValue(const char *name, float &var, float min, float max, float step/*==0*/, uint32_t actionCode/*==0*/)
{
// make a NvTweakVar on the fly. this will leak currently.
NvTweakVar<float> *tvar = new NvTweakVar<float>(var, name, min, max, step);
NvUISlider *sld = MakeStdSlider(name, var, min, max, step, false, actionCode);
tvar->setActionCode(sld->GetActionCode());
NvUIElement *te = new NvTweakVarUI<float>(*tvar, sld, sld->GetActionCode());
addValueReadout(tvar, max);
addPadding();
AddElement(te);
if (m_compactLayout)
{
NvUIRect tr;
te->GetScreenRect(tr);
te->SetOrigin(tr.left + te->GetWidth()*0.45f, tr.top-(0.4f*te->GetHeight()));
te->SetDimensions(te->GetWidth()*0.35f, te->GetHeight());
}
addPadding();
return tvar;
}
rsRetVal
rsgcryEncrypt(gcryfile pF, uchar *buf, size_t *len)
{
int gcryError;
DEFiRet;
if(*len == 0)
FINALIZE;
addPadding(pF, buf, len);
gcryError = gcry_cipher_encrypt(pF->chd, buf, *len, NULL, 0);
if(gcryError) {
dbgprintf("gcry_cipher_encrypt failed: %s/%s\n",
gcry_strsource(gcryError),
gcry_strerror(gcryError));
ABORT_FINALIZE(RS_RET_ERR);
}
finalize_it:
RETiRet;
}
/*
* Convert a HeapTuple into a byte-sequence, and store it directly
* into a chunklist for transmission.
*
* This code is based on the printtup_internal_20() function in printtup.c.
*/
void
SerializeTupleIntoChunks(HeapTuple tuple, SerTupInfo * pSerInfo, TupleChunkList tcList)
{
TupleChunkListItem tcItem = NULL;
MemoryContext oldCtxt;
TupleDesc tupdesc;
int i,
natts;
bool fHandled;
AssertArg(tcList != NULL);
AssertArg(tuple != NULL);
AssertArg(pSerInfo != NULL);
tupdesc = pSerInfo->tupdesc;
natts = tupdesc->natts;
/* get ready to go */
tcList->p_first = NULL;
tcList->p_last = NULL;
tcList->num_chunks = 0;
tcList->serialized_data_length = 0;
tcList->max_chunk_length = Gp_max_tuple_chunk_size;
if (natts == 0)
{
tcItem = getChunkFromCache(&pSerInfo->chunkCache);
if (tcItem == NULL)
{
ereport(FATAL, (errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("Could not allocate space for first chunk item in new chunk list.")));
}
/* TC_EMTPY is just one chunk */
SetChunkType(tcItem->chunk_data, TC_EMPTY);
tcItem->chunk_length = TUPLE_CHUNK_HEADER_SIZE;
appendChunkToTCList(tcList, tcItem);
return;
}
tcItem = getChunkFromCache(&pSerInfo->chunkCache);
if (tcItem == NULL)
{
ereport(FATAL, (errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("Could not allocate space for first chunk item in new chunk list.")));
}
/* assume that we'll take a single chunk */
SetChunkType(tcItem->chunk_data, TC_WHOLE);
tcItem->chunk_length = TUPLE_CHUNK_HEADER_SIZE;
appendChunkToTCList(tcList, tcItem);
AssertState(s_tupSerMemCtxt != NULL);
if (is_heaptuple_memtuple(tuple))
{
addByteStringToChunkList(tcList, (char *)tuple, memtuple_get_size((MemTuple)tuple, NULL), &pSerInfo->chunkCache);
addPadding(tcList, &pSerInfo->chunkCache, memtuple_get_size((MemTuple)tuple, NULL));
}
else
{
TupSerHeader tsh;
unsigned int datalen;
unsigned int nullslen;
HeapTupleHeader t_data = tuple->t_data;
datalen = tuple->t_len - t_data->t_hoff;
if (HeapTupleHasNulls(tuple))
nullslen = BITMAPLEN(HeapTupleHeaderGetNatts(t_data));
else
nullslen = 0;
tsh.tuplen = sizeof(TupSerHeader) + TYPEALIGN(TUPLE_CHUNK_ALIGN,nullslen) + datalen;
tsh.natts = HeapTupleHeaderGetNatts(t_data);
tsh.infomask = t_data->t_infomask;
addByteStringToChunkList(tcList, (char *)&tsh, sizeof(TupSerHeader), &pSerInfo->chunkCache);
/* If we don't have any attributes which have been toasted, we
* can be very very simple: just send the raw data. */
if ((tsh.infomask & HEAP_HASEXTERNAL) == 0)
{
if (nullslen)
{
addByteStringToChunkList(tcList, (char *)t_data->t_bits, nullslen, &pSerInfo->chunkCache);
addPadding(tcList,&pSerInfo->chunkCache,nullslen);
}
addByteStringToChunkList(tcList, (char *)t_data + t_data->t_hoff, datalen, &pSerInfo->chunkCache);
addPadding(tcList,&pSerInfo->chunkCache,datalen);
}
else
{
/* We have to be more careful when we have tuples that
* have been toasted. Ideally we'd like to send the
* untoasted attributes in as "raw" a format as possible
* but that makes rebuilding the tuple harder .
*/
oldCtxt = MemoryContextSwitchTo(s_tupSerMemCtxt);
/* deconstruct the tuple (faster than a heap_getattr loop) */
heap_deform_tuple(tuple, tupdesc, pSerInfo->values, pSerInfo->nulls);
MemoryContextSwitchTo(oldCtxt);
/* Send the nulls character-array. */
addByteStringToChunkList(tcList, pSerInfo->nulls, natts, &pSerInfo->chunkCache);
addPadding(tcList,&pSerInfo->chunkCache,natts);
/*
* send the attributes of this tuple: NOTE anything which allocates
* temporary space (e.g. could result in a PG_DETOAST_DATUM) should be
* executed with the memory context set to s_tupSerMemCtxt
*/
for (i = 0; i < natts; ++i)
{
SerAttrInfo *attrInfo = pSerInfo->myinfo + i;
Datum origattr = pSerInfo->values[i],
attr;
bytea *outputbytes=0;
/* skip null attributes (already taken care of above) */
if (pSerInfo->nulls[i])
continue;
/*
* If we have a toasted datum, forcibly detoast it here to avoid
* memory leakage: we want to force the detoast allocation(s) to
* happen in our reset-able serialization context.
*/
if (attrInfo->typisvarlena)
{
oldCtxt = MemoryContextSwitchTo(s_tupSerMemCtxt);
/* we want to detoast but leave compressed, if
* possible, but we have to handle varlena
* attributes (and others ?) differently than we
* currently do (first step is to use
* heap_tuple_fetch_attr() instead of
* PG_DETOAST_DATUM()). */
attr = PointerGetDatum(PG_DETOAST_DATUM(origattr));
MemoryContextSwitchTo(oldCtxt);
}
else
attr = origattr;
/*
* Assume that the data's output will be handled by the special IO
* code, and if not then we can handle it the slow way.
*/
fHandled = true;
switch (attrInfo->atttypid)
{
case INT4OID:
addInt32ToChunkList(tcList, DatumGetInt32(attr), &pSerInfo->chunkCache);
break;
case CHAROID:
addCharToChunkList(tcList, DatumGetChar(attr), &pSerInfo->chunkCache);
addPadding(tcList,&pSerInfo->chunkCache,1);
break;
case BPCHAROID:
case VARCHAROID:
case INT2VECTOROID: /* postgres serialization logic broken, use our own */
case OIDVECTOROID: /* postgres serialization logic broken, use our own */
case ANYARRAYOID:
{
text *pText = DatumGetTextP(attr);
int32 textSize = VARSIZE(pText) - VARHDRSZ;
addInt32ToChunkList(tcList, textSize, &pSerInfo->chunkCache);
addByteStringToChunkList(tcList, (char *) VARDATA(pText), textSize, &pSerInfo->chunkCache);
addPadding(tcList,&pSerInfo->chunkCache,textSize);
break;
}
case DATEOID:
{
DateADT date = DatumGetDateADT(attr);
addByteStringToChunkList(tcList, (char *) &date, sizeof(DateADT), &pSerInfo->chunkCache);
break;
}
case NUMERICOID:
{
/*
* Treat the numeric as a varlena variable, and just push
* the whole shebang to the output-buffer. We don't care
* about the guts of the numeric.
*/
Numeric num = DatumGetNumeric(attr);
int32 numSize = VARSIZE(num) - VARHDRSZ;
addInt32ToChunkList(tcList, numSize, &pSerInfo->chunkCache);
addByteStringToChunkList(tcList, (char *) VARDATA(num), numSize, &pSerInfo->chunkCache);
addPadding(tcList,&pSerInfo->chunkCache,numSize);
break;
}
case ACLITEMOID:
{
AclItem *aip = DatumGetAclItemP(attr);
char *outputstring;
int32 aclSize ;
outputstring = DatumGetCString(DirectFunctionCall1(aclitemout,
PointerGetDatum(aip)));
aclSize = strlen(outputstring);
addInt32ToChunkList(tcList, aclSize, &pSerInfo->chunkCache);
addByteStringToChunkList(tcList, outputstring,aclSize, &pSerInfo->chunkCache);
addPadding(tcList,&pSerInfo->chunkCache,aclSize);
break;
}
case 210: /* storage manager */
{
char *smgrstr;
int32 strsize;
smgrstr = DatumGetCString(DirectFunctionCall1(smgrout, 0));
strsize = strlen(smgrstr);
addInt32ToChunkList(tcList, strsize, &pSerInfo->chunkCache);
addByteStringToChunkList(tcList, smgrstr, strsize, &pSerInfo->chunkCache);
addPadding(tcList,&pSerInfo->chunkCache,strsize);
break;
}
default:
fHandled = false;
}
if (fHandled)
continue;
/*
* the FunctionCall2 call into the send function may result in some
* allocations which we'd like to have contained by our reset-able
* context
*/
oldCtxt = MemoryContextSwitchTo(s_tupSerMemCtxt);
/* Call the attribute type's binary input converter. */
if (attrInfo->send_finfo.fn_nargs == 1)
outputbytes =
DatumGetByteaP(FunctionCall1(&attrInfo->send_finfo,
attr));
else if (attrInfo->send_finfo.fn_nargs == 2)
outputbytes =
DatumGetByteaP(FunctionCall2(&attrInfo->send_finfo,
attr,
ObjectIdGetDatum(attrInfo->send_typio_param)));
else if (attrInfo->send_finfo.fn_nargs == 3)
outputbytes =
DatumGetByteaP(FunctionCall3(&attrInfo->send_finfo,
attr,
ObjectIdGetDatum(attrInfo->send_typio_param),
Int32GetDatum(tupdesc->attrs[i]->atttypmod)));
else
{
ereport(ERROR,
(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
errmsg("Conversion function takes %d args",attrInfo->recv_finfo.fn_nargs)));
}
MemoryContextSwitchTo(oldCtxt);
/* We assume the result will not have been toasted */
addInt32ToChunkList(tcList, VARSIZE(outputbytes) - VARHDRSZ, &pSerInfo->chunkCache);
addByteStringToChunkList(tcList, VARDATA(outputbytes),
VARSIZE(outputbytes) - VARHDRSZ, &pSerInfo->chunkCache);
addPadding(tcList,&pSerInfo->chunkCache,VARSIZE(outputbytes) - VARHDRSZ);
/*
* this was allocated in our reset-able context, but we *are* done
* with it; and for tuples with several large columns it'd be nice to
* free the memory back to the context
*/
pfree(outputbytes);
}
MemoryContextReset(s_tupSerMemCtxt);
}
}
/*
* if we have more than 1 chunk we have to set the chunk types on our
* first chunk and last chunk
*/
if (tcList->num_chunks > 1)
{
TupleChunkListItem first,
last;
first = tcList->p_first;
last = tcList->p_last;
Assert(first != NULL);
Assert(first != last);
Assert(last != NULL);
SetChunkType(first->chunk_data, TC_PARTIAL_START);
SetChunkType(last->chunk_data, TC_PARTIAL_END);
/*
* any intervening chunks are already set to TC_PARTIAL_MID when
* allocated
*/
}
return;
}
void AtlasPresentationBridge::listListItem()
{
mMapsInList.push(0);
addPadding();
}
void AtlasPresentationBridge::mapListItem(const std::string& name)
{
mMapsInList.push(0);
mStream << mPadding << name << std::endl;
addPadding();
}
void AtlasPresentationBridge::mapMapItem(const std::string& name)
{
mStream << mPadding << name << std::endl;
addPadding();
}
void AtlasPresentationBridge::streamMessage()
{
addPadding();
}
void AtlasPresentationBridge::streamBegin()
{
addPadding();
}
/*
* Convert a HeapTuple into a byte-sequence, and store it directly
* into a chunklist for transmission.
*
* This code is based on the printtup_internal_20() function in printtup.c.
*/
void
SerializeTupleIntoChunks(GenericTuple gtuple, SerTupInfo *pSerInfo, TupleChunkList tcList)
{
TupleChunkListItem tcItem = NULL;
MemoryContext oldCtxt;
TupleDesc tupdesc;
int i,
natts;
AssertArg(tcList != NULL);
AssertArg(gtuple != NULL);
AssertArg(pSerInfo != NULL);
tupdesc = pSerInfo->tupdesc;
natts = tupdesc->natts;
/* get ready to go */
tcList->p_first = NULL;
tcList->p_last = NULL;
tcList->num_chunks = 0;
tcList->serialized_data_length = 0;
tcList->max_chunk_length = Gp_max_tuple_chunk_size;
if (natts == 0)
{
tcItem = getChunkFromCache(&pSerInfo->chunkCache);
if (tcItem == NULL)
{
ereport(FATAL, (errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("Could not allocate space for first chunk item in new chunk list.")));
}
/* TC_EMTPY is just one chunk */
SetChunkType(tcItem->chunk_data, TC_EMPTY);
tcItem->chunk_length = TUPLE_CHUNK_HEADER_SIZE;
appendChunkToTCList(tcList, tcItem);
return;
}
tcItem = getChunkFromCache(&pSerInfo->chunkCache);
if (tcItem == NULL)
{
ereport(FATAL, (errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("Could not allocate space for first chunk item in new chunk list.")));
}
/* assume that we'll take a single chunk */
SetChunkType(tcItem->chunk_data, TC_WHOLE);
tcItem->chunk_length = TUPLE_CHUNK_HEADER_SIZE;
appendChunkToTCList(tcList, tcItem);
AssertState(s_tupSerMemCtxt != NULL);
if (is_memtuple(gtuple))
{
MemTuple mtuple = (MemTuple) gtuple;
addByteStringToChunkList(tcList, (char *) mtuple, memtuple_get_size(mtuple), &pSerInfo->chunkCache);
addPadding(tcList, &pSerInfo->chunkCache, memtuple_get_size(mtuple));
}
else
{
HeapTuple tuple = (HeapTuple) gtuple;
HeapTupleHeader t_data = tuple->t_data;
TupSerHeader tsh;
unsigned int datalen;
unsigned int nullslen;
datalen = tuple->t_len - t_data->t_hoff;
if (HeapTupleHasNulls(tuple))
nullslen = BITMAPLEN(HeapTupleHeaderGetNatts(t_data));
else
nullslen = 0;
tsh.tuplen = sizeof(TupSerHeader) + TYPEALIGN(TUPLE_CHUNK_ALIGN,nullslen) + datalen;
tsh.natts = HeapTupleHeaderGetNatts(t_data);
tsh.infomask = t_data->t_infomask;
addByteStringToChunkList(tcList, (char *)&tsh, sizeof(TupSerHeader), &pSerInfo->chunkCache);
/* If we don't have any attributes which have been toasted, we
* can be very very simple: just send the raw data. */
if ((tsh.infomask & HEAP_HASEXTERNAL) == 0)
{
if (nullslen)
{
addByteStringToChunkList(tcList, (char *)t_data->t_bits, nullslen, &pSerInfo->chunkCache);
addPadding(tcList,&pSerInfo->chunkCache,nullslen);
}
addByteStringToChunkList(tcList, (char *)t_data + t_data->t_hoff, datalen, &pSerInfo->chunkCache);
addPadding(tcList,&pSerInfo->chunkCache,datalen);
}
else
{
/* We have to be more careful when we have tuples that
* have been toasted. Ideally we'd like to send the
* untoasted attributes in as "raw" a format as possible
* but that makes rebuilding the tuple harder .
*/
oldCtxt = MemoryContextSwitchTo(s_tupSerMemCtxt);
/* deconstruct the tuple (faster than a heap_getattr loop) */
heap_deform_tuple(tuple, tupdesc, pSerInfo->values, pSerInfo->nulls);
MemoryContextSwitchTo(oldCtxt);
/* Send the nulls character-array. */
addByteStringToChunkList(tcList, pSerInfo->nulls, natts, &pSerInfo->chunkCache);
addPadding(tcList,&pSerInfo->chunkCache,natts);
/*
* send the attributes of this tuple: NOTE anything which allocates
* temporary space (e.g. could result in a PG_DETOAST_DATUM) should be
* executed with the memory context set to s_tupSerMemCtxt
*/
for (i = 0; i < natts; ++i)
{
SerAttrInfo *attrInfo = pSerInfo->myinfo + i;
Datum origattr = pSerInfo->values[i],
attr;
/* skip null attributes (already taken care of above) */
if (pSerInfo->nulls[i])
continue;
if (attrInfo->typlen == -1)
{
int32 sz;
char *data;
/*
* If we have a toasted datum, forcibly detoast it here to avoid
* memory leakage: we want to force the detoast allocation(s) to
* happen in our reset-able serialization context.
*/
oldCtxt = MemoryContextSwitchTo(s_tupSerMemCtxt);
attr = PointerGetDatum(PG_DETOAST_DATUM_PACKED(origattr));
MemoryContextSwitchTo(oldCtxt);
sz = VARSIZE_ANY_EXHDR(attr);
data = VARDATA_ANY(attr);
/* Send length first, then data */
addInt32ToChunkList(tcList, sz, &pSerInfo->chunkCache);
addByteStringToChunkList(tcList, data, sz, &pSerInfo->chunkCache);
addPadding(tcList, &pSerInfo->chunkCache, sz);
}
else if (attrInfo->typlen == -2)
{
int32 sz;
char *data;
/* CString, we would send the string with the terminating '\0' */
data = DatumGetCString(origattr);
sz = strlen(data) + 1;
/* Send length first, then data */
addInt32ToChunkList(tcList, sz, &pSerInfo->chunkCache);
addByteStringToChunkList(tcList, data, sz, &pSerInfo->chunkCache);
addPadding(tcList, &pSerInfo->chunkCache, sz);
}
else if (attrInfo->typbyval)
{
/*
* We send a full-width Datum for all pass-by-value types, regardless of
* the actual size.
*/
addByteStringToChunkList(tcList, (char *) &origattr, sizeof(Datum), &pSerInfo->chunkCache);
addPadding(tcList, &pSerInfo->chunkCache, sizeof(Datum));
}
else
{
addByteStringToChunkList(tcList, DatumGetPointer(origattr), attrInfo->typlen, &pSerInfo->chunkCache);
addPadding(tcList, &pSerInfo->chunkCache, attrInfo->typlen);
attr = origattr;
}
}
MemoryContextReset(s_tupSerMemCtxt);
}
}
/*
* if we have more than 1 chunk we have to set the chunk types on our
* first chunk and last chunk
*/
if (tcList->num_chunks > 1)
{
TupleChunkListItem first,
last;
first = tcList->p_first;
last = tcList->p_last;
Assert(first != NULL);
Assert(first != last);
Assert(last != NULL);
SetChunkType(first->chunk_data, TC_PARTIAL_START);
SetChunkType(last->chunk_data, TC_PARTIAL_END);
/*
* any intervening chunks are already set to TC_PARTIAL_MID when
* allocated
*/
}
return;
}
/*
* Convert RecordCache into a byte-sequence, and store it directly
* into a chunklist for transmission.
*
* This code is based on the printtup_internal_20() function in printtup.c.
*/
void
SerializeRecordCacheIntoChunks(SerTupInfo *pSerInfo,
TupleChunkList tcList,
MotionConn *conn)
{
TupleChunkListItem tcItem = NULL;
MemoryContext oldCtxt;
TupSerHeader tsh;
List *typelist = NULL;
int size = -1;
char * buf = NULL;
AssertArg(tcList != NULL);
AssertArg(pSerInfo != NULL);
/* get ready to go */
tcList->p_first = NULL;
tcList->p_last = NULL;
tcList->num_chunks = 0;
tcList->serialized_data_length = 0;
tcList->max_chunk_length = Gp_max_tuple_chunk_size;
tcItem = getChunkFromCache(&pSerInfo->chunkCache);
if (tcItem == NULL)
{
ereport(FATAL, (errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("Could not allocate space for first chunk item in new chunk list.")));
}
/* assume that we'll take a single chunk */
SetChunkType(tcItem->chunk_data, TC_WHOLE);
tcItem->chunk_length = TUPLE_CHUNK_HEADER_SIZE;
appendChunkToTCList(tcList, tcItem);
AssertState(s_tupSerMemCtxt != NULL);
/*
* To avoid inconsistency of record cache between sender and receiver in
* the same motion, send the serialized record cache to receiver before the
* first tuple is sent, the receiver is responsible for registering the
* records to its own local cache and remapping the typmod of tuples sent
* by sender.
*/
oldCtxt = MemoryContextSwitchTo(s_tupSerMemCtxt);
typelist = build_tuple_node_list(conn->sent_record_typmod);
buf = serializeNode((Node *) typelist, &size, NULL);
MemoryContextSwitchTo(oldCtxt);
tsh.tuplen = sizeof(TupSerHeader) + size;
/*
* we use natts==0xffff and infomask==0xffff to identify this special
* tuple which actually carry the serialized record cache table.
*/
tsh.natts = RECORD_CACHE_MAGIC_NATTS;
tsh.infomask = RECORD_CACHE_MAGIC_INFOMASK;
addByteStringToChunkList(tcList,
(char *)&tsh,
sizeof(TupSerHeader),
&pSerInfo->chunkCache);
addByteStringToChunkList(tcList, buf, size, &pSerInfo->chunkCache);
addPadding(tcList, &pSerInfo->chunkCache, size);
/*
* if we have more than 1 chunk we have to set the chunk types on our
* first chunk and last chunk
*/
if (tcList->num_chunks > 1)
{
TupleChunkListItem first,
last;
first = tcList->p_first;
last = tcList->p_last;
Assert(first != NULL);
Assert(first != last);
Assert(last != NULL);
SetChunkType(first->chunk_data, TC_PARTIAL_START);
SetChunkType(last->chunk_data, TC_PARTIAL_END);
/*
* any intervening chunks are already set to TC_PARTIAL_MID when
* allocated
*/
}
return;
}