void PusherClient::getAuthString(const String& channel, String& auth) { Sha256Class sha256; //Sha init with secret key { String secret; getPusherInfoItem(2, secret); sha256.initHmac((uint8_t*)&secret[0], secret.length()); } //Set the data to encrypt { String text; text.reserve(_socketid.length() + 1 + channel.length()); text = _socketid; text += ':'; text += channel; sha256.print(text); } uint8_t* result = sha256.resultHmac(); String hexChars; getStringTableItem(19, hexChars); auth.reserve(21 /*key*/ + 1 + 64 /*sha256*/); getPusherInfoItem(1, auth); //key auth += ':'; for (int i=0; i<32; i++) { auth += hexChars.charAt(result[i]>>4); auth += hexChars.charAt(result[i]&0xf); } }
void ESP8266WebServerEx::redirect(const char* homePath) { uint16_t port = g_ModuleSettings.data.port; String url; if ( !homePath ) return; url.reserve(50); url = "http://"; url += GetHost(); url += homePath; String content; content.reserve(250); content = "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n<meta http-equiv=\"refresh\" content=\"0; URL='"; content += url; content += "'\" />\n<title>Login</title>\n</head>\n<body onload=\"window.location='"; content += url; content += "';\">\n</body>\n</html>"; sendHeader("Location",url); sendHeader("Cache-Control","no-cache"); sendHeader("Pragma","no-cache"); TRACE("Redirect..."); send(302,"text/html",content); }
String JID::generateDescription(String localPart, String domainPart, String resourcePart) { String description; if (!resourcePart.empty()) { if (!localPart.empty()) { description.reserve(localPart.length() + domainPart.length() + resourcePart.length() + 2); description += localPart; description += "@"; description += domainPart; description += "/"; description += resourcePart; } else { description.reserve(domainPart.length() + resourcePart.length() + 1); description += domainPart; description += "/"; description += resourcePart; } } else { if (!localPart.empty()) { description.reserve(localPart.length() + domainPart.length() + 1); description += localPart; description += "@"; description += domainPart; } else { description = domainPart; } } return description; }
void setup() { response.reserve(RESPONSE_BUFFER); url.reserve(STRING_BUFFER); cmd.reserve(COMMAND_BUFFER); Serial.begin(9600); Serial.println("PowerInterlock Start"); turnOff(); disableTiming(); RFID.begin(2400); delay(500); pinMode(RFID_ENABLE, OUTPUT); //digitalWrite(RFID_ENABLE, LOW); pinMode(DEVICE_PIN, OUTPUT); Ethernet.begin(mac, ip, dns1); //After a couple hours, the DHCP started to fail for some reason /*if (Ethernet.begin(mac) == 0) { Serial.println("Failed to configure Ethernet using DHCP"); Ethernet.begin(mac, ip); }*/ // give the Ethernet shield a second to initialize: delay(1000); }
void BootConfig::_onDeviceInfoRequest() { Logger.logln("Received device info request"); DynamicJsonBuffer jsonBuffer; JsonObject& json = jsonBuffer.createObject(); json["device_id"] = Helpers.getDeviceId(); json["homie_version"] = VERSION; JsonObject& firmware = json.createNestedObject("firmware"); firmware["name"] = this->_shared_interface->fwname; firmware["version"] = this->_shared_interface->fwversion; JsonArray& nodes = json.createNestedArray("nodes"); for (int i = 0; i < this->_shared_interface->nodes.size(); i++) { HomieNode node = this->_shared_interface->nodes[i]; JsonObject& json_node = jsonBuffer.createObject(); json_node["id"] = node.id; json_node["type"] = node.type; nodes.add(json_node); } // 110 bytes for {"homie_version":"11.10.0","firmware":{"name":"awesome-light-great-top","version":"11.10.0-beta"},"nodes":[]} // 60 bytes for {"id":"lightifydefoulooooo","type":"lightifydefouloooo"}, (-1 for leading ","), +1 for terminator String jsonString; jsonString.reserve(110 + (60 * this->_shared_interface->nodes.size()) - 1 + 1); json.printTo(jsonString); this->_http.send(200, FPSTR(PROGMEM_CONFIG_APPLICATION_JSON), jsonString); }
String::size_type ccppFile::readFile( String & str ) { str.reserve(getSize()); char buff[1024]; std::fstream & fStr= getStream(); //String::size_type size = 0; while ( ! fStr.eof() ) { fStr.read( buff, sizeof(buff) ); if ( fStr.bad() ) { throw std::runtime_error("Error while reading from file stream (bad)"); } else if ( fStr.fail() ) { if (! fStr.eof() ) { throw std::runtime_error("Error while reading from file stream (fail)"); } } str.append( buff,fStr.gcount() ); //size+= fStr.gcount(); } return str.length(); }
String format_strings(const String& fmt, const String *args[], size_t nargs) { String str; str.reserve(fmt.length() * 2); String::const_iterator it; for (it = fmt.begin(); it != fmt.end(); ++it) { if (*it == '%') { ++it; if (it == fmt.end()) break; int n = *it - '0'; if (n > 0 && static_cast<unsigned int>(n) <= nargs) str += *args[n - 1]; else str += *it; } else { str += *it; } } return str; }
void setup() { randomSeed((analogRead(A4) & 0x1F) | (analogRead(A5) << 5)); pinMode(ledPin, OUTPUT); digitalWrite(ledPin, LOW); //start LED off pinMode(PPM_pin, INPUT); pinMode(MOSI_pin, OUTPUT); pinMode(SCK_pin, OUTPUT); pinMode(CS_pin, OUTPUT); pinMode(CE_pin, OUTPUT); pinMode(MISO_pin, INPUT); // PPM ISR setup //attachInterrupt(PPM_pin - 2, ISR_ppm, CHANGE); TCCR1A = 0; //reset timer1 TCCR1B = 0; TCCR1B |= (1 << CS11); //set timer1 to increment every 1 us @ 8MHz, 0.5 us @16MHz set_txid(false); // Serial port input/output setup Serial.begin(115200); // reserve 200 bytes for the inputString: inputString.reserve(200); }
String strutil_flatten_array(const wxArrayString& array, wxChar chSep) { String s; s.reserve(1024); const size_t count = array.GetCount(); for ( size_t n = 0; n < count; n++ ) { if ( n > 0 ) s += chSep; for ( String::const_iterator p = array[n].begin(), end = array[n].end(); p != end; ++p ) { const wxChar ch = *p; // escape the separator characters if ( ch == chSep || ch == '\\' ) s += '\\'; s += ch; } } return s; }
void AVL_tree::SendNodes(Node node, EthernetClient* client){ if(node){ SendNodes(node->left, client); // DO STRING String* buffer = new String(""); buffer->reserve(sizeof(unsigned char)*20); *buffer += node->d; *buffer += ':'; if(node->status) *buffer += '1'; else *buffer += '0'; *buffer += ':'; *buffer += node->timerid; *buffer += ':' ; *buffer += node->onHour; *buffer += ':' ; *buffer += node->onMinute; *buffer += ':' ; *buffer += node->offHour; *buffer += ':'; *buffer += node->offMinute; *buffer += 'N'; client->print(*buffer); Serial.println(*buffer); delete buffer; SendNodes(node->right, client); } }
/** Enforces LF '\n' newline convention. @param in string to copy @return the UNIXified string */ String strutil_enforceLF(String const &in) { String out; out.reserve(in.length()); size_t cursor = 0; while ( cursor < in.size() ) { wxChar one = in[cursor]; if ( one != _T('\r') ) { out += one; cursor++; } else { out += '\n'; if ( cursor + 1 < in.size() ) { if ( in[cursor + 1] == '\n' ) cursor += 2; else cursor++; } else cursor++; } } return out; }
void Document::loadFileToString( const String& file_name_, String &buffer_ ) { FRL_EXCEPT_GUARD(); if( ! fs::exists( file_name_ ) ) FRL_THROW_S_CLASS( Document::FileNotFound ); size_t length = static_cast< size_t >( fs::file_size( file_name_ ) ); if( length == 0 ) FRL_THROW_S_CLASS( Document::EmptyFile ); if( ! buffer_.empty() ) buffer_.clear(); static const size_t buffer_size = 4096; stream_std::InFile in( file_name_.c_str(), std::ios::binary ); if( ! in.is_open() ) FRL_THROW_S_CLASS( Document::UnknownError ); std::vector< Char > buf( buffer_size ); buffer_.reserve( length ); while( in ) { in.read( &buf[ 0 ], buffer_size ); buffer_.append( &buf[ 0 ], in.gcount() ); } in.close(); }
void DesktopFile::set_not_show_in(const list<String>& lst) { /* * Desktop entry specs requires only one of OnlyShowIn or NotShowIn * can exists in one section */ if(Config::key_exist(ENTRY_SECT, "OnlyShowIn")) return; if(lst.empty()) return; if(errcode != DESK_FILE_SUCCESS && errcode != DESK_FILE_EMPTY) return; String all; all.reserve(256); list<String>::const_iterator it = lst.begin(), it_end = lst.end(); for(; it != it_end; ++it) { all += (*it); all += ';'; // intentionally since value must ends with ':' } Config::set(ENTRY_SECT, "NotShowIn", all.c_str()); }
/** Enforces CR/LF newline convention. @param in string to copy @return the DOSified string */ String strutil_enforceCRLF(String const &in) { String out; out.reserve(in.length()); const wxChar *cptr = in.c_str(); bool has_cr = false; if(! cptr) return wxEmptyString; while(*cptr) { switch(*cptr) { case '\r': has_cr = true; out += '\r'; break; case '\n': if(! has_cr) out += '\r'; out += '\n'; has_cr = false; break; default: out += *cptr; has_cr = false; break; } cptr++; } return out; }
String XMLSerializer::convertEntityInText(const String& text) { String res; res.reserve(text.size()*2); const String::const_iterator iterEnd = text.end(); for (String::const_iterator iter = text.begin(); iter != iterEnd ; ++iter) { switch(*iter) { case '<': res += "<"; break; case '>': res += ">"; break; case '&': res += "&"; break; case '\'': res += "'"; break; case '"': res += """; break; default: res += *iter; } } return res; }
//----------------------------------------------------------------------- String ConfigFileEx::deconvertSpecialChars(const String& _str) { String ret; ret.reserve(_str.length()); size_t i = 0; while(i != _str.length()) { char ch = _str[i++]; if(ch == '\\') { ch = _str[i++]; switch(ch) { case 'n': ret += '\n'; break; case 'r': ret += '\r'; break; case 't': ret += '\t'; break; default: ret += ch; } } else { ret += ch; } } return ret; }
String colorize(const String &string, AnsiColor color, int from, int len) { assert(from <= string.size()); assert(from >= 0); if (len == -1) { len = string.size() - from; } assert(from + len <= string.size()); if (!len) return string; String ret; ret.reserve(string.size() + 20); const char *str = string.constData(); if (from > 0) { ret.append(str, from); str += from; } ret.append(colors[color]); ret.append(str, len); str += len; ret.append(colors[AnsiColor_Default]); if (from + len != string.size()) ret.append(str, string.size() - from - len); return ret; }
String xxtea_c::encrypt(String data) { // Works only if the Key in setup if(this->keyset && data.length() != 0) { // If the Data within the limits of the Engine if(data.length() < MAX_XXTEA_DATA8) { size_t len; // Assign the Maximum buffer we have len = MAX_XXTEA_DATA8; // Perform Encryption if(xxtea_encrypt((uint8_t *)data.c_str(),data.length(), this->data,&len) == XXTEA_STATUS_SUCCESS) { String result; size_t i; result.reserve(len*2 + 1); result = ""; for(i=0;i<len;i++) { result+=tohex((this->data[i] >> 4) & 0x0F); result+=tohex(this->data[i] & 0x0F); } return result; } }
//--------------------------------- String Utils::checkNCName ( const String &ncName ) { String result; result.reserve ( ncName.length() ); // check if first character is an alpha character char firstCharacter = ncName[0]; if ( isAsciiAlphaChar ( firstCharacter ) ) result.append ( 1, firstCharacter ); else result.append ( 1, '_' ); //replace all spaces and colons by underlines for ( size_t i = 1; i<ncName.length(); ++i ) { char character = ncName[i]; if ( isIDChar ( character ) ) result.append ( 1, character ); else result.append ( 1, '_' ); } return result; }
void ArduRPC_SensorNode::submitData() { uint16_t i; char hostname[NODE_EEPROM_API_HOSTNAME_MAX_LENGTH + 1]; uint16_t port; if(this->status != 4) { return; } if(WiFi.status() != WL_CONNECTED) { return; } /* if(connectSensorAPI() == false) { return; } */ getAPIHostnameOrDefault(&hostname[0], NODE_EEPROM_API_HOSTNAME_MAX_LENGTH); port = getAPIPortOrDefault(); HTTPClient http; String path; path.reserve(64); path = "/sensors/"; path += this->sensor_uuid; http.begin(hostname, port, path); http.addHeader("X-Sensor-Api-Key", this->sensor_key); http.addHeader("X-Sensor-Version", "1"); int code; code = http.POST(this->cache.data, this->cache.length); NODE_DEBUG_PRINT("Code "); NODE_DEBUG_PRINTLN(code); // ToDo: validate code this->status = 0; /* client.print("POST /sensors/"); client.println(this->sensor_uuid); client.print("Host: "); client.println(hostname); client.println("Connection: close"); client.print("X-Sensor-Api-Key: "); client.println(this->sensor_key); client.println("X-Sensor-Version: 1"); client.print("Content-Length: "); client.println(this->cache.length); client.println(); for(i = 0; i < this->cache.length; i++) { Serial.print((char)this->cache.data[i]); } this->status = 0; client.stop(); */ }
String ToString<std::string> (std::string str) { String ret; ret.reserve (str.size()); for (auto c : str) ret += Char(c); return ret; }
const String operator+(const String& str, const StringRef& strRef) { String ret; ret.reserve(str.length() + strRef.length()); ret.append(str); ret.append(strRef); return ret; }
const String operator+(const String& str1, const String& str2) { String ret; ret.reserve(str1.length() + str2.length()); ret.append(str1); ret.append(str2); return ret; }
const String operator+(const String& str, char c) { String ret; ret.reserve(str.length() + 1); ret.append(str); ret.appendChar(c); return ret; }
String Publish::payload_string(void) const { String str; str.reserve(_payload_len); for (uint32_t i = 0; i < _payload_len; i++) str += (char)_payload[i]; return str; }
void Reserve(String &Str,size_t Size) { if (Size>size_t(Str.max_size())) return; if (Str.capacity()<Size) Str.reserve(Size); }
CXChildVisitResult DumpThread::visitor(CXCursor cursor, CXCursor, CXClientData userData) { DumpThread *that = reinterpret_cast<DumpThread*>(userData); assert(that); CXSourceLocation location = clang_getCursorLocation(cursor); if (!clang_equalLocations(location, nullLocation)) { CXString file; unsigned line, col; clang_getPresumedLocation(location, &file, &line, &col); Path path = RTags::eatString(file); if (!path.isEmpty()) { uint32_t &fileId = that->mFiles[path]; if (!fileId) { const Path resolved = path.resolved(); fileId = Location::insertFile(resolved); that->mFiles[path] = that->mFiles[resolved] = fileId; } if (that->mQueryFlags & QueryMessage::DumpIncludeHeaders || fileId == that->mSource.fileId) { const Location loc(fileId, line, col); String message; message.reserve(256); if (!(that->mQueryFlags & QueryMessage::NoContext)) message += loc.context(); CXSourceRange range = clang_getCursorExtent(cursor); CXSourceLocation rangeEnd = clang_getRangeEnd(range); unsigned endLine, endColumn; clang_getPresumedLocation(rangeEnd, 0, &endLine, &endColumn); if (endLine == line) { message += String::format<32>(" // %d-%d, %d: ", col, endColumn, that->mIndentLevel); } else { message += String::format<32>(" // %d-%d:%d, %d: ", col, endLine, endColumn, that->mIndentLevel); } message += RTags::cursorToString(cursor, RTags::AllCursorToStringFlags); message.append(" " + RTags::typeName(cursor) + " "); CXCursor ref = clang_getCursorReferenced(cursor); if (clang_equalCursors(ref, cursor)) { message.append("refs self"); } else if (!clang_equalCursors(ref, nullCursor)) { message.append("refs "); message.append(RTags::cursorToString(ref, RTags::AllCursorToStringFlags)); } CXCursor canonical = clang_getCanonicalCursor(cursor); if (!clang_equalCursors(canonical, cursor) && !clang_equalCursors(canonical, nullCursor)) { message.append("canonical "); message.append(RTags::cursorToString(canonical, RTags::AllCursorToStringFlags)); } that->writeToConnetion(message); } } } ++that->mIndentLevel; clang_visitChildren(cursor, DumpThread::visitor, userData); --that->mIndentLevel; return CXChildVisit_Continue; }
String read<String>(uint8_t *buf, uint32_t& pos) { uint16_t len = read<uint16_t>(buf, pos); String val; val.reserve(len); for (uint16_t i = 0; i < len; i++) val += (char)read<uint8_t>(buf, pos); return val; }
String read<String>(Client& client) { uint16_t len = read<uint16_t>(client); String val; val.reserve(len); for (uint16_t i = 0; i < len; i++) val += (char)read<uint8_t>(client); return val; }
const String operator+(const String& str, const char* cstr) { String ret; size_t cstrLen = ::strlen(cstr); ret.reserve(str.length() + cstrLen); ret.append(str); ret.append(cstr, cstrLen); return ret; }