void
tr_peerIoUnrefImpl( const char * file, int line, tr_peerIo * io )
{
    assert( tr_isPeerIo( io ) );

    dbgmsg( io, "%s:%d is decrementing the IO's refcount from %d to %d",
                file, line, io->refCount, io->refCount-1 );

    if( !--io->refCount )
        tr_peerIoFree( io );
}

static void
tr_peerIoFree( tr_peerIo * io )
{
    if( io )
    {
        dbgmsg( io, "in tr_peerIoFree" );
        io->canRead = NULL;
        io->didWrite = NULL;
        io->gotError = NULL;
        tr_runInEventThread( io->session, io_dtor, io );
    }
}

static int
readPayloadStream( tr_handshake    * handshake,
                   struct evbuffer * inbuf )
{
    int i;
    const size_t      needlen = HANDSHAKE_SIZE;

    dbgmsg( handshake, "reading payload stream... have %zu, need %zu",
            evbuffer_get_length( inbuf ), needlen );
    if( evbuffer_get_length( inbuf ) < needlen )
        return READ_LATER;

    /* parse the handshake ... */
    i = parseHandshake( handshake, inbuf );
    dbgmsg( handshake, "parseHandshake returned %d", i );
    if( i != HANDSHAKE_OK )
        return tr_handshakeDone( handshake, FALSE );

    /* we've completed the BT handshake... pass the work on to peer-msgs */
    return tr_handshakeDone( handshake, TRUE );
}

static bool
preallocate_file_full (tr_sys_file_t fd, uint64_t length, tr_error ** error)
{
  tr_error * my_error = NULL;

  if (length == 0)
    return true;

  if (tr_sys_file_preallocate (fd, length, 0, &my_error))
    return true;

  dbgmsg ("Preallocating (full, normal) failed (%d): %s", my_error->code, my_error->message);

  if (!TR_ERROR_IS_ENOSPC (my_error->code))
    {
      uint8_t buf[4096];
      bool success = true;

      memset (buf, 0, sizeof (buf));
      tr_error_clear (&my_error);

      /* fallback: the old-fashioned way */
      while (success && length > 0)
        {
          const uint64_t thisPass = MIN (length, sizeof (buf));
          uint64_t bytes_written;
          success = tr_sys_file_write (fd, buf, thisPass, &bytes_written, &my_error);
          length -= bytes_written;
        }

      if (success)
        return true;

      dbgmsg ("Preallocating (full, fallback) failed (%d): %s", my_error->code, my_error->message);
    }

  tr_error_propagate (error, &my_error);
  return false;
}

static void
task_finish( struct tr_web_task * task, long response_code )
{
    dbgmsg( "finished web task %lu; got %ld", task->tag, response_code );

    if( task->done_func != NULL )
        task->done_func( task->session,
                         response_code,
                         EVBUFFER_DATA( task->response ),
                         EVBUFFER_LENGTH( task->response ),
                         task->done_func_user_data );
    task_free( task );
}

/*-----------------------------------------------------------------------------
 * memcpy:
 *  
 * CAUTION: do not use with overleaping buffers like: 
    char tab[] = "qwertyuiopasdfghjklzxcvbnm";
    char* ptr_src = tab;
    char* ptr_dst = tab + 1;
    uint32 sz = 5;
 *-----------------------------------------------------------------------------*/
