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); } } }