/* push a bytes into the state tracker */
void telnet_recv(telnet_t *telnet, const char *buffer,
size_t size) {
#if defined(HAVE_ZLIB)
/* if we have an inflate (decompression) zlib stream, use it */
if (telnet->z != 0 && !(telnet->flags & TELNET_PFLAG_DEFLATE)) {
char inflate_buffer[1024];
int rs;
/* initialize zlib state */
telnet->z->next_in = (unsigned char*)buffer;
telnet->z->avail_in = (unsigned int)size;
telnet->z->next_out = (unsigned char *)inflate_buffer;
telnet->z->avail_out = sizeof(inflate_buffer);
/* inflate until buffer exhausted and all output is produced */
while (telnet->z->avail_in > 0 || telnet->z->avail_out == 0) {
/* reset output buffer */
/* decompress */
rs = inflate(telnet->z, Z_SYNC_FLUSH);
/* process the decompressed bytes on success */
if (rs == Z_OK || rs == Z_STREAM_END)
_process(telnet, inflate_buffer, sizeof(inflate_buffer) -
telnet->z->avail_out);
else
_error(telnet, __LINE__, __func__, TELNET_ECOMPRESS, 1,
"inflate() failed: %s", zError(rs));
/* prepare output buffer for next run */
telnet->z->next_out = (unsigned char *)inflate_buffer;
telnet->z->avail_out = sizeof(inflate_buffer);
/* on error (or on end of stream) disable further inflation */
if (rs != Z_OK) {
telnet_event_t ev;
/* disable compression */
inflateEnd(telnet->z);
free(telnet->z);
telnet->z = 0;
/* send event */
ev.type = TELNET_EV_COMPRESS;
ev.compress.state = 0;
telnet->eh(telnet, &ev, telnet->ud);
break;
}
}
/* COMPRESS2 is not negotiated, just process */
} else
#endif /* defined(HAVE_ZLIB) */
_process(telnet, buffer, size);
}
process_t Process( const char * path,... )
{
char * entry ;
char ** args ;
char ** e ;
size_t size = sizeof( char * ) ;
int index = 1 ;
va_list list ;
process_t p ;
if( path == NULL ){
return _process( NULL ) ;
}
p = _process( path ) ;
if( p == ProcessVoid ){
return ProcessVoid ;
}
args = p->args ;
va_start( list,path ) ;
while( 1 ){
entry = va_arg( list,char * ) ;
e = realloc( args,( 1 + index ) * size ) ;
if( e == NULL ){
ProcessCleanUp( &p ) ;
free( args ) ;
va_end( list ) ;
_ProcessError() ;
return ProcessVoid ;
}else{
args = e ;
}
if( entry == NULL ){
*( args + index ) = NULL ;
break ;
}else{
*( args + index ) = entry ;
index++ ;
}
}
va_end( list ) ;
p->args = args ;
p->args[ 0 ] = p->exe ;
p->str.args = args ;
return p ;
}
void CSODistance::handleNotification(Field* field)
{
ML_TRACE_IN("void CSODistance::handleNotification(Field* field)");
if (field == _input0CSOFld){
if (!_isInNotificationCB && _csoList0 ) { _csoList0->removeNotificationObserver(_csoListNotificationCB, this);}
if (BASE_IS_A((static_cast<Base*>(_input0CSOFld->getBaseValue())), CSOList)){
_csoList0 = static_cast<CSOList*>(_input0CSOFld->getBaseValue());
if (_csoList0 != NULL){
if (!_isInNotificationCB) { _csoList0->addNotificationObserver(_csoListNotificationCB, this); }
}
} else {
_csoList0 = NULL;
}
if (_autoApplyFld->getBoolValue()) { _process(); }
} else
if (field == _input1CSOFld){
if (!_isInNotificationCB && _csoList1 ) { _csoList1->removeNotificationObserver(_csoListNotificationCB, this);}
if (BASE_IS_A((static_cast<Base*>(_input1CSOFld->getBaseValue())), CSOList)){
_csoList1 = static_cast<CSOList*>(_input1CSOFld->getBaseValue());
if (_csoList1 != NULL){
if (!_isInNotificationCB) { _csoList1->addNotificationObserver(_csoListNotificationCB, this); }
}
} else {
_csoList1 = NULL;
}
if (_autoApplyFld->getBoolValue()) { _process(); }
} else
if ( field == _applyFld || ( _autoApplyFld->getBoolValue() &&
( field == _tolleranceFld || field == _curveStatistic )) ){
_process();
}
BaseOp::handleNotification(field);
}
static int _poll(kevent_loop_t *el)
{
int nev, i;
nev = epoll_wait(el->epd, el->events, el->event_size,
KEVENT_POLL_TIMEOUT);
if (nev == KEVENT_ERR) {
el->error_handler(el, errno);
return KEVENT_ERR;
}
for (i = 0; i < nev; i++) {
kevent_t *ev;
eventtype_t et = KEVENT_FREE;
ev = &el->kevents[el->events[i].data.fd];
if (el->events[i].events & EPOLLERR
|| el->events[i].events & EPOLLHUP)
et |= KEVENT_FAULTY;
if (el->events[i].events & EPOLLIN)
et |= KEVENT_READABLE;
if (el->events[i].events & EPOLLOUT)
et |= KEVENT_WRITABLE;
ev->eventtype = et;
_process(el, ev);
}
return nev;
}
void MeshLodGenerator::generateLodLevels(LodConfig& lodConfig,
LodCollapseCostPtr cost,
LodDataPtr data,
LodInputProviderPtr input,
LodOutputProviderPtr output,
LodCollapserPtr collapser)
{
// If we don't have generated Lod levels, we can use _generateManualLodLevels.
bool hasGeneratedLevels = false;
for(size_t i = 0; i < lodConfig.levels.size(); i++) {
if(lodConfig.levels[i].manualMeshName.empty()) {
hasGeneratedLevels = true;
break;
}
}
if(hasGeneratedLevels || (LodWorkQueueInjector::getSingletonPtr() && LodWorkQueueInjector::getSingletonPtr()->getInjectorListener())) {
_resolveComponents(lodConfig, cost, data, input, output, collapser);
if(lodConfig.advanced.useBackgroundQueue) {
_initWorkQueue();
LodWorkQueueWorker::getSingleton().addRequestToQueue(lodConfig, cost, data, input, output, collapser);
} else {
_process(lodConfig, cost.get(), data.get(), input.get(), output.get(), collapser.get());
}
} else {
_generateManualLodLevels(lodConfig);
}
}
bool signerSignMsg(MyMessage &msg)
{
bool ret;
#if defined(MY_SIGNING_FEATURE)
// If destination is known to require signed messages and we are the sender,
// sign this message unless it is identified as an exception
if (DO_SIGN(msg.destination) && msg.sender == getNodeId()) {
if (skipSign(msg)) {
ret = true;
} else {
// Send nonce-request
_signingNonceStatus=SIGN_WAITING_FOR_NONCE;
if (!_sendRoute(build(_msgSign, msg.destination, msg.sensor, C_INTERNAL,
I_NONCE_REQUEST).set(""))) {
SIGN_DEBUG(PSTR("Failed to transmit nonce request!\n"));
ret = false;
} else {
SIGN_DEBUG(PSTR("Nonce requested from %d. Waiting...\n"), msg.destination);
// We have to wait for the nonce to arrive before we can sign our original message
// Other messages could come in-between. We trust _process() takes care of them
unsigned long enter = hwMillis();
_msgSign = msg; // Copy the message to sign since message buffer might be touched in _process()
while (hwMillis() - enter < MY_VERIFICATION_TIMEOUT_MS &&
_signingNonceStatus==SIGN_WAITING_FOR_NONCE) {
_process();
}
if (hwMillis() - enter > MY_VERIFICATION_TIMEOUT_MS) {
SIGN_DEBUG(PSTR("Timeout waiting for nonce!\n"));
ret = false;
} else {
if (_signingNonceStatus == SIGN_OK) {
// process() received a nonce and signerProcessInternal successfully signed the message
msg = _msgSign; // Write the signed message back
SIGN_DEBUG(PSTR("Message to send has been signed\n"));
ret = true;
// After this point, only the 'last' member of the message structure is allowed to be altered if the
// message has been signed, or signature will become invalid and the message rejected by the receiver
} else {
SIGN_DEBUG(PSTR("Message to send could not be signed!\n"));
ret = false;
}
}
}
}
} else if (getNodeId() == msg.sender) {
mSetSigned(msg, 0); // Message is not supposed to be signed, make sure it is marked unsigned
SIGN_DEBUG(PSTR("Will not sign message for destination %d as it does not require it\n"),
msg.destination);
ret = true;
} else {
SIGN_DEBUG(PSTR("Will not sign message since it was from %d and we are %d\n"), msg.sender,
getNodeId());
ret = true;
}
#else
(void)msg;
ret = true;
#endif // MY_SIGNING_FEATURE
return ret;
}
void systemProcessTest::testArg() {
y::sys::process _process("ls");
_process.arg("-al");
_process.run(y::sys::stdOut);
if (!_process.success()) {
CPPUNIT_ASSERT(false);
}
}
void * iothread_main( void * arg )
{
uint32_t maxtasks = 0;
struct iothread * thread = (struct iothread *)arg;
struct iothreads * parent = (struct iothreads *)(thread->parent);
sigset_t mask;
sigfillset(&mask);
pthread_sigmask(SIG_SETMASK, &mask, NULL);
// 初始化队列
struct taskqueue doqueue;
QUEUE_INIT(taskqueue)( &doqueue, MSGQUEUE_DEFAULT_SIZE );
for ( ; parent->runflags; )
{
uint32_t nprocess = 0;
// 轮询网络事件
evsets_dispatch( thread->sets );
// 处理事件
nprocess = _process( parent, thread, &doqueue );
// 最大任务数
maxtasks = MAX( maxtasks, nprocess );
}
// 清理队列中剩余数据
_process( parent, thread, &doqueue );
// 清空队列
QUEUE_CLEAR(taskqueue)( &doqueue );
// 日志
syslog( LOG_INFO, "%s(INDEX=%d) : the Maximum Number of Requests is %d in EachFrame .",
__FUNCTION__, thread->index, maxtasks );
// 向主线程发送终止信号
pthread_mutex_lock( &parent->lock );
--parent->nrunthreads;
pthread_cond_signal( &parent->cond );
pthread_mutex_unlock( &parent->lock );
return NULL;
}
int ProcessExecute( const char * exe,... )
{
char * entry ;
char ** args ;
char ** e ;
size_t size = sizeof( char * ) ;
int index = 1 ;
va_list list ;
process_t p ;
if( exe == NULL ){
return -1 ;
}
p = _process( exe ) ;
if( p == ProcessVoid ){
return -1 ;
}
args = p->args ;
va_start( list,exe ) ;
while( 1 ){
entry = va_arg( list,char * ) ;
e = realloc( args,( 1 + index ) * size ) ;
if( e == NULL ){
ProcessCleanUp( &p ) ;
free( args ) ;
va_end( list ) ;
_ProcessError() ;
return -1 ;
}else{
args = e ;
}
if( entry == NULL ){
*( args + index ) = NULL ;
break ;
}else{
*( args + index ) = entry ;
index++ ;
}
}
va_end( list ) ;
p->args = args ;
p->args[ 0 ] = p->exe ;
p->str.args = args ;
ProcessStart( p ) ;
return ProcessWaitUntilFinished( &p ) ;
}
/*
* GO: sets the tree cursors on each term in terms, processes the terms by advancing
* the terms cursors and storing the partial
* results and lastly calculates the top results
* @param results, the priority queue containing the top results
* @param limit, number of results in the priority queue
*/
void FTSSearch::go(Results* results, unsigned limit ) {
vector< shared_ptr<BtreeCursor> > cursors;
for ( unsigned i = 0; i < _query.getTerms().size(); i++ ) {
const string& term = _query.getTerms()[i];
BSONObj min = FTSIndexFormat::getIndexKey( MAX_WEIGHT, term, _indexPrefix );
BSONObj max = FTSIndexFormat::getIndexKey( 0, term, _indexPrefix );
shared_ptr<BtreeCursor> c( BtreeCursor::make( _ns, _id, min, max, true, -1 ) );
cursors.push_back( c );
}
while ( !inShutdown() ) {
bool gotAny = false;
for ( unsigned i = 0; i < cursors.size(); i++ ) {
if ( cursors[i]->eof() )
continue;
gotAny = true;
_process( cursors[i].get() );
cursors[i]->advance();
}
if ( !gotAny )
break;
RARELY killCurrentOp.checkForInterrupt();
}
// priority queue using a compare that grabs the lowest of two ScoredLocations by score.
for ( Scores::iterator i = _scores.begin(); i != _scores.end(); ++i ) {
if ( i->second < 0 )
continue;
// priority queue
if ( results->size() < limit ) { // case a: queue unfilled
if ( !_ok( i->first ) )
continue;
results->push( ScoredLocation( i->first, i->second ) );
}
else if ( i->second > results->top().score ) { // case b: queue filled
if ( !_ok( i->first ) )
continue;
results->pop();
results->push( ScoredLocation( i->first, i->second ) );
}
else {
// else do nothing (case c)
}
}
}
void wait(unsigned long ms) {
unsigned long enter = hwMillis();
while (hwMillis() - enter < ms) {
_process();
#if defined(MY_GATEWAY_ESP8266)
yield();
#endif
}
}
void wait(unsigned long ms, uint8_t cmd, uint8_t msgtype) {
unsigned long enter = hwMillis();
// invalidate msg type
_msg.type = !msgtype;
while ( (hwMillis() - enter < ms) && !(mGetCommand(_msg)==cmd && _msg.type==msgtype) ) {
_process();
#if defined(MY_GATEWAY_ESP8266)
yield();
#endif
}
}
void
assert_msg_matches_and_output_message_has_tag_with_timeout(const gchar *pattern, gint timeout, gint ndx, const gchar *tag, gboolean set)
{
LogMessage *msg;
msg = _construct_message("prog2", pattern);
_process(msg);
_advance_time(timeout);
assert_output_message_has_tag(ndx, tag, set);
log_msg_unref(msg);
}
void
assert_msg_matches_and_no_such_output_message(const gchar *pattern, gint ndx)
{
LogMessage *msg;
msg = _construct_message("prog2", pattern);
_process(msg);
assert_no_such_output_message(ndx);
log_msg_unref(msg);
}
void
assert_msg_matches_and_output_message_nvpair_equals_with_timeout(const gchar *pattern, gint timeout, gint ndx, const gchar *name, const gchar *value)
{
LogMessage *msg;
msg = _construct_message("prog2", pattern);
_process(msg);
_advance_time(timeout);
assert_output_message_nvpair_equals(ndx, name, value);
log_msg_unref(msg);
}
//----------------------------------------------------------------------------------
//! Handle field changes of the field field.
//----------------------------------------------------------------------------------
void SegmentationEvaluationMetric::handleNotification (Field *field)
{
ML_TRACE_IN("SegmentationEvaluationMetric::handleNotification ()");
if (_isAutoApplyFld->isOn() || (field == _applyFld)) {
if (getUpdatedInImg(0) && getUpdatedInImg(1) ) {
_process();
} else {
_reset();
}
}
}
static void loop_wrapper() {
static bool setup_done = false;
preloop_update_frequency();
if (!setup_done) {
_begin(); // Startup MySensors library
setup_done = true;
}
_process(); // Process incoming data
loop();
run_scheduled_functions();
esp_schedule();
}
static void
_feed_message_to_correllation_state(const gchar *program, const gchar *message, const gchar *name, const gchar *value)
{
LogMessage *msg;
gboolean result;
msg = _construct_message_with_nvpair(program, message, name, value);
result = _process(msg);
log_msg_unref(msg);
assert_true(result, "patterndb expected to match but it didn't");
_dont_reset_patterndb_state_for_the_next_call();
}
int main(int argc, char *argv[])
{
int opt, log_opts, debug = 0, foreground = 1;
/* register the signal handler */
signal(SIGINT, handle_sigint);
signal(SIGTERM, handle_sigint);
while ((opt = getopt(argc, argv, "hdb")) != -1) {
switch (opt) {
case 'h':
print_usage();
exit(0);
case 'd':
debug = 1;
break;
case 'b':
foreground = 0;
break;
default:
print_usage();
exit(0);
}
}
log_opts = LOG_CONS;
if (foreground && isatty(STDIN_FILENO)) {
// Also print syslog to stderror
log_opts |= LOG_PERROR;
}
if (!debug) {
setlogmask(LOG_UPTO (LOG_INFO));
}
openlog(NULL, log_opts, LOG_USER);
if (!foreground && !debug) {
if (daemonize() != 0) {
exit(EXIT_FAILURE);
}
}
mys_log(LOG_INFO, "Starting gateway...\n");
mys_log(LOG_INFO, "Protocol version - %s\n", MYSENSORS_LIBRARY_VERSION);
_begin(); // Startup MySensors library
for (;;) {
_process(); // Process incoming data
if (loop) loop(); // Call sketch loop
}
return 0;
}
static void
assert_msg_with_program_matches_and_nvpair_equals(const gchar *program, const gchar *message,
const gchar *name, const gchar *expected_value)
{
LogMessage *msg;
gboolean result;
msg = _construct_message(program, message);
result = _process(msg);
assert_true(result, "patterndb expected to match but it didn't");
assert_log_message_value(msg, log_msg_get_value_handle(name), expected_value);
log_msg_unref(msg);
}
static void
assert_msg_doesnot_match(const gchar *message)
{
LogMessage *msg;
gboolean result;
msg = _construct_message("prog1", message);
result = _process(msg);
assert_false(result, "patterndb expected to match but it didn't");
assert_log_message_value(msg, log_msg_get_value_handle(".classifier.class"), "unknown");
assert_log_message_has_tag(msg, ".classifier.unknown");
log_msg_unref(msg);
}
std::string LSystem::_process(const std::string &state, unsigned depth) {
if (depth <= 0)
return state;
std::string next = "";
for(unsigned i = 0; i < state.length(); ++i) {
const char cur = state[i];
if (m_rules.find(cur) != std::string::npos)
next += _processRule(cur);
else next += cur;
}
return _process(next, depth - 1);
}
static void
assert_msg_matches_and_has_tag(const gchar *pattern, const gchar *tag, gboolean set)
{
LogMessage *msg;
gboolean result;
msg = _construct_message("prog1", pattern);
result = _process(msg);
assert_true(result, "patterndb expected to match but it didn't");
if (set)
assert_log_message_has_tag(msg, tag);
else
assert_log_message_doesnt_have_tag(msg, tag);
log_msg_unref(msg);
}
void EyesStatesDetectorApp::run(int argc, const char* argv[])
{
for (int i = 1; i < argc; ++i)
{
if (_parseCmdArgs(i, argc, argv))
continue;
// if (_parseHelpCmdArg(i, argc, argv))
// return;
std::ostringstream msg;
msg << "Unknown command line argument: " << argv[i];
throw std::runtime_error(msg.str());
}
_process();
}
void NaughtyProcessMonitor::slotTimeout()
{
uint cpu = cpuLoad();
emit(load(cpu));
if(cpu > d->triggerLevel_ * (d->interval_ / 1000))
{
uint load;
QValueList< ulong > l(pidList());
for(QValueList< ulong >::ConstIterator it(l.begin()); it != l.end(); ++it)
if(getLoad(*it, load))
_process(*it, load);
}
d->timer_->start(d->interval_, true);
}
int main(void)
{
init();
#if defined(USBCON)
USBDevice.attach();
#endif
_begin(); // Startup MySensors library
for(;;) {
_process(); // Process incoming data
if (loop) {
loop(); // Call sketch loop
}
if (serialEventRun) {
serialEventRun();
}
}
return 0;
}
static void* jack_thread(void *arg)
{
jack_client_t* client = (jack_client_t*) arg;
while (1) {
jack_nframes_t frames = jack_cycle_wait (client);
int status = _process(frames);
jack_cycle_signal (client, status);
/*
Possibly do something else after signaling next clients in the graph
*/
/* End condition */
if (status != 0)
return 0;
}
/* not reached*/
return 0;
}
void
rq_add_line(request_t *h, const char *line)
{
size_t len = strlen(line);
int res;
switch (h->state)
{
case ST_START:
res = parse_request_line(h, line);
if (res == 0)
{
h->error = 1;
return;
}
h->state = ST_HEADER;
h->line[0] = '\0';
break;
case ST_HEADER:
if (len == 0)
{
h->done = 1;
}
if ( (len == 0) || ( (len > 0) && !isspace(line[0]) ) )
{
if (strlen(h->line) > 0)
{
/* We have a full line of header, now we can analyze it. */
char *colon = strchr(h->line, ':');
size_t keylen;
char *key;
char *value;
if (colon == NULL)
{
/* We didn't find a colon. */
h->error = 1;
return;
}
keylen = colon - h->line;
key = strndup(h->line, keylen);
if (key == NULL)
{
/* Allocation error */
h->error = 1;
return;
}
value = strdup(colon + 1);
/* Now we have key and value, process them */
_process(h, key, value);
}
}
if (len > 0)
{
if ( !isspace(line[0]) )
h->line[0] = '\0';
else
line++; /* skip the starting space */
}
if (len > 0)
{
int plen = strlen(h->line);
int left = LINE_BUFFER_SIZE - plen - 1;
char *to = h->line + plen;
strncpy(to, line, left);
}
default:
break;
}
}
static void _process(telnet_t *telnet, const char *buffer, size_t size) {
telnet_event_t ev;
unsigned char byte;
size_t i, start;
for (i = start = 0; i != size; ++i) {
byte = buffer[i];
switch (telnet->state) {
/* regular data */
case TELNET_STATE_DATA:
/* on an IAC byte, pass through all pending bytes and
* switch states */
if (byte == TELNET_IAC) {
if (i != start) {
ev.type = TELNET_EV_DATA;
ev.data.buffer = buffer + start;
ev.data.size = i - start;
telnet->eh(telnet, &ev, telnet->ud);
}
telnet->state = TELNET_STATE_IAC;
}
break;
/* IAC command */
case TELNET_STATE_IAC:
switch (byte) {
/* subnegotiation */
case TELNET_SB:
telnet->state = TELNET_STATE_SB;
break;
/* negotiation commands */
case TELNET_WILL:
telnet->state = TELNET_STATE_WILL;
break;
case TELNET_WONT:
telnet->state = TELNET_STATE_WONT;
break;
case TELNET_DO:
telnet->state = TELNET_STATE_DO;
break;
case TELNET_DONT:
telnet->state = TELNET_STATE_DONT;
break;
/* IAC escaping */
case TELNET_IAC:
/* event */
ev.type = TELNET_EV_DATA;
ev.data.buffer = (char*)&byte;
ev.data.size = 1;
telnet->eh(telnet, &ev, telnet->ud);
/* state update */
start = i + 1;
telnet->state = TELNET_STATE_DATA;
break;
/* some other command */
default:
/* event */
ev.type = TELNET_EV_IAC;
ev.iac.cmd = byte;
telnet->eh(telnet, &ev, telnet->ud);
/* state update */
start = i + 1;
telnet->state = TELNET_STATE_DATA;
}
break;
/* negotiation commands */
case TELNET_STATE_WILL:
case TELNET_STATE_WONT:
case TELNET_STATE_DO:
case TELNET_STATE_DONT:
_negotiate(telnet, byte);
start = i + 1;
telnet->state = TELNET_STATE_DATA;
break;
/* subnegotiation -- determine subnegotiation telopt */
case TELNET_STATE_SB:
telnet->sb_telopt = byte;
telnet->buffer_pos = 0;
telnet->state = TELNET_STATE_SB_DATA;
break;
/* subnegotiation -- buffer bytes until end request */
case TELNET_STATE_SB_DATA:
/* IAC command in subnegotiation -- either IAC SE or IAC IAC */
if (byte == TELNET_IAC) {
telnet->state = TELNET_STATE_SB_DATA_IAC;
} else if (telnet->sb_telopt == TELNET_TELOPT_COMPRESS && byte == TELNET_WILL) {
/* In 1998 MCCP used TELOPT 85 and the protocol defined an invalid
* subnegotiation sequence (IAC SB 85 WILL SE) to start compression.
* Subsequently MCCP version 2 was created in 2000 using TELOPT 86
* and a valid subnegotiation (IAC SB 86 IAC SE). libtelnet for now
* just captures and discards MCCPv1 sequences.
*/
start = i + 2;
telnet->state = TELNET_STATE_DATA;
/* buffer the byte, or bail if we can't */
} else if (_buffer_byte(telnet, byte) != TELNET_EOK) {
start = i + 1;
telnet->state = TELNET_STATE_DATA;
}
break;
/* IAC escaping inside a subnegotiation */
case TELNET_STATE_SB_DATA_IAC:
switch (byte) {
/* end subnegotiation */
case TELNET_SE:
/* return to default state */
start = i + 1;
telnet->state = TELNET_STATE_DATA;
/* process subnegotiation */
if (_subnegotiate(telnet) != 0) {
/* any remaining bytes in the buffer are compressed.
* we have to re-invoke telnet_recv to get those
* bytes inflated and abort trying to process the
* remaining compressed bytes in the current _process
* buffer argument
*/
telnet_recv(telnet, &buffer[start], size - start);
return;
}
break;
/* escaped IAC byte */
case TELNET_IAC:
/* push IAC into buffer */
if (_buffer_byte(telnet, TELNET_IAC) !=
TELNET_EOK) {
start = i + 1;
telnet->state = TELNET_STATE_DATA;
} else {
telnet->state = TELNET_STATE_SB_DATA;
}
break;
/* something else -- protocol error. attempt to process
* content in subnegotiation buffer, then evaluate the
* given command as an IAC code.
*/
default:
_error(telnet, __LINE__, __func__, TELNET_EPROTOCOL, 0,
"unexpected byte after IAC inside SB: %d",
byte);
/* enter IAC state */
start = i + 1;
telnet->state = TELNET_STATE_IAC;
/* process subnegotiation; see comment in
* TELNET_STATE_SB_DATA_IAC about invoking telnet_recv()
*/
if (_subnegotiate(telnet) != 0) {
telnet_recv(telnet, &buffer[start], size - start);
return;
} else {
/* recursive call to get the current input byte processed
* as a regular IAC command. we could use a goto, but
* that would be gross.
*/
_process(telnet, (char *)&byte, 1);
}
break;
}
break;
}
}
/* pass through any remaining bytes */
if (telnet->state == TELNET_STATE_DATA && i != start) {
ev.type = TELNET_EV_DATA;
ev.data.buffer = buffer + start;
ev.data.size = i - start;
telnet->eh(telnet, &ev, telnet->ud);
}
}
vector<unsigned char> DESCoder::decode(vector<unsigned char> data)
{
return _process(data, false);
}