void *fmf_memcpy( void *dest, const void *src, uint32 count ) 
{
#ifdef LIBSTR_memcpy_linuxkernel_nasm
   	/*-----------------------------------------------------------------------------
    	* 32bit nasm implementation of linux kernel memcpy, it compiles on windows as well
    	*-----------------------------------------------------------------------------*/
#ifdef LIBSTR_DEBUG
	dbgmsg( "memcpy_linuxkernel_nasm" );
#endif
	//if( count < 4 )
	// only small for now
		return nasm_memcpy_s( dest, src, count );
	//else
	//	return nasm_memcpy_b( dest, src, count );
#elif LIBSTR_memcpy_prefetch
	/*-----------------------------------------------------------------------------
	 *  32bit nasm implementation of memcpy prefetch
	 *-----------------------------------------------------------------------------*/
#ifdef LIBSTR_DEBUG
	dbgmsg( "memcpy_prefetch" );
#endif
	return nasm_memcpy_prefetch( dest, src, count );
#elif LIBSTR_memcpy_linuxkernel_att
   	/*-----------------------------------------------------------------------------
    	* inline AT&T linux kernel memcpy
    	*-----------------------------------------------------------------------------*/
#ifdef LIBSTR_DEBUG
	dbgmsg( "memcpy_linuxkernel_att" );
#endif
	int32 d0, d1, d2;
	if( count < 4 ) {
		register uint32  dummy;
		__asm__ __volatile__(
  		"rep; movsb"
  		:"=&D"(dest), "=&S"(src), "=&c"(dummy)
  		:"0" (dest), "1" (src),"2" (count)
  		: "memory");
  	} else

static void
event_disable( struct tr_peerIo * io, short event )
{
    assert( tr_amInEventThread( io->session ) );
    assert( io->session != NULL );
    assert( io->session->events != NULL );
    assert( event_initialized( &io->event_read ) );
    assert( event_initialized( &io->event_write ) );

    if( ( event & EV_READ ) && ( io->pendingEvents & EV_READ ) )
    {
        dbgmsg( io, "disabling libevent ready-to-read polling" );
        event_del( &io->event_read );
        io->pendingEvents &= ~EV_READ;
    }

    if( ( event & EV_WRITE ) && ( io->pendingEvents & EV_WRITE ) )
    {
        dbgmsg( io, "disabling libevent ready-to-write polling" );
        event_del( &io->event_write );
        io->pendingEvents &= ~EV_WRITE;
    }
}

static int wait_for_cpu_online(void)
{
	if (!decision_engine_stalled())
		return 0;

	pthread_mutex_lock(&hotplug_mutex);
	dbgmsg("Waiting for cpu to be online\n");
	while (stall_decision) {
		pthread_cond_wait(&hotplug_condition, &hotplug_mutex);
	}
	pthread_mutex_unlock(&hotplug_mutex);

	return 1;
}

static int
tr_handshakeDone (tr_handshake * handshake, bool isOK)
{
  bool success;

  dbgmsg (handshake, "handshakeDone: %s", isOK ? "connected" : "aborting");
  tr_peerIoSetIOFuncs (handshake->io, NULL, NULL, NULL, NULL);

  success = fireDoneFunc (handshake, isOK);

  tr_handshakeFree (handshake);

  return success ? READ_LATER : READ_ERR;
}

int amba_vtouch_release_abs_mt_sync(struct amba_vtouch_data *data)
{
	if((amba_vtouch_dev==NULL) || (amba_vtouch_dev->input_dev==NULL)){
		return -1;
	}
	dbgmsg("===> %s, %d,%d\n",__func__, data->finger[0].x, data->finger[0].y);

	input_report_abs(amba_vtouch_dev->input_dev, ABS_MT_TOUCH_MAJOR, 0);
	input_mt_sync(amba_vtouch_dev->input_dev);

	input_sync(amba_vtouch_dev->input_dev);

	return 0;
}

extern	Bool
CheckNetFile(
	NETFILE	*fp)
{
	Bool	ret;

	if		(  fp && fp->fOK  ) {
		ret = TRUE;
	} else {
		dbgmsg("bad net file");
		ret = FALSE;
	}
	return	(ret);
}

/* This method searches in the local constant pool for a method and returns the index
     of the method in the MethodLookupTable. */
Method* find_method_name(Class *vmclass, const char *qualifiedName)
{
    unsigned short n, nameIndex;

#ifdef DEBUG
    printf("Link: finding method %s...", qualifiedName);
#endif

    if (vmclass == NULL) {
        return NULL;
    }

    for (n = 0; n < vmclass->MethodsNum; n++) {
        nameIndex = vmclass->Methods[n].NameIndex - 1;  /* Constant Pool index starts with 1, so we must subtract one */
        if (strcmp(qualifiedName, ((struct CONSTANT_UTF8_INFO *)vmclass->ConstantPool[nameIndex].Data)->Text) == 0) {
            dbgmsg("Found method.");
            return &(vmclass->Methods[n]);
        }
    }

    dbgmsg("Method not found!");
    return NULL;
}

extern	PacketDataType
RecvStringData(
	NETFILE	*fp,
	char	*str,
	size_t	size)
{
	PacketDataType	type;

ENTER_FUNC;
	type = GL_RecvDataType(fp);
	switch	(type) {
	  case	GL_TYPE_INT:
		dbgmsg("int");
		sprintf(str,"%d",GL_RecvInt(fp));
		break;
	  case	GL_TYPE_CHAR:
	  case	GL_TYPE_VARCHAR:
	  case	GL_TYPE_DBCODE:
	  case	GL_TYPE_TEXT:
		GL_RecvString(fp, size, str);
		break;
	  case	GL_TYPE_BINARY:
	  case	GL_TYPE_BYTE:
	  case	GL_TYPE_OBJECT:
		dbgmsg("LBS");
		GL_RecvLBS(fp,LargeBuff);
		if		(  LBS_Size(LargeBuff)  >  0  ) {
			memcpy(str,LBS_Body(LargeBuff),LBS_Size(LargeBuff));
			str[LBS_Size(LargeBuff)] = 0;
		} else {
			*str = 0;
		}
		break;
	}
LEAVE_FUNC;
	return type;
}

static void restore_power_modes()
{
	if(control_sleep_modes == 0)
		return;

	dbgmsg("Restoring power modes\n");
	if(saved_sapc_idle_en_c0  != -1)
		set_power_mode(0, "standalone_power_collapse", "idle_enabled", saved_sapc_idle_en_c0 );
	if(saved_sapc_idle_en_c1  != -1)
		set_power_mode(1, "standalone_power_collapse", "idle_enabled", saved_sapc_idle_en_c1 );
	if(saved_pc_idle_en_c0 != -1)
		set_power_mode(0, "power_collapse", "idle_enabled", saved_pc_idle_en_c0);
	if(saved_pc_idle_en_c1 != -1)
		set_power_mode(1, "power_collapse", "idle_enabled", saved_pc_idle_en_c1);
}

static void
task_finish_func( void * vtask )
{
    struct tr_web_task * task = vtask;
    dbgmsg( "finished web task %p; got %ld", task, task->code );

    if( task->done_func != NULL )
        task->done_func( task->session,
                         task->code,
                         evbuffer_pullup( task->response, -1 ),
                         evbuffer_get_length( task->response ),
                         task->done_func_user_data );

    task_free( task );
}

static void
task_finish_func( void * vtask )
{
    struct tr_web_task * task = vtask;
    dbgmsg( "finished web task %p; got %ld", task, task->code );

    if( task->done_func != NULL )
        task->done_func( task->session,
                         task->code,
                         EVBUFFER_DATA( task->response ),
                         EVBUFFER_LENGTH( task->response ),
                         task->done_func_user_data );

    task_free( task );
}

static void sendBitfield(tr_peerMsgs * msgs) {
    void * bytes; size_t byte_count = 0;       // bitfield e seu comprimento
    struct evbuffer * out = msgs->outMessages; // buffer de saída

    (...)
    // Cria o bitfield conforme as partes que possui no momento.
    bytes = tr_cpCreatePieceBitfield(&msgs->torrent->completion, &byte_count);

    // <tamanho> = 1 + tamanho do bitfield
    evbuffer_add_uint32(out, sizeof(uint8_t) + byte_count);

    evbuffer_add_uint8(out, BT_BITFIELD); // <ID da mensagem> = 5
    evbuffer_add(out, bytes, byte_count); // <dados=mapa de bits>
    dbgmsg(msgs, "sending bitfield... outMessage size is now %zu", evbuffer_get_length(out));
    (...)
}

// set _current_frame to its n+1'th tail (i.e. pop n+1 frames)
// Invariant: result is non-null
void _npop_frame(unsigned int n) {
  struct _ThreadKey *t = tcb();
  struct _RuntimeStack *current_frame = t->stack._current_frame;
  unsigned int i;

  for(i = n; i <= n; i--) {
    if(current_frame == NULL) 
      errquit("internal error: empty frame stack\n");
    dbgmsg("\nPOPING frame : %p code = %p" ,
             current_frame, current_frame->cleanup);
    if (current_frame->cleanup != NULL)
       current_frame->cleanup(current_frame);
    current_frame = current_frame->next;
  }
  t->stack._current_frame = current_frame;
}

void
tr_peerIoWrite( tr_peerIo   * io,
                const void  * bytes,
                size_t        byteCount,
                tr_bool       isPieceData )
{
    /* FIXME(libevent2): this implementation snould be moved to tr_peerIoWriteBuf.   This function should be implemented as evbuffer_new() + evbuffer_add_reference() + a call to tr_peerIoWriteBuf() + evbuffer_free() */
    struct tr_datatype * datatype;

    assert( tr_amInEventThread( io->session ) );
    dbgmsg( io, "adding %zu bytes into io->output", byteCount );

    datatype = tr_new( struct tr_datatype, 1 );
    datatype->isPieceData = isPieceData != 0;
    datatype->length = byteCount;
    tr_list_append( &io->outbuf_datatypes, datatype );

    switch( io->encryptionMode )
    {
        case PEER_ENCRYPTION_RC4:
        {
            /* FIXME(libevent2): use evbuffer_reserve_space() and evbuffer_commit_space() instead of tmp */
            void * tmp = tr_sessionGetBuffer( io->session );
            const size_t tmplen = SESSION_BUFFER_SIZE;
            const uint8_t * walk = bytes;
            evbuffer_expand( io->outbuf, byteCount );
            while( byteCount > 0 )
            {
                const size_t thisPass = MIN( byteCount, tmplen );
                tr_cryptoEncrypt( io->crypto, thisPass, walk, tmp );
                evbuffer_add( io->outbuf, tmp, thisPass );
                walk += thisPass;
                byteCount -= thisPass;
            }
            tr_sessionReleaseBuffer( io->session );
            break;
        }

        case PEER_ENCRYPTION_NONE:
            evbuffer_add( io->outbuf, bytes, byteCount );
            break;

        default:
            assert( 0 );
            break;
    }
}

static void
setsock( curl_socket_t            sockfd,
         int                      action,
         struct tr_web          * g,
         struct tr_web_sockinfo * f )
{
    const int kind = EV_PERSIST
                   | (( action & CURL_POLL_IN ) ? EV_READ : 0 )
                   | (( action & CURL_POLL_OUT ) ? EV_WRITE : 0 );
    dbgmsg( "setsock: fd is %d, curl action is %d, libevent action is %d",
            sockfd, action, kind );
    if( f->evset )
        event_del( &f->ev );
    event_set( &f->ev, sockfd, kind, event_cb, g );
    f->evset = 1;
    event_add( &f->ev, NULL );
}