vector< vector<u32> > kmeans_pp(const vector< vector<f64> >& points, u32 k,
algo::iLCG& lcg,
vector< vector<f64> >& centers)
{
if (points.size() == 0)
throw eInvalidArgument("There must be points to cluster!");
if (points[0].size() == 0)
throw eInvalidArgument("There must be at least one dimension!");
for (size_t i = 1; i < points.size(); i++)
if (points[i].size() != points[0].size())
throw eInvalidArgument("All data points must have the same dimensionality.");
if (k == 0)
throw eInvalidArgument("Clustering into zero clusters makes no sense.");
centers.resize(k);
centers[0] = points[lcg.next() % points.size()];
for (u32 i = 1; i < k; i++)
{
vector<f64> cumDists(points.size());
for (size_t d = 0; d < cumDists.size(); d++)
{
f64 mind = s_distanceSquared(points[d], centers[0]);
for (u32 j = 1; j < i; j++)
mind = std::min(mind, s_distanceSquared(points[d], centers[j]));
cumDists[d] = (d == 0) ? (mind) : (cumDists[d-1]+mind);
}
f64 ran = ((f64)lcg.next()) / ((f64)lcg.randMax()) * cumDists.back();
size_t d;
for (d = 0; ran > cumDists[d]; d++) { }
centers[i] = points[d];
}
return kmeans(points, k, centers);
}
static
nKeyLengthAES s_toKeyLen(size_t vectsize)
{
switch (vectsize)
{
case 128/8: return k128bit;
case 192/8: return k192bit;
case 256/8: return k256bit;
default: throw eInvalidArgument("Invalid aes key length!");
}
}
vector< vector<u32> > kmeans(const vector< vector<f64> >& points, u32 k,
f64 rmin, f64 rmax, algo::iLCG& lcg,
vector< vector<f64> >& centers)
{
if (points.size() == 0)
throw eInvalidArgument("There must be points to cluster!");
if (points[0].size() == 0)
throw eInvalidArgument("There must be at least one dimension!");
for (size_t i = 1; i < points.size(); i++)
if (points[i].size() != points[0].size())
throw eInvalidArgument("All data points must have the same dimensionality.");
if (k == 0)
throw eInvalidArgument("Clustering into zero clusters makes no sense.");
if (rmin >= rmax)
throw eInvalidArgument("rmin >= rmax makes no sense.");
centers.resize(k);
for (u32 i = 0; i < k; i++)
centers[i] = s_randPoint(lcg, rmin, rmax, (u32)points[0].size());
return kmeans(points, k, centers);
}
tSecureStream::tSecureStream(iReadable* internalReadable,
iWritable* internalWritable,
const tRSA& rsa,
string appGreeting)
: m_internal_readable(internalReadable),
m_internal_writable(internalWritable)
{
if (internalReadable == NULL || internalWritable == NULL)
throw eInvalidArgument("The internal streams may not be null.");
if (rsa.hasPrivateKey())
m_setupServer(rsa, appGreeting);
else
m_setupClient(rsa, appGreeting);
}
vector< vector<u32> > kmeans(const vector< vector<f64> >& points, u32 k,
vector< vector<f64> >& centers)
{
if (points.size() == 0)
throw eInvalidArgument("There must be points to cluster!");
if (points[0].size() == 0)
throw eInvalidArgument("There must be at least one dimension!");
for (size_t i = 1; i < points.size(); i++)
if (points[i].size() != points[0].size())
throw eInvalidArgument("All data points must have the same dimensionality.");
if (k == 0)
throw eInvalidArgument("Clustering into zero clusters makes no sense.");
if ((u32)centers.size() != k)
throw eInvalidArgument("You must supply k initial centers to this version of kmeans().");
for (u32 i = 0; i < k; i++)
if (centers[i].size() != points[0].size())
throw eInvalidArgument("All initial centers must have the same dimensionality as the data points.");
vector< vector<u32> > clusters(k);
while (true)
{
vector< vector<u32> > newClusters(k);
for (size_t i = 0; i < points.size(); i++)
{
f64 dist = s_distanceSquared(points[i], centers[0]);
u32 closest = 0;
for (u32 c = 1; c < k; c++)
{
f64 distHere = s_distanceSquared(points[i], centers[c]);
if (distHere < dist)
{
closest = c;
dist = distHere;
}
}
newClusters[closest].push_back((u32)i);
}
for (u32 i = 0; i < k; i++)
if (newClusters[i].size() > 0)
centers[i] = s_calcCenter(points, newClusters[i]);
// Else, what should I do? Leave it? Randomize a new center?
if (clusters == newClusters)
break;
clusters = newClusters;
}
return clusters;
}
tAddr tSocket::receive(u8* buf, i32 maxSize, i32& bufSize, u16& port)
{
if (maxSize <= 0)
throw eInvalidArgument("maxSize must be positive");
struct sockaddr_in6 sockAddr;
socklen_t sockAddrLen = sizeof(sockAddr);
socklen_t returnedLen = sockAddrLen;
#if __linux__ || __APPLE__ || __CYGWIN__
int flags = MSG_TRUNC;
#elif __MINGW32__
int flags = 0;
#else
#error What platform are you on!?
#endif
ssize_t ret = ::recvfrom(m_fd, (char*)buf, (size_t)maxSize, flags,
(struct sockaddr*)&sockAddr,
&returnedLen);
if (ret == -1)
{
throw eRuntimeError(
std::string("Cannot recvfrom udp socket. Error: ") +
strerror(errno));
}
if (returnedLen > sockAddrLen)
{
throw eLogicError("Something is crazy wrong (2).");
}
bufSize = (i32) ret;
tAddr addr((struct sockaddr*)&sockAddr, (int)returnedLen);
port = addr.getUpperProtoPort();
return addr;
}
void tSocket::send(const u8* buf, i32 bufSize, tAddr dest, u16 port)
{
if (dest.getVersion() == kIPv4)
{
tAddrGroup addrGroup(std::string("::ffff:") + dest.toString());
dest = addrGroup[0];
}
if (bufSize <= 0)
throw eInvalidArgument("bufSize must be positive");
dest.setUpperProtoPort(port);
int flags = 0;
ssize_t ret = ::sendto(m_fd, (const char*)buf, (size_t)bufSize, flags,
(struct sockaddr*)(dest.m_sockaddr),
dest.m_sockaddrlen);
if (ret == -1)
{
throw eRuntimeError(
std::string("Cannot sendto udp socket. Error: ") +
strerror(errno));
}
}
void tImageAsyncReadable::takeInput(const u8* buffer, i32 length)
{
if (length <= 0)
throw eInvalidArgument("Stream read/write length must be >0");
while (length > 0)
{
switch (m_stage)
{
case kStageBufUsed:
{
while (m_bufPos < 4 && length > 0)
{
m_buf[m_bufPos++] = *buffer++;
--length;
}
if (m_bufPos == 4)
{
m_bufPos = 0;
m_stage = kStageBufData;
m_image.setBufUsed(s_toU32(m_buf));
if (m_image.bufSize() < m_image.bufUsed())
m_image.setBufSize(m_image.bufUsed());
}
break;
}
case kStageBufData:
{
u32 bufUsed = m_image.bufUsed();
u8* imagebuf = m_image.buf();
while (m_bufPos < bufUsed && length > 0)
{
imagebuf[m_bufPos++] = *buffer++;
--length;
}
if (m_bufPos == bufUsed)
{
m_bufPos = 0;
m_stage = kStageWidth;
}
break;
}
case kStageWidth:
{
while (m_bufPos < 4 && length > 0)
{
m_buf[m_bufPos++] = *buffer++;
--length;
}
if (m_bufPos == 4)
{
m_bufPos = 0;
m_stage = kStageHeight;
m_image.setWidth(s_toU32(m_buf));
}
break;
}
case kStageHeight:
{
while (m_bufPos < 4 && length > 0)
{
m_buf[m_bufPos++] = *buffer++;
--length;
}
if (m_bufPos == 4)
{
m_bufPos = 0;
m_stage = kStageFormat;
m_image.setHeight(s_toU32(m_buf));
}
break;
}
case kStageFormat:
{
while (m_bufPos < 4 && length > 0)
{
m_buf[m_bufPos++] = *buffer++;
--length;
}
if (m_bufPos == 4)
{
m_bufPos = 0;
m_stage = kStageBufUsed;
m_image.setFormat((nImageFormat)(s_toU32(m_buf)));
try {
m_observer->gotImage(m_image);
} catch (...) { }
}
break;
}
default:
{
throw eRuntimeError("Unknown state. How did this happen!?");
}
}
}
}
void tDecAES::dec(u8* ctbuf, u8* ptbuf, u32 numblocks, u8* iv)
{
// Fast ASM impl:
if (m_useASM)
{
sAesData data;
data.in_block = ctbuf;
data.out_block = ptbuf;
data.expanded_key = m_expandedKey;
data.iv = iv;
data.num_blocks = numblocks;
if (m_opmode == kOpModeCBC && iv)
{
switch (m_keylen)
{
case k128bit: iDec128_CBC(&data); break;
case k192bit: iDec192_CBC(&data); break;
case k256bit: iDec256_CBC(&data); break;
default: throw eInvalidArgument("The keylen parameter is not valid!");
}
}
else
{
switch (m_keylen)
{
case k128bit: iDec128(&data); break;
case k192bit: iDec192(&data); break;
case k256bit: iDec256(&data); break;
default: throw eInvalidArgument("The keylen parameter is not valid!");
}
}
}
// Fallback impl:
else
{
u32* rk = m_rk;
int Nr = m_Nr;
if (m_opmode == kOpModeCBC && iv)
{
u8 ct[AES_BLOCK_SIZE];
for (u32 i = 0; numblocks > 0; i+=AES_BLOCK_SIZE, --numblocks)
{
for (u32 j = 0; j < AES_BLOCK_SIZE; j++)
ct[j] = ctbuf[i+j];
rijndaelDecrypt(rk, Nr, ct, ptbuf+i);
for (u32 j = 0; j < AES_BLOCK_SIZE; j++)
{
ptbuf[i+j] ^= iv[j];
iv[j] = ct[j];
}
}
}
else
{
for (u32 i = 0; numblocks > 0; i+=AES_BLOCK_SIZE, --numblocks)
{
rijndaelDecrypt(rk, Nr, ctbuf+i, ptbuf+i);
}
}
}
}
void tDecAES::m_init(nOperationModeAES opmode, const u8 key[], nKeyLengthAES keylen,
bool useFastASM)
{
// Set fields.
m_opmode = opmode;
m_keylen = keylen;
m_useASM = useFastASM;
m_expandedKey = NULL;
// Check the opmode.
switch (opmode)
{
case kOpModeECB: break;
case kOpModeCBC: break;
default: throw eInvalidArgument("The opmode parameter is not valid!");
}
// Check the keylen.
switch (keylen)
{
case k128bit: break;
case k192bit: break;
case k256bit: break;
default: throw eInvalidArgument("The keylen parameter is not valid!");
}
// Fast ASM setup:
if (m_useASM)
{
m_expandedKey = s_aligned_malloc(256, 16);
switch (keylen)
{
case k128bit:
{
u8* key_copy = new u8[16];
memcpy(key_copy, key, 16);
iDecExpandKey128(key_copy, m_expandedKey);
delete [] key_copy;
break;
}
case k192bit:
{
u8* key_copy = new u8[24];
memcpy(key_copy, key, 24);
iDecExpandKey192(key_copy, m_expandedKey);
delete [] key_copy;
break;
}
case k256bit:
{
u8* key_copy = new u8[32];
memcpy(key_copy, key, 32);
iDecExpandKey256(key_copy, m_expandedKey);
delete [] key_copy;
break;
}
default: throw eInvalidArgument("The keylen parameter is not valid!");
}
}
// Fallback setup:
else
{
int keybits;
int expectedNr;
switch (keylen)
{
case k128bit: keybits = 128; expectedNr = 10; break;
case k192bit: keybits = 192; expectedNr = 12; break;
case k256bit: keybits = 256; expectedNr = 14; break;
default: throw eInvalidArgument("The keylen parameter is not valid!");
}
m_Nr = rijndaelKeySetupDec(m_rk, key, keybits);
if (m_Nr != expectedNr)
throw eImpossiblePath();
}
}
