void arg_meas(uint8_t event, context_t *context)
{
#define AMEAS_PROMPT "\nMEA>"
if (event == EVENT_HELP) {
buffer_nl(&gMnuBuffer);
buffer_ch(&gMnuBuffer, MEAS_BEGIN);
buffer_str(&gMnuBuffer, " .. ");
buffer_ch(&gMnuBuffer, MEAS_END);
buffer_str(&gMnuBuffer, AMEAS_PROMPT);
}
else if (event == EVENT_PROMPT) {
buffer_str(&gMnuBuffer, AMEAS_PROMPT);
}
else if (event == EVENT_BACKSP) {
change_state(context, &menu_meas);
}
else if ((event >= MEAS_BEGIN) && (event <= MEAS_END)) {
add_arg(context, event - MEAS_BEGIN);
buffer_ch(&gMnuBuffer, event);
if ((context->action == act_meas_high) ||
(context->action == act_meas_low))
{
change_state(context, arg_value);
}
else {
change_state(context, menu_root);
}
}
else {
invalid_character(context);
}
}
void menu_utest(uint8_t event, context_t *context)
{
#define UTEST_PROMPT "\nRU>"
reset_action(context);
switch (event) {
case EVENT_HELP:
buffer_str(&gMnuBuffer, "\n\nAtest Btest" UTEST_PROMPT);
break;
case EVENT_ENTER:
case EVENT_PROMPT:
buffer_str(&gMnuBuffer, UTEST_PROMPT);
break;
case EVENT_BACKSP:
change_state(context, &menu_root);
break;
case 'a':
change_state(context, menu_root);
break;
case 'b':
change_state(context, menu_root);
break;
default:
invalid_character(context);
break;
}
}
void menu_settings(uint8_t event, context_t *context)
{
#define SETTING_PROMPT "\nRS>"
reset_action(context);
switch (event) {
case EVENT_HELP:
buffer_str(&gMnuBuffer, "\n\nClock Debug" SETTING_PROMPT);
break;
case EVENT_ENTER:
case EVENT_PROMPT:
buffer_str(&gMnuBuffer, SETTING_PROMPT);
break;
case EVENT_BACKSP:
change_state(context, &menu_root);
break;
case 'c':
context->action = act_set_clock;
change_state(context, arg_clock);
break;
case 'd':
buffer_str(&gMnuBuffer, "\nDebug mode\n");
break;
default:
invalid_character(context);
break;
}
}
//------------------------------------------------------------------------------
void menu_root(uint8_t event, context_t *context)
{
#define ROOT_PROMPT "\nR>"
switch (event) {
case EVENT_HELP:
buffer_str(&gMnuBuffer, "\n\nMeas Timer Settings Version Utest" ROOT_PROMPT);
break;
case EVENT_ENTER:
case EVENT_PROMPT:
buffer_str(&gMnuBuffer, ROOT_PROMPT);
break;
case EVENT_BACKSP:
break;
case 'm':
change_state(context, &menu_meas);
break;
case 't':
change_state(context, &menu_timer);
break;
case 's':
change_state(context, &menu_settings);
break;
case 'v':
show_version();
break;
case 'u':
change_state(context, menu_utest);
default:
invalid_character(context);
break;
}
}
char* queue_encode_entry (queue_entry_t* entry, char* buf, int size)
{
char* buf_p = buf;
*(hfs_time_t*)buf_p = entry->ts;
buf_p += sizeof (hfs_time_t);
if ((buf_p = buffer_str (buf_p, entry->server, size)) == NULL)
return NULL;
if ((buf_p = buffer_str (buf_p, entry->key, size-(buf_p-buf))) == NULL)
return NULL;
if ((buf_p = buffer_str (buf_p, entry->value, size-(buf_p-buf))) == NULL)
return NULL;
if ((buf_p = buffer_str (buf_p, entry->error, size-(buf_p-buf))) == NULL)
return NULL;
if ((buf_p = buffer_str (buf_p, entry->lastlogsize, size-(buf_p-buf))) == NULL)
return NULL;
if ((buf_p = buffer_str (buf_p, entry->timestamp, size-(buf_p-buf))) == NULL)
return NULL;
if ((buf_p = buffer_str (buf_p, entry->source, size-(buf_p-buf))) == NULL)
return NULL;
if ((buf_p = buffer_str (buf_p, entry->severity, size-(buf_p-buf))) == NULL)
return NULL;
return buf_p;
}
void arg_value(uint8_t event, context_t *context)
{
if ((event == EVENT_HELP) ||
(event == EVENT_PROMPT))
{
buffer_str(&gMnuBuffer, "\nVAL>");
}
else if (event == EVENT_BACKSP) {
if (context->substate > 0) {
context->substate--;
context->currentArg--;
}
else {
}
}
else if ((context->substate == 0 && event >= '0' && event <= '9') ||
(context->substate == 1 && event >= '0' && event <= '9') ||
(context->substate == 2 && event >= '0' && event <= '9'))
{
buffer_ch(&gMnuBuffer, event);
add_arg(context, event - '0');
(context->substate)++;
if (context->substate == 3) {
execute(context);
change_state(context, menu_root);
}
}
else {
invalid_character(context);
}
}
void arg_on_off(uint8_t event, context_t *context)
{
#define AONOFF_PROMPT "\nSTA>"
switch (event) {
case EVENT_HELP:
case EVENT_PROMPT:
buffer_str(&gMnuBuffer, AONOFF_PROMPT);
break;
case EVENT_BACKSP:
if (context->action == act_timer_activate) {
change_state(context, arg_timer);
}
else {
change_state(context, menu_root);
}
break;
case '0':
case '1':
add_arg(context, event - '0');
if (context->action == act_timer_activate) {
execute(context);
}
change_state(context, menu_root);
break;
default:
invalid_character(context);
break;
}
}
void dump_args(uint8_t len, uint8_t *args)
{
uint8_t i;
buffer_str(&gMnuBuffer, "\nARG=");
for (i=0; i<len; i++) {
buffer_ch(&gMnuBuffer, ' ');
buffer_hex8(&gMnuBuffer, args[i]);
}
buffer_nl(&gMnuBuffer);
}
void menu_timer(uint8_t event, context_t *context)
{
#define TIMER_PROMPT "\nRT>"
reset_action(context);
switch (event) {
case EVENT_HELP:
buffer_str(&gMnuBuffer, "\n\nActivate Show Begin End" TIMER_PROMPT);
break;
case EVENT_ENTER:
case EVENT_PROMPT:
buffer_str(&gMnuBuffer, TIMER_PROMPT);
break;
case EVENT_BACKSP:
change_state(context, &menu_root);
break;
case 'a':
context->action = act_timer_activate;
change_state(context, &arg_timer);
break;
case 's':
buffer_nl(&gMnuBuffer);
sche_show(1);
gFuncMLine = sche_show;
break;
case 'b':
context->action = act_timer_begin;
change_state(context, &arg_timer);
break;
case 'e':
context->action = act_timer_end;
change_state(context, &arg_timer);
break;
default:
invalid_character(context);
break;
}
}
void arg_timer(uint8_t event, context_t *context)
{
#define ATIMER_PROMPT "\nTIM>"
if (event == EVENT_HELP) {
buffer_nl(&gMnuBuffer);
buffer_ch(&gMnuBuffer, TIMER_BEGIN);
buffer_str(&gMnuBuffer, " .. ");
buffer_ch(&gMnuBuffer, TIMER_END);
buffer_str(&gMnuBuffer, ATIMER_PROMPT);
}
else if (event == EVENT_PROMPT) {
buffer_str(&gMnuBuffer, ATIMER_PROMPT);
}
else if (event == EVENT_BACKSP) {
change_state(context, &menu_timer);
}
else if ((event >= TIMER_BEGIN) && (event <= TIMER_END)) {
add_arg(context, event - TIMER_BEGIN);
buffer_ch(&gMnuBuffer, event);
if ((context->action == act_timer_begin) ||
(context->action == act_timer_end))
{
change_state(context, arg_clock);
}
else if (context->action == act_timer_activate) {
change_state(context, &arg_on_off);
}
else {
change_state(context, &menu_root);
}
}
else {
invalid_character(context);
}
}
void menu_meas(uint8_t event, context_t *context)
{
#define MEAS_PROMPT "\nRM>"
reset_action(context);
switch (event) {
case EVENT_HELP:
buffer_str(&gMnuBuffer, "\n\nShow Trigger Highlimit Lowlimit" MEAS_PROMPT);
break;
case EVENT_PROMPT:
buffer_str(&gMnuBuffer, MEAS_PROMPT);
break;
case EVENT_BACKSP:
change_state(context, &menu_root);
break;
case 's':
buffer_nl(&gMnuBuffer);
meas_show(1);
gFuncMLine = meas_show;
break;
case 't':
buffer_str(&gMnuBuffer, "\nmeasure trigger\n");
break;
case 'h':
context->action = act_meas_high;
change_state(context, &arg_meas);
break;
case 'l':
context->action = act_meas_low;
change_state(context, &arg_meas);
break;
default:
invalid_character(context);
break;
}
}
int queue_encode_history_header (queue_history_entry_t* entry, const char* server, const char* key)
{
int len = 0;
char* res_p;
memset (entry, 0, sizeof (queue_history_entry_t));
len += sizeof (int);
if (server)
len += strlen (server) + 1;
len += sizeof (int);
if (key)
len += strlen (key) + 1;
len += sizeof (int);
entry->buf = (char*)malloc (len);
entry->buf_size = len;
/* reserve space for items count */
res_p = entry->buf;
res_p += sizeof (int);
/* server and key strings */
res_p = buffer_str (res_p, server, len);
if (!res_p)
goto error;
res_p = buffer_str (res_p, key, len-(res_p-entry->buf));
if (!res_p)
goto error;
return 1;
error:
if (entry->buf)
free (entry->buf);
return 0;
}
//文字を書き込む
bool Console::write(const VOID* buffer,DWORD buffer_size,LPDWORD written_chars){
bool result=false;
DWORD written=0;
if(isRedirected()){
tstring buffer_str((const TCHAR*)buffer);
str::replaceString(buffer_str,_T("\n"),_T("\r\n"));
#ifdef UNICODE
if(isAnsiMode()){
std::string ansi=str::utf162sjis(buffer_str);
result=::WriteFile(m_handle,ansi.c_str(),ansi.length()*sizeof(char),&written,NULL)!=0;
}else
#endif
result=::WriteFile(m_handle,buffer_str.c_str(),buffer_str.length()*sizeof(TCHAR),&written,NULL)!=0;
if(written_chars)*written_chars=written/sizeof(TCHAR);
}else{
//バッファサイズが大き過ぎる場合出力されない
// result=::WriteConsole(m_handle,buffer,buffer_size,&written,NULL);
//分割して出力
#ifdef UNICODE
if(!isAnsiMode()){
#endif
const TCHAR* ptr=static_cast<const TCHAR*>(buffer);
const TCHAR* end=ptr+lstrlen(static_cast<const TCHAR*>(buffer));
for(DWORD write_size=io_buffer_size;ptr<end;ptr+=written){
if(write_size>static_cast<DWORD>(end-ptr))write_size=end-ptr;
result=::WriteConsole(m_handle,ptr,write_size,&written,NULL)!=0;
}
if(written_chars)*written_chars=ptr-(const TCHAR*)buffer;
#ifdef UNICODE
}else{
std::string ansi=str::utf162sjis(static_cast<const wchar_t*>(buffer));
const char* ptr=ansi.c_str();
const char* end=ptr+lstrlenA(ansi.c_str());
for(DWORD write_size=io_buffer_size;ptr<end;ptr+=written){
if(write_size>static_cast<DWORD>(end-ptr))write_size=end-ptr;
result=::WriteConsoleA(m_handle,ptr,write_size,&written,NULL)!=0;
}
if(written_chars)*written_chars=ptr-ansi.c_str();
}
#endif
}
return result;
}
FileTypes::Type FileHandler::getTypeByContent(const String& filename)
{
String first_line;
String two_five;
String all_simple;
// only the first five lines will be set for compressed files
// so far, compression is only supported for XML files
vector<String> complete_file;
// test whether the file is compressed (bzip2 or gzip)
ifstream compressed_file(filename.c_str());
char bz[2];
compressed_file.read(bz, 2);
char g1 = 0x1f;
char g2 = 0;
g2 |= 1 << 7;
g2 |= 1 << 3;
g2 |= 1 << 1;
g2 |= 1 << 0;
compressed_file.close();
if (bz[0] == 'B' && bz[1] == 'Z') // bzip2
{
Bzip2Ifstream bzip2_file(filename.c_str());
char buffer[1024];
bzip2_file.read(buffer, 1024);
String buffer_str(buffer);
vector<String> split;
buffer_str.split('\n', split);
split.resize(5);
first_line = split[0];
two_five = split[1] + ' ' + split[2] + ' ' + split[3] + ' ' + split[4];
all_simple = first_line + ' ' + two_five;
complete_file = split;
}
else if (bz[0] == g1 && bz[1] == g2) // gzip
{
GzipIfstream gzip_file(filename.c_str());
char buffer[1024];
gzip_file.read(buffer, 1024);
String buffer_str(buffer);
vector<String> split;
buffer_str.split('\n', split);
split.resize(5);
first_line = split[0];
two_five = split[1] + ' ' + split[2] + ' ' + split[3] + ' ' + split[4];
all_simple = first_line + ' ' + two_five;
complete_file = split;
}
//else {} // TODO: ZIP
else // uncompressed
{
//load first 5 lines
TextFile file(filename, true, 5);
TextFile::ConstIterator file_it = file.begin();
// file could be empty
if (file_it == file.end())
{
two_five = " ";
all_simple = " ";
first_line = " ";
}
else
{
// concat elements 2 to 5
two_five = "";
++file_it;
for (int i = 1; i < 5; ++i)
{
if (file_it != file.end())
{
two_five += *file_it;
++file_it;
}
else
{
two_five += "";
}
two_five += " ";
}
// remove trailing space
two_five = two_five.chop(1);
two_five.substitute('\t', ' ');
all_simple = *(file.begin()) + ' ' + two_five;
first_line = *(file.begin());
}
complete_file.insert(complete_file.end(), file.begin(), file.end());
}
//std::cerr << "\n Line1:\n" << first_line << "\nLine2-5:\n" << two_five << "\nall:\n" << all_simple << "\n\n";
//mzXML (all lines)
if (all_simple.hasSubstring("<mzXML"))
return FileTypes::MZXML;
//mzData (all lines)
if (all_simple.hasSubstring("<mzData"))
return FileTypes::MZDATA;
//mzML (all lines)
if (all_simple.hasSubstring("<mzML"))
return FileTypes::MZML;
//"analysisXML" aka. mzid (all lines)
if (all_simple.hasSubstring("<mzIdentML"))
return FileTypes::MZIDENTML;
//mzq (all lines)
if (all_simple.hasSubstring("<qcML"))
return FileTypes::MZQUANTML;
//subject to change!
if (all_simple.hasSubstring("<MzQualityMLType"))
return FileTypes::QCML;
//pepXML (all lines)
if (all_simple.hasSubstring("xmlns=\"http://regis-web.systemsbiology.net/pepXML\""))
return FileTypes::PEPXML;
//protXML (all lines)
if (all_simple.hasSubstring("xmlns=\"http://regis-web.systemsbiology.net/protXML\""))
return FileTypes::PROTXML;
//feature map (all lines)
if (all_simple.hasSubstring("<featureMap"))
return FileTypes::FEATUREXML;
//idXML (all lines)
if (all_simple.hasSubstring("<IdXML"))
return FileTypes::IDXML;
//consensusXML (all lines)
if (all_simple.hasSubstring("<consensusXML"))
return FileTypes::CONSENSUSXML;
//TOPPAS (all lines)
if (all_simple.hasSubstring("<PARAMETERS") && all_simple.hasSubstring("<NODE name=\"info\"") && all_simple.hasSubstring("<ITEM name=\"num_vertices\""))
return FileTypes::TOPPAS;
//INI (all lines) (must be AFTER TOPPAS) - as this is less restrictive
if (all_simple.hasSubstring("<PARAMETERS"))
return FileTypes::INI;
//TrafoXML (all lines)
if (all_simple.hasSubstring("<TrafoXML"))
return FileTypes::TRANSFORMATIONXML;
//GelML (all lines)
if (all_simple.hasSubstring("<GelML"))
return FileTypes::GELML;
//traML (all lines)
if (all_simple.hasSubstring("<TraML"))
return FileTypes::TRAML;
//OMSSAXML file
if (all_simple.hasSubstring("<MSResponse"))
return FileTypes::OMSSAXML;
//MASCOTXML file
if (all_simple.hasSubstring("<mascot_search_results"))
return FileTypes::MASCOTXML;
//FASTA file
// .. check this fairly early on, because other file formats might be less specific
{
Size i = 0;
Size bigger_than = 0;
while (i < complete_file.size())
{
if (complete_file[i].trim().hasPrefix(">"))
{
++bigger_than;
++i;
}
else if (complete_file[i].trim().hasPrefix("#"))
++i;
else
break;
}
if (bigger_than > 0)
return FileTypes::FASTA;
}
// PNG file (to be really correct, the first eight bytes of the file would
// have to be checked; see e.g. the Wikipedia article)
if (first_line.substr(1, 3) == "PNG")
return FileTypes::PNG;
//MSP (all lines)
for (Size i = 0; i != complete_file.size(); ++i)
{
if (complete_file[i].hasPrefix("Name: ") && complete_file[i].hasSubstring("/"))
{
return FileTypes::MSP;
}
if (complete_file[i].hasPrefix("Num peaks: "))
{
return FileTypes::MSP;
}
}
//tokenize lines 2-5
vector<String> parts;
two_five.split(' ', parts);
//DTA
if (parts.size() == 8)
{
bool conversion_error = false;
try
{
for (Size i = 0; i < 8; ++i)
{
parts[i].toFloat();
}
}
catch (Exception::ConversionError)
{
conversion_error = true;
}
if (!conversion_error)
return FileTypes::DTA;
}
//DTA2D
if (parts.size() == 12)
{
bool conversion_error = false;
try
{
for (Size i = 0; i < 12; ++i)
{
parts[i].toFloat();
}
}
catch (Exception::ConversionError)
{
conversion_error = true;
}
if (!conversion_error)
return FileTypes::DTA2D;
}
// MGF (Mascot Generic Format)
if (two_five.hasSubstring("BEGIN IONS"))
{
return FileTypes::MGF;
}
else
{
for (Size i = 0; i != complete_file.size(); ++i)
{
if (complete_file[i].trim() == "FORMAT=Mascot generic" || complete_file[i].trim() == "BEGIN IONS")
{
return FileTypes::MGF;
}
}
}
// MS2 file format
if (all_simple.hasSubstring("CreationDate"))
{
if (all_simple.size() > 0 && all_simple[0] == 'H')
{
return FileTypes::MS2;
}
}
// msInspect file (.tsv)
for (Size i = 0; i != complete_file.size(); ++i)
{
if (complete_file[i].hasSubstring("scan\ttime\tmz\taccurateMZ\tmass\tintensity\tcharge\tchargeStates\tkl\tbackground\tmedian\tpeaks\tscanFirst\tscanLast\tscanCount\ttotalIntensity\tsumSquaresDist\tdescription"))
{
return FileTypes::TSV;
}
}
// specArray file (.pepList)
if (first_line.hasSubstring(" m/z\t rt(min)\t snr\t charge\t intensity"))
{
return FileTypes::PEPLIST;
}
// hardkloer file (.hardkloer)
/**
NOT IMPLEMENTED YET
if (first_line.hasSubstring("File First Scan Last Scan Num of Scans Charge Monoisotopic Mass Base Isotope Peak Best Intensity Summed Intensity First RTime Last RTime Best RTime Best Correlation Modifications"))
{
return FileTypes::HARDKLOER;
}
**/
// kroenik file (.kroenik)
if (first_line.hasSubstring("File\tFirst Scan\tLast Scan\tNum of Scans\tCharge\tMonoisotopic Mass\tBase Isotope Peak\tBest Intensity\tSummed Intensity\tFirst RTime\tLast RTime\tBest RTime\tBest Correlation\tModifications"))
{
return FileTypes::KROENIK;
}
// EDTA file
// hard to tell... so we don't even try...
return FileTypes::UNKNOWN;
}
int queue_encode_history_item (queue_history_entry_t* entry, hfs_time_t ts, const char* value, const char* lastlogsize,
const char* timestamp, const char* source, const char* severity)
{
int len = entry->buf_size, l;
char* res_p, *p;
len += sizeof (ts);
len += str_buffer_length (value);
len += str_buffer_length (lastlogsize);
len += str_buffer_length (timestamp);
len += str_buffer_length (source);
len += str_buffer_length (severity);
res_p = entry->buf = (char*)realloc (entry->buf, len);
if (!res_p)
goto error;
res_p += entry->buf_size;
l = entry->buf_size;
entry->buf_size = len;
len -= l;
*((hfs_time_t*)res_p) = ts;
res_p += sizeof (ts);
len -= sizeof (ts);
p = res_p;
res_p = buffer_str (res_p, value, len);
if (!res_p)
goto error;
len -= res_p - p;
p = res_p;
res_p = buffer_str (res_p, lastlogsize, len);
if (!res_p)
goto error;
len -= res_p - p;
p = res_p;
res_p = buffer_str (res_p, timestamp, len);
if (!res_p)
goto error;
len -= res_p - p;
p = res_p;
res_p = buffer_str (res_p, source, len);
if (!res_p)
goto error;
len -= res_p - p;
p = res_p;
res_p = buffer_str (res_p, severity, len);
if (!res_p)
goto error;
len -= res_p - p;
return 1;
error:
if (entry->buf)
free (entry->buf);
return 0;
}
///gets called when a complete 24 byte header is actually received: uses the UUID within to match up appropriate sockets
void buildStream(TcpSstHeaderArray *buffer,
TCPSocket *socket,
std::tr1::shared_ptr<TCPStreamListener::Data> data,
const boost::system::error_code &error,
std::size_t bytes_transferred)
{
// Buffer always needs to be cleaned up when we get out of this method
std::auto_ptr<TcpSstHeaderArray> buffer_ptr(buffer);
// Sanity check start
if (error || bytes_transferred < 5 || std::string((const char*)buffer->begin(), 5) != std::string("GET /")) {
SILOG(tcpsst,warning,"Connection received with truncated header: "<<error);
delete socket;
return;
}
// Sanity check end: 8 bytes from WebSocket spec after headers, then
// \r\n\r\n before that.
std::string buffer_str((const char*)buffer->begin(), bytes_transferred);
if (buffer_str[ bytes_transferred - 12] != '\r' ||
buffer_str[ bytes_transferred - 11] != '\n' ||
buffer_str[ bytes_transferred - 10] != '\r' ||
buffer_str[ bytes_transferred - 9] != '\n')
{
SILOG(tcpsst,warning,"Request doesn't end properly:\n" << buffer_str << "\n");
delete socket;
return;
}
std::string headers_str = buffer_str.substr(0, bytes_transferred - 10);
// Parse headers
UUID context;
std::map<std::string, std::string> headers;
std::string::size_type offset = 0;
while(offset < headers_str.size()) {
std::string::size_type last_offset = offset;
offset = headers_str.find("\r\n", offset);
if (offset == std::string::npos) {
SILOG(tcpsst,warning,"Error parsing headers.");
delete socket;
return;
}
std::string line = headers_str.substr(last_offset, offset - last_offset);
// Special case the initial GET line
if (line.substr(0, 5) == "GET /") {
std::string::size_type uuid_end = line.find(' ', 5);
if (uuid_end == std::string::npos) {
SILOG(tcpsst,warning,"Error parsing headers: invalid get line.");
delete socket;
return;
}
std::string uuid_str = line.substr(5, uuid_end - 5);
try {
context = UUID(uuid_str,UUID::HumanReadable());
} catch(...) {
SILOG(tcpsst,warning,"Error parsing headers: invalid get uuid.");
delete socket;
return;
}
offset += 2;
continue;
}
std::string::size_type colon = line.find(":");
if (colon == std::string::npos) {
SILOG(tcpsst,warning,"Error parsing headers: missing colon.");
delete socket;
return;
}
std::string head = line.substr(0, colon);
std::string val = line.substr(colon+2);
headers[head] = val;
// Advance to get past the \r\n
offset += 2;
}
if (headers.find("Host") == headers.end() ||
headers.find("Origin") == headers.end() ||
headers.find("Sec-WebSocket-Key1") == headers.end() ||
headers.find("Sec-WebSocket-Key2") == headers.end())
{
SILOG(tcpsst,warning,"Connection request didn't specify all required fields.");
delete socket;
return;
}
std::string host = headers["Host"];
std::string origin = headers["Origin"];
std::string protocol = "wssst1";
if (headers.find("Sec-WebSocket-Protocol") != headers.end())
protocol = headers["Sec-WebSocket-Protocol"];
std::string key1 = headers["Sec-WebSocket-Key1"];
std::string key2 = headers["Sec-WebSocket-Key2"];
std::string key3 = buffer_str.substr(bytes_transferred - 8);
assert(key3.size() == 8);
std::string reply_str = getWebSocketSecReply(key1, key2, key3);
bool binaryStream=protocol.find("sst")==0;
bool base64Stream=!binaryStream;
boost::asio::ip::tcp::no_delay option(data->mNoDelay);
socket->set_option(option);
IncompleteStreamMap::iterator where=sIncompleteStreams.find(context);
unsigned int numConnections=1;
for (std::string::iterator i=protocol.begin(),ie=protocol.end();i!=ie;++i) {
if (*i>='0'&&*i<='9') {
char* endptr=NULL;
const char *start=protocol.c_str();
size_t offset=(i-protocol.begin());
start+=offset;
numConnections=strtol(start,&endptr,10);
size_t numberlen=endptr-start;
if (numConnections>data->mMaxSimultaneousSockets) {
numConnections=data->mMaxSimultaneousSockets;
char numcon[256];
sprintf(numcon,"%d",numConnections);
protocol=protocol.substr(0,offset)+numcon+protocol.substr(offset+numberlen);
}
break;
}
}
if (where==sIncompleteStreams.end()){
sIncompleteStreams[context].mNumSockets=numConnections;
where=sIncompleteStreams.find(context);
assert(where!=sIncompleteStreams.end());
// Setup a timer to clean up the sockets if we don't complete it in time
data->strand->post(
Duration::seconds(10),
std::tr1::bind(&handleBuildStreamTimeout, context)
);
}
if ((int)numConnections!=where->second.mNumSockets) {
SILOG(tcpsst,warning,"Single client disagrees on number of connections to establish: "<<numConnections<<" != "<<where->second.mNumSockets);
sIncompleteStreams.erase(where);
}else {
where->second.mSockets.push_back(socket);
where->second.mWebSocketResponses[socket] = reply_str;
if (numConnections==(unsigned int)where->second.mSockets.size()) {
MultiplexedSocketPtr shared_socket(
MultiplexedSocket::construct<MultiplexedSocket>(data->strand,context,data->cb,base64Stream));
shared_socket->initFromSockets(where->second.mSockets,data->mSendBufferSize);
std::string port=shared_socket->getASIOSocketWrapper(0).getLocalEndpoint().getService();
std::string resource_name='/'+context.toString();
MultiplexedSocket::sendAllProtocolHeaders(shared_socket,origin,host,port,resource_name,protocol, where->second.mWebSocketResponses);
sIncompleteStreams.erase(where);
Stream::StreamID newID=Stream::StreamID(1);
TCPStream * strm=new TCPStream(shared_socket,newID);
TCPSetCallbacks setCallbackFunctor(&*shared_socket,strm);
data->cb(strm,setCallbackFunctor);
if (setCallbackFunctor.mCallbacks==NULL) {
SILOG(tcpsst,error,"Client code for stream "<<newID.read()<<" did not set listener on socket");
shared_socket->closeStream(shared_socket,newID);
}
}else{
sStaleUUIDs.push_back(context);
}
}
}
