static int run_remote(int fd, const char *command)
{
	fflush(stdout);

	if (!ctl_send_chars(fd, command, -1)) {
		printf("\r[%sFAIL%s]\n", c(RED, use_colors), c(CLEAR, use_colors));
		return COMMAND_FAILED;
	}

	struct luadebug_user *readline_user = luadebug_user_readline();
	if (!readline_user) {
		printf(": %ls", clear_error());
		printf("\r[%sFAIL%s]\n", c(RED, use_colors), c(CLEAR, use_colors));
	}

	if (check_status(fd, NULL) == COMMAND_SUCCESS) {
		luadebug_user_remote_server(fd, readline_user);
		if (check_error()) {
			message(HAKA_LOG_FATAL, L"debug", clear_error());
			return COMMAND_FAILED;
		}
		return COMMAND_SUCCESS;
	}
	else {
		return COMMAND_FAILED;
	}
}

static char *vacuum1_thread_writer(int iTid, void *pArg){
  Error err = {0};                /* Error code and message */
  Sqlite db = {0};                /* SQLite database connection */
  opendb(&err, &db, "test.db", 0);
  i64 i = 0;

  while( !timetostop(&err) ){
    i++;

    /* Insert lots of rows. Then delete some. */
    execsql(&err, &db, 
        "WITH loop(i) AS (SELECT 1 UNION ALL SELECT i+1 FROM loop WHERE i<100) "
        "INSERT INTO t1 SELECT randomblob(50), randomblob(2500) FROM loop"
    );

    /* Delete lots of rows */
    execsql(&err, &db, "DELETE FROM t1 WHERE rowid = :i", &i);
    clear_error(&err, SQLITE_LOCKED);

    /* Select the rows */
    execsql(&err, &db, "SELECT * FROM t1 ORDER BY x");
    clear_error(&err, SQLITE_LOCKED);
  }

  closedb(&err, &db);
  print_and_free_err(&err);
  return sqlite3_mprintf("ok");
}

inline int fcntl(int d, long cmd, long arg, boost::system::error_code& ec)
{
    clear_error(ec);
    int result = error_wrapper(::fcntl(d, cmd, arg), ec);
    if (result != -1)
        clear_error(ec);
    return result;
}

inline int open(const char* path, int flags, boost::system::error_code& ec)
{
    clear_error(ec);
    int result = error_wrapper(::open(path, flags), ec);
    if (result >= 0)
        clear_error(ec);
    return result;
}

inline int close(int d, boost::system::error_code& ec)
{
    clear_error(ec);
    int result = error_wrapper(::close(d), ec);
    if (result == 0)
        clear_error(ec);
    return result;
}

inline int ioctl(int d, long cmd, ioctl_arg_type* arg,
                 boost::system::error_code& ec)
{
    clear_error(ec);
    int result = error_wrapper(::ioctl(d, cmd, arg), ec);
    if (result >= 0)
        clear_error(ec);
    return result;
}

inline int scatter_read(int d, buf* bufs, size_t count,
                        boost::system::error_code& ec)
{
    clear_error(ec);
    int result = error_wrapper(::readv(d, bufs, static_cast<int>(count)), ec);
    if (result >= 0)
        clear_error(ec);
    return result;
}

inline int gather_write(int d, const buf* bufs, size_t count,
                        boost::system::error_code& ec)
{
    clear_error(ec);
    int result = error_wrapper(::writev(d, bufs, static_cast<int>(count)), ec);
    if (result >= 0)
        clear_error(ec);
    return result;
}

inline int poll_write(int d, boost::system::error_code& ec)
{
  clear_error(ec);
  pollfd fds;
  fds.fd = d;
  fds.events = POLLOUT;
  fds.revents = 0;
  clear_error(ec);
  return error_wrapper(::poll(&fds, 1, -1), ec);
}

inline int poll_read(int d, boost::system::error_code& ec)
{
    clear_error(ec);
    pollfd fds;
    fds.fd = d;
    fds.events = POLLIN;
    fds.revents = 0;
    clear_error(ec);
    int result = error_wrapper(::poll(&fds, 1, -1), ec);
    if (result >= 0)
        clear_error(ec);
    return result;
}

int
hstcpcli::request_send()
{
  if (error_code < 0) {
    return error_code;
  }
  clear_error();
  if (fd.get() < 0) {
    close();
    return set_error(-1, "write: closed");
  }
  if (num_req_bufd == 0 || num_req_sent > 0 || num_req_rcvd > 0) {
    close();
    return set_error(-1, "request_send: protocol out of sync");
  }
  const size_t wrlen = writebuf.size();
  const ssize_t r = send(fd.get(), writebuf.begin(), wrlen, MSG_NOSIGNAL);
  if (r <= 0) {
    close();
    return set_error(-1, r < 0 ? "write: failed" : "write: eof");
  }
  writebuf.erase_front(r);
  if (static_cast<size_t>(r) != wrlen) {
    close();
    return set_error(-1, "write: incomplete");
  }
  num_req_sent = num_req_bufd;
  num_req_bufd = 0;
  DBG(fprintf(stderr, "REQSEND 0\n"));
  return 0;
}

struct stumpless_element *
stumpless_new_element( const char *name ) {
  struct stumpless_element *element;

  clear_error(  );

  if( !name ) {
    raise_argument_empty( "name is NULL" );
    goto fail;
  }

  element = alloc_mem( sizeof( *element ) );
  if( !element ) {
    goto fail;
  }

  element->name = cstring_to_sized_string( name, &( element->name_length ) );
  if( !element->name ) {
    goto fail_name;
  }

  element->params = NULL;
  element->param_count = 0;

  return element;

fail_name:
  free_mem( element );

fail:
  return NULL;
}

status_t
rdef_compile(const char *outputFile)
{
	clear_error();

	if (outputFile == NULL || outputFile[0] == '\0') {
		rdef_err = B_BAD_VALUE;
		return rdef_err;
	}

	rsrc_file = outputFile;
	rdef_err = open_output_file();
	if (rdef_err != B_OK)
		return rdef_err;

	for (ptr_iter_t i = input_files.begin(); 
			(i != input_files.end()) && (rdef_err == B_OK); ++i) {
		char *path = (char *)*i;

		AddIncludeDir add(path);
		compile_file(path);
	}

	close_output_file();
	return rdef_err;
}

struct stumpless_entry *
stumpless_add_element( struct stumpless_entry *entry,
                       struct stumpless_element *element ) {

  struct stumpless_element **new_elements;
  size_t old_elements_size;
  size_t new_elements_size;

  clear_error(  );

  if( !entry ) {
    raise_argument_empty( "entry is NULL" );
    return NULL;
  }

  if( !element ) {
    raise_argument_empty( "element is NULL" );
    return NULL;
  }
  // todo need to check for duplicates first

  old_elements_size = sizeof( element ) * entry->element_count;
  new_elements_size = old_elements_size + sizeof( element );

  new_elements = realloc_mem( entry->elements, new_elements_size );
  if( !new_elements ) {
    return NULL;
  }

  new_elements[entry->element_count] = element;
  entry->elements = new_elements;
  entry->element_count++;

  return entry;
}

struct stumpless_entry *
vstumpless_set_entry_message( struct stumpless_entry *entry,
                              const char *message,
                              va_list subs ) {
  char *formatted_message;
  size_t message_length;

  clear_error(  );

  if( !entry ) {
    raise_argument_empty( "entry is NULL" );
    return NULL;
  }

  if( !message ) {
    free_mem( entry->message );
    entry->message = NULL;
    entry->message_length = 0;

  } else {
    formatted_message = config_format_string( message, subs, &message_length );
    if( !formatted_message ) {
      return NULL;

    } else {
      free_mem( entry->message );
      entry->message = formatted_message;
      entry->message_length = message_length;

    }
  }

  return entry;
}

struct stumpless_element *
stumpless_add_param( struct stumpless_element *element,
                     struct stumpless_param *param ) {

  struct stumpless_param **new_params;
  size_t old_params_size;
  size_t new_params_size;

  clear_error(  );

  if( !element ) {
    raise_argument_empty( "element is NULL" );
    return NULL;
  }

  if( !param ) {
    raise_argument_empty( "param is NULL" );
    return NULL;
  }

  old_params_size = sizeof( param ) * element->param_count;
  new_params_size = old_params_size + sizeof( param );

  new_params = realloc_mem( element->params, new_params_size );
  if( !new_params ) {
    return NULL;
  }

  new_params[element->param_count] = param;
  element->param_count++;
  element->params = new_params;

  return element;
}

	void radc_compiler::begin(const char * str, const radc_varlist * _varlist)
	{
		clear_error();

		_break = false;
		_options = 0;
		_cache_program = programs.Find(str);
		if (_cache_program == -1)
		{
			int length = strlen(str);

			buffer.Resize(length + 1);

			int i = 0;
			while (*str)
			{
				buffer[i++] = charmap[*str++];
			}

			buffer[i] = 0;
		}

		inputlist = _varlist;

		outputlist->clear();
	}

int c_syb_make (int m_size)
{
  int count;
  
  error_message = (char *) malloc (sizeof (char) * (m_size + ERROR_MESSAGE_SIZE));
  clear_error ();
  max_size = m_size;
  
  if (dbinit () == FAIL)
    {
      return error_number;
      /* exit(ERREXIT); */
    }
  
  dberrhandle ((EHANDLEFUNC)err_handler);
  dbmsghandle ((MHANDLEFUNC)msg_handler);
  
  if (login == NULL)
    {
		login = safe_alloc (dblogin());
		DBSETLCHARSET (login, "utf8");
    }
 
  for (count = 0; count < MAX_DESCRIPTOR; count++)
    {
      descriptor[count] = NULL;
    }
  
  return error_number;
}

void legacy_image_device_base::unload()
{
	if (is_loaded()) {
		call_unload();
	}
    clear();
	clear_error();
}

int syb_exec_immediate (char *order)
{
  DBPROCESS * dbp = descriptor[PRIVATE_DESCRIPTOR];
  clear_error ();
  dbcmd (dbp, order);
  dbsqlexec (dbp);
  return error_number;
}